python用input输入列表有缺陷_Python的模块

模块的基本知识点：

1、定义：一个.py文件就是一个模块

2、模块的种类：

(1)Python标准库(内置模块)

(2)第三方模块

(3)应用程序自定义模块

3、调用模块的关键字：

import : 1、执行调用的文件。 2、引用。

补充：

package(包)的基本知识点：

包的两种调用方式：

## 第一种调用方式

from package1.package2 importtest## 第二种调用方式

from package1.package2.test import function

(1)下面介绍第三方模块的调用方式：

1 ## file_模块.py 文件的内容：

2

3 defadd(a,b):4 return a+b5 defsub(a,b):6 return a*b7

8 if __name__ == '__main__': ## 注意：这里只有在文件内才能运行

9 c = add(1,2)10 print(c)

1 importfile_模块2 c = file_模块.add(2,3)3 print(c)

运行结果： 　　5

(2)Python的内置模块有：

下面逐一介绍各个模块的方法：

1. time模块

1 importtime2

3 #时间戳：

4 print(time.time())5

6 #结构化时间--当地时间

8 print(time.localtime(1585482263.9318557))9 #运行结果：time.struct_time(tm_year=2020, tm_mon=3, tm_mday=29, tm_hour=19, tm_min=44, tm_sec=23, tm_wday=6, tm_yday=89, tm_isdst=0)

10

11 t =time.localtime()12 print(t.tm_year) ## 打印出当地时间的年份

13

14 #结构化时间 -- UTC

15 print(time.gmtime())16 #运行结果：time.struct_time(tm_year=2020, tm_mon=3, tm_mday=29, tm_hour=11, tm_min=50, tm_sec=1, tm_wday=6, tm_yday=89, tm_isdst=0)

17

18 #将结构化时间转化成时间戳

19 print(time.mktime(time.localtime()))20 #运行结果：1585482737.0

21

22 #将结构化时间转化成字符串时间

23 print(time.strftime('%Y--%m--%d %X',time.localtime()))24 #运行结果：2020--03--29 19:57:20

25

26 #将字符串时间转化成结构化时间

27 print(time.strptime('2020--03--29 19:57:20','%Y--%m--%d %X'))28 #运行结果：time.struct_time(tm_year=2020, tm_mon=3, tm_mday=29, tm_hour=19, tm_min=57, tm_sec=20, tm_wday=6, tm_yday=89, tm_isdst=-1)

29

30 print(time.asctime())31 #运行结果：Sun Mar 29 20:00:33 2020

32 print(time.ctime())33

34 importdatetime35 print(datetime.datetime.now())36 #运行结果：2020-03-29 20:02:28.666899

View Code

2.random模块

1 importrandom2

3 ## 从 0-1 随机选出一个小数

4 print(random.random())5

6 ## 从 a-b 随机选出一个整数

7 print(random.randint(1,5))8

9 ## 从 a-b 随机选出一个整数，不包括b

10 print(random.randrange(1,5))11

12 ## 从列表 [11,22,33,44,55] 随机选出一个元素

13 print(random.choice([11,22,33,44,55]))14

15 ## 从列表 [11,22,33,44,55] 随机选出n个元素

16 print(random.sample([11,22,33,44,55],2))17

18 ## 从 a-b 随机选出一个小数

19 print(random.uniform(1,5))20

21 ## 重新排序

22 ret = [1,2,3,4,5]23random.shuffle(ret)24 print(ret)25

26 ## 随机验证码

28 defv_code():29 ret = ''

30 for i in range(4):31 res = random.randint(1,9)32 alf = chr(random.randint(65,122))33 s =str(random.choice([res,alf]))34 ret +=s35 returnret36

37 res =v_code()38 print(res)

View Code

3. json 模块和 pickle 模块

JSON(JavaScript Object Notation, JS 对象标记) 是一种轻量级的数据交换格式。JSON的数据格式其实就是python里面的字典格式，里面可以包含方括号括起来的数组，也就是python里面的列表。

在python中，有专门处理json格式的模块—— json 和 picle模块

Json   模块提供了四个方法： dumps、dump、loads、load

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

下面依次介绍 json 模块和 pickle 模块：

(一) json模块

dumps 和 dump：

dumps 和 dump 序列化：

dumps 会将对象转化成一个带双引号的字符串

