模块：为了编写可维护的代码，我们将很多函数分组，分别放到不同的文件里，这样，代码的可利用率提高，代码量减少。在Python中，一个 .py文件就称之为一个模块（module）。
模块有以下几种方式：
a.Python标准库
b.第三方模块
c.引用程序自定义模块
引入模块方式：
1、import 模块名1,模块名2（调用：模块名1.函数名）
1 #!/usr/bin/env python
2 # -*- coding:utf-8 -*-
3
4
5 def add(x, y):
6 return x+y
7
8
9 def sub(x, y):
10 return x-y1 #!/usr/bin/env python
2 # -*- coding:utf-8 -*-
3 import cal
4
5
6 print(cal.add(3, 5))2、from 模块名1 import 函数名（调用：函数名）
#!/usr/bin/env python
# -*- coding:utf-8 -*-
def add(x, y):
return x+y
def sub(x, y):
return x-y1 #!/usr/bin/env python
2 # -*- coding:utf-8 -*-
3 from cal import add # 只引入一个函数
4 from cal import * # 引入多个函数
5
6
7 print(add(3, 5))1 #!/usr/bin/env python
2 # -*- coding:utf-8 -*-
3 import sys # 引入标准库
4 print(sys.path) # 查看当前路径
5
6 from my_module import cal # 引入自定义库，在当前路径的下一层
7 from my_module.module1.module2 import cal # 引入自定义库，多级目录
8 print(cal.add(3, 2))•time模块
在Python中，通常有这几种方式来表示时间：
a.时间戳（timestamp）：通常来说，时间戳表示的是从1970年1月1日00:00:00开始按秒计算的偏移量。我们运行“type(time.time())”，返回的是float类型
b. 格式化的时间字符串
c.元祖（struct_time）：struct_time元祖共有9个元素（年，月，日，时，分，秒，一年中第几周，一年中第几天，夏令时）
1 #!/usr/bin/env python
2 # -*- coding:utf-8 -*-
3 import time
4
5 # 时间戳,用于计算
6 print(time.time()) # 1548861231.773613秒,从1970年1月1日 00:00:00开始计算
7 # 结构化时间，当地时间
8 print(time.localtime()) # time.struct_time(tm_year=2019, tm_mon=1, tm_mday=30, tm_hour=23, tm_min=18, tm_sec=52, tm_wday=2, tm_yday=30, tm_isdst=0)
9 t = time.localtime()
10 print(t.tm_year) # 获取当前年份
11 print(t.tm_mday) # 获取当前月的第多少天
12 print(t.tm_wday) # 获取这周第几天，默认从0-6
13 # 结构化时间，标准时间--UTC
14 print(time.gmtime()) # 世界标准时间，英国；time.struct_time(tm_year=2019, tm_mon=1, tm_mday=30, tm_hour=15, tm_min=26, tm_sec=17, tm_wday=2, tm_yday=30, tm_isdst=0)
15 '''
16 struct_time ---> Timestamp:mktime
17 Timestamp ---> struct_time:localtime/gmtime
18 struct_time ---> Format string:strftime
19 Format string ---> struct_time:strptime
20 strptime：把一个格式化时间字符串转换为struct_time。实际上它和strftime()是逆操作
21 %Y:年
22 %m:月
23 %d:日
24 %X:时分秒
25 '''
26 # ----将结构化时间转换成时间戳
27 print(time.mktime(time.localtime()))
28 # ----将结构化时间转成字符串时间
29 print(time.strftime("%Y-%m-%d %X", time.localtime()))
30 # ----将字符串时间转成结构化时间
31 print(time.strptime("2019:01:30:23:53:59", "%Y:%m:%d:%X"))
32
33 print(time.asctime()) # Wed Jan 30 23:56:16 2019
34 print(time.ctime()) # Wed Jan 30 23:57:09 2019
35 '''
36 time.sleep(3)：线程推迟指定的时间运行，单位为秒
37 time.clock()：
38 a.UNIX系统上，他返回的是“进程时间”，它是用秒表示的浮点数
39 b.Windows中，第一次调用，返回的是进程运行的实际时间；第二次之后的调用时第一次调用以后到现在运行的时间，即时间差
40 '''
41
42
43 import datetime
44 print(datetime.datetime.now()) # 2019-01-31 00:04:25.944866•random模块
1 #!/usr/bin/env python
2 # -*- coding:utf-8 -*-
3 import random
4 print(random.random()) # 0-1之间的随机数
5 print(random.randint(1, 10)) # 自定义范围的整形
6 print(random.randrange(1, 5)) # 自定义范围，第二个数取不到
7 print(random.choice([11, 12, 13, 14, 15]))
8 print(random.sample([11, 12, 13, 14, 15], 2)) # 指定一个列表，并指定随机产生的个数
9 print(random.uniform(1, 3)) # 取任意范围的float
10 item = [1, 3, 5, 7, 9]
11 random.shuffle(item) # 打乱集合中的顺序
12 print(item)
1 #!/usr/bin/env python
2 # -*- coding:utf-8 -*-
3 import random
4
5
6 def v_code():
7 res = ""
8 for i in range(5):
9 num = random.randint(0, 9)
10 alf = chr(random.randint(65, 122))
11 s = str(random.choice([num, alf]))
12 res += s
13 return res
14
15
16 print(v_code()) # 25Ze5random验证码
•OS模块
OS模块是与操作系统交互的一个接口
1 #!/usr/bin/env python
2 # -*- coding:utf-8 -*-
3 import os
4 print(os.getcwd()) # 获取当前工作目录，即当前python脚本工作的目录路径
5 # print(os.chdir("dirname")) # 改变当前脚本工作目录，相当于shell下cd
6 print(os.curdir) # 返回当前目录：（'.'）
7 print(os.pardir) # 获取当前目录的父目录字符串名：（'..'）
8 print(os.makedirs('dirname1/dirname2')) # 可生成多层递归目录
9 print(os.removedirs('dirname')) # 若目录为空，则删除，并递归到上一级目录，如若也为空，则删除，以此类推
10 print(os.mkdir('dirname')) # 生成单级目录，相当于shell中 mkdir dirname
11 print(os.rmdir('dirname')) # 删除单级空目录，若目录不为空则无法删除，报错；相当于shell中rmdir dirname
12 print(os.listdir('dirname')) # 列出指定目录下的所有文件和子目录，包括隐藏文件，并以列表方式打印
13 print(os.remove('dirname')) # 删除一个文件
14 print(os.rename('oldname', 'newname')) # 重命名文件/目录
15 print(os.stat('path/filename')) # 获取文件/目录信息
16 print(os.sep) # 输出操作系统特定的路径分隔符，win下为'\\'，linux下为'\'
17 print(os.linesep) # 输出当前平台使用的行终止符，win下为'\r\n',linux下为'\n'
18 print(os.pathsep) # 输出用于分割文件路径的字符串win下为';',linux下为': '
19 print(os.name) # 输出字符串指定当前使用平台。win下为'nt'，linux下为'posix'
20 print(os.system('bash command')) # 运行shell命令，直接显示
21 print(os.environ) # 获取系统环境变量
22 print(os.path.abspath('path')) # 返回path规范化的绝对路径
23 print(os.path.split('path')) # 将path分割成目录和文件名二元祖返回
24 print(os.path.dirname('path')) # 返回path目录，其实就是os.path.split('path') 的第一个元素
25 print(os.path.basename('path')) # 返回path最后的文件名。
26 print(os.path.exists('path')) # 如果path存在，返回True；反之则False
27 print(os.path.isabs('path')) # 如果path是绝对路径，返回True
28 print(os.path.isdir('path')) # 如果path是一个存在的目录，则返回True，反之则False
29 print(os.path.join('path1', 'path2')) # 将多个路径组合后返回，第一个绝对路径之前的参数将被忽略
30 print(os.path.getatime('path')) # 返回path所指向的文件或目录的最后存取时间
31 print(os.path.getmtime('path')) # 返回path所指向的文件或目录的最后修改时间•sys模块
1 #!/usr/bin/env python
2 # -*- coding:utf-8 -*-
3 import sys
4 print(sys.argv) # 命令行参数list，第一个元素是程序本身路径
5 print(sys.exit('n')) # 退出程序，正常退出时exit(0)
6 print(sys.version) # 获取Python解释程序的版本信息
7 print(sys.path) # 返回模块的搜索路径，初始化时使用Pythonpath环境变量的值
8 print(sys.platform) # 返回操作系统平台名称
1 #!/usr/bin/env python
2 # -*- coding:utf-8 -*-
3 import sys,time
4 for i in range(100):
5 sys.stdout.write('#')
6 time.sleep(0.1) # 睡眠0.1秒
7 sys.stdout.flush() # 刷新缓存进度条
•json & pickle 模块
之前学习过的Python内置函数eval方法可以将一个字符串转成python对象，不过，eval方法是有局限性的，对于普通的数据类型，json.loads和eval都能用，但遇到特殊类型的时候，eval就不管用了，所以eval的重点还是通常用来执行一个字符串表达式，并返回表达式的值。
1 #!/usr/bin/env python
2 # -*- coding:utf-8 -*-
3 import json
4 # x = "[null,true,false,1]"
5 # # print(eval（x)) # 报错
6 # print(json.loads(x)) # [None, True, False, 1]
7 dic = {"name": "alex"}
8 f = open("hello", "w")
9 dic_str = json.dumps(dic)
10 f.write(dic_str) # 等价于 json.dump(dic,f)，一般用于文件操作1 # import pickle
2 # dic = {'name': 'alex', 'age': 23, 'sex': 'male'}
3 # print(type(dic)) # <class 'dict'>
4 # j = pickle.dumps(dic)
5 # print(type(j)) # <class 'bytes'>
6 # f = open('序列化对象_pickle', 'wb') # 注意是w是写入str，wb是写入bytes，j是'bytes'
7 # f.write(j) # 等价于 pickle.dump(dic,j)
8 # f.close()
9
10 # -------反序列化
11 import pickle
12 f = open('序列化对象_pickle', 'rb')
13 data = pickle.loads(f.read()) # 等价于 data = pickle.load(f)
14 print(data['name'])什么是序列化？
我们把对象（变量）从内存中编程可存储或传输的过程称之为序列化，在Python中叫pickling，在其他语言中也被称为serialization,marshalling,flattening等等，都是一个意思。
序列化之后，就可以把序列化后的内存写入磁盘，或者通过网络传输到别的机器上。
反过来，把变量内存从序列化的对象重新读到内存里称之为反序列化，即unpickling。
json
如果我们要在不同的编程语言之间传递对象，就必须把对象序列化为标准格式，比如XML，但更好的方法是序列化未JSON，因为JSON表示出来就是一个字符串，可以被所有语言读取，也可以方便地存储到磁盘或者通过网络传输。JSON不仅是标准格式，并且比XML更快，而且可以直接在Web页面中读取，非常方便。
•XML模块
XML是实现不同语言或程序之间进行数据交换的协议，跟json差不多，但json使用起来更简单，不过，以前在json还没诞生的黑暗年代，大家只能选择用XML呀，至今很多传统公司如金融行业的很多系统的接口还主要是XML。
XML的格式如下，就是通过<>节点来区别数据结构的：
1 <?xml version ="1.0" ?>
2 <date>
3 <country name="Liechtenstein">
4 <rank updated="yes">2</rank>
5 <year>2008</year>
6 <gdppc>141100</gdppc>
7 <neighbor name="Austria" direction="E"/>
8 <neighbor name="Switzerland" direction="W"/>
9 </country>
10 </date>xml格式
XML协议在各个语言里的都是支持的，在Python中可以用以下模块操作xml：
1 #!/usr/bin/env python
2 # -*- coding:utf-8 -*-
3 import xml.etree.ElementTree as ET
4
5 tree = ET.parse("xml_lesson") # 调用ET下的parse解析这个XML文件,拿到的对象赋值给tree
6 root = tree.getroot()
7 print(root.tag)
8
9 # 遍历XML文档
10 for child in root:
11 print(child.tag, child.attrib) # child.attrib:获取节点属性
12 for i in child:
13 print(i.tag, i.attrib, i.text)
14
15 # 只遍历year节点
16 for node in root.iter('rank'): # 遍历root根节点下的iter某一节点的“rank”
17 print(node.tag, node.text)
18
19 # 修改
20 for node_update in root.iter('rank'):
21 new_rank = int(node_update.text) + 1
22 node_update.text = str(new_rank)
23 node_update.set('updated', 'no') # 设置他的标签值
24
25 tree.write('xml_lesson') # 将内存中的数据重新写入进去
26
27 # 删除node
28 for country in root.findall('country'):
29 rank = int(country.find('rank').text)
30 if rank == 5:
31 root.remove(country)
32
33 tree.write('xml_lesson')
1 #!/usr/bin/env python
2 # -*- coding:utf-8 -*-
3 import xml.etree.ElementTree as ET
4 new_xml = ET.Element("namelist") # 创建根节点
5 name = ET.SubElement(new_xml, "name", attrib={"enrooled": "yes"})
6 age = ET.SubElement(name, "age", attrib={"checked": "no"})
7 sex = ET.SubElement(name, "sex")
8 sex.text = '33'
9 name2 = ET.SubElement(new_xml, "name", attrib={"enrolled": "no"})
10 age = ET.SubElement(name2, "age")
11 age.text = '19'
12
13 et = ET.ElementTree(new_xml) # 生成文档对象
14 et.write("xml_test.xml", encoding="utf-8", xml_declaration=True)
15
16 ET.dump(new_xml) # 打印生成的格式
17
18 # =========以下为XML创建效果=====
19 <?xml version='1.0' encoding='utf-8'?>
20 <namelist>
21 <name enrooled="yes">
22 <age checked="no" />
23 <sex>33</sex>
24 </name>
25 <name enrolled="no">
26 <age>19</age>
27 </name>
28 </namelist>创建XML
•re模块
正则表达式（或re）是一种小型的、高度专业化的编程语言，（Python）它内嵌在Python中，并通过re模块实现。正则表达式模式被编译成一系列的字节码，然后由用C编写的匹配引擎执行。
正则表达式匹配汉子数字字母：^[a-zA-Z\u4e00-\u9fa5][a-zA-Z0-9\u4e00-\u9fa5]*(/[a-zA-Z\u4e00-\u9fa5][a-zA-Z0-9\u4e00-\u9fa5]*){1,2}$
字符匹配（普通字符，元字符）：
普通字符 >>>re.findall('alex', 'zhangsanalexlisi')
['alex']
.、^、$、*、+、?、{}、[]、|、()、\
.：匹配任意字符，除\n之外
1 #!/usr/bin/env python
2 # -*- coding:utf-8 -*-
3 import re
4 print(re.findall('alex', 'zhangsanalexlisi')) # ['alex']
5 print(re.findall('a..x', 'zhangsanalexlisi')) # ['alex']元字符：.
^：必须将“^”放在字符串开头位置，判断字符串以XXX开头，返回布尔值，如果以XXX开头，返回“真”，反之则“假”
1 #!/usr/bin/env python
2 # -*- coding:utf-8 -*-
3 import re
4 print(re.findall('^alex', 'zhangsanalexlisi')) # []
5 print(re.findall('^alex', 'alexzhangsanlisi')) # ['alex']
6 print(re.findall('^a..x', 'zhangsanalexlisi')) # []
7 print(re.findall('^a..x', 'alexzhangsanlisi')) # ['alex']元字符：^
$：必须将“$”放在字符串结尾位置，判断字符串以XXX结尾，返回布尔值，如果以XXX结尾，返回“真”，反之则“假”
1 #!/usr/bin/env python
2 # -*- coding:utf-8 -*-
3 import re
4 print(re.findall('alex$', 'zhangsanalexlisi')) # []
5 print(re.findall('alex$', 'zhangsanlisialex')) # ['alex']
6 print(re.findall('^alex$', 'zhangsanalexlisi')) # []
7 print(re.findall('^alex$', 'alex')) # ['alex']
8 print(re.findall('a..x$', 'zhangsanalexlisi')) # []
9 print(re.findall('a..x$', 'zhangsanlisialex')) # ['alex']
10 print(re.findall('^a..x$', 'zhangsanlisialex')) # ['']
11 print(re.findall('^a..x$', 'alex')) # ['alex']元字符：$
*、+、？、{}：以x重复出现
1 #!/usr/bin/env python
2 # -*- coding:utf-8 -*-
3 import re
4 # *：范围（0，无穷）
5 print(re.findall('d*', 'zhangsanddddddalexlisi')) # ['', '', '', '', '', '', '', '', 'dddddd', '', '', '', '', '', '', '', '', '']
6
7
8 # +：范围（1，无穷）
9 print(re.findall('d+', 'zhangsanddddddalexlisi')) # ['dddddd']
10
11
12 # *与+区别：
13 print(re.findall('alex*', 'asdfgalex')) # ['alex']
14 print(re.findall('alex+', 'asdfgalex')) # ['alex']
15 print(re.findall('alex*', 'asdfgale')) # ['ale']
16 print(re.findall('alex+', 'asdfgale')) # []
17
18
19 # ？：范围（0,1）
20 print(re.findall('alex?', 'asdfgale')) # ['ale']
21 print(re.findall('alex?', 'asdfgalex')) # ['alex']
22
23
24 # *与？共用：以最小匹配0次
25 print(re.findall('alex*?', 'asdfgale')) # ['ale']
26 print(re.findall('alex*?', 'asdfgalexxxx')) # ['ale']
27
28
29 # +与？共用：以最小匹配1次
30 print(re.findall('alex+?', 'asdfgale')) # []
31 print(re.findall('alex+?', 'asdfgalexxxx')) # ['alex']
32
33
34 # {}: 给定一个范围
35 # {0，无穷}==>*
36 # {1，无穷}==>+
37 # {0,1} ==>?
38 # {6}:出现6次
39 # {1,6}：出现1至6任意一个次数
40 print(re.findall('alex{6}', 'asdfgalex')) # []
41 print(re.findall('alex{6}', 'asdfgalexxxxxx')) # ['alexxxxxx']
42 print(re.findall('alex{1,6}', 'asdfgalexxx')) # ['alexxx']
43 print(re.findall('alex{1,6}', 'asdfgalexxxxxx')) # ['alexxxxxx']元字符：*、+、？、{}
[]：中间出现的全部为普通字符；相当于“或”；只匹配一个；表示范围
1 #!/usr/bin/env python
2 # -*- coding:utf-8 -*-
3 import re
4
5 # []字符串:中间出现的全部为普通字符；相当于“或”；只匹配一个；表示范围
6 print(re.findall('x[y]', 'abcx')) # []
7 print(re.findall('x[y]', 'abcxy')) # ['xy']
8
9
10 # 中间出现：*
11 print(re.findall('x[y*]', 'abcx')) # []
12 print(re.findall('x[y*]', 'abcxy')) # ['xy']
13 print(re.findall('x[y*]', 'abcx*')) # ['x*']
14
15
16 # 中间出现：-;范围不允许a-Z,只能a-z或者A-Z
17 print(re.findall('a[a-z]', 'a2bcdefghijklmnopqrxtuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ')) # []
18 print(re.findall('a[a-z]', 'abcdefghijklmnopqrxtuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ')) # ['ab']
19 print(re.findall('a[A-Z]', 'a2bcdefghijklmnopqrxtuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ')) # []
20 print(re.findall('a[A-Z]', 'aAbcdefghijklmnopqrxtuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ')) # ['aA']
21
22
23 # 后面在出现一个：*
24 print(re.findall('a[a-z]*', 'a2bcdefghijklmnopqrxtuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ')) # ['a']
25 print(re.findall('a[a-z]*', 'abcdefghijklmnopqrxtuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ')) # ['abcdefghijklmnopqrxtuvwxyz']
26 print(re.findall('a[a-z]*', 'abcdefghijklmnopqrxtuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ9')) # ['abcdefghijklmnopqrxtuvwxyz']
27
28
29 # 中间出现:^；代表“非”
30 print(re.findall('q[^a-z]', 'qabc')) # []
31 print(re.findall('q[^a-z]', 'q12')) # ['q1']转义符：[]
|：“或”的意思，要么左边，要么右边
1 #!/usr/bin/env python
2 # -*- coding:utf-8 -*-
3 import re
4 print(re.findall(r'ka|b', 'sdfgjkabc')) # ['ka', 'b']
5 print(re.findall(r'ka|b', 'sdfgjkac')) # ['ka']
6 print(re.findall(r'ka|b', 'sdfgjkbc')) # ['b']转义符：|
()：分组，代表一个整体
1 #!/usr/bin/env python
2 # -*- coding:utf-8 -*-
3 import re
4 print(re.findall('(abc)', 'abcabcabc')) # ['abc', 'abc', 'abc']
5 print(re.search('\d', 'dfas25fd35')) # <re.Match object; span=(4, 5), match='2'>
6 print(re.search('\d', 'dfas25fd35').group()) # 2
7 print(re.search('\d+', 'dfas25fd35')) # <re.Match object; span=(4, 6), match='25'>
8 print(re.search('\d+', 'dfas25fd35').group()) # 25
9 print(re.search('\d{3}', 'dfas25fd35')) # None
10 print(re.search('(?P<name>[a-z]+)', 'alex28liming33')) # <re.Match object; span=(0, 4), match='alex'>
11 print(re.search('(?P<name>[a-z]+)', 'alex28liming33').group()) # alex
12 print(re.search('(?P<name>[a-z]+)\d+', 'alex28liming33')) # <re.Match object; span=(0, 6), match='alex28'>
13 print(re.search('(?P<name>[a-z]+)\d+', 'alex28liming33').group()) # alex28
14 print(re.search('(?P<name>[a-z]+)\d+', 'alex28liming33').group('name')) # alex转义符：()
\：转义符
反斜杠后面跟元字符去除特殊功能
反斜杠后面跟普通字符实现特殊功能
\d：匹配任何十进制数；相当于[0-9]
1 #!/usr/bin/env python
2 # -*- coding:utf-8 -*-
3 import re
4 print(re.findall('\d', '12+(34*6+2-5*(2-1))')) # ['1', '2', '3', '4', '6', '2', '5', '2', '1']
5 print(re.findall('\d+', '12+(34*6+2-5*(2-1))')) # ['12', '34', '6', '2', '5', '2', '1']转义符:\d
\D：匹配任何非十进制数；相当于[^0-9]
1 #!/usr/bin/env python
2 # -*- coding:utf-8 -*-
3 import re
4 print(re.findall('\D', '12+(34*6+2-5*(2-1))')) # ['+', '(', '*', '+', '-', '*', '(', '-', ')', ')']
5 print(re.findall('\D+', '12+(34*6+2-5*(2-1))')) # ['+(', '*', '+', '-', '*(', '-', '))']转义符：\D
\s：匹配任何空白字符；相当于[\t\n\r\f\v]
1 #!/usr/bin/env python
2 # -*- coding:utf-8 -*-
3 import re
4
5 # 转义符:\
6 print(re.findall('\s', 'hello word!')) # [' ']转义符：\s
\S：匹配任何非空白字符；相当于[^\t\n\r\f\v]
1 #!/usr/bin/env python
2 # -*- coding:utf-8 -*-
3 import re
4
5 print(re.findall('\S', 'hello word!')) # ['h', 'e', 'l', 'l', 'o', 'w', 'o', 'r', 'd', '!']
6 print(re.findall('\S+', 'hello word!')) # ['hello', 'word!']转义符：\S
\w：匹配任何字母数字字符；相当于[a-zA-Z0-9]
\W：匹配任何非字母数字字符；相当于[^a-zA-Z0-9]
\b：匹配任何一个特殊字符边界，如：空格、&、#等
re模块下的常用方法
1 #!/usr/bin/env python
2 # -*- coding:utf-8 -*-
3 import re
4 # 1
5 print(re.findall('a', 'alex lisi')) # ['a'];返回所有满足匹配条件的结果，放到列表里
6
7
8 # 2
9 print(re.search('a', 'alex lisi').group()) # a;函数在字符串内查找模式匹配，只能找到第一个匹配然后返回一个包；通过调用group()方法得到匹配的字符串，如果字符串没有匹配，则返回node
10
11
12 # 3
13 print(re.match('a', 'zabc')) # None；同search()，仅匹配字符串开始处
14
15
16 # 4
17 print(re.split(' ', 'hello word abc')) # ['hello', 'word', 'abc']
18
19
20 # 5
21 print(re.sub('\d+', 'A', 'alex6jack5', 1)) # alexAjack5
22 print(re.subn('\d+', 'A', 'alex6jack5', 1)) # ('alexAjack5', 1)
23
24
25 # 6
26 com = re.compile('\d{3}')
27 print(com.search('abc123de45').group()) # 123；可以多次调用
28
29 # 7
30 ret = re.finditer("\d+", "ab35cde47fg88")
31 print(ret) # <callable_iterator object at 0x00000028E5A765C0>
32 print(next(ret).group()) # 35
33 print(next(ret).group()) # 47
34 print(next(ret).group()) # 88re补充：
1 #!/usr/bin/env python
2 # -*- coding:utf-8 -*-
3 import re
4 print(re.findall('www\.(baidu|sina)\.com', 'www.baidu.com')) # ['baidu'];优先匹配分组的内容
5
6 # 分组中添加‘？:’去除优先级
7 print(re.findall('www\.(?:baidu|sina)\.com', 'www.baidu.com')) # ['www.baidu.com']•logging模块
一（简单引用）
1 #!/usr/bin/env python
2 # -*- coding:utf-8 -*-
3 import logging
4 logging.debug('debug message')
5 logging.info('info message')
6 logging.warning('warning message') # WARNING:root:warning message
7 logging.error('error message') # ERROR:root:error message
8 logging.critical('critical message') # CRITICAL:root:critical message可见，默认情况下Python和logging模块将日志打印到了标准输出中，且只显示了大于等于WARNING级别的日志，这说明默认的日志级别设置为WARNING（日志级别登记CRITICAL>ERROR>WARNING>INFO>DEBUG>NOTSET），默认的日志格式为日志级别，Logging名称：用户输出消息。
二 灵活配置日志级别，日志格式，输出位置
1 #!/usr/bin/env python
2 # -*- coding:utf-8 -*-
3 import logging
4
5 logging.basicConfig(
6 level=logging.DEBUG, # 设置级别，大于等于当前级别的打印出来
7 filename='logger.log', # 指定存放位置，默认为追加的模式
8 filemode='w', # 设置日志的格式
9 format='%(asctime)s %(filename)s [%(lineno)d] %(message)s'
10
11 # %(asctime)s;2019-02-04 19:02:34,392
12
13 # %(asctime)s %(lineno)d
14 # 2019-02-04 19:03:03,556 15
15 # 2019-02-04 19:03:03,556 16
16 # 2019-02-04 19:03:03,556 17
17 # 2019-02-04 19:03:03,556 18
18 # 2019-02-04 19:03:03,557 19
19
20 # %(asctime)s [%(lineno)d] %(message)s
21 # 2019-02-04 19:16:13,040 [20] debug message
22 # 2019-02-04 19:16:13,040 [21] info message
23 # 2019-02-04 19:16:13,040 [22] warning message
24 # 2019-02-04 19:16:13,040 [23] error message
25 # 2019-02-04 19:16:13,040 [24] critical message
26
27 # %(asctime)s %(filename)s [%(lineno)d] %(message)s
28 # 2019-02-04 19:21:47,164 sys_logging.py [26] debug message
29 # 2019-02-04 19:21:47,165 sys_logging.py [27] info message
30 # 2019-02-04 19:21:47,165 sys_logging.py [28] warning message
31 # 2019-02-04 19:21:47,165 sys_logging.py [29] error message
32 # 2019-02-04 19:21:47,165 sys_logging.py [30] critical message
33 )
34
35 logging.debug('debug message')
36 logging.info('info message')
37 logging.warning('warning message') # WARNING:root:warning message
38 logging.error('error message') # ERROR:root:error message
39 logging.critical('critical message') # CRITICAL:root:critical messagefilemode：文件打开方式，在指定了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：字符串形式的当前时间，默认格式是'2019-02-04 20:07:00,896'。逗号后面的是毫秒
%(thread)d：线程ID。可能没有
%(threadName)s：线程名。可能没有
%(process)d：进程ID。可能没有
%(message)s：用户输出的消息
三 logger对象
上述几个例子中我们了解了logging.debug()、logging.info()、logging.warning()、logging.error()、logging.critical()（分别用以记录不同级别的日志信息），logging.basicConfig()（用默认日志格式(Formatter)）为日志系统建立一个默认的流处理器(StreamHandler)，设置基础配置(如日志级别等)并加到(root logger(根Logger)中)这几个logging模块级别的函数，另外还有一个模块级别的函数是logging.getLogger([name])(返回一个logger对象，如果没有指定名字将返回root logger)
下面是一个最简单的过程：
1 #!/usr/bin/env python
2 # -*- coding:utf-8 -*-
3 import logging
4 logger = logging.getLogger() # 创建一个文件
5
6 fh = logging.FileHandler('test_log')
7 ch = logging.StreamHandler()
8
9 fm = logging.Formatter('%(asctime)s %(message)s')
10 fh.setFormatter(fm)
11 ch.setFormatter(fm)
12
13 logger.addHandler(fh)
14 logger.addHandler(ch)
15 logger.setLevel('DEBUG')
16
17 logger.debug('debug')
18 logger.info('info')
19 logger.warning('warning') # 2019-02-04 20:38:33,423 warning
20 logger.error('error') # 2019-02-04 20:38:33,423 error
21 logger.critical('critical') # 2019-02-04 20:38:33,424 critical•configparser模块
好多软件的常见文档格式如下：
1 [DEFAULT]
2 ServerAliveInterval = 45
3 Compression = yes
4 CompressionLevel = 9
5 ForwardXll = yes
6
7 [bitbucket.org]
8 User = hg
9
10 [topsecret.server.com]
11 Port = 50022
12 ForwardXll = no如果想用Python生成一个这样的文档怎么做呢？
1 #!/usr/bin/env python
2 # -*- coding:utf-8 -*-
3 import configparser
4
5 config = configparser.ConfigParser() # config = {} 一个空字典
6 config["DEFAULT"] = {
7 'ServerAliveInterval': '45',
8 'Compression': 'yes',
9 'CompressionLevel': '9'
10 }
11
12 config['bitbucket.org'] = {}
13 config['bitbucket.org']['user'] = 'hg'
14 config['topsecret.server.com'] = {}
15 topsecret = config['topsecret.server.com']
16 topsecret['Host Port'] = '50022' # mutates the parser
17 topsecret['ForwardXll'] = 'no' # same here
18 # config['DEFAULT']['ForwardXll'] = 'yes'
19 with open('example.ini', 'w') as f:
20 config.write(f)
1 #!/usr/bin/env python
2 # -*- coding:utf-8 -*-
3 import configparser
4 config = configparser.ConfigParser()
5
6 # ----查询----
7 print(config.sections()) # []
8 config.read('example.ini') # 读文件
9 print(config.sections()) # ['bitbucket.org', 'topsecret.server.com']
10 print(config['bitbucket.org']['User']) # hg
11
12 for key in config['bitbucket.org']:
13 print(key)
14 # 打印结果
15 # user
16 # serveraliveinterval
17 # compression
18 # compressionlevel
19 # forwardxll
20
21 print(config.options('bitbucket.org')) # ['user', 'serveraliveinterval', 'compression', 'compressionlevel', 'forwardxll']
22 print(config.items('bitbucket.org')) # [('serveraliveinterval', '45'), ('compression', 'yes'), ('compressionlevel', '9'), ('forwardxll', 'yes'), ('user', 'hg')]
23 print(config.get('bitbucket.org', 'compression')) # yes；获取键值对中的值
24
25 # ----删、改、增：config.write(open('i.cfg', 'w'))----
26 config.add_section('user_name') # 新增一个块
27 config.set('user_name', 'user', 'test') # 给新增块，添加键值对
28 config.remove_section('user_nsmr') # 删除块
29 config.remove_option('topsecret.server.com', 'forwardxll') # 删除块的,键值对
30 config.write(open('i.cfg', 'w'))configparser增删改查
•hashlib模块
用于加密相关的操作，3.x里代替了md5模块和sha模块，主要提供SHA1,SHA224,SHA256,SHA384,SHA512,MD5算法
1 #!/usr/bin/env python
2 # -*- coding:utf-8 -*-
3 import hashlib
4 obj = hashlib.md5() # m = hashlib.sha256()
5 obj.update("hello".encode('utf8'))
6 print(obj.hexdigest()) # 5d41402abc4b2a76b9719d911017c592以上加密算法虽然依然非常厉害，但是存在缺陷，即：通过撞库可以反解。所以，有必要对加密算法中添加自定义key再来加密。
1 #!/usr/bin/env python
2 # -*- coding:utf-8 -*-
3 import hashlib
4 hash = hashlib.sha256('alex'.encode('utf8'))
5 hash.update('admin'.encode('utf8'))
6 print(hash.hexdigest()) # dee0368f9334b2fd79fa8a37305064025be9ae0ddc8860c0f886b519867c2875Python还有一个hmac模块，它内部对我们创建key和内容，再进行处理然后再加密：
1 #!/usr/bin/env python
2 # -*- coding:utf-8 -*-
3 import hmac
4 h = hmac.new('alex'.encode('utf8'))
5 h.update('hello'.encode('utf8'))
6 print(h.hexdigest()) # c28dbb0cd8e52d54fdcbbff08a5d2dc0
作者：陈彦斌
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
