Python基础 12.常用模块

一、时间模块（time、datetime）

Python中有三种时间的表示方式：

时间戳 1970年1月1日之后的秒，即：time.time()
格式化时间 2014-11-11 11:11，即：time.strftime('%Y-%m-%d')
结构化时间元组包含了：年、日、星期等... time.struct_time 即：time.localtime()

1.1、几种时间表示方

 1 #时间戳转结构化时间
 2 import time
 3 y=time.time()  #时间戳
 4 x=time.localtime(y) #时间戳转换结构化时间
 5 #结构化时间转成时间戳
 6 z=time.mktime(x)   #结构化时间z转时间戳
 7 time.gmtime()  #世界标准时间（结构化时间）
 8  
 9  
10 #结构化时间转换为格式化时间
11 time.strftime(%Y-%m-%d-%b %H:%M:%S',x)) #可带参数指定结构化时间
12 time.strftime('%Y/%m/%d %H:%M:%S')  #没有参数默认就是localtime
13 #格式化时间转换成结构化时间
14 time.strptime('2011-05-05 16:37:06', '%Y-%m-%d %X'))
15 #strptime(string, format)
16  
17 #  %Y  %m %d %H %M %S    %X          %a %b
18 #  年   月 日 时 分  秒  时分秒统称     周  月
19  
20  
21 time.asctime()
22 #把一个表示时间的元组或者struct_time表示为这种形式：'Sun Jun 20 15:21:05 1998',如果没有参数，将会将time.localtime()作为参数传入
23 time.ctime()
24 #把一个时间戳（按秒计算的浮点数）转化为time.asctime()的形式。如果参数未给或者为None的时候，将会默认time.time()为参数

1.2、datetime模块

 1 import datetime
 2    
 3 print(datetime.datetime.now())   #返回格式 2018-12-16 17:12:41.621179
 4 print(datetime.date.fromtimestamp(time.time()) )# 时间戳直接转成日期格式 2018-12-16
 5 print(datetime.datetime.now() + datetime.timedelta(3)) #当前时间+3天
 6 print(datetime.datetime.now() + datetime.timedelta(-3)) #当前时间-3天
 7 print(datetime.datetime.now() + datetime.timedelta(hours=3)) #当前时间+3小时
 8 print(datetime.datetime.now() + datetime.timedelta(minutes=30)) #当前时间+30分
 9 print(datetime.datetime.now() + datetime.timedelta(seconds=30)) #当前时间+30秒
10  
11  
12 n_time  = datetime.datetime.now()
13 print(n_time.replace(minute=3,hour=2)) #时间替换

执行结果：

二、random 随机模块

 1 import random   #随机模块
 2 random.random()   #0-1 浮点型
 3 random.uniform(1,3)  # 随机取1-3的浮点数
 4 random.randint(1,4) #随机取1-4的整型
 5 random.randrange(1,4)  #随机取1-3的整数
 6 random.choice([1,23,[22]])  #列表随机取一个值
 7 print(random.sample([1,2,3],3))  #列表随机取多个值
 8  
 9 list=[1,3,5,7,9]
10 random.shuffle(list)  #随机打乱列表顺序
11 print(list)
12 chr(random.randint(65,90))  #随机大写字母A-Z
13 chr(random.randint(97,122))  #随机小写字母a-z

随机取4个值要求包含0-9,a-z，A-Z

 1 import random
 2 def code():
 3     li = []
 4     for i in range(1,5):
 5         a=random.randint(0,9)
 6         b=chr(random.randint(65,90))
 7         c=chr(random.randint(97,122))
 8         c=random.sample([a,b,c],1)
 9         li.append(c)
10     return li
11 print(code())

其实上面这个例子并不严谨，0-9，a-z，A-Z各取一个，然后在从三个里面再任意取一个，把获取的四个值任意排序即可

