package概念：

包是一个分层次的文件目录结构，它定义了一个由模块及子包，和子包下的子包等组成的 Python 的应用环境。简单来说，包就是文件夹，但该文件夹下必须存在 __init__.py 文件, 该文件的内容可以为空。__int__.py用于标识当前文件夹是一个包。

str.rfind(substr)

返回str中substr最后出现的位置，未匹配到返回-1

Python中的self,cls,@classmethod,@staticmethod

python类里会出现这三个单词，self和cls都可以用别的单词代替，类的方法有三种，

一是通过def定义的普通的一般的，需要至少传递一个参数，一般用self，这样的方法必须通过一个类的实例去访问，类似于c++中通过对象去访问；

二是在def前面加上@classmethod，这种类方法的一个特点就是可以通过类名去调用，但是也必须传递一个参数，一般用cls表示class，表示可以通过类直接调用；

三是在def前面加上@staticmethod，这种类方法是静态的类方法，类似于c++的静态函数，他的一个特点是参数可以为空，同样支持类名和对象两种调用方式；

Python中的dumps() loads() dump() load():

str = json.dumps(dict):将字典转换为字符串

dict = json.loads(str)：将字符串转换为字典，字符串必须是json格式

dump();load()功能与上述类似，只是同时需要传入一个文件对象，将转换后的结果直接存储到文件中。

python 跳出循环

break：跳出整个循环

continue：跳出本次循环

**itertools.product(*Iterables[,repeat])**

创建一个迭代器，生成表示item1，item2等中的项目的笛卡尔积的元组，repeat是一个关键字参数，指定重复生成序列的次数。

def product(*args, **kwds):

    # product('ABCD', 'xy') --
>
 Ax Ay Bx By Cx Cy Dx Dy
    # product(range(2), repeat=3) --
>
 000 001 010 011 100 101 110 111
    pools = map(tuple, args) * kwds.get('repeat', 1)
    result = [[]]
    for pool in pools:
        result = [x+[y] for x in result for y in pool]
    for prod in result:
        yield tuple(prod)

生成器与迭代器：

gernerator 包括generator 和包含yeild关键字的generator function

能作用于for循环的都叫做可迭代对象。

generator不仅能作用于for循环，还能作用于next()函数，不断计算下一个值。

能被next()调用并不断返回下一个值得对象称为迭代器。

由此可见，生成器都是迭代器；可迭代对象（str,list,tuple,dict等)虽不是迭代器，但可通过iter(“abc”),iter([])变成一个迭代器。

rang() 、xrange()

xrange()函数用法与range完全相同，所不同的是生成的不是一个数组，而是一个生成器

python文件编码声明：

#coding=utf-8 ; 默认使用ASCII编码

list set dict tuple 之间的相互转换

list->set: set(seq) set(seq)函数可以将任何序列转换成set

set->list: list(seq) list(seq)函数把一个序列类型和可迭代的对象转换成一个列表

tuple(seq)可以把所有可迭代的(iterable)序列转换成一个tuple, 元素不变，排序也不变；单元素元祖 tuple(1,)
zip函数和强大的集合操作可以方便的将两个list元素一一对应转换为dict
names = ['n1','n2','n3']

values = [1,2,3]

nvs = zip(names,values)

nvDict = dict( (name,value) for name,value in nvs)

使用subProcess创建子进程

import subProcess

subProcess.Popen()函数：

subprocess.Popen(args, bufsize=0, executable=None, stdin=None, stdout=None,stderr=None, preexec_fn=None,
close_fds=False,shell=False, cwd=None,env=None, universal_newlines=False,startupinfo=None, creationflags=0)

创建并返回一个子进程，并在这个进程中执行指定的程序。

实例化 Popen 可以通过许多参数详细定制子进程的环境，但是只有一个参数是必须的，即位置参数 args ，下面也会详细介绍剩余的具名参数。

参数介绍：

args：要执行的命令或可执行文件的路径。一个由字符串组成的序列（通常是列表），列表的第一个元素是可执行程序的路径，剩下的是传给这个程序的参数，如果没有要传给这个程序的参数，args 参数可以仅仅是一个字符串。

bufsize：控制 stdin, stdout, stderr 等参数指定的文件的缓冲，和打开文件的 open()函数中的参数 bufsize 含义相同。

executable：如果这个参数不是 None，将替代参数 args 作为可执行程序；

stdin：指定子进程的标准输入；

stdout：指定子进程的标准输出；

stderr：指定子进程的标准错误输出；
对于stdin, stdout和stderr而言，如果他们是 None（默认情况），那么子进程使用和父进程相同的标准流文件。

