常用模块

一 time 模块

　　1、time.altzone（）

　　作用：返回与utc（协调时间时，又称时间统一时间，以英国为标准）时间的时间差，以秒计算。

　　2、time.process_time()

　　作用：计算处理器的运算时间，但是不包括sleep时间，sleep只是把程序挂起。

 　  3、time.asctime()

　　作用：返回时间格式 Wed Apr  5 22:45:08 2017

      4、time.localtime()

　　作用：返回本地时间的struct time 对象格式

>>> import time
>>> t = time.localtime()  #返回本地时间的对象，通过对象获取对应的年月日等信息
>>> t
time.struct_time(tm_year=2017, tm_mon=4, tm_mday=20, tm_hour=15, tm_min=41, tm_sec=1, tm_wday=3, tm_yday=110, tm_isdst=0)
>>> t.tm_hour   # 获取小时数
15

　　 5、time.time()

　　 作用：返回当前时间戳，从1970（uinx元年）年开始到目前。1970年1月1日为nuix操作系统的出生日

　　 6、time.gmtime()

　　 作用：返回当前utc时间（伦敦时间），跟北京时间差8个小时。

　　 7、time.strptime("2017-4-5 22:30","%Y-%m-%d %H:%M")

　　 作用：将字符串转换成时间结构体，格式("2017-4-5 22:30","%Y-%m-%d %H:%M")

>>>time.strptime("2017-4-5 22:30","%Y-%m-%d %H:%M")
time.struct_time(tm_year=2017, tm_mon=4, tm_mday=5, tm_hour=22, tm_min=30, tm_sec=0, tm_wday=2, tm_yday=95, tm_isdst=-1)

　　

　　 8、time.mktime

　　作用： 将时间结构体对象（struct_time）转换成时间戳

import time
>>>a = time.strptime("2017-4-5 22:30","%Y-%m-%d %H:%M")
>>>time.mktime(a)
1491402600.0

　　 9、time.strftime

　　作用：将struct_time时间对象转换成时间字符串。

>>>a = time.strptime("2017-4-5 22:30","%Y-%m-%d %H:%M")
>>>m = time.strftime("%Y-%m-%d %H:%M",a)
2017-04-05 22:30

　　它们之间的转换关系如图：

　　

　　时间格式转换关系：

二 datetime 模块

　　1 datetime.datetime.now()

　　作用：显示当前时间 　

import datetime
>>>datetime.datetime.now()
2017-04-20 16:22:24.451419

　　2 datetime.data.fromtimestamp(time.time())

　　作用：时间戳直接转换成日期格式　　

import time,datetime
>>>datetime.date.fromtimestamp(time.time())
2017-04-20

　　3 datetime.datetime.now()+datetime.timedelta(hours = 3)

import datetime
>>>datetime.datetime.now() + datetime.timedelta(days = 3,hours = 4)
2017-04-23 20:31:07.561339

#正常时间是2017-04-20 16:31:07.56133

　　4 datetime.datetime.now.replace(hour = 2,minute = 3)时间替换

import datetime
>>>datetime.datetime.now().replace(hour=2)
2017-04-20 02:33:14.862621

三 random 模块　　

　　1、random.random() 随机0~1之间小数　　

　　2、random.randint(a,b) 随机从a，b选一个数，包括a和b　　

　　3、random.randrange(a,b)或者random.randrange(b) 随机从a，b选一个数，不包括b　　

　　4、random.sample(tuple,x) 从tuple中选出x个元素

       生成由数字和大小写字母组成的4位随机验证码，代码如下：

 

四 string模块　　

　　1、string.ascii_letters

　　作用：返回大小写字母的字符串。注：一般用于验证码

import 
>>>string.ascii_letters
abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ

　　2、string.digits

　　作用：返回数字0-9的字符串

　　3、string.ascii_lowercase 

　　作用：返回小写字母的字符串

import string
>>>string.ascii_lowercase
abcdefghijklmnopqrstuvwxyz

　　4 string.ascii_uppercase

　　作用：返回大写字母的字符串

　　5 string.punctuation

