跟我一起学python（四），python的模块

模块，用一砣代码实现了某个功能的代码集合。

类似于函数式编程和面向过程编程，函数式编程则完成一个功能，其他代码用来调用即可，提供了代码的重用性和代码间的耦合。而对于一个复杂的功能来，可能需要多个函数才能完成（函数又可以在不同的.py文件中），n个 .py 文件组成的代码集合就称为模块。

如：os 是系统相关的模块；file是文件操作相关的模块

模块分为三种：

自定义模块
第三方模块
内置模块

自定义模块

1、定义模块：

情景一：

情景二：

情景三：

2、导入模块：

Python之所以应用越来越广泛，在一定程度上也依赖于其为程序员提供了大量的模块以供使用，如果想要使用模块，则需要导入。导入模块有一下几种方法：

import modulefrom module.xx.xx import xxfrom module.xx.xx import xx as rename from module.xx.xx import *

导入模块其实就是告诉Python解释器去解释那个py文件

导入一个py文件，解释器解释该py文件导入一个包，解释器解释该包下的 __init__.py 文件 【py2.7】

那么问题来了，导入模块时是根据那个路径作为基准来进行的呢？即：sys.path

print sys.path#如果sys.path路径列表没有你想要的路径，可以通过 sys.path.append('路径') 添加。

import sysimport osproject_path = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))sys.path.append(project_path)

模块介绍

sys模块：
用于提供对Python解释器相关的操作

sys.argv    可以接收外部传入的参数,传入参数变为列表的形式sys.path    查看模块默认地址sys.path.append("E:\\")可以添加模块的搜寻地址    sys.path.append("D:\python")    #在D盘下找到python找模块sys.exit(n)        退出程序，正常退出时exit(0)sys.version        获取Python解释程序的版本信息sys.maxint         最大的Int值sys.platform       返回操作系统平台名称sys.stdin          输入相关sys.stdout         输出相关    sys.stdout.flush()  输出清空    sys.stdout.write(变量或文本) 不会换行直接写sys.stderror       错误相关

sys举例–进度条：

import sysimport timedef view_bar(num, total):    rate = num / total    rate_num = int(rate * 100)    r = '\r%d%%' % (rate_num, )     #\r 回到当前行的首个位置 就是把内容抹去    sys.stdout.write(r)    sys.stdout.flush()if __name__ == '__main__':    for i in range(0, 101):        time.sleep(0.1)        view_bar(i, 100)

sys举例–进度条 带进度的：

import sysimport timedef view_bar(num, total):    rate = num / total    rate_num = int(rate * 100)    r = '\r%s%d%%' % ("="*num,rate_num)     #\r 回到当前行的首个位置 就是把内容抹去    sys.stdout.write(r)    sys.stdout.flush()if __name__ == '__main__':    for i in range(0, 101):        time.sleep(0.1)        view_bar(i, 100)

os模块：
用于提供系统级别的操作