三、OS模块

 1 #当前工作目录相关的
 2 os.getcwd() #获取当前工作目录，即当前python脚本工作的目录路径
 3 os.chdir("dirname")  #改变当前脚本工作目录；相当于shell下cd
 4 os.curdir  #返回当前目录: ('.')
 5 os.pardir  #获取当前目录的父目录字符串名：('..')
 6  
 7 #和文件相关
 8 os.makedirs('name1/name2')    #可生成多层递归目录
 9 os.removedirs('dirname')    #删除多层目录，为空删除，否则报错
10 os.mkdir('dirname')    #生成单级目录；相当于shell中mkdir dirname
11 os.rmdir('dirname')    #删除单级空目录，若目录不为空则无法删除
12 os.listdir('dirname')    #列出指定目录下的所有文件和子目录，包括隐藏文件
13 os.remove('filename')   #删除一个文件
14 os.rename("oldname","newname")   #重命名文件/目录
15 os.stat('path/filename')    #获取文件/目录信息
16  
17 # 和执行系统命令相关
18 os.system("bash command")  #运行系统命令，直接显示
19 os.popen("bash command").read()  #运行系统命令，获取执行结果
20 os.environ  #获取系统环境变量
21 os.name()  #字符串指示当前使用平台。win->'nt'; Linux->'posix'
22  
23 #path系列，和路径相关
24 os.path.abspath(path) #返回path规范化的绝对路径
25 os.path.split(path)#将path分割成目录和文件名二元组返回
26 os.path.dirname(path) #返回path的目录。其实就是os.path.split(path)的第一个元素
27 os.path.basename(path) #返回path最后的文件名。如何path以／或结尾，那么就会返回空值，即os.path.split(path)的第二个元素。
28 os.path.exists(path)  #如果path存在，返回True；如果path不存在，返回False
29 os.path.isabs(path)  #如果path是绝对路径，返回True
30 os.path.isfile(path)  #如果path是一个存在的文件，返回True。否则返回False
31 os.path.isdir(path)  #如果path是一个存在的目录，则返回True。否则返回False
32 os.path.join(path,*paths)  #将多个路径组合后返回
33 os.path.getatime(path)  #返回path所指向的文件或者目录的最后访问时间
34 os.path.getmtime(path)  #返回path所指向的文件或者目录的最后修改时间
35 os.path.getsize(path) #返回path的大小

os.stat('path/filename') 获取文件/目录信息的详细说明

st_mode: inode 保护模式
st_ino: inode 节点号。
st_dev: inode 驻留的设备。
st_nlink: inode 的链接数。
st_uid: 所有者的用户ID。
st_gid: 所有者的组ID。
st_size: 普通文件以字节为单位的大小；包含等待某些特殊文件的数据。
st_atime: 上次访问的时间。
st_mtime: 最后一次修改的时间。
st_ctime: 由操作系统报告的"ctime"。在某些系统上（如Unix）是最新的元数据更改的时间，在其它系统上（如Windows）是创建时间

OS模块中os.path.join()asename()split() 比较重要（对文件路径拼接、文件名操作等）

四、sys模块

 1 sys.argv          # 命令行参数，第一个元素是程序本身路径，后面为输入参数（list）
 2 sys.exit()        #退出程序，正常退出时exit(0)
 3 sys.version        #获取Python解释程序的版本信息
 4 sys.maxint         #最大的Int值
 5 sys.path           #返回模块的搜索路径，初始化时使用PYTHONPATH环境变量的值
 6 sys.platform      # 返回操作系统平台名称
 7 sys.stdin          #输入相关
 8 sys.stdout         #输出相关
 9 sys.stderror       #错误相关
10 sys.stdout.write("#")  #输出"#"
11 sys.stdout.flush() #刷新缓存

五、数据转换相关（序列化）

5.1、josn 用于【字符串】和【python基本数据类型】间进行转换

　　josn模块提供了四个功能：dumps、dump、loads、load

 1 #dumps和loads
 2 import json
 3 dic = {'k1':'v1','k2':'v2','k3':'v3'}
 4 str_dic = json.dumps(dic)  #序列化：将一个字典转换成一个字符串
 5 print(type(str_dic),str_dic)  #<class 'str'> {"k3": "v3", "k1": "v1", "k2": "v2"}
 6 #注意，json转换完的字符串类型的字典中的字符串是由""表示的
 7  
 8 dic2 = json.loads(str_dic)  #反序列化：将一个字符串格式的字典转换成一个字典
 9 #注意，要用json的loads功能处理的字符串类型的字典中的字符串必须由""表示
