Python（经常使用模块）

时间 2019-11-19

标签 python 经常使用模块栏目 Python 繁體版

原文原文链接

模块

模块本质上就是一个.py文件html

内置模块（解释器层面）
第三方模块（Python lib文件）
自定义模块（当前路径）
- 模块调用，包的概念

在计算机程序的开发过程当中，随着程序代码越写越多，在一个文件里代码就会愈来愈长，愈来愈不容易维护。python

为了编写可维护的代码，咱们把不少函数分组，分别放到不一样的文件里，这样，每一个文件包含的代码就相对较少，不少编程语言都采用这种组织代码的方式。在Python中，一个.py文件就称之为一个模块（Module）。linux

使用模块有什么好处？web

最大的好处是大大提升了代码的可维护性。其次，编写代码没必要从零开始。当一个模块编写完毕，就能够被其余地方引用。咱们在编写程序的时候，也常常引用其余模块，包括Python内置的模块和来自第三方的模块。算法

使用模块还能够避免函数名和变量名冲突。相同名字的函数和变量彻底能够分别存在不一样的模块中，所以，咱们本身在编写模块时，没必要考虑名字会与其余模块冲突。可是也要注意，尽可能不要与内置函数名字冲突。点这里查看Python的全部内置函数。shell

你也许还想到，若是不一样的人编写的模块名相同怎么办？为了不模块名冲突，Python又引入了按目录来组织模块的方法，称为包（Package）。数据库

举个例子，一个abc.py的文件就是一个名字叫abc的模块，一个xyz.py的文件就是一个名字叫xyz的模块。编程

如今，假设咱们的abc和xyz这两个模块名字与其余模块冲突了，因而咱们能够经过包来组织模块，避免冲突。方法是选择一个顶层包名，好比mycompany，按照以下目录存放：json

引入了包之后，只要顶层的包名不与别人冲突，那全部模块都不会与别人冲突。如今，abc.py模块的名字就变成了mycompany.abc，相似的，xyz.py的模块名变成了mycompany.xyz。windows

请注意，每个包目录下面都会有一个__init__.py的文件，这个文件是必须存在的，不然，Python就把这个目录当成普通目录，而不是一个包。__init__.py能够是空文件，也能够有Python代码，由于__init__.py自己就是一个模块，而它的模块名就是mycompany。

相似的，能够有多级目录，组成多级层次的包结构。好比以下的目录结构：

文件www.py的模块名就是mycompany.web.www，两个文件utils.py的模块名分别是mycompany.utils和mycompany.web.utils。

本身建立模块时要注意命名，不能和Python自带的模块名称冲突。例如，系统自带了sys模块，本身的模块就不可命名为sys.py，不然将没法导入系统自带的sys模块。

mycompany.web也是一个模块，请指出该模块对应的.py文件。

一 time模块

时间表示形式

数据类型：数字（int、float）、数据结构（list……）、字符串、bool、时间。

在Python中，一般有这三种方式来表示时间：时间戳、元组(struct_time)、格式化的时间字符串：
(1)时间戳(timestamp) ：一般来讲，时间戳表示的是从1970年1月1日00:00:00开始按秒计算的偏移量。咱们运行“type(time.time())”，返回的是float类型。

(2)格式化的时间字符串(Format String)： ‘1988-03-16’