os.path.abspath()   #获取绝对路径 #路径的作用主要用于程序跨机器和平台    os.path.abspath(__file__)os.path.dirname()   #获取文件的上级目录    os.path.dirname(os.path.abspath(__file__))  #找到上一级目录        sys.path.append()os.path.dirname(os.path.dirname(os.path.abspath(__file__))))        #找到/bin下内容的主目录，主要用于在其他机器也能正常运行 必加！！！        sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))os.getcwd()                 获取当前工作目录，即当前python脚本工作的目录路径os.chdir("dirname")         改变当前脚本工作目录；相当于shell下cdos.curdir                   返回当前目录: ('.')os.pardir                   获取当前目录的父目录字符串名：('..')os.makedirs('dir1/dir2')    可生成多层递归目录os.removedirs('dirname1')   若目录为空，则删除，并递归到上一级目录，如若也为空，则删除，依此类推os.mkdir('dirname')         生成单级目录；相当于shell中mkdir dirnameos.rmdir('dirname')         删除单级空目录，若目录不为空则无法删除，报错；相当于shell中rmdir dirnameos.listdir('dirname')       列出指定目录下的所有文件和子目录，包括隐藏文件，并以列表方式打印os.remove()                 删除一个文件os.rename("oldname","new")  重命名文件/目录os.stat('path/filename')    获取文件/目录信息,会用文件大小os.sep                      操作系统特定的路径分隔符，win下为"\\",Linux下为"/"os.linesep                  当前平台使用的行终止符，win下为"\t\n",Linux下为"\n"os.pathsep                  用于分割文件路径的字符串os.name                     字符串指示当前使用平台。win->'nt'; Linux->'posix'os.system("bash command")   运行shell命令，直接显示os.environ                  获取系统环境变量os.path.abspath(path)       必会！！返回path规范化的绝对路径os.path.split(path)         将path分割成目录和文件名二元组返回os.path.dirname(path)       必会！！返回path的目录。其实就是os.path.split(path)的第一个元素os.path.basename(path)      返回path最后的文件名。如何path以／或\结尾，那么就会返回空值。即os.path.split(path)的第二个元素os.path.exists(path)        如果path存在，返回True；如果path不存在，返回Falseos.path.isabs(path)         如果path是绝对路径，返回Trueos.path.isfile(path)        如果path是一个存在的文件，返回True。否则返回Falseos.path.isdir(path)         如果path是一个存在的目录，则返回True。否则返回Falseos.path.join(path1[, path2[, ...]]) 将多个路径组合后返回，第一个绝对路径之前的参数将被忽略，这个必会，日后用途非常广泛！os.path.getatime(path)      返回path所指向的文件或者目录的最后存取时间os.path.getmtime(path)      返回path所指向的文件或者目录的最后修改时间

hashlib加密模块：
用于加密相关的操作，代替了md5模块和sha模块，主要提供 SHA1, SHA224, SHA256, SHA384, SHA512 ，MD5 算法

import hashlib# ######## md5 ########hash = hashlib.md5()# help(hash.update)hash.update(bytes('admin', encoding='utf-8'))print(hash.hexdigest())print(hash.digest())######## sha1 ########hash = hashlib.sha1()hash.update(bytes('admin', encoding='utf-8'))print(hash.hexdigest())# ######## sha256 ########hash = hashlib.sha256()hash.update(bytes('admin', encoding='utf-8'))print(hash.hexdigest())# ######## sha384 ########hash = hashlib.sha384()hash.update(bytes('admin', encoding='utf-8'))print(hash.hexdigest())# ######## sha512 ########hash = hashlib.sha512()hash.update(bytes('admin', encoding='utf-8'))print(hash.hexdigest())

以上加密算法虽然依然非常厉害，但时候存在缺陷，即：通过撞库可以反解。所以，有必要对加密算法中添加自定义key再来做加密。

import hashlib# ######## md5 ########hash = hashlib.md5(bytes('898oaFs09f',encoding="utf-8"))hash.update(bytes('admin',encoding="utf-8"))print(hash.hexdigest())

re模块：
正则表达式处理模块

flags: 便宜标志位，用于修改正则的表达式的匹配方式，如：是否区分大小写，多行匹配等等re.findall() 将结果分别保存列表中的元素中refindall("规则","要搜索的内容")re.match()  只匹配字符串的启示位置，并将结果返回成对象的形式通过调用对象的方法获得具体的值    re.match("规则","要搜索的内容",flags=0)start() 返回匹配开始的位置end()   返回匹配结束的位置span()  返回一个元祖包含匹配(开始,结束)的位置group() 返回re整个匹配的字符串，可以一次输入多个组号，对应组号匹配的字符串re.search() 匹配字符串内任意字符，并将第一个匹配结果返回成对象，通过调用对象的方法获得值，对象的方法同matchre.search("规则","要搜索的内容",flags=0)re.finditer()   同findall一样，但finditer返回的是对象re.sub()        匹配替换    re.sub("模式","替换的新字符串","要被搜索的字符串",max)   max为数字，意思是替换的最大次数   re.split()  对字符串做分割re.split("\d+","one1two2three3four4")   #返回：['one', 'two', 'three', 'four', '']# 无分组origin = "hello alex bcd alex lge alex acd 19"r = re.split("alex", origin, 1)print(r)# 有分组origin = "hello alex bcd alex lge alex acd 19"r1 = re.split("(alex)", origin, 1)print(r1)r2 = re.split("(al(ex))", origin, 1)print(r2)re.compile() 将模式封装成对象，然后调用对象可以批量匹配字符串    text = "sad123oo123dff"    regex=re.compile(r'\w*oo\w*)    #先把模式封装成regex的对象，r的意思是让python解释器不转译，将原生字符直接传送给函数    print regex.findall(text)       #查找text里oo字符    