10 print(type(dic2),dic2)  #<class 'dict'> {'k1': 'v1', 'k2': 'v2', 'k3': 'v3'}
11  
12  
13 list_dic = [1,['a','b','c'],3,{'k1':'v1','k2':'v2'}]
14 str_dic = json.dumps(list_dic) #也可以处理嵌套的数据类型
15 print(type(str_dic),str_dic) #<class 'str'> [1, ["a", "b", "c"], 3, {"k1": "v1", "k2": "v2"}]
16 list_dic2 = json.loads(str_dic)
17 print(type(list_dic2),list_dic2) #<class 'list'> [1, ['a', 'b', 'c'], 3, {'k1': 'v1', 'k2': 'v2'}]

 1 #dump和load
 2 import json
 3 f = open('json_file','w')
 4 dic = {'k1':'v1','k2':'v2','k3':'v3'}
 5 json.dump(dic,f)  #dump方法接收一个文件句柄，直接将字典转换成json字符串写入文件
 6 f.close()
 7  
 8 f = open('json_file')
 9 dic2 = json.load(f)  #load方法接收一个文件句柄，直接将文件中的json字符串转换成数据结构返回
10 f.close()
11 print(type(dic2),dic2)

5.2、pickle 用于【python特有的类型】和【python基本数据类型】间进行转换

pickle模块提供了四个功能：dumps、loads、dump、load （不仅可以序列化字典，列表...可以把python中任意的数据类型序列化）

 1 import pickle
 2 dic = {'k1':'v1','k2':'v2','k3':'v3'}
 3 str_dic = pickle.dumps(dic)
 4 print(str_dic)  #一串二进制内容
 5  
 6 dic2 = pickle.loads(str_dic)
 7 print(dic2)    #字典
 8  
 9 abc  = {"k":1,"k1":2}
10 f = open('pickle_file','wb')
11 pickle.dump(abc,f)
12 f.close()
13  
14 f = open('pickle_file','rb')
15 struct_time2 = pickle.load(f)
16 print(abc["k"])

5.3、shelve也是python提供给我们的序列化工具，比pickle用起来更简单一些。shelve只提供给我们一个open方法，是用key来访问的，使用起来和字典类似

1 import shelve
2 f1 = shelve.open('shelve_file')
3 f1['k1']={'name':'jump','age':18,'job':['php','smoking']}  #写
4 print(f1['k1']['job'])  #取  ['php', 'smoking']
5 f1.close()

5.4、XML是实现不同语言或程序之间进行数据交换的协议，XML文件格式如下：

 1 <data>
 2     <city name="bj">
 3         <rank updated="yes">1</rank>
 4         <year>2018</year>
 5         <gdppc>141100</gdppc>
 6     </city>
 7     <city name="nj">
 8         <rank updated="yes">5</rank>
 9         <year>2018</year>
10         <gdppc>59900</gdppc>
11     </city>
12     <city name="sh">
13         <rank updated="yes">2</rank>
14         <year>2018</year>
15         <gdppc>13600</gdppc>
16     </city>
17 </data>

XML操作：

 1 import xml.etree.ElementTree as ET
 2 tree= ET.parse(filename)  #解析文件
 3 root=tree.getroot()  #获取根节点
 4 root.tag  #根标签名称
 5  
 6 for child in root:
 7     print(child.tag, child.attrib) # 子节点的标签名称和标签属性
 8      
 9     for i in child:   #遍历XML文档的第三层
10         print(i.tag,i.text)  # 二级节点的标签名称和内容
11  
12 for i in root.iter("xxx"):   #遍历根节点下面的所有xxx节点,然后修改
13        xx=int（i.text）+1
14        i.text=str(xx)
15        i.set("k",'v')   #设置属性
16        del node.attrib['k']  #删除
17 tree.write("filename")  #保存文件
18  
19 for  i in root.findall("city"):
20        xx = int（city.find("rank").text）
21        if xx>3:
22            root.remove(city)  #删除排名大于3的