(3)元组(struct_time) ：struct_time元组共有9个元素共九个元素:(年，月，日，时，分，秒，一年中第几周，一年中第几天等）

# <1> 时间戳

>>> import time
>>> time.time()      #--------------返回当前时间的时间戳（float）

1493136727.099066

# <2> 时间字符串          #-------------------给人看的

>>> time.strftime("%Y-%m-%d %X")
'2017-04-26 00:32:18'

# <3> 时间元组 ----------------能够方便的取出各个时间元素

>>> time.localtime()      #------------------结构化的时间（元组）（当地时间） .tm_year能够单独打印出年份（以时间戳为参数，不加的话默认为当前时间戳，更多转换方式见图）
time.struct_time(tm_year=2017, tm_mon=4, tm_mday=26,
                 tm_hour=0, tm_min=32, tm_sec=42, tm_wday=2,
                 tm_yday=116, tm_isdst=0)
time.gmtime()                   #------结构化时间对象（格林尼治标准时间）

小结：时间戳是计算机可以识别的时间；时间字符串是人可以看懂的时间；元组则是用来操做时间的

几种时间形式的转换

(1)

#一 时间戳<－－－－>结构化时间：  localtime/gmtime   mktime

>>> time.localtime(3600*24)
>>> time.gmtime(3600*24)

>>> time.mktime(time.localtime())


#字符串时间<－－－－>结构化时间： strftime／strptime

>>> time.strftime("%Y-%m-%d %X", time.localtime())
>>> time.strptime("2017-03-16","%Y-%m-%d")

(2)

>>> time.asctime(time.localtime(312343423))
'Sun Nov 25 10:03:43 1979'
>>> time.ctime(312343423)
'Sun Nov 25 10:03:43 1979'

1 #--------------------------其余方法
2 # sleep(secs)    #------------------time.sleep()  I/O阻塞，（相似于input）不占cpu
3 # 线程推迟指定的时间运行，单位为秒。

    %Y  Year with century as a decimal number.
    %m  Month as a decimal number [01,12].
    %d  Day of the month as a decimal number [01,31].
    %H  Hour (24-hour clock) as a decimal number [00,23].
    %M  Minute as a decimal number [00,59].
    %S  Second as a decimal number [00,61].
    %z  Time zone offset from UTC.
    %a  Locale's abbreviated weekday name.
    %A  Locale's full weekday name.
    %b  Locale's abbreviated month name.
    %B  Locale's full month name.
    %c  Locale's appropriate date and time representation.
    %I  Hour (12-hour clock) as a decimal number [01,12].
    %p  Locale's equivalent of either AM or PM.

View Code

二 random模块

>>> import random
>>> random.random()      # 大于0且小于1之间的小数
0.7664338663654585

>>> random.randint(1,5)  # 大于等于1且小于等于5之间的整数
2

>>> random.randrange(1,3) # 大于等于1且小于3之间的整数
1

>>> random.choice([1,'23',[4,5]])  # #1或者23或者[4,5]
1

>>> random.sample([1,'23',[4,5]],2) # #列表元素任意2个组合
[[4, 5], '23']

>>> random.uniform(1,3) #大于1小于3的小数
1.6270147180533838

>>> item=[1,3,5,7,9]
>>> random.shuffle(item) # 打乱次序
>>> item
[5, 1, 3, 7, 9]
>>> random.shuffle(item)
>>> item
[5, 9, 7, 1, 3]

练习：生成验证码

import random

def v_code():

    code = ''
    for i in range(5):

        num=random.randint(0,9)
        alf=chr(random.randint(65,90))
        add=random.choice([num,alf])
        code="".join([code,str(add)])

    return code

print(v_code())

View Code

三 hashlib

3.1 算法介绍

Python的hashlib提供了常见的摘要算法，如MD5，SHA1等等。

什么是摘要算法呢？摘要算法又称哈希算法、散列算法。它经过一个函数，把任意长度的数据转换为一个长度固定的数据串（一般用16进制的字符串表示）。

摘要算法就是经过摘要函数f()对任意长度的数据data计算出固定长度的摘要digest，目的是为了发现原始数据是否被人篡改过。

摘要算法之因此能指出数据是否被篡改过，就是由于摘要函数是一个单向函数，计算f(data)很容易，但经过digest反推data却很是困难。并且，对原始数据作一个bit的修改，都会致使计算出的摘要彻底不一样。

咱们以常见的摘要算法MD5为例，计算出一个字符串的MD5值：

import hashlib
 
md5 = hashlib.md5()
md5.update(b'how to use md5 in python hashlib?')
print (md5.hexdigest())

计算结果以下：
d26a53750bc40b38b65a520292f69306

若是数据量很大，能够分块屡次调用update()，最后计算的结果是同样的：

md5 = hashlib.md5()
md5.update(b'how to use md5 in ')
md5.update(b'python hashlib?')
print (md5.hexdigest())

MD5是最多见的摘要算法，速度很快，生成结果是固定的128 bit字节，一般用一个32位的16进制字符串表示。另外一种常见的摘要算法是SHA1，调用SHA1和调用MD5彻底相似：

import hashlib
 
sha1 = hashlib.sha1()
sha1.update(b'how to use sha1 in ')
sha1.update(b'python hashlib?')
print (sha1.hexdigest())

SHA1的结果是160 bit字节，一般用一个40位的16进制字符串表示。比SHA1更安全的算法是SHA256和SHA512，不过越安全的算法越慢，并且摘要长度更长。

3.2 摘要算法应用

任何容许用户登陆的网站都会存储用户登陆的用户名和口令。如何存储用户名和口令呢？方法是存到数据库表中：

name    | password
--------+----------
michael | 123456
bob     | abc999
alice   | alice2008

View Code

若是以明文保存用户口令，若是数据库泄露，全部用户的口令就落入黑客的手里。此外，网站运维人员是能够访问数据库的，也就是能获取到全部用户的口令。正确的保存口令的方式是不存储用户的明文口令，而是存储用户口令的摘要，好比MD5：

username | password
---------+---------------------------------
michael  | e10adc3949ba59abbe56e057f20f883e
bob      | 878ef96e86145580c38c87f0410ad153
alice    | 99b1c2188db85afee403b1536010c2c9

View Code

考虑这么个状况，不少用户喜欢用123456，888888，password这些简单的口令，因而，黑客能够事先计算出这些经常使用口令的MD5值，获得一个反推表：

'e10adc3949ba59abbe56e057f20f883e': '123456'
'21218cca77804d2ba1922c33e0151105': '888888'
'5f4dcc3b5aa765d61d8327deb882cf99': 'password'

View Code

这样，无需破解，只须要对比数据库的MD5，黑客就得到了使用经常使用口令的用户帐号。

对于用户来说，固然不要使用过于简单的口令。可是，咱们可否在程序设计上对简单口令增强保护呢？

因为经常使用口令的MD5值很容易被计算出来，因此，要确保存储的用户口令不是那些已经被计算出来的经常使用口令的MD5，这一方法经过对原始口令加一个复杂字符串来实现，俗称“加盐”：

hashlib.md5("salt".encode("utf8"))

通过Salt处理的MD5口令，只要Salt不被黑客知道，即便用户输入简单口令，也很难经过MD5反推明文口令。

可是若是有两个用户都使用了相同的简单口令好比123456，在数据库中，将存储两条相同的MD5值，这说明这两个用户的口令是同样的。有没有办法让使用相同口令的用户存储不一样的MD5呢？

若是假定用户没法修改登陆名，就能够经过把登陆名做为Salt的一部分来计算MD5，从而实现相同口令的用户也存储不一样的MD5。

摘要算法在不少地方都有普遍的应用。要注意摘要算法不是加密算法，不能用于加密（由于没法经过摘要反推明文），只能用于防篡改，可是它的单向计算特性决定了能够在不存储明文口令的状况下验证用户口令。

四 os模块

os模块是与操做系统交互的一个接口（os 操做系统（operate system）调用硬件）

'''
os.getcwd() 获取当前工做目录，即当前python脚本工做的目录路径
os.chdir("dirname")  改变当前脚本工做目录；至关于shell下cd
os.curdir  返回当前目录: ('.')
os.pardir  获取当前目录的父目录字符串名：('..')
os.makedirs('dirname1/dirname2')    可生成多层递归目录
os.removedirs('dirname1')    若目录为空，则删除，并递归到上一级目录，如若也为空，则删除，依此类推
os.mkdir('dirname')    生成单级目录；至关于shell中mkdir dirname
os.rmdir('dirname')    删除单级空目录，若目录不为空则没法删除，报错；至关于shell中rmdir dirname
os.listdir('dirname')    列出指定目录下的全部文件和子目录，包括隐藏文件，并以列表方式打印
os.remove()  删除一个文件
os.rename("oldname","newname")  重命名文件/目录
os.stat('path/filename')  获取文件/目录信息
os.sep    输出操做系统特定的路径分隔符，win下为"\\",Linux下为"/"
os.linesep    输出当前平台使用的行终止符，win下为"\t\n",Linux下为"\n"
os.pathsep    输出用于分割文件路径的字符串 win下为;,Linux下为:
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不存在，返回False
os.path.isabs(path)  若是path是绝对路径，返回True
os.path.isfile(path)  若是path是一个存在的文件，返回True。不然返回False
os.path.isdir(path)  若是path是一个存在的目录，则返回True。不然返回False
os.path.join(path1[, path2[, ...]])  将多个路径组合后返回，第一个绝对路径以前的参数将被忽略
os.path.getatime(path)  返回path所指向的文件或者目录的最后存取时间（access time）
os.path.getmtime(path)  返回path所指向的文件或者目录的最后修改时间（modify time）
os.path.getsize(path) 返回path的大小
'''

五 sys模块

sys.argv           命令行参数List，第一个元素是程序自己路径-----------（不跟括号）

import sys
ret=sys.argv
if ret[ret.index('-u')+1]=='egon' and ret[ret.index('-p')+1]=='666':
    print('login successful')

print(ret)
'''
在cmd中执行，能够直接Python  文件  用户名  密码  来登陆
'''

sys.exit(n)        退出程序，正常退出时exit(0)-------------退出程序
sys.version        获取Python解释程序的版本信息
sys.maxint         最大的Int值
sys.path           返回模块的搜索路径，初始化时使用PYTHONPATH环境变量的值

'''
path
模块搜索路径，添加执行路径到最开头后再返回（pycharm还会添加执行路径的父路径）
[执行文件所在目录]，[Python环境]
添加环境变量：sys.path.append(路径）
'''

sys.platform       返回操做系统平台名称

六 logging模块

6.1 函数式简单配置

import logging  
logging.debug('debug message')  
logging.info('info message')  
logging.warning('warning message')  
logging.error('error message')  
logging.critical('critical message')

默认状况下Python的logging模块将日志打印到了标准输出中，且只显示了大于等于WARNING级别的日志，这说明默认的日志级别设置为WARNING（日志级别等级CRITICAL > ERROR > WARNING > INFO > DEBUG），默认的日志格式为日志级别：Logger名称：用户输出消息。

灵活配置日志级别，日志格式，输出位置:

import logging  
logging.basicConfig(level=logging.DEBUG,  
                    format='%(asctime)s %(filename)s[line:%(lineno)d] %(levelname)s %(message)s',  
                    datefmt='%a, %d %b %Y %H:%M:%S',  
                    filename='/tmp/test.log',  
                    filemode='w')  
  
logging.debug('debug message')  
logging.info('info message')  
logging.warning('warning message')  
logging.error('error message')  
logging.critical('critical message')

配置参数：

logging.basicConfig()函数中可经过具体参数来更改logging模块默认行为，可用参数有：

filename：用指定的文件名建立FiledHandler，这样日志会被存储在指定的文件中。
filemode：文件打开方式，在指定了filename时使用这个参数，默认值为“a”还可指定为“w”。
format：指定handler使用的日志显示格式。
datefmt：指定日期时间格式。
level：设置rootlogger（后边会讲解具体概念）的日志级别
stream：用指定的stream建立StreamHandler。能够指定输出到sys.stderr,sys.stdout或者文件(f=open(‘test.log’,’w’))，默认为sys.stderr。若同时列出了filename和stream两个参数，则stream参数会被忽略。

format参数中可能用到的格式化串：
%(name)s Logger的名字
%(levelno)s 数字形式的日志级别
%(levelname)s 文本形式的日志级别
%(pathname)s 调用日志输出函数的模块的完整路径名，可能没有
%(filename)s 调用日志输出函数的模块的文件名
%(module)s 调用日志输出函数的模块名
%(funcName)s 调用日志输出函数的函数名
%(lineno)d 调用日志输出函数的语句所在的代码行
%(created)f 当前时间，用UNIX标准的表示时间的浮 点数表示
%(relativeCreated)d 输出日志信息时的，自Logger建立以 来的毫秒数
%(asctime)s 字符串形式的当前时间。默认格式是 “2003-07-08 16:49:45,896”。逗号后面的是毫秒
%(thread)d 线程ID。可能没有
%(threadName)s 线程名。可能没有
%(process)d 进程ID。可能没有
%(message)s用户输出的消息

View Code

6.2 logger对象配置

import logging

logger = logging.getLogger()
# 建立一个handler，用于写入日志文件
fh = logging.FileHandler('test.log')

# 再建立一个handler，用于输出到控制台
ch = logging.StreamHandler()

formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')

fh.setFormatter(formatter)
ch.setFormatter(formatter)

logger.addHandler(fh) #logger对象能够添加多个fh和ch对象
logger.addHandler(ch)

logger.debug('logger debug message')
logger.info('logger info message')
logger.warning('logger warning message')
logger.error('logger error message')
logger.critical('logger critical message')

logging库提供了多个组件：Logger、Handler、Filter、Formatter。Logger对象提供应用程序可直接使用的接口，Handler发送日志到适当的目的地，Filter提供了过滤日志信息的方法，Formatter指定日志显示格式。另外，能够经过：logger.setLevel(logging.Debug)设置级别。

import logging
logger=logging.getLogger()
logger.setLevel(logging.INFO)
#---logger,以及级别----------
fh=logging.FileHandler(r'D:\py\empty\test.log')
fh.setLevel(logging.WARNING)         #能够分别设置
ch=logging.StreamHandler()
ch.setLevel(logging.DEBUG)          #没法生效，不能低于logger
#------输出位置，能够多个-------
formater=logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
#------格式-------------------
fh.setFormatter(formater)
ch.setFormatter(formater)
#------分别设定输出格式----------
logger.addHandler(fh)
logger.addHandler(ch)
#---------分别输出-----------------
logging.debug('debug message')
logging.info('info message')
logging.warning('warning message')
logging.error('error message')
logging.critical('critical message')

View Code

七序列化模块

以前咱们学习过用eval内置方法能够将一个字符串转成python对象，不过，eval方法是有局限性的，对于普通的数据类型，json.loads和eval都能用，但遇到特殊类型的时候，eval就无论用了,因此eval的重点仍是一般用来执行一个字符串表达式，并返回表达式的值。

#---转换类型

d={"name":"yuan"}

s=str(d)

print(type(s))

d2=eval(s)

print(d2[1])

with open("test") as f:

    for i in f :

        if type(eval(i.strip()))==dict:
            print(eval(i.strip())[1])
            
# 计算

print(eval("12*7+5-3"))

View Code

什么是序列化？

咱们把对象(变量)从内存中变成可存储或传输的过程称之为序列化，在Python中叫pickling，在其余语言中也被称之为serialization，marshalling，flattening等等，都是一个意思。序列化以后，就能够把序列化后的内容写入磁盘，或者经过网络传输到别的机器上。反过来，把变量内容从序列化的对象从新读到内存里称之为反序列化，即unpickling。

json

若是咱们要在不一样的编程语言之间传递对象，就必须把对象序列化为标准格式，好比XML，但更好的方法是序列化为JSON，由于JSON表示出来就是一个字符串，能够被全部语言读取，也能够方便地存储到磁盘或者经过网络传输。JSON不只是标准格式，而且比XML更快，并且能够直接在Web页面中读取，很是方便。

JSON表示的对象就是标准的JavaScript语言的对象一个子集，JSON和Python内置的数据类型对应以下：

import json
i=10
s='hello'
t=(1,4,6)
l=[3,5,7]
d={'name':"yuan"}

json_str1=json.dumps(i)
json_str2=json.dumps(s)
json_str3=json.dumps(t)
json_str4=json.dumps(l)
json_str5=json.dumps(d)

print(json_str1)   #'10'
print(json_str2)   #'"hello"'
print(json_str3)   #'[1, 4, 6]'
print(json_str4)   #'[3, 5, 7]'
print(json_str5)   #'{"name": "yuan"}'

View Code

python在文本中的使用：

#----------------------------序列化
import json

dic={'name':'alvin','age':23,'sex':'male'}
print(type(dic))#<class 'dict'>

data=json.dumps(dic)
print("type",type(data))#<class 'str'>
print("data",data)


f=open('序列化对象','w')
f.write(data)  #-------------------等价于json.dump(dic,f)
f.close()


#-----------------------------反序列化<br>
import json
f=open('序列化对象')
new_data=json.loads(f.read())#  等价于data=json.load(f)

print(type(new_data))

'''
json.load() = f.read+json.loads()

json.dumps(dic)的简化：json.dump(dic,f)    
'''

pickle

'''
支持Python的全部数据类型，但只支持在两个Python文件之间做用
'''

##----------------------------序列化
import pickle
 
dic={'name':'alvin','age':23,'sex':'male'}
 
print(type(dic))#<class 'dict'>
 
j=pickle.dumps(dic)
print(type(j))#<class 'bytes'>
 
 
f=open('序列化对象_pickle','wb')#注意是w是写入str,wb是写入bytes,j是'bytes'
f.write(j)  #-------------------等价于pickle.dump(dic,f)
 
f.close()
#-------------------------反序列化
import pickle
f=open('序列化对象_pickle','rb')
 
data=pickle.loads(f.read())#  等价于data=pickle.load(f)
 
print(data['age'])

shelve模块

shelve模块比pickle模块简单，只有一个open函数，返回相似字典的对象，可读可写;key必须为字符串，而值能够是python所支持的数据类型

 
         import  
         shelve 
        
         f  
         =  
         shelve. 
         open 
         (r 
         'shelve.txt' 
         ) 
        
         # f['stu1_info']={'name':'alex','age':'18'} 
        
         # f['stu2_info']={'name':'alvin','age':'20'} 
        
         # f['school_info']={'website':'oldboyedu.com','city':'beijing'} 
        
         # 
        
         # 
        
         # f.close() 
        
         print 
         (f.get( 
         'stu_info' 
         )[ 
         'age' 
         ])

configparser模块

该模块适用于配置文件的格式与windows ini文件相似，能够包含一个或多个节（section），每一个节能够有多个参数（键=值）。

建立文件

来看一个好多软件的常见文档格式以下：

[DEFAULT]        #关键字，default 若是有的话存放默认信息，与其余字段区别开，其余字段地位同样，能够根据须要设定。default中的内容，至关于在其余每个字段当中（此例子中的另外两个字段分别有五、6个值）
ServerAliveInterval = 45
Compression = yes
CompressionLevel = 9
ForwardX11 = yes
  
[bitbucket.org]
User = hg
  
[topsecret.server.com]
Port = 50022
ForwardX11 = no

若是想用python生成一个这样的文档怎么作呢？

import configparser

config = configparser.ConfigParser()

config["DEFAULT"] = {'ServerAliveInterval': '45',
                      'Compression': 'yes',
                     'CompressionLevel': '9',
                     'ForwardX11':'yes'
                     }

config['bitbucket.org'] = {'User':'hg'}

config['topsecret.server.com'] = {'Host Port':'50022','ForwardX11':'no'}

with open('example.ini', 'w') as configfile:

   config.write(configfile)

查找文件

import configparser

config = configparser.ConfigParser()

#---------------------------查找文件内容,基于字典的形式

print(config.sections())        #  []

config.read('example.ini')

print(config.sections())        #   ['bitbucket.org', 'topsecret.server.com']

print('bytebong.com' in config) # False
print('bitbucket.org' in config) # True


print(config['bitbucket.org']["user"])  # hg

print(config['DEFAULT']['Compression']) #yes

print(config['topsecret.server.com']['ForwardX11'])  #no


print(config['bitbucket.org'])          #<Section: bitbucket.org>

for key in config['bitbucket.org']:     # 注意,有default会默认default的键
    print(key)

print(config.options('bitbucket.org'))  # 同for循环,找到'bitbucket.org'下全部键

print(config.items('bitbucket.org'))    #找到'bitbucket.org'下全部键值对

print(config.get('bitbucket.org','compression')) # yes       get方法取深层嵌套的值

增删改操做

import configparser

config = configparser.ConfigParser()

config.read('example.ini')

config.add_section('yuan')



config.remove_section('bitbucket.org')
config.remove_option('topsecret.server.com',"forwardx11")


config.set('topsecret.server.com','k1','11111')
config.set('yuan','k2','22222')

config.write(open('new2.ini', "w"))

subprocess模块

当咱们须要调用系统的命令的时候，最早考虑的os模块。用os.system()和os.popen()来进行操做。可是这两个命令过于简单，不能完成一些复杂的操做，如给运行的命令提供输入或者读取命令的输出，判断该命令的运行状态，管理多个命令的并行等等。这时subprocess中的Popen命令就能有效的完成咱们须要的操做。

subprocess模块容许一个进程建立一个新的子进程，经过管道链接到子进程的stdin/stdout/stderr，获取子进程的返回值等操做。

The subprocess module allows you to spawn new processes, connect to their input/output/error pipes, and obtain their return codes.

This module intends to replace several other, older modules and functions, such as: os.system、os.spawn*、os.popen*、popen2.*、commands.*

这个模块只一个类：Popen。

简单命令

import subprocess

#  建立一个新的进程,与主进程不一样步  if in win: s=subprocess.Popen('dir',shell=True)
s=subprocess.Popen('ls')
s.wait()                  # s是Popen的一个实例对象

print('ending...')

命令带参数

linux：

import subprocess

subprocess.Popen('ls -l',shell=True)

#subprocess.Popen(['ls','-l'])

控制子进程

当咱们想要更个性化咱们的需求的时候，就要转向Popen类，该类生成的对象用来表明子进程。刚才咱们使用到了一个wait方法

此外，你还能够在父进程中对子进程进行其它操做：

s.poll() # 检查子进程状态
s.kill() # 终止子进程
s.send_signal() # 向子进程发送信号
s.terminate() # 终止子进程

s.pid:子进程号

子进程的文本流控制

能够在Popen()创建子进程的时候改变标准输入、标准输出和标准错误，并能够利用subprocess.PIPE将多个子进程的输入和输出链接在一块儿，构成管道(pipe)：

import subprocess

# s1 = subprocess.Popen(["ls","-l"], stdout=subprocess.PIPE)
# print(s1.stdout.read())



#s2.communicate()

s1 = subprocess.Popen(["cat","/etc/passwd"], stdout=subprocess.PIPE)
s2 = subprocess.Popen(["grep","0:0"],stdin=s1.stdout, stdout=subprocess.PIPE)
out = s2.communicate()

print(out)

ubprocess.PIPE实际上为文本流提供一个缓存区。s1的stdout将文本输出到缓存区，随后s2的stdin从该PIPE中将文本读取走。s2的输出文本也被存放在PIPE中，直到communicate()方法从PIPE中读取出PIPE中的文本。
注意：communicate()是Popen对象的一个方法，该方法会阻塞父进程，直到子进程完成

快捷API

'''
subprocess.call()

父进程等待子进程完成
返回退出信息(returncode，至关于Linux exit code)


subprocess.check_call()
父进程等待子进程完成
返回0,检查退出信息，若是returncode不为0，则举出错误subprocess.CalledProcessError，该对象包含
有returncode属性，可用try…except…来检查


subprocess.check_output()
父进程等待子进程完成
返回子进程向标准输出的输出结果
检查退出信息，若是returncode不为0，则举出错误subprocess.CalledProcessError，该对象包含
有returncode属性和output属性，output属性为标准输出的输出结果，可用try…except…来检查。


'''

Python（经常使用模块）

模块

一 time模块

时间表示形式

几种时间形式的转换

二 random模块

三 hashlib

3.1 算法介绍

3.2 摘要算法应用

四 os模块

五 sys模块

六 logging模块

6.1 函数式简单配置

6.2 logger对象配置

七 序列化模块

什么是序列化？

json

pickle

shelve模块

configparser模块

建立文件

查找文件

增删改操做

subprocess模块

简单命令

命令带参数

控制子进程

子进程的文本流控制

快捷API

七序列化模块