正则分组：
去已经提取到的数据中再提取数据

match和search分组：r = re.match("h(\w+).*(?P<name>\d)$", origin)print(r.group())     # 获取匹配到的所有结果print(r.groups())    # 获取模型中匹配到的分组结果print(r.groupdict()) # 获取模型中匹配到的分组中所有执行了key的组多层括号会从外层逐层取值

正则表达式基础用法:
元字符

.   单个任意字符^   锁定起始位置$  锁定结束位置*   匹配其前面的字符任意次

a*b  的含义是b前面可以有任意一个a    .*任意长度的任意字符+   必须最少有一个字符    a+b ab之间至少有一个字符{}  规定ab之间可以有多少个字符可以匹配a.{1，5}b        指的是ab之间可以匹配1-5个字符a.{1，}b     任意多次a.{，5}b     从0次开始    如果不加. 就会重复a[]  字符范围，元字符在中括号里不起任何作用，除了-(范围),^(非),\（转义）a[bc]d  可以匹配acd、abd[a-z]   可以匹配a-z[a-z]+  可以匹配个a-z[^f]    可以比配不是f的任意一个字符，相当于否定|       或者    C|cat  匹配是C或者Cat    (C|c)at 匹配是Cat或者cat   ()      分组        a（ab）*c 可以匹配a和c之间出现任意一次ab

\   第一个功能是转译，跟后面字幕实现特殊功能\d  匹配任何十进制数(后面是相当于)        [0-9]\D  匹配任意非数字字符：              [^0-9]\s  匹配任何空白字符                    [\t\n\r\f\v]\S  匹配任何非空白字符                   [^\t\n\r\f\v]\w  匹配任何字母数字字符              [a-zA-Z0-9_]\W  匹配任何非字母数字字符             [a-zA-Z0-9_]\b  匹配一个单词（连续字幕、数字、下划线组成的字符串）边界，以空格、非字幕数字都可以匹配

#IP：    ^(25[0-5]|2[0-4]\d|[0-1]?\d?\d)(\.(25[0-5]|2[0-4]\d|[0-1]?\d?\d)){3}$#手机号：    ^1[3|4|5|8][0-9]\d{8}$#邮箱：    [a-zA-Z0-9_-]+@[a-zA-Z0-9_-]+(\.[a-zA-Z0-9_-]+)+

configparser模块：
用于处理特定格式的文件，其本质上是利用open来操作文件。

只支持以下两种注释方法：# 注释1; 注释2[section1] # 节点k1 = v1    # 值k2:v2       # 值[section2] # 节点k1 = v1    # 值

1、获取所有节点

import configparserconfig = configparser.ConfigParser()config.read('xxxooo', encoding='utf-8')ret = config.sections()print(ret)

2、获取指定节点下所有的键值对

import configparserconfig = configparser.ConfigParser()config.read('xxxooo', encoding='utf-8')ret = config.items('section1')print(ret)

3、获取指定节点下所有的键

import configparserconfig = configparser.ConfigParser()config.read('xxxooo', encoding='utf-8')ret = config.options('section1')print(ret)

4、获取指定节点下指定key的值

import configparserconfig = configparser.ConfigParser()config.read('xxxooo', encoding='utf-8') v = config.get('section1', 'k1')# v = config.getint('section1', 'k1')       #可以将数值转换成int# v = config.getfloat('section1', 'k1')# v = config.getboolean('section1', 'k1')print(v)

5、检查、删除、添加节点