XML文件创建

1 import xml.etree.ElementTree as ET
2 new_xml=ET.Element("xxx")  #创建根节点
3 name=ET.SubElement(new_xml,"name",attrib={"k":"v"})  #创建子节点
4 age=ET.SubElement(name,"age",attrib={"k1":"v1"})  #创建二级子节点
5 age.text = "22"   #给节点定义值
6 et=ET.ElementTree(new_xml) #生成文档对象
7 et.write("abc.xml",encoding="utf8")  #创建xml文件

六、文件及加密相关

6.1、configparser

configparser用于处理特定格式的文件，该模块适用于配置文件的格式与windows ini文件类似，可以包含一个或多个节（section），每个节可以有多个参数（键=值）

配置文件形式（mysql）

 1 [client]
 2 port = 3306
 3 [mysqld]
 4 port = 3306
 5 datadir=D:websoftmysql-5.6.15data
 6 basedir=D:websoftmysql-5.6.15
 7 max_connections=500
 8 performance_schema=0
 9 key_buffer = 16M
10 max_allowed_packet = 1M
11 #table_cache = 64
12 sort_buffer_size = 512K
13 net_buffer_length = 8K
14 read_buffer_size = 256K
15 read_rnd_buffer_size = 512K
16 myisam_sort_buffer_size = 8M
17 slow_query_log_file=D:websoftmysql-5.6.15logslow.log

创建一个配置文件：

1 import configparser
2 config= configparser.ConfigParser()  #新建对象
3 config["Name"] ={'server':'hostname','IP':'111'}  #Name节点下sever和IP
4 with open("config.conf","w")as f:   #创建配置文件
5       config.write(f)

增删改查操作：

 1 import configparser
 2 config= configparser.ConfigParser()
 3 config.read("config.conf")   #打开配置文件
 4 print(config.sections()) #获取所有的节点名称
 5  
 6 print(config["Name"]["server"])  #获取Name节点下server的值
 7 print(config.options("Name2"))   #获取Name2节点下的键
 8 print(config.items("Name"))    #获取Name节点下所有的键值对
 9 print(config.get("Name","server"))  #获取Name 节点下server 的值
10  
11 has_sec = config.has_section('section1')
12 print(has_sec)           #判断是否包含section1这个节点，返回False/True
13  
14 config.add_section("section1")
15 config.write(open('config.conf', 'w'))  #增加一个节点section1
16 config.remove_section("section1")      
17 config.write(open('config.conf', 'w'))    #删除一个节点section1
18  
19 config.set('section1', 'k10', "123") 
20 config.write(open('config.conf', 'w'))   #将section1节点下的k10设置为123
21 config.remove_option('section1', 'k10')
22 config.write(open('config.conf', 'w'))    #将section1节点下的k10删除
23  
24 config.has_option('section1', 'k10') #检查section节点下k10是否存在，返回False/True

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

 1 import shutil
 2  
 3 # shutil.copyfileobj(fsrc, fdst[, length]) 将文件内容拷贝到另一个文件中
 4 shutil.copyfileobj(open('oldfilename','r'), open('newfilename', 'w'))
 5  
 6 #shutil.copyfile(src, dst)  拷贝文件，目标文件无需存在
 7 shutil.copyfile('f1', 'f2')
 8  
 9 #shutil.copymode(src, dst)仅拷贝权限。内容、组、用户均不变