父进程如果想要和子进程通过 communicate() 方法通信，对应的参数必须是 subprocess.PIPE

shell：布尔型变量，明确要求使用shell运行程序，与参数 executable 一同指定子进程运行在什么 Shell 中——如果executable=None 而 shell=True，则使用 /bin/sh 来执行 args 指定的程序；也就是说，Python首先起一个shell，再用这个shell来解释指定运行的命令。

同 Linux 中创建子进程类似，父进程创建完子进程后，并不会自动等待子进程执行，父进程在子进程之前推出将导致子进程成为孤儿进程，孤儿进程统一由 init 进程接管，负责其终止后的回收工作。

如果父进程在子进程之后终止，但子进程终止时父进程没有进行最后的回收工作，子进程残留的数据结构称为僵尸进程。大量僵尸进程将耗费系统资源，因此父进程及时等待和回收子进程是必要的，除非能够确认自己比子进程先终止，从而将回收工作过渡给 init 进程。

这个等待和回收子进程的操作就是wait()函数。

Popen对象的属性：

p.pid：子进程的PID

p.returncode：该属性表示子进程的返回状态，returncode可能有多重情况:

       None —— 子进程尚未结束；

       ==0 —— 子进程正常退出；

       &gt; 0—— 子进程异常退出，returncode对应于出错码；

       &lt; 0—— 子进程被信号杀掉了

p.stdin, stdout, stderr ：子进程对应的一些初始文件，如果调用Popen()的时候对应的参数是subprocess.PIPE，则这里对应的属性是一个包裹了这个管道的 file 对象，

Popen对象的方法：

p.poll()：检查子进程 p 是否已经终止，返回 p.returncode 属性

p.wait()：等待子进程 p 终止，返回 p.returncode 属性；wait()会立即阻塞父进程，直到子进程结束。

p.communicate(input=None)：和子进程 p 交流，将参数 input （字符串）中的数据发送到子进程的 stdin，同时从子进程的 stdout 和 stderr 读取数据，直到EOF。返回二元组 (stdoutdata, stderrdata) 分别表示从标准输出和标准错误中读出的数据。

父进程调用 p.communicate() 和子进程通信有以下限制：

（1） 只能通过管道和子进程通信，也就是说，只有调用 Popen() 创建子进程的时候参数 stdin=subprocess.PIPE，才能通过 p.communicate(input) 向子进程的 stdin 发送数据；只有参数 stout 和 stderr 也都为 subprocess.PIPE ，才能通过p.communicate() 从子进程接收数据，否则接收到的二元组中，对应的位置是None。

（2）父进程从子进程读到的数据缓存在内存中，因此commucate()不适合与子进程交换过大的数据。

communicate()会立即阻塞父进程，直到子进程结束。

p.send_signal(signal)：向子进程发送signal信号

p.terminate()：终止子进程p，等于向p发送SIGTERM信号

p.kill()：杀死子进程p，等于向p发送SIGKILL信号

subProcess对象的其它方法：

subprocess.call(args, *, stdin=None, stdout=None, stderr=None, shell=False)

父进程直接创建子进程执行程序，然后等待子进程完成。

call() 返回子进程的退出状态即 child.returncode 属性；如果子进程的退出状态不是0，check_call() 抛出异常 CalledProcessError，异常对象中包含了 child.returncode 对应的返回码

subprocess.check_call(args, *, stdin=None, stdout=None, stderr=None, shell=False)

父进程直接创建子进程执行程序，然后等待子进程完成，具体可以使用的参数，参考Popen 类

无论子进程是否成功，该函数都返回 0；但是，如果子进程的退出状态不是0，check_call() 抛出异常 CalledProcessError，异常对象中包含了 child.returncode 对应的返回码无论子进程是否成功，该函数都返回 0；

subprocess.check_output(args, *, stdin=None, stderr=None, shell=False, universal_newlines=False)

父进程直接创建子进程执行程序，以字符串的形式返回子进程的输出。

返回字符串形式的子进程的输出结果，但是如果子进程的退出状态不是0，那么抛出异常 CalledProcessError，异常对象中包含了 child.returncode 对应的返回码。

check_output() 的函数签名中没有参数stdout，调用该方法时，子进程的输出默认就返回给父进程。

使用上面提到的三个方法：call()、check_call() 和 check_output() 时，尽量不要将参数stderr和stdout设置为 subprocess.PIPE，这几个函数默认都会等待子进程完成，子进程产生大量的输出数据如果造成管道堵塞，父进程再等待子进程完成可能造成死锁。

subprocess模块的缺陷在于默认提供的父子进程间通信手段有限，只有管道；同时创建的子进程专门用来执行外部的程序或命令。

Python