dump 必须传文件描述符，只能用在文件操作中

dumps例子：

1 importjson2 res = {'name':'alex','age':17,'agen':'man'}3 print(res)4 print(json.dumps(res))

运行结果：

1 #{'name': 'alex', 'age': 17, 'agen': 'man'}

2 #{"name": "alex", "age": 17, "agen": "man"}

dump例子：

1 importjson2

3 f_write = open('json_test','w')4 res = {'name':'alex','age':17,'agen':'man'}5 json.dump(res,f_write) ## 这里实际上做了两步操作：1、res_dumps = json.dumps(res) 　　2、f_write.write(res_dumps)

loads 和 load 反序列：

loads 只完成了反序列化，

load 只接收文件描述符，完成了读取文件和反序列化

loads例子：

1 importjson2 print(type(json.loads('123')))3 print(type(json.loads('[12]')))4 dic = {'name':'alex'}5 dic_dumps =json.dumps(dic)6 print(dic_dumps)7 dic_loads =json.loads(dic_dumps)8 print(type(dic_loads))

运行结果：

1 #

2 #

3 #{"name": "alex"}

4 #

load例子：

1 importjson2 f = open('json_test','r')3 r_read = json.load(f) ## 相当于： 1、r_read = f.read() 2、r_read = json.loads(r_read)

4 print(r_read,type(r_read))

运行结果：

1 #{'name': 'alex', 'age': 17, 'agen': 'man'}

(二)pickle模块

dumps 和 dump：

dumps 和 dump 序列化：

dumps 会将对象转化成一个二进制

dump 必须传文件描述符，只能用在文件操作中

dumps例子：

1 importpickle2 res = '这是一个字符串'

3 res =pickle.dumps(res)4 print(res,'\n',type(res))

运行结果：

1 #b'\x80\x03X\x15\x00\x00\x00\xe8\xbf\x99\xe6\x98\xaf\xe4\xb8\x80\xe4\xb8\xaa\xe5\xad\x97\xe7\xac\xa6\xe4\xb8\xb2q\x00.'

2 #

dump例子：

1 importpickle2 f = open('pickle_test','wb')3 res = '这是pickle_test的内容'

4 pickle.dump(res,f) ## 相当于：1、res = pickle.dumps(res) 2、f.write(res)

loads 和 load 反序列：

loads 只完成了反序列化，

load 只接收文件描述符，完成了读取文件和反序列化

loads例子：

1 importpickle2 res = b'\x80\x03X\x15\x00\x00\x00\xe8\xbf\x99\xe6\x98\xaf\xe4\xb8\x80\xe4\xb8\xaa\xe5\xad\x97\xe7\xac\xa6\xe4\xb8\xb2q\x00.'

3 print(pickle.loads(res))

运行结果：

1 #这是一个字符串

load例子：

1 importpickle2 f = open('pickle_test','rb')3 res =pickle.load(f)4 print(res)

运行结果：

1 #这是pickle_test的内容

(三)python对象(obj) 与json对象的对应关系

+-------------------+---------------+

| Python | JSON |

+===================+===============+

| dict | object |

+-------------------+---------------+

| list, tuple | array |

+-------------------+---------------+

| str | string |

+-------------------+---------------+

| int, float | number |

+-------------------+---------------+

| True | true |

+-------------------+---------------+

| False | false |

+-------------------+---------------+

| None | null |

+-------------------+---------------+

(四)总结

1. json序列化方法：

dumps：无文件操作            dump：序列化+写入文件

2. json反序列化方法：

loads：无文件操作              load： 读文件+反序列化

3. json模块序列化的数据 更通用

picle模块序列化的数据 仅python可用，但功能强大，可以序列号函数

4. json模块可以序列化和反序列化的  数据类型 见  python对象(obj) 与json对象的对应关系表

5. 格式化写入文件利用  indent = 4

4.os模块

os模块是与操作系统交互的一个接口