10 shutil.copymode('f1', 'f2') #目标文件必须存在
11  
12 #shutil.copystat(src, dst)仅拷贝文件状态的信息
13 shutil.copystat('f1', 'f2') #目标文件必须存在
14  
15 #shutil.copy2(src, dst) 拷贝文件和状态信息
16 shutil.copy2('f1', 'f2')
17  
18 #shutil.copy(src, dst) 拷贝文件和权限
19 shutil.copy('f1', 'f2')
20  
21 #shutil.ignore_patterns(*patterns)
22 #shutil.copytree(src, dst, symlinks=False, ignore=None)
23 #递归的去拷贝文件夹
24 shutil.copytree('dir1', 'dir2', ignore=shutil.ignore_patterns('*.txt'))
25 #目标目录不能存在，注意对dir2目录父级目录要有可写权限，ignore的意思是排除
26  
27 #shutil.rmtree(path[, ignore_errors[, onerror]])
28 #递归的去删除文件夹
29 shutil.rmtree('dir1')
30  
31 #shutil.move(src, dst)
32 #递归的去移动文件，它类似mv命令，其实就是重命名。
33 shutil.move('dir1', 'dir3')
34  
35 #shutil.make_archive(base_name, format,...)  压缩文件
36 #base_name： 压缩包的文件名，也可以是压缩包的路径
37 #format：压缩包种类，“zip”, “tar”, “bztar”，“gztar”
38 #root_dir：要压缩的文件夹路径（默认当前目录）
39 shutil.make_archive("/bak/data_bak", 'zip', root_dir='/data')
40  
41 #shutil 对压缩包的处理是调用 ZipFile 和 TarFile 两个模块来进行的，如下：
42 import zipfile
43 # 压缩
44 z = zipfile.ZipFile('bak.zip', 'w')
45 z.write('1.txt')
46 z.write('2.txt')
47 z.close()
48 # 解压
49 z = zipfile.ZipFile('bak.zip', 'r')
50 z.extractall(path='.')
51 z.close()
52  
53 import tarfile
54 tar = tarfile.open('your.tar','w')  # 创建一个压缩包
55 tar.add('/Users/bbs2.log', arcname='bbs2.log')  # 将文件添加到压缩包并命名
56 tar.add('/Users/cmdb.log', arcname='cmdb.log') 
57 tar.close()  # 关闭压缩包
58 # 解压
59 tar = tarfile.open('your.tar','r')  # 打开一个压缩包
60 tar.extractall()  # 解压包内所有文件（可设置解压地址）
61 tar.close()  # 关闭压缩包

6.3、hashlib

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

1 import hashlib
2 obj=hashlib.md5()  #建立一个对象
3 obj.update("hello".encode("utf-8"))  #加密
4 print(obj.hexdigest()) #5d41402abc4b2a76b9719d911017c592 (十六进制)
5 print(obj.digest)

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

1 import hashlib
2 obj=hashlib.md5("jump".encode("utf8"))  #加自定义key
3 obj.update("hello".encode("utf-8"))
4 print(obj.hexdigest())   #b455addaf0e23904477ba8db951f3edc

七、 re 正则

正则就是用一些具有特殊含义的符号组合到一起（称为正则表达式）来描述字符或者字符串的方法。或者说：正则就是用来描述一类事物的规则。（在Python中）它内嵌在Python中，并通过 re 模块实现。正则表达式模式被编译成一系列的字节码，然后由用 C 编写的匹配引擎执行

元字符	匹配内容
w	匹配字母（包含中文）或数字或下划线
W	匹配非字母（包含中文）或数字或下划线
s	匹配任意的空白符
S	匹配任意非空白符
d	匹配数字
D	匹配非数字
A	从字符串开头匹配
z	匹配字符串的结束，如果是换行，只匹配到换行前的结果
	匹配字符串的结束
	匹配一个换行符
	匹配一个制表符
^	匹配字符串的开始
$	匹配字符串的结尾
.	匹配任意字符，除了换行符，当re.DOTALL标记被指定时，则可以匹配包括换行符的任意字符。
[...]	匹配字符组中的字符
[^...]	匹配除了字符组中的字符的所有字符
*	匹配0个或者多个左边的字符。
+	匹配一个或者多个左边的字符。
？	匹配0个或者1个左边的字符，非贪婪方式。
{n}	精准匹配n个前面的表达式。
{n,m}	匹配n到m次由前面的正则表达式定义的片段，贪婪方式
a\|b	匹配a或者b。
()	匹配括号内的表达式，也表示一个组