import configparserconfig = configparser.ConfigParser()config.read('xxxooo', encoding='utf-8')# 检查has_sec = config.has_section('section1')print(has_sec)      #返回Ture和False# 添加节点config.add_section("SEC_1")config.write(open('xxxooo', 'w'))# 删除节点config.remove_section("SEC_1")config.write(open('xxxooo', 'w'))

6、检查、删除、设置指定组内的键值对

import configparserconfig = configparser.ConfigParser()config.read('xxxooo', encoding='utf-8')# 检查has_opt = config.has_option('section1', 'k1')print(has_opt)# 删除config.remove_option('section1', 'k1')config.write(open('xxxooo', 'w'))# 设置config.set('section1', 'k10', "123")config.write(open('xxxooo', 'w'))

XML模块：

引用模块：from xml.etree import ElementTree as ET

1 解析XML：

#利用ElementTree.XML将字符串解析成xml对象from xml.etree import ElementTree as ET# 打开文件，读取XML内容str_xml = open('xo.xml', 'r').read()# 将字符串解析成xml特殊对象，root代指xml文件的根节点root = ET.XML(str_xml)#利用ElementTree.parse将文件直接解析成xml对象:from xml.etree import ElementTree as ET# 直接解析xml文件tree = ET.parse("xo.xml")# 获取xml文件的根节点root = tree.getroot()

2、操作XML ：
XML格式类型是节点嵌套节点，对于每一个节点均有以下功能，以便对当前节点进行操作

Example form:<tag attrib>text</tag>salf    相当于Element的节点(node)名称tag     标签attrib  属性text    文本salf.tag,salf.attrib,salf.text

def makeelement(self, tag, attrib): #创建一个新节点def copy(self):                     #同列表复制def append(self, subelement):       #为当前节点追加一个子节点def extend(self, elements):         #为当前节点扩展 n 个子节点def insert(self, index, subelement):#在当前节点的子节点中插入某个节点，即：为当前节点创建子节点，然后插入指定位置def remove(self, subelement):#在当前节点在子节点中删除某个节点def getchildren(self):#获取所有的子节点（废弃）def find(self, path, namespaces=None):#获取第一个寻找到的子节点def findtext(self, path, default=None, namespaces=None):#获取第一个寻找到的子节点的内容def findall(self, path, namespaces=None):#获取所有的子节点def iterfind(self, path, namespaces=None):#获取所有指定的节点，并创建一个迭代器（可以被for循环）def clear(self):#清空节点def get(self, key, default=None):#获取当前节点的属性值def set(self, key, value):#为当前节点设置属性值def keys(self):#获取当前节点的所有属性的 keydef items(self):#获取当前节点的所有属性值，每个属性都是一个键值对def iter(self, tag=None):#在当前节点的子孙中根据节点名称寻找所有指定的节点，并返回一个迭代器（可以被for循环）。def itertext(self):#在当前节点的子孙中根据节点名称寻找所有指定的节点的内容，并返回一个迭代器（可以被for循环）。 

由于 每个节点 都具有以上的方法，并且在上一步骤中解析时均得到了root（xml文件的根节点），so 可以利用以上方法进行操作xml文件

a. 遍历XML文档的所有内容

############ 解析方式一 ############# 打开文件，读取XML内容str_xml = open('xo.xml', 'r').read()# 将字符串解析成xml特殊对象，root代指xml文件的根节点root = ET.XML(str_xml)############ 解析方式二 ############# 直接解析xml文件tree = ET.parse("xo.xml")# 获取xml文件的根节点root = tree.getroot()### 操作# 顶层标签print(root.tag)# 遍历XML文档的第二层for child in root:    # 第二层节点的标签名称和标签属性    print(child.tag, child.attrib)    # 遍历XML文档的第三层    for i in child:        # 第二层节点的标签名称和内容        print(i.tag,i.text)

b、遍历XML中指定的节点