1os.getcwd() 获取当前工作目录，即当前python脚本工作的目录路径2 os.chdir("dirname") 改变当前脚本工作目录；相当于shell下cd3 os.curdir 返回当前目录: ('.')4 os.pardir 获取当前目录的父目录字符串名：('..')5 os.makedirs('dirname1/dirname2') 可生成多层递归目录6 os.removedirs('dirname1') 若目录为空，则删除，并递归到上一级目录，如若也为空，则删除，依此类推7 os.mkdir('dirname') 生成单级目录；相当于shell中mkdir dirname8 os.rmdir('dirname') 删除单级空目录，若目录不为空则无法删除，报错；相当于shell中rmdir dirname9 os.listdir('dirname') 列出指定目录下的所有文件和子目录，包括隐藏文件，并以列表方式打印10os.remove() 删除一个文件11 os.rename("oldname","newname") 重命名文件/目录12 os.stat('path/filename') 获取文件/目录信息13 os.sep 输出操作系统特定的路径分隔符，win下为"\\",Linux下为"/"

14 os.linesep 输出当前平台使用的行终止符，win下为"\t\n",Linux下为"\n"

15os.pathsep 输出用于分割文件路径的字符串 win下为;,Linux下为:16 os.name 输出字符串指示当前使用平台。win->'nt'; Linux->'posix'

17 os.system("bash command") 运行shell命令，直接显示18os.environ 获取系统环境变量19os.path.abspath(path) 返回path规范化的绝对路径20os.path.split(path) 将path分割成目录和文件名二元组返回21os.path.dirname(path) 返回path的目录。其实就是os.path.split(path)的第一个元素22os.path.basename(path) 返回path最后的文件名。如何path以／或\结尾，那么就会返回空值。即os.path.split(path)的第二个元素23os.path.exists(path) 如果path存在，返回True；如果path不存在，返回False24os.path.isabs(path) 如果path是绝对路径，返回True25os.path.isfile(path) 如果path是一个存在的文件，返回True。否则返回False26os.path.isdir(path) 如果path是一个存在的目录，则返回True。否则返回False27os.path.join(path1[, path2[, ...]]) 将多个路径组合后返回，第一个绝对路径之前的参数将被忽略28os.path.getatime(path) 返回path所指向的文件或者目录的最后存取时间29os.path.getmtime(path) 返回path所指向的文件或者目录的最后修改时间30os.system和os.popen的区别：

os.system返回是否运行成功，成功返回0，失败返回1

os.popen返回shell运行的结果

5.re模块(重点)

正则表达式本身是一种小型的、高度专业化的编程语言，而在python中，通过内嵌集成re模块，程序员们可以直接调用来实现正则匹配。正则表达式模式被编译成一系列的字节码，然后由用C编写的匹配引擎执行。

本小结需要掌握的知识点有：

一、元字符

二、正则表达式的函数

下面分别学习两大知识点：

一、元字符

元字符有 . ^ $ * + {} ? () [ ] |  \

下面依次进行学习：

(1).

进行匹配时，一个.可以代替一个换行符以外的任意字符串，下面例子：

1 importre2 res = 'jksdjaexxofjasklgoasdalexijgjasgiojwoijrwng'

3 ret = re.findall('j..d',res) ## 模糊匹配，这里(..)代替两个除了换行符以外的任意的字符串，假如条件一样，那么结果会出现多个

4 print(ret)5 #运行结果：['jksd']

元字符 .

(2)^

匹配对象开头部分，下面例子：

1 importre2 res = 'jksdjaexxofjasklgoasdalexijgjasgiojwoijrwng'

3 ret = re.findall('^j..d',res) ## 模糊匹配，只能匹配对象开头的部分，若是开头匹配不了则传回一个空列表

4 print(ret)5 #运行结果：['jksd']

元字符 ^

(3)$

匹配对象末尾部分，下面例子：

1 importre2 res = 'jksdjaexxofjasklgoasdalexijgjasgiojwoijrwng'

3 ret = re.findall('rw.g$',res) ## 模糊匹配，只能匹配对象末尾的部分，若是末尾匹配不了则传回一个空列表

4 print(ret)5 #运行结果：['rwng']

元字符 $

(4)*(贪婪匹配)

匹配0次或者多次前面出现的正则表达式，下面例子：

1 importre2 res = 'dddddddddddddddddddddddijodjsgjjjjjjjjjjjjjjjjjj'

3 ret = re.findall('d*',res) ## 模糊匹配，返回一个列表，匹配 0-无穷次 的重复内容

4 print(ret)5 ## 运行结果：['ddddddddddddddddddddddd', '', '', '', 'd', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '']