　　作用：以字符串形式返回所有的字符  注：一般用于验证码

import sting
>>>string.punctuation
!"#$%&'()*+,-./:;<=>?@[\]^_`{|}~

五 hashlib 模块

　　用于加密相关的操作，3.x里代替了md5模块和sha模块，主要提供SHA1、SHA224、SHA256、SHA384、SHA512、MD5算法。使用方法都是一样的。

　　MD5加密原则：只要你的输入是固定的，你的输出也一定是固定的。一般用于检测文件的一致性。

import hashlib
m = hashlib.md5()  # 创建hash对象
print(m)         # <md5 HASH object @ 0x0000000000B90A30>
m.update(b"liupeng") #更新哈希对象以字符串参数
print(m.digest()) #返回摘要，作为二进制数据字符串值
print(m.hexdigest()) # 返回十六进制数字字符串
print(m.digest_size) # 产生散列的字节大小
print(m.block_size)

　　常用属性：

　　1 hashlib.algorithms # 列出所有的算法

　　2 h.digest_size #产生的散列的字节大小

　　3 h.block_size 

　　常用方法：

　　1 hash.update(arg) 更新哈希对象以字符串参数，如果同一个hash对象重复调用该方法，则m.update(a);m.update(b) == m.update(a+b)

　　2 hash.digest() 返回摘要，作为二进制数据字符串

　　3 hash.hexdigest() 返回摘要，作为十六进制数据字符串值

　　4 hash.copy() 复制

六 subprocess 模块

　　从python2.4开始，python引入subprocess模块来管理子进程。

　　subprocess不仅可以创建子进程，还提供一些标准流（standard stream）和管道（pipe）的工具,从而在进程间使用文本通信。

　　常用的功能：

　　1、subprocess.call()

　　父进程等待子进程完成，返回退出信息（相当于linux exit code）。如果不需要与子进程通讯就可以使用该函数来创建。

　　2、subprocess.check_call()

　　与subprocess.call()功能一样，只是如果子进程返回的returncode不为0的话，将触发calledprocesserror异常，在异常对象中包括进程的returncode信息。一般用try...except..来检查。

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

　　4、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)

　　对其参数一个个解释：

　　args 字符串或者序列类型（如list、元组），表示要执行的命令和命令的参数;

　　bufsize 指定缓冲

　　executable 用于指定可执行程序，如果将shell 设定为 True,executable 将指定程序使用shell

　　stdin、stdout、stderr分别表示程序的标准输入、输出、错与句柄。他们可以是PIPE，文件描述或文件对象，也可以设置为None,表示从父进程继承。

　　preexec_fn只在Unix平台下有效，用于指定一个可执行对象，它将在子进程运行之前被调用。

　　shell = True,表示你前面的传入的命令将在shell下执行，如果你的命令是个可执行文件或者bat。

　　cwd用于设置子进程的当前目录

　　env 它是字典类型，用于指定子进程的环境变量。如果env = None,子进程的环境变量将从父进程中继承。

　　universal_newlines 不同操作系统下，文本的换行符是不一样的。如在windows下，用'/r/n' 表示换行，而在linux下用'/n'.如果将此参数设置为True,python统一把这些换行符当做为'/n'

　　startupinfo 与createionflags 只在windows下有小，他们将被传递给底层的creteprocess()函数，用于设置子进程的一些属性，如：主窗口的外观、进程的优先级等等、

　　Popen对象创建后，主程序不会自动等待子进程完成。必须调用对象的wait()方法，父进程才会等待（也就是阻塞block）,举个例子来说说：

>>> import subprocess
>>> child = subprocess.Popen('ping -c 4n www.baidu.com',shell =True)
>>> child.wait()
>>> print 'parent process'

　　从运行结果中看，父进程在开启子进程之后等待child的完成，再运行print。如果没有wait()就会，直接运行print.

　　此外，还能在父进程中对子进程进行操作，如:

　　a、child.poll() 检查子进程状态，设置并返回returncode 属性

　　b、child.kill() 、child.terminate() 终止子进程

      c、child.send_signal() 向子进程发送信号