rom xml.etree import ElementTree as ET############ 解析方式一 ############"""# 打开文件，读取XML内容str_xml = open('xo.xml', 'r').read()# 将字符串解析成xml特殊对象，root代指xml文件的根节点root = ET.XML(str_xml)"""############ 解析方式二 ############# 直接解析xml文件tree = ET.parse("xo.xml")# 获取xml文件的根节点root = tree.getroot()### 操作# 顶层标签print(root.tag)# 遍历XML中所有的year节点for node in root.iter('year'):# 节点的标签名称和内容print(node.tag, node.text)

c、修改节点内容
由于修改的节点时，均是在内存中进行，其不会影响文件中的内容。所以，如果想要修改，则需要重新将内存中的内容写到文件。

#解析字符串方式，修改，保存from xml.etree import ElementTree as ET############ 解析方式一 ############     # 打开文件，读取XML内容str_xml = open('xo.xml', 'r').read()# 将字符串解析成xml特殊对象，root代指xml文件的根节点root = ET.XML(str_xml)############ 操作 ############# 顶层标签print(root.tag)# 循环所有的year节点for node in root.iter('year'):# 将year节点中的内容自增一new_year = int(node.text) + 1node.text = str(new_year)# 设置属性node.set('name', 'alex')node.set('age', '18')# 删除属性del node.attrib['name']############ 保存文件 ############tree = ET.ElementTree(root)tree.write("newnew.xml", encoding='utf-8')

#解析文件方式，修改，保存from xml.etree import ElementTree as ET############ 解析方式二 ############ # 直接解析xml文件tree = ET.parse("xo.xml")# 获取xml文件的根节点root = tree.getroot()############ 操作 ############# 顶层标签print(root.tag)# 循环所有的year节点for node in root.iter('year'):    # 将year节点中的内容自增一    new_year = int(node.text) + 1    node.text = str(new_year)    # 设置属性    node.set('name', 'alex')    node.set('age', '18')    # 删除属性    del node.attrib['name']############ 保存文件 ############tree.write("newnew.xml", encoding='utf-8')

d、删除节点

#解析字符串方式打开，删除，保存from xml.etree import ElementTree as ET############ 解析字符串方式打开 ############# 打开文件，读取XML内容str_xml = open('xo.xml', 'r').read()# 将字符串解析成xml特殊对象，root代指xml文件的根节点root = ET.XML(str_xml)############ 操作 ############# 顶层标签print(root.tag)# 遍历data下的所有country节点for country in root.findall('country'):    # 获取每一个country节点下rank节点的内容    rank = int(country.find('rank').text)    if rank > 50:        # 删除指定country节点        root.remove(country)############ 保存文件 ############tree = ET.ElementTree(root)tree.write("newnew.xml", encoding='utf-8')

#解析文件方式打开，删除，保存from xml.etree import ElementTree as ET############ 解析文件方式 ############# 直接解析xml文件tree = ET.parse("xo.xml")# 获取xml文件的根节点root = tree.getroot()############ 操作 ############# 顶层标签print(root.tag)# 遍历data下的所有country节点for country in root.findall('country'):    # 获取每一个country节点下rank节点的内容    rank = int(country.find('rank').text)    if rank > 50:        # 删除指定country节点        root.remove(country)############ 保存文件 ############tree.write("newnew.xml", encoding='utf-8')

3、创建XML文档：

#第一种 基础from xml.etree import ElementTree as ET# 创建根节点root = ET.Element("famliy")# 创建节点大儿子son1 = ET.Element('son', {'name': '儿1'})# 创建小儿子son2 = ET.Element('son', {"name": '儿2'})# 在大儿子中创建两个孙子grandson1 = ET.Element('grandson', {'name': '儿11'})grandson2 = ET.Element('grandson', {'name': '儿12'})son1.append(grandson1)son1.append(grandson2)# 把儿子添加到根节点中root.append(son1)root.append(son1)tree = ET.ElementTree(root)tree.write('oooo.xml',encoding='utf-8', short_empty_elements=False)