元字符 *

(5)+(贪婪匹配)

匹配1次或者多次前面出现的正则表达式，下面例子：

1 importre2 res = 'dddddddddddddddddddddddijodjsgjjjjjjjjjjjjjjjjjj'

3 ret = re.findall('d+',res) ## 模糊匹配，返回一个列表，匹配 1-无穷次 的重复内容

4 print(ret)5 ## 运行结果： ['ddddddddddddddddddddddd', 'd']

元字符 +

注意： * 和 + 都是匹配其前面的那一个字符的重复内容，下面例子：

1 res1 = re.findall('alex*','hello alea alexxxxx123')2 res2 = re.findall('alex+','hello alse aleads')3 print(res1,'分割线--分割线',res2)4 ## 运行结果：['ale', 'alexxxxx'] 分割线--分割线 []

* 和 +

总结： * 和 + 都是贪婪匹配(尽可能匹配)

(6){ }

格式：{ a,b }　　精准匹配 a-b 次前面出现的正则表达式

1 importre2 ret1 = re.findall('alex{6}','alexxx') ## 注意：{6} 表示前面的正则表达式必须要出现6次

3 ret2 = re.findall('alex{0,6}','alejjjalexxjjj')4 print(ret1,'\n',ret2)

元字符 {}

运行结果：

1 #[]

2 #['ale', 'alexx']

(7)? (惰性匹配)

匹配0次或者1次前面出现的正则表达式

*和 + 后面加入 ？ 可以变成惰性匹配(最多只能匹配一次)，下面例子：

1 importre2 res = 'alexxxx alexx alexxxx alexxx'

3 ret1 = re.findall('alex?',res)4 ret2 = re.findall('alex*?',res) ## 将 * 变成惰性匹配

5 ret3 = re.findall('alex+?',res) ## 将 + 变成惰性匹配

6 print(ret1,'\n',ret2,'\n',ret3)

元字符 ？

1 #运行结果：

2 #['alex', 'alex', 'alex', 'alex']

3 #['ale', 'ale', 'ale', 'ale']

4 #['alex', 'alex', 'alex', 'alex']

(8)( ) (分组)

匹配封闭的正则表达式，然后另存为子组，下面例子：

1 importre2 ret1 = re.findall('(abc)+','abcabcabcabcaaabcabc')3 ret2 = re.findall('(?:abc)+','abcabcabcabcaaabcabc') ## 和上式的区别：显示重复(abc)

4 print(ret1,'\n',ret2)

分组元字符 ()

运行结果：

1 #运行结果：

2 #['abc', 'abc']

3 #['abcabcabcabc', 'abcabc']

注意：像"abcabc"这种连在一起的进行分组匹配时，只能匹配出一个['abc']

分组权限比普通权限要高，加(？：)可以去权限

1 importre2 ## 分组权限

3 res = re.findall('d(\d)','abcd123')4 print(res) ##`['1']

5

6 ## 去权限

7 res = re.findall('d(?:\d)','abcd123')8 print(res) ## ['d1']

分组权限

(9) [ ]

1、形式：[..] 　　匹配来自字符集的任意单个字符

2、形式：[x-y]　　匹配x~y范围中的任意单个字符

3、形式：[^x-y]　　匹配x~y范围以外的任意单个字符

例子：

1 importre2 ret1 = re.findall('a[bc]d','abcdffabdfffacdffad')3 ret2 = re.findall('[a-z]','abc123abc')4 ret3 = re.findall('[^a-z]','abc123abc')5 print(ret1,'\n',ret2,'\n',ret3)

元字符 []

运行结果：

1 #['abd', 'acd']

2 #['a', 'b', 'c', 'a', 'b', 'c']

3 #['1', '2', '3']

(10) | 管道符

格式： ab|c　　匹配 ab 或者 c

例子：

1 importre2 ret = re.findall('ab|c','acabddbddcddab')3 print(ret)

运行结果：

#['c', 'ab', 'c', 'ab']

(11) \ 转义字符

1、转移符可以让无意义的字母变成有意义的符号，也就是下面的特殊功能

下面是转义字符的用法：

2、转移符也可以让有意义的元字符变成无意义的字符串，如"."加上 "\."就可以让"."这个元字符变成一个普通的字符串

下面注意一个现象：