　　d、child.communicate 可以与新进程交互，向stdin发送数据，或从stdout和stderr中读取数据。可选参数input指定发送到子进程的参数。

　　　　communicate()返回一个元组：（stdoutdata,stderrdata）。注意:如果希望通过进程的stdin向其发送数据，在创建Popen对象的时候

　　　　参数stin必须被设置为PIPE。同样，如果希望从stdout和stderr获取数据，必须将stdout和stderr设置为PIPE

>>> import subprocess
>>> child1 = subprocess.Popen(["cat","/etc/passwd"], stdout=subprocess.PIPE)
>>> child2 = subprocess.Popen(["grep","0:0"],stdin=child1.stdout, stdout=subprocess.PIPE)
>>> out = child2.communicate()

#输出
('root:x:0:0:root:/root:/bin/bash\n', None)

　　在Popen()建立子进程的时候改变标准输入、标准输出和标准错误，并可以利用subprocess.PIPE将多个子进程的输入和输出连接在一起，构成管道(pipe)。

　　subprocess.PIPE实际上为文本流提供一个缓存区。child1的stdout将文本输出到缓存区，随后child2的stdin从该PIPE中将文本读取走。child2的输出文本也被存放在PIPE中，直到communicate()方法从PIPE中读取出PIPE中的文本。

　　注意：communicate()是Popen对象的一个方法，该方法会阻塞父进程，直到子进程完成

7、logging模块

　　在程序中都有记录日志的需求，并且日志中包含的信息即有正常的程序访问。python的logging模块提供了标准的日志接口，可以通过它存储各种格式的日志，logging的日志可以分为debug()、info()、warning()、error()、and critical() 5个级别，级别是越来越高，设置的级别越低，打印日志等级越多。

　　基本用法：

import logging
logging.basicConfig(filename='test.log',level=logging.INFO,format='%(asctime)s %(module)s %(levelname)s %(message)s',datefmt='%m/%d/%Y %H:%M:%S %p')
#注意上面字母的大小写，不能混淆
logging.debug("debug")
logging.info("info")
logging.warning("waring")
输出结果：

05/03/2017 10:27:11 AM test INFO info

05/03/2017 10:27:11 AM test WARNING waring

format的日志格式：

  　高级用法：

　　python使用logging模块记录日志设计的四个主要类：

　　A logger:提供应用程序可以直接使用的接口。

logger = logging.getLogger("chat.gui")

　　1、在输出日志之前都需要获取一个logger,logger通常对应了程序的模块名。

logger.setLevel(logging.DEBUG)

　　2、设置最低的日志级别，低于lel的级别将被忽略（debug是最低，critical为最高）

　　3、logger.addFilter(filt) logger.removeFilter(filt) 添加或删除指定的filter

　　4 logger.addHandler(hdlr),logger.removeHandler(hdlr) 添加或删除指定的handler

ch = logging.StreamHandler() #创建一个handler，用于输出到控制台
logger.addHandler(fh)#给logger添加handler

　　5、logger.debug() logger.info() logger.warning() logger.error() logger.critical() ,设置日志的级别

　　B handler:将（logger创建的）日志记录发送到合适的目的输出。python的日志系统有很多种handler可以使用，有些handler可以把信息输出到控制台，有些logger可以把信息输出到文件，还有些handler可以信息发送到网络上，如果嫌少，还能编写自己的handler，通过addHandler()方法添加多个handler。

　　1 handler.setlevel(lel) 指定被处理的信息级别，低于lel级别的信息将被忽略。

ch = logging.StreamHandler()
ch.setLevel(logging.DEBUG)

　　2 handler.setFormatter() 为该handler设置格式

ch_formatter = logging.Formatter("%(asctime)s - %(name)s - %(levelname)s - %(message)s") #生成格式
 
ch.setFormatter(ch_formatter) #设置格式

　　3 logging.StreamHandler(strm) 使用这个handler可以向屏幕输出,其中strm参数是一个文件对象，默认是sys.stderr