#第二种 使用makeelementfrom xml.etree import ElementTree as ET# 创建根节点root = ET.Element("famliy")# 创建大儿子# son1 = ET.Element('son', {'name': '儿1'})son1 = root.makeelement('son', {'name': '儿1'})# 创建小儿子# son2 = ET.Element('son', {"name": '儿2'})son2 = root.makeelement('son', {"name": '儿2'})# 在大儿子中创建两个孙子# grandson1 = ET.Element('grandson', {'name': '儿11'})grandson1 = son1.makeelement('grandson', {'name': '儿11'})# grandson2 = ET.Element('grandson', {'name': '儿12'})grandson2 = son1.makeelement('grandson', {'name': '儿12'})son1.append(grandson1)son1.append(grandson2)# 把儿子添加到根节点中root.append(son1)root.append(son1)tree = ET.ElementTree(root)tree.write('oooo.xml',encoding='utf-8', short_empty_elements=False)

#第三种 使用SubElementfrom xml.etree import ElementTree as ET# 创建根节点root = ET.Element("famliy")# 创建节点大儿子son1 = ET.SubElement(root, "son", attrib={'name': '儿1'})# 创建小儿子son2 = ET.SubElement(root, "son", attrib={"name": "儿2"})# 在大儿子中创建一个孙子grandson1 = ET.SubElement(son1, "age", attrib={'name': '儿11'})grandson1.text = '孙子'et = ET.ElementTree(root)  #生成文档对象et.write("test.xml", encoding="utf-8", xml_declaration=True, short_empty_elements=False)

4、创建XML带有缩进：
由于原生保存的XML时默认无缩进，如果想要设置缩进的话， 需要修改保存方式

rom xml.etree import ElementTree as ETfrom xml.dom import minidomdef prettify(elem):    #将节点转换成字符串，并添加缩进。    rough_string = ET.tostring(elem, 'utf-8')    reparsed = minidom.parseString(rough_string)    return reparsed.toprettyxml(indent="\t")# 创建根节点root = ET.Element("famliy")# 创建大儿子# son1 = ET.Element('son', {'name': '儿1'})son1 = root.makeelement('son', {'name': '儿1'})# 创建小儿子# son2 = ET.Element('son', {"name": '儿2'})son2 = root.makeelement('son', {"name": '儿2'})# 在大儿子中创建两个孙子# grandson1 = ET.Element('grandson', {'name': '儿11'})grandson1 = son1.makeelement('grandson', {'name': '儿11'})# grandson2 = ET.Element('grandson', {'name': '儿12'})grandson2 = son1.makeelement('grandson', {'name': '儿12'})son1.append(grandson1)son1.append(grandson2)# 把儿子添加到根节点中root.append(son1)root.append(son1)raw_str = prettify(root)f = open("xxxoo.xml",'w',encoding='utf-8')f.write(raw_str)f.close()

5、其他技巧
tree.write 增加参数，xml_declaration=True 即可输出带有头部标识的xml

shutil模块：
高级的 文件、文件夹、压缩包 处理模块

shutil.copyfileobj(fsrc, fdst[, length])        #将文件内容拷贝到另一个文件中    shutil.copyfileobj(open('old.xml','r'), open('new.xml', 'w'))shutil.copyfile(src, dst)                       #拷贝文件    shutil.copyfile('f1.log', 'f2.log')shutil.copymode(src, dst)                       #仅拷贝权限。内容、组、用户均不变    shutil.copymode('f1.log', 'f2.log')shutil.copystat(src, dst)                       #仅拷贝状态的信息，包括：mode bits, atime, mtime, flags    shutil.copy2('f1.log', 'f2.log')shutil.ignore_patterns(*patterns)shutil.copytree(src, dst, symlinks=False, ignore=None)  #递归的去拷贝文件夹    shutil.copytree('folder1', 'folder2', ignore=shutil.ignore_patterns('*.pyc', 'tmp*'))shutil.rmtree(path[, ignore_errors[, onerror]])         #递归的去删除文件    shutil.rmtree('folder1')shutil.move(src, dst)                           #递归的去移动文件，它类似mv命令，其实就是重命名。    shutil.move('folder1', 'folder3')shutil.make_archive(base_name, format,...)    创建压缩包并返回文件路径，例如：zip、tar        base_name： 压缩包的文件名，也可以是压缩包的路径。只是文件名时，则保存至当前目录，否则保存至指定路径，        如：www                        =>保存至当前路径        如：/Users/wupeiqi/www =>保存至/Users/wupeiqi/        format： 压缩包种类，“zip”, “tar”, “bztar”，“gztar”        root_dir：   要压缩的文件夹路径（默认当前目录）        owner：  用户，默认当前用户        group：  组，默认当前组        logger： 用于记录日志，通常是logging.Logger对象        zip压缩            import zipfile            # 压缩            z = zipfile.ZipFile('laxi.zip', 'w')            z.write('a.log')            z.write('data.data')            z.close()            # 解压            z = zipfile.ZipFile('laxi.zip', 'r')            z.extractall()            z.close()        tar压缩            import tarfile            # 压缩            tar = tarfile.open('your.tar','w')            tar.add('/Users/wupeiqi/PycharmProjects/bbs2.log', arcname='bbs2.log')            tar.add('/Users/wupeiqi/PycharmProjects/cmdb.log', arcname='cmdb.log')            tar.close()            # 解压            tar = tarfile.open('your.tar','r')            tar.extractall()  # 可设置解压地址            tar.close()