7.1、常用方法举例

 1 import re
 2 #findall 全部找到返回一个列表
 3 #findall(pattern, string, flags=0)
 4 print(re.findall("a","abcdabcdaa")) #['a', 'a', 'a', 'a']
 5  
 6 #search 只到找到第一个匹配然后返回一个包含匹配信息的对象,该对象可以通过调用group()方法得到匹配的字符串,如果字符串没有匹配，则返回None。
 7 # search(pattern, string, flags=0)
 8 print(re.search("a","abcdabcdaa").group())  #a
 9 print(re.search("a","abcdabcdaa"))   #<_sre.SRE_Match object; span=(0, 1), match='a'>
10  
11 #match 同search,不过在字符串开始处进行匹配,完全可以用search+^代替match
12 #match(pattern, string, flags=0)
13 # pattern： 正则模型
14 # string ： 要匹配的字符串
15 # falgs  ： 匹配模式
16 print(re.match('e','ebcdh').group())  #e
17 print(re.match('e','ebcdh'))   #<_sre.SRE_Match object; span=(0, 1), match='e'>
18  
19 #split 分割 可按照任意分割符进行分割
20 #split(pattern, string, maxsplit=0, flags=0)
21 # pattern： 正则模型
22 # string ： 要匹配的字符串
23 # maxsplit：指定分割个数
24 # flags  ： 匹配模式
25 print(re.split('[ab]','abcd'))     #['', '', 'cd']，先按'a'分割得到''和'bcd',再对''和'bcd'分别按'b'分割
26  
27 #sub 替换
28 #sub(pattern, repl, string, count=0, flags=0)
29 # pattern： 正则模型
30 # repl   ： 要替换的字符串或可执行对象
31 # string ： 要匹配的字符串
32 # count  ： 指定匹配个数
33 # flags  ： 匹配模式
34 r = re.sub("d+", "999", "123abcd456edcf789", 2)
35 print(r)  #999abcd999edcf789
36  
37 #re.compile()
38 obj = re.compile("d+")
39 print(obj.search("abcd123efg456yhn789").group())
40 print(obj.findall("abcd123efg456yhn789"))
41  
42 #返回123 和['123', '456', '789']

7.2、命名分组

 1 print(re.search("(?P<tag_name>w+)","abcd"))
 2 #(?P<name>) 分组固定格式
 3  
 4 print((re.search("(?P<tag_name>w+)","abcd").group("tag_name")))
 5 #取分组值
 6  
 7  
 8 print(re.search("<(?P<tag_name>w+)>w+</(?P=tag_name)>","<h1>hello</h1>").group())
 9 print(re.findall("<(?P<tag_name>w+)>w+</(?P=tag_name)>","<h1>hello</h1>"))
10 #返回的结果为：<h1>hello</h1>和[h1]
11 #group的作用是将所有组拼接到一起显示出来
12 #findall结果是组内的结果,且是最后一个组的结果

八、logging 用于便捷记录日志且线程安全的模块（日志模块）

日志等级：

1 CRITICAL = 50  #FATAL = CRITICAL
2 ERROR = 40
3 WARNING = 30  #WARN = WARNING
4 INFO = 20
5 DEBUG = 10
6 NOTSET = 0 #不设置

 1 import logging
 2  
 3 logging.debug('调试debug')
 4 logging.info('消息info')
 5 logging.warning('警告warn')
 6 logging.error('错误error')
 7 logging.critical('严重critical')
 8  
 9 #返回结果：
10 """WARNING:root:警告warn
11 ERROR:root:错误error
12 CRITICAL:root:严重critical"""
13  
14 #默认级别为warning，默认打印到终端

8.1、单文件日志

 1 import logging 
 2 logging.basicConfig(level=logging.DEBUG, 
 3                     format='%(asctime)s %(filename)s[line:%(lineno)d] %(levelname)s %(message)s', 
 4                     datefmt='%a, %d %b %Y %H:%M:%S', 
 5                     filename='1.log', 
 6                     filemode='w') 
 7    
 8 logging.debug('debug message') 
 9 logging.info('info message') 
10 logging.warning('warning message') 
11 logging.error('error message') 
12 logging.critical('critical message')

　执行结果：