　　4 logging.FileHandler(filename[,mode]) 用于向一个文件输出日志信息，它会帮你打开这个文件，其中filename是文件名，必须制定.mode是文件的打开方法，默认是'a',即添加到文件末尾。

　　5 logging.handlers.RotatinFileHandler 功能和 4 类似，但它可以管理文件大小，当文件达到一定大小之后，它会自动将日志文件改名，然后创建一个新的同名日志继续输出。比如日志文件是chat.log，当它达到指定的大小后，RotatingFileHandler自动把文件改名为chat.log.1。不过，如果chat.log.1已经存在，会先把chat.log.1重命名为chat.log。最后重新创建chat.log,继续输出日志信息，构造函数：RotatingFileHandler(filename,mod,maxBytes,backupCount),前2个参数和FileHandler一样，maxByte用于指定日志文件的最大文件大小，如果maxByter为0，意味着日志文件可以无限大，这时上面描述的重命名过程就不会发生。backupCount用于指定保留的备份文件的个数。比如，如果指定为2，当上面描述的重命名过程发生时，原有的chat.log.2并不会被更名，而是被删除。

　　6 logging.handlers.TimeRotatingFileHandler 它没有判断文件大小决定何时重新创建日志文件，而是间隔一定时间就自动创建新的日志文件。重命名的过程与RotatingFileHandler类似，不过新的文件不是附加数字，而是当前时间。构造函数：TimeRotatingFileHandler(filename,when,interval,backupCount),interval是时间间隔，when参数是一个字符串。表示时间间隔的单位，不区分大小写，它有以下取值：S 秒、M分、H小时、D天、W每星期（interval=0 时代表星期一）、midnight每天凌晨。

　　C filter:提供了细度设备来决定输出哪条日志记录。

　　D formatter:决定日志记录的最终输出格式。

　　举例说明：

# create logger
logger = logging.getLogger('TEST-LOG')
logger.setLevel(logging.DEBUG)

# create console handler and set level to debug
ch = logging.StreamHandler()
ch.setLevel(logging.DEBUG)

# create file handler and set level to warning
fh = logging.FileHandler("access.log")
fh.setLevel(logging.WARNING)
# create formatter
formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')

# add formatter to ch and fh
ch.setFormatter(formatter)
fh.setFormatter(formatter)

# add ch and fh to logger
logger.addHandler(ch)
logger.addHandler(fh)

# 'application' code
logger.debug('debug message')
logger.info('info message')
logger.warn('warn message')
logger.error('error message')
logger.critical('critical message')

 

8 re模块

　　正则表达式（RE）是一种小型的、高度专业化的编程语言。它被内嵌在python中，并通过re模块实现。

　　正则表达式（RE）可以被连接，从而形成新的正则表达式；例如A和B都是正则表达式，那么AB也是正则表达式。

　　一般地，如果字符串p与A匹配，q与B匹配的话，那么字符串pq也会与AB匹配，但A或者B里含有边界限定条件或者命名组操作的情况除外。也就是说，复杂的正则表达式可以用简单的连接而成。

　　常用表达式符号：

'.'     默认匹配除\n之外的任意一个字符，若指定flag DOTALL,则匹配任意字符，包括换行
'^'     匹配字符开头，若指定flags MULTILINE,这种也可以匹配上(r"^a","\nabc\neee",flags=re.MULTILINE)
'$'     匹配字符结尾，或e.search("foo$","bfoo\nsdfsf",flags=re.MULTILINE).group()也可以
'*'     匹配*号前的字符0次或多次，re.findall("ab*","cabb3abcbbac")  结果为['abb', 'ab', 'a']
'+'     匹配前一个字符1次或多次，re.findall("ab+","ab+cd+abb+bba") 结果['ab', 'abb']
'?'     匹配前一个字符1次或0次
'{m}'   匹配前一个字符m次
'{n,m}' 匹配前一个字符n到m次，re.findall("ab{1,3}","abb abc abbcbbb") 结果'abb', 'ab', 'abb']
'|'     匹配|左或|右的字符，re.search("abc|ABC","ABCBabcCD").group() 结果'ABC'
'(...)' 分组匹配，re.search("(abc){2}a(123|456)c", "abcabca456c").group() 结果 abcabca456c
 
 
'\A'    只从字符开头匹配，re.search("\Aabc","alexabc") 是匹配不到的
'\Z'    匹配字符结尾，同$
'\d'    匹配数字0-9
'\D'    匹配非数字
'\w'    匹配[A-Za-z0-9]
'\W'    匹配非[A-Za-z0-9]
's'     匹配空白字符、\t、\n、\r , re.search("\s+","ab\tc1\n3").group() 结果 '\t'
 