系统命令：subprocess模块

call        #执行命令，返回状态码    ret = subprocess.call(["ls", "-l"], shell=False)    ret = subprocess.call("ls -l", shell=True)check_call  #执行命令，如果执行状态码是 0 ，则返回0，否则抛异常    subprocess.check_call(["ls", "-l"])    subprocess.check_call("exit 1", shell=True)check_output    #执行命令，如果状态码是 0 ，则返回执行结果，否则抛异常    subprocess.check_output(["echo", "Hello World!"])    subprocess.check_output("exit 1", shell=True)

subprocess.Popen(...)   #用于执行复杂的系统命令（不常用）    args：shell命令，可以是字符串或者序列类型（如：list，元组）    bufsize：指定缓冲。0 无缓冲,1 行缓冲,其他 缓冲区大小,负值 系统缓冲    stdin, stdout, stderr：分别表示程序的标准输入、输出、错误句柄    preexec_fn：只在Unix平台下有效，用于指定一个可执行对象（callable object），它将在子进程运行之前被调用    close_sfs：在windows平台下，如果close_fds被设置为True，则新创建的子进程将不会继承父进程的输入、输出、错误管道。所以不能将close_fds设置为True同时重定向子进程的标准输入、输出与错误(stdin, stdout, stderr)。    shell：同上    cwd：用于设置子进程的当前目录    env：用于指定子进程的环境变量。如果env = None，子进程的环境变量将从父进程中继承。    universal_newlines：不同系统的换行符不同，True -> 同意使用 \n    startupinfo与createionflags只在windows下有效    将被传递给底层的CreateProcess()函数，用于设置子进程的一些属性，如：主窗口的外观，进程的优先级等等 

执行普通命令：

import subprocess            ret1 = subprocess.Popen(["mkdir","t1"])            ret2 = subprocess.Popen("mkdir t2", shell=True)

终端输入的命令分为两种：
输入即可得到输出，如：ifconfig
输入进行某环境，依赖再输入，如：python #交互式

#第一段import subprocessobj = subprocess.Popen("mkdir t3", shell=True, cwd='/home/dev',)#第二段import subprocessobj = subprocess.Popen(["python"], stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE, universal_newlines=True)obj.stdin.write("print(1)\n")obj.stdin.write("print(2)")obj.stdin.close()cmd_out = obj.stdout.read()obj.stdout.close()cmd_error = obj.stderr.read()obj.stderr.close()print(cmd_out)print(cmd_error)#第三段import subprocessobj = subprocess.Popen(["python"], stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE, universal_newlines=True)obj.stdin.write("print(1)\n")obj.stdin.write("print(2)")out_error_list = obj.communicate()      #相当于第二段代码的  cmd_out = obj.stdout.read()及往下四行print(out_error_list)#第四段import subprocessobj = subprocess.Popen(["python"], stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE, universal_newlines=True)out_error_list = obj.communicate('print("hello")')  #简单的交互式命令print(out_error_list)