1 importre2 ret = re.findall('c\b','abc abc')3 print(ret)4 #运行结果：[]

分析一下：为什么这里会匹配不出来呢？"\b"不是代表空格吗？

原因是re只是一个模块，如果上述"c\b"直接交给re模块肯定没问题，但是我们是用Python解释器进行解释提交给re模块，而中间的过程由于反斜杠“\b”是有意义的，Python解释器提前把“\b”解释了，后面真正交给re模块的就只剩下“c”了，所以我们可以有两种方法来解决这个问题：

第一种方法：

1 importre2 ret = re.findall('c\\b','abc abc') ## 在 \ 前加入一个 \ ，Python解释器先转义一层，再交给re

3 print(ret)4 #运行结果：['c', 'c']

第二种方法：

转义前加入 r ，r 表示Python解释器不做任何转义

1 importre2 ret = re.findall(r'c\b','abc abc')3 print(ret)4 #运行结果：['c', 'c']

由于第二种方法会比较简单，不用管加入几个反斜杠，所以尽量使用第二种方法。

二、正则表达式的方法

常用的方法有：

1，findall：生成一个列表

2，search：返回值是一个对象，如果匹配不成功就返回一个None

3，match：跟search一样，不过只在最前面匹配

4，split：分隔符，功能比字符串的要强大一些

1 importre2 ##### 常用方法有：

3 #1，findall：生成一个列表

4 #2，search：返回值是一个对象，如果匹配不成功就返回一个None

5 ret = re.search('a','abc')6 print(ret)7 print(ret.group())8 #运行结果：

9 #a

10

11 #3，match：跟search一样，不过只在最前面匹配

12 #4，split：分隔符，功能比字符串的要强大一些

13 ret = re.split('[ab]','abnidsabci') ## 将a和b作为两个分隔符进行分割

14 print(ret)15 ## 运行结果：['', '', 'nids', '', 'ci']

16

17 ## 5，sub：替换

18 ret = re.sub('\d','A','jiosdf1235df485eg1d5ge',5) ## 把字符串里的数字全部换成A，后面可以带参数

19 print(ret)20 ## 运行结果：jiosdfAAAAdfA85eg1d5ge

21 ret = re.subn('\d','A','jiosdf1235df485eg1d5ge') ## 替换，并且返回替换的次数

22 print(ret)23 ## 匹配结果：('jiosdfAAAAdfAAAegAdAge', 9)

24

25 ## 6，compile： 编译成一个对象，生成一个方法，直接调用匹配

26 ret = re.compile('\d+') ## 生成一个对象，直接调用匹配，方便多次调用

27 ret = ret.findall('d54g8ege44')28 print(ret)29 ## 运行结果：['54', '8', '44']

30

31 ## 7,finditer:跟findall一样，区别在于会生成一个迭代器,可以直接用next调用

32 ret = re.finditer('\d+','4df48ge54ge24ge6561ge')33 print(next(ret).group())34 print(next(ret).group())35 print(next(ret).group())36 print(next(ret).group())37 print(next(ret).group())38

39 ######################## 补充：

40 ret = re.findall('www\.(baidu|163)\.com','hoishdwww.baidu.comjisjdwww.163.com46') ## 括号优先匹配，这会优先把括号里面的内容打印出来，打印结果是['baidu', '163']

41 ret1 = re.findall('www\.(?:baidu|163)\.com','hoishdwww.baidu.comjisjdwww.163.com46') ## 这个会去优先级，把www.baidu.com整个都给打印出来['www.baidu.com', 'www.163.com']

42 #ret1 = re.findall(r'www.(?:baidu|163).com','hoishdwww.baidu.comjisjdwww.163.com46')

43 print(ret1,ret)

re模块常用方法

6.sys模块

进度条：

1 importsys,time2 for i in range(10):3 sys.stdout.write('#')4 time.sleep(1)5 sys.stdout.flush()

7、xml 模块

xml是实现不同语言或程序之间进行数据交换的协议，跟json差不多，但json使用起来更简单，不过，古时候，在json还没诞生的黑暗年代，大家只能选择用xml呀，至今很多传统公司如金融行业的很多系统的接口还主要是xml。

xml的格式如下，就是通过<>节点来区别数据结构的:

1 <?xml version="1.0"?>

2