'(?P<name>...)' 分组匹配 re.search("(?P<province>[0-9]{4})(?P<city>[0-9]{2})(?P<birthday>[0-9]{4})","371481199306143242").groupdict("city") 结果{'province': '3714', 'city': '81', 'birthday': '1993'}
22 [] 大括号，用于指定一个字符的集合

　　常用语法

　　1 search(pattern,string，flags = 0) 扫面整个字符串并返回第一个成功的匹配 否则返回none

　　2 match(pattern,string,flags = 0) 尝试从字符串的起始位置匹配一个模式，如果不是起始位置匹配成功的话，返回none

 　　pattern 表示匹配的正则表达式

　　 string  表示要匹配的字符串

　　 flags 表示一个标志位，用于控制正则表达式的匹配方式，如：是否区分大小写，多行匹配等

　　3 findall（pattern,string,flags=0） 以列表获取字符串中所有匹配到的字符串

       4 sub re.sub(pattern,repl,string,coun=0t,flags=0) 前三者是必选，后两者是可选

　　   使用repl 代替string中pattern部分

　　5 split(pattern,string,maxsplit = 0,flags = 0)

　　　根据指定匹配进行分组

　　对获取的结果，可以做如下处理：　

　　1 group() 返回所有匹配的字符，括号里可以加数字1、2、3 ,用于分段

　　1 groups() 以列表形式返回匹配到的字符

　　注意：r 表示原生字符串，不用担心漏写反斜杠 

9 json 和pickle 

　json 它只能对简单的数据类型进行处理，且它是跨语言的，只能对字符串进行处理  在py2.x中 可以多次load/dump 但是3.x只能 load 和 dump一次

　json.dumps(data,sort_keys ,indent,separators)  把一个python对象编码转成json字符串 --编码

　data 表示数据、sort_keys表示是否排序，indent表示缩进参数、separators表示压缩

　json.loads() 把json格式字符串解码转换成python对象 -- 解码

>>>jsonData = '{"a":1,"b":2,"c":3,"d":4,"e":5}'
>>>s = json.loads(jsonData)
>>>print(s["a"])
输出 1

1 >>>jsonData = {"a":1,"b":2,"c":3,"d":4,"e":5}
2 >>>s = json.dumps(jsonData)
3 >>>print(type(s))
4 <class 'str'>

　loads()和dumps() 针对内存对象，loads()将python内置数据序列化为字符串,也就是将字典转成str

   注意：如果使用json.loads 进行反序列化，再操作文件时，需要read

import json
with open("test.txt","r") as f:  #以普通模式读
    data = json.loads(f.read())   #用loads反序列化

　 load()和dump() 针对文件句柄，dump()将内置类型序列化为json对象后写入文件

 　dump() 序列化

import  json
info = {
    'name':"李四",
    "age":250
}
with open("test.txt","w") as f:   #文件以写的方式打开
    json.dump(info,f)    #第1个参数是内存的数据对象 ，第2个参数是文件句柄

　load()反序列化

>>>import json
>>>with open("test.txt","r") as f:   #以读的方式打开文件
 >>>   data = json.load(f)  #输入文件对象
>>>print(data.get("age"))
输出250

　 pickle 能处理复杂的数据类型 只能在python中使用.json序列化的是字符，而pickle序列化的是字节

　 它有两个常用函数方法，dump() 序列化数据 和load() 反序列化

　　

　

 

 

 

 

 

 

 

、