3

4 2

5 2008

6 141100

7

8

9

10

11 5

12 2011

13 59900

14

15

16

17 69

18 2011

19 13600

20

21

22

23

View Code

下面用xml模块对上面的xml文件进行增删改查：

1 importxml.etree.ElementTree as ET2

3 tree = ET.parse('xml_lesson') ## 打开xml_lesson 这个文件，parse和open相似

4 root = tree.getroot() ## 生成一个根对象

5 print(root.tag) ## 标签名

6

7 ## 遍历xml root根

8 for i inroot:9 print(i.tag) ## 打印各个标签名

10 ## 运行结果：country

11 #country

12 #country

13

14 print(i.attrib) ## 打印各个属性，结果返回一个字典

15 ## 运行结果：{'name': 'Liechtenstein'}

16 #{'name': 'Singapore'}

17 #{'name': 'Panama'}

18

19 for j in i: ## 继续遍历i

20 #print(j.tag)

21 print(j.text) ## 打印文本内容

22 ## 打印结果：2

23 #2008

24 #141100

25 #None

26 #None

27 #5

28 #2011

29 #59900

30 #None

31 #69

32 #2011

33 #13600

34 #None

35 #None

36

37 ## 只遍历year标签

38 for i in root.iter('year'):39 print(i.tag,i.text)40 ## 运行结果：year 2008

41 #year 2011

42 #year 2011

43

44 ## 增删改

45

46 for nood in root.iter('year'):47 #增改

48 new_text = int(nood.text)+1

49 nood.text =str(new_text)50 nood.set('update','yes') ## 增加属性

51 tree.write('xml_lesson.xml') ## 建立和xml文件的联系，重新写入文件中

52

53 #删

54 for country in root.findall('country'):55 rank = int(country.find('rank').text)56 if rank>50:57 root.remove(country)58

59 tree.write('output.xml')

xml增删改查

用xml模块生成一个xml文件：

1 ################################## 生成一个xml的文件对象 ####################################

2 importxml3 importxml.etree.ElementTree as ET4 new_xml = ET.Element('name list')5 name = ET.SubElement(new_xml,'name',attrib={'enrolled':'yes'}) ## new_xml 是对象，name是标签

6 age = ET.SubElement(name,'age',attrib={'checked':'no'})7 sex = ET.SubElement(name,'sex')8 sex.text = '39'

9 name2 = ET.SubElement(new_xml,'name',attrib={'enrolled':'no'})10 age = ET.SubElement(name2,'age',attrib={'check':'yes'})11 age.text = '19'

12 et = ET.ElementTree(new_xml) ##### 把上面的内容写进一个新文档里去，固定格式

13 et.write('test.xml')

xml模块生成一个xml文件

8、configparser模块

config：配置。也就是说这个文件是为了配置文件而开发的

用configparser模块创建一个新的配置文件：

1 importconfigparser2 config = configparser.ConfigParser() ## config = {}

3

4 config['DEFAULT'] ={5 'ServerAliveInterval':'45',6 'Compression':'yes',7 'CompressionLevel':'9'

8 }9 config['DEFAULT']['ForwardX11'] = 'yes'

10

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

13

14 config['topsecret.server.com'] ={}15 topsecret = config['topsecret.server.com']16 topsecret['Host.Port'] = '50022'

17 topsecret['ForwardX11'] = 'no'

18

19 #写入文件中

20 with open('config_test','w') as configfile:21 config.write(configfile)22 configfile.close()23

24 ################################ 增删改查 ##############################

25 importconfigparser26 config =configparser.ConfigParser()27 print(config.sections()) ## []

28

29 #####################################查--------------------------------------

30 config.read('config_test')31 print(config.sections()) ## 只打印除了默认以外的键值

32 print(config['bitbucket.org']['user'])33 for key in config['bitbucket.org']:34 print(key) ## 会把DEFAULT下的内容都变历出来

35 print(config.options('bitbucket.org')) ## 遍历key值组成一个列表显示出来

36 print(config.items('bitbucket.org')) ## 遍历内容组成一个元祖显示出来

37 print(config.get('bitbucket.org','compression'))38 print(config.get('bitbucket.org','compressionlevel')) ## 取'bitbucket.org'下的'compressionlevel'对应的值

39

40 ###########################################增删--------------------------------------------

41 config.add_section('yuan') ## 增加块

42 config.set('yuan','s1','11111111111111')43 #config.remove_section('bitbucket.org') ## 删除块

44 config.remove_option('topsecret.server.com','host.port') ## 删除键值对

45 config.write(open('config','w'))

configparser创建配置文件

生成的文件：

[DEFAULT]

serveraliveinterval= 45compression=yes

compressionlevel= 9forwardx11=yes

[bitbucket.org]

user=hg

[topsecret.server.com]

forwardx11=no

[yuan]

s1= 11111111111111

配置文件

9、haslib模块

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

1 ###################################### hashlib：加密 ###################################

2 importhashlib3 obj =hashlib.md5()4 obj.update('root'.encode('utf8')) ## 63a9f0ea7bb98050796b649e85481845

5 print(obj.hexdigest())6

7 obj.update('admin'.encode('utf8'))8 print(obj.hexdigest()) ## cd92a26534dba48cd785cdcc0b3e6bd1 注意：这是在原有root基础后面加上了admin

9

10 obj.update('root'.encode('gbk'))11 print(obj.hexdigest()) ## 407e011dea1df3c552d2c49659c0ad27

hashlib

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

1 importhashlib2

3 ######### 256 ########

4

5 hash = hashlib.sha256('898oaFs09f'.encode('utf8'))6 hash.update('alvin'.encode('utf8'))7 print (hash.hexdigest())#e79e68f070cdedcfe63eaf1a2e92c83b4cfb1b5c6bc452d214c1b7e77cdfd1c7

加入自定义key

python 还有一个 hmac 模块，它内部对我们创建 key 和 内容 再进行处理然后再加密:

1 importhmac2 h = hmac.new('alvin'.encode('utf8'))3 h.update('hello'.encode('utf8'))4 print (h.hexdigest())#320df9832eab4c038b6c1d7ed73a5940

hmac

10、logging模块(重点)

下面写一个简单的logging文件，并且分成了五个级别，约到后面等级越高

1 importlogging2

3 logging.debug('debug message')4

5 logging.info('info message')6

7 logging.warning('warning message')8

9 logging.error('error message')10

11 logging.critical('critical message')

简单的logging

修改参数：

1 ##--------------------------》 basicConfig 方式

2 importlogging3 logging.basicConfig(4 level=logging.DEBUG, ##修改默认打印值

5 filename= 'logging.log', ## 追加模式，生成一个文件logging.log

6 filemode='w', ## 从追加模式改为覆盖模式

7 format = '%(asctime)s %(filename)s [%(lineno)d] %(message)s' ## 添加参数 lineno-->显示第几行

8 )9 logging.debug('debug message')10 logging.info('info message')11 logging.warning('warning message') ## 默认会打印到warning级别，想要全部打印就需要修改默认值

12 logging.error('error message')13 logging.critical('critical message')

修改参数

生成的文件：

2020-03-31 21:29:13,084 loggingģ��.py [11] debug message2020-03-31 21:29:13,090 loggingģ��.py [12] info message2020-03-31 21:29:13,090 loggingģ��.py [13] warning message2020-03-31 21:29:13,090 loggingģ��.py [14] error message2020-03-31 21:29:13,090 loggingģ��.py [15] critical message

logging.log

如果需要多次使用日志功能，那么就可以写出一个日志功能的函数，直接调用就可以了，且这种方式是用的最多的

1 #-------------------------------> logger 对象

2 deflogger():3 logger =logging.getLogger()4

5 fh = logging.FileHandler('test_log') ## 文件修改

6 ch = logging.StreamHandler() ## 屏幕打印

7

8 fm = logging.Formatter('%(asctime)s %(message)s') ## 自定义格式

9

10 fh.setFormatter(fm) ## 修改设定

11 ch.setFormatter(fm)12

13 logger.addHandler(fh)14 logger.addHandler(ch)15 logger.setLevel('DEBUG') ## 修改默认值

16 #logger.filemode('w')

17 returnlogger18 ## logger对象的设定

19

20 ##------------------------------------

21

22 ## logger对象的调用

23 logger =logger()24 logger.debug('debug')25 logger.info('info')26 logger.warning('warning')27 logger.error('error')28 logger.critical('critical')

logger

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用户输出的消息