Python的模块

模块的基本知识点：

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

2、模块的种类：

　　（1）Python标准库（内置模块）

　　（2）第三方模块

　　（3）应用程序自定义模块

3、调用模块的关键字：

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

补充：

package（包）的基本知识点：

包的两种调用方式：

##    第一种调用方式
from package1.package2 import test

##    第二种调用方式
from package1.package2.test import function

（1）下面介绍第三方模块的调用方式：

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

def add(a,b):
    return a+b
def sub(a,b):
    return a*b

if __name__ == '__main__':    ##   注意：这里只有在文件内才能运行
    c = add(1,2)
    print(c)

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

运行结果： 　　5

（2）Python的内置模块有：

1. time（时间）模块
2. random（随机）模块
3. json模块和pickle模块
4. os模块（文件操作）
5. re模块（正则表达式）（重点）
6. sys模块
7. xml模块
8. configparser模块
9. hashlib模块（加密）
10. logging模块（日志）（重点）

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

• 1. time模块

 1 import time
 2 
 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 import datetime
35 print(datetime.datetime.now())
36 #   运行结果：2020-03-29 20:02:28.666899

• 2.random模块

 1 import random
 2 
 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]
23 random.shuffle(ret)
24 print(ret)
25 
26 ##  随机验证码
28 def v_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 += s
35     return ret
36 
37 res = v_code()
38 print(res)

• 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例子：

import  json
res = {'name':'alex','age':17,'agen':'man'}
print(res)
print(json.dumps(res))

 运行结果：

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

dump例子：

import json

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

loads 和 load 反序列：

       loads 只完成了反序列化，

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

loads例子：

import json
print(type(json.loads('123')))
print(type(json.loads('[12]')))
dic = {'name':'alex'}
dic_dumps = json.dumps(dic)
print(dic_dumps)
dic_loads = json.loads(dic_dumps)
print(type(dic_loads))

运行结果：

# <class 'int'>
# <class 'list'>
# {"name": "alex"}
# <class 'dict'>

load例子：

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

 运行结果：

# {'name': 'alex', 'age': 17, 'agen': 'man'} <class 'dict'>

（二）pickle模块

dumps 和 dump：

 

dumps 和 dump 序列化：

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

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

 

dumps例子：

import pickle
res = '这是一个字符串'
res = pickle.dumps(res)
print(res,'
',type(res))

 运行结果：

# b'x80x03Xx15x00x00x00xe8xbfx99xe6x98xafxe4xb8x80xe4xb8xaaxe5xadx97xe7xacxa6xe4xb8xb2qx00.' 
#  <class 'bytes'>

dump例子：

import pickle
f = open('pickle_test','wb')
res = '这是pickle_test的内容'
pickle.dump(res,f)      ##  相当于：1、res = pickle.dumps(res)  2、f.write(res)

 

 

loads 和 load 反序列：

       loads 只完成了反序列化，

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

 

loads例子：

import pickle
res = b'x80x03Xx15x00x00x00xe8xbfx99xe6x98xafxe4xb8x80xe4xb8xaaxe5xadx97xe7xacxa6xe4xb8xb2qx00.'
print(pickle.loads(res))

 运行结果：

#这是一个字符串

load例子：

import pickle
f = open('pickle_test','rb')
res = pickle.load(f)
print(res)

运行结果：

#这是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模块是与操作系统交互的一个接口

1 os.getcwd() 获取当前工作目录，即当前python脚本工作的目录路径
 2 os.chdir("dirname")  改变当前脚本工作目录；相当于shell下cd
 3 os.curdir  返回当前目录: ('.')
 4 os.pardir  获取当前目录的父目录字符串名：('..')
 5 os.makedirs('dirname1/dirname2')    可生成多层递归目录
 6 os.removedirs('dirname1')    若目录为空，则删除，并递归到上一级目录，如若也为空，则删除，依此类推
 7 os.mkdir('dirname')    生成单级目录；相当于shell中mkdir dirname
 8 os.rmdir('dirname')    删除单级空目录，若目录不为空则无法删除，报错；相当于shell中rmdir dirname
 9 os.listdir('dirname')    列出指定目录下的所有文件和子目录，包括隐藏文件，并以列表方式打印
10 os.remove()  删除一个文件
11 os.rename("oldname","newname")  重命名文件/目录
12 os.stat('path/filename')  获取文件/目录信息
13 os.sep    输出操作系统特定的路径分隔符，win下为"\",Linux下为"/"
14 os.linesep    输出当前平台使用的行终止符，win下为"	
",Linux下为"
"
15 os.pathsep    输出用于分割文件路径的字符串 win下为;,Linux下为:
16 os.name    输出字符串指示当前使用平台。win->'nt'; Linux->'posix'
17 os.system("bash command")  运行shell命令，直接显示
18 os.environ  获取系统环境变量
19 os.path.abspath(path)  返回path规范化的绝对路径
20 os.path.split(path)  将path分割成目录和文件名二元组返回
21 os.path.dirname(path)  返回path的目录。其实就是os.path.split(path)的第一个元素
22 os.path.basename(path)  返回path最后的文件名。如何path以／或结尾，那么就会返回空值。即os.path.split(path)的第二个元素
23 os.path.exists(path)  如果path存在，返回True；如果path不存在，返回False
24 os.path.isabs(path)  如果path是绝对路径，返回True
25 os.path.isfile(path)  如果path是一个存在的文件，返回True。否则返回False
26 os.path.isdir(path)  如果path是一个存在的目录，则返回True。否则返回False
27 os.path.join(path1[, path2[, ...]])  将多个路径组合后返回，第一个绝对路径之前的参数将被忽略
28 os.path.getatime(path)  返回path所指向的文件或者目录的最后存取时间
29 os.path.getmtime(path)  返回path所指向的文件或者目录的最后修改时间
30 os.system和os.popen的区别：
　　　　os.system返回是否运行成功，成功返回0，失败返回1
　　　　os.popen返回shell运行的结果

•   5.re模块（重点）

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

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

　一、元字符

　二、正则表达式的函数

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

一、元字符

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

下面依次进行学习：

（1）.

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

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

（2） ^ 

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

1 import re
2 res = 'jksdjaexxofjasklgoasdalexijgjasgiojwoijrwng'
3 ret = re.findall('^j..d',res)    ##   模糊匹配，只能匹配对象开头的部分，若是开头匹配不了则传回一个空列表
4 print(ret)
5 #   运行结果：['jksd']

（3）$

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

1 import re
2 res = 'jksdjaexxofjasklgoasdalexijgjasgiojwoijrwng'
3 ret = re.findall('rw.g$',res)    ##   模糊匹配，只能匹配对象末尾的部分，若是末尾匹配不了则传回一个空列表
4 print(ret)
5 #   运行结果：['rwng']

（4）* （贪婪匹配）

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

import re
res = 'dddddddddddddddddddddddijodjsgjjjjjjjjjjjjjjjjjj'
ret = re.findall('d*',res)      ##  模糊匹配，返回一个列表，匹配 0-无穷次 的重复内容
print(ret)
##  运行结果：['ddddddddddddddddddddddd', '', '', '', 'd', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '']

（5）+ （贪婪匹配）

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

import re
res = 'dddddddddddddddddddddddijodjsgjjjjjjjjjjjjjjjjjj'
ret = re.findall('d+',res)      ##  模糊匹配，返回一个列表，匹配 1-无穷次 的重复内容
print(ret)
##  运行结果： ['ddddddddddddddddddddddd', 'd']

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

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

总结： * 和 + 都是贪婪匹配（尽可能匹配） 

（6）{ } 

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

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

 运行结果：

# [] 
# ['ale', 'alexx']

（7） ? （惰性匹配）

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

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

import re
res = 'alexxxx alexx alexxxx alexxx'
ret1 = re.findall('alex?',res)
ret2 = re.findall('alex*?',res)     ##  将 * 变成惰性匹配
ret3 = re.findall('alex+?',res)     ##  将 + 变成惰性匹配
print(ret1,'
',ret2,'
',ret3)

# 运行结果：
# ['alex', 'alex', 'alex', 'alex'] 
# ['ale', 'ale', 'ale', 'ale'] 
# ['alex', 'alex', 'alex', 'alex']

（8） ( )  （分组）

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

import re
ret1 = re.findall('(abc)+','abcabcabcabcaaabcabc')
ret2 = re.findall('(?:abc)+','abcabcabcabcaaabcabc')     ##  和上式的区别：显示重复（abc）
print(ret1,'
',ret2)

 运行结果：

# 运行结果：
# ['abc', 'abc'] 
# ['abcabcabcabc', 'abcabc']

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

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

import re
##  分组权限
res = re.findall('d(d)','abcd123')
print(res)      ##`['1']

##  去权限
res = re.findall('d(?:d)','abcd123')
print(res)      ##  ['d1']

（9） [ ] 

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

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

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

例子：

import re
ret1 = re.findall('a[bc]d','abcdffabdfffacdffad')
ret2 = re.findall('[a-z]','abc123abc')
ret3 = re.findall('[^a-z]','abc123abc')
print(ret1,'
',ret2,'
',ret3)

 运行结果：

#  ['abd', 'acd'] 
#  ['a', 'b', 'c', 'a', 'b', 'c'] 
#  ['1', '2', '3']

（10） | 管道符

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

例子：

import re
ret = re.findall('ab|c','acabddbddcddab')
print(ret)

运行结果：

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

（11） 转义字符

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

下面是转义字符的用法：

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

下面注意一个现象：

import re
ret = re.findall('c','abc abc')
print(ret)
#   运行结果：[]

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

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

第一种方法：

import re
ret = re.findall('c\b','abc abc')      ##  在  前加入一个  ，Python解释器先转义一层，再交给re
print(ret)
#   运行结果：['c', 'c']

第二种方法：

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

import re
ret = re.findall(r'c','abc abc')      
print(ret)
#   运行结果：['c', 'c']

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

二、正则表达式的方法

常用的方法有：

1，findall：生成一个列表
2，search：返回值是一个对象，如果匹配不成功就返回一个None
3，match：跟search一样，不过只在最前面匹配
4，split：分隔符，功能比字符串的要强大一些

import re
#####   常用方法有：
 # 1，findall：生成一个列表
 # 2，search：返回值是一个对象，如果匹配不成功就返回一个None
ret = re.search('a','abc')
print(ret)
print(ret.group())
# 运行结果： <re.Match object; span=(0, 1), match='a'>
#             a

 # 3，match：跟search一样，不过只在最前面匹配
 # 4，split：分隔符，功能比字符串的要强大一些
ret = re.split('[ab]','abnidsabci')     ##  将a和b作为两个分隔符进行分割
print(ret)
##  运行结果：['', '', 'nids', '', 'ci']

##  5，sub：替换
ret = re.sub('d','A','jiosdf1235df485eg1d5ge',5)       ##  把字符串里的数字全部换成A，后面可以带参数
print(ret)
##  运行结果：jiosdfAAAAdfA85eg1d5ge
ret = re.subn('d','A','jiosdf1235df485eg1d5ge')      ##  替换，并且返回替换的次数
print(ret)
##  匹配结果：('jiosdfAAAAdfAAAegAdAge', 9)

##  6，compile：  编译成一个对象，生成一个方法，直接调用匹配
ret = re.compile('d+')     ##  生成一个对象，直接调用匹配，方便多次调用
ret = ret.findall('d54g8ege44')
print(ret)
##  运行结果：['54', '8', '44']

##  7,finditer:跟findall一样，区别在于会生成一个迭代器,可以直接用next调用
ret = re.finditer('d+','4df48ge54ge24ge6561ge')
print(next(ret).group())
print(next(ret).group())
print(next(ret).group())
print(next(ret).group())
print(next(ret).group())

########################    补充：
ret = re.findall('www.(baidu|163).com','hoishdwww.baidu.comjisjdwww.163.com46')   ##  括号优先匹配，这会优先把括号里面的内容打印出来，打印结果是['baidu', '163']
ret1 = re.findall('www.(?:baidu|163).com','hoishdwww.baidu.comjisjdwww.163.com46')    ## 这个会去优先级，把www.baidu.com整个都给打印出来['www.baidu.com', 'www.163.com']
# ret1 = re.findall(r'www.(?:baidu|163).com','hoishdwww.baidu.comjisjdwww.163.com46')
print(ret1,ret)

• 6.sys模块

1 2 3 4 5 6

sys.argv           命令行参数List，第一个元素是程序本身路径 sys.exit(n)        退出程序，正常退出时exit(0) sys.version        获取Python解释程序的版本信息 sys.maxint         最大的Int值 sys.path           返回模块的搜索路径，初始化时使用PYTHONPATH环境变量的值 sys.platform       返回操作系统平台名称

进度条：

import sys,time
for i in range(10):
    sys.stdout.write('#')
    time.sleep(1)
    sys.stdout.flush()

• 7、xml 模块

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

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

<?xml version="1.0"?>
<data>
    <country name="Liechtenstein">
        <rank updated="yes">2</rank>
        <year>2008</year>
        <gdppc>141100</gdppc>
        <neighbor name="Austria" direction="E"/>
        <neighbor name="Switzerland" direction="W"/>
    </country>
    <country name="Singapore">
        <rank updated="yes">5</rank>
        <year>2011</year>
        <gdppc>59900</gdppc>
        <neighbor name="Malaysia" direction="N"/>
    </country>
    <country name="Panama">
        <rank updated="yes">69</rank>
        <year>2011</year>
        <gdppc>13600</gdppc>
        <neighbor name="Costa Rica" direction="W"/>
        <neighbor name="Colombia" direction="E"/>
    </country>
</data>

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

import xml.etree.ElementTree as ET

tree = ET.parse('xml_lesson')   ##  打开xml_lesson 这个文件，parse和open相似
root = tree.getroot()   ##  生成一个根对象
print(root.tag)     ##  标签名

##      遍历xml root根
for i in root:
    print(i.tag)      ##  打印各个标签名
    ##  运行结果：country
                # country
                # country

    print(i.attrib)     ##  打印各个属性，结果返回一个字典
    ##  运行结果：{'name': 'Liechtenstein'}
    #   {'name': 'Singapore'}
    #   {'name': 'Panama'}

    for j in i:     ##  继续遍历i
        # print(j.tag)
        print(j.text)       ##  打印文本内容
        ##  打印结果：2
                    # 2008
                    # 141100
                    # None
                    # None
                    # 5
                    # 2011
                    # 59900
                    # None
                    # 69
                    # 2011
                    # 13600
                    # None
                    # None

##      只遍历year标签
for i in root.iter('year'):
    print(i.tag,i.text)
    ##  运行结果：year 2008
                # year 2011
                # year 2011

##  增删改

for nood in root.iter('year'):
    #   增改
    new_text = int(nood.text)+1
    nood.text = str(new_text)
    nood.set('update','yes')    ##  增加属性
tree.write('xml_lesson.xml')    ##  建立和xml文件的联系，重新写入文件中

    #   删
for country in root.findall('country'):
    rank = int(country.find('rank').text)
    if rank>50:
        root.remove(country)

tree.write('output.xml')

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

##################################  生成一个xml的文件对象    ####################################
import xml
import xml.etree.ElementTree as ET
new_xml = ET.Element('name list')
name = ET.SubElement(new_xml,'name',attrib={'enrolled':'yes'})      ## new_xml 是对象，name是标签
age = ET.SubElement(name,'age',attrib={'checked':'no'})
sex = ET.SubElement(name,'sex')
sex.text = '39'
name2 = ET.SubElement(new_xml,'name',attrib={'enrolled':'no'})
age = ET.SubElement(name2,'age',attrib={'check':'yes'})
age.text = '19'
et = ET.ElementTree(new_xml)        #####       把上面的内容写进一个新文档里去，固定格式
et.write('test.xml')

• 8、configparser模块

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

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

import configparser
config = configparser.ConfigParser()        ##  config = {}

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

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

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

#  写入文件中
with open('config_test','w') as configfile:
    config.write(configfile)
    configfile.close()

################################  增删改查    ##############################
import configparser
config = configparser.ConfigParser()
print(config.sections())            ##  []

#####################################查--------------------------------------
config.read('config_test')
print(config.sections())        ##  只打印除了默认以外的键值
print(config['bitbucket.org']['user'])
for key in config['bitbucket.org']:
    print(key)              ##  会把DEFAULT下的内容都变历出来
print(config.options('bitbucket.org'))      ##  遍历key值组成一个列表显示出来
print(config.items('bitbucket.org'))    ##  遍历内容组成一个元祖显示出来
print(config.get('bitbucket.org','compression'))
print(config.get('bitbucket.org','compressionlevel'))     ##  取'bitbucket.org'下的'compressionlevel'对应的值

###########################################增删--------------------------------------------
config.add_section('yuan')      ##  增加块
config.set('yuan','s1','11111111111111')
# config.remove_section('bitbucket.org')      ##  删除块
config.remove_option('topsecret.server.com','host.port')        ##  删除键值对
config.write(open('config','w'))

生成的文件：

[DEFAULT]
serveraliveinterval = 45
compression = yes
compressionlevel = 9
forwardx11 = 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 算法

######################################  hashlib：加密  ###################################
import hashlib
obj = hashlib.md5()
obj.update('root'.encode('utf8'))       ##  63a9f0ea7bb98050796b649e85481845
print(obj.hexdigest())      

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

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

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

import hashlib
 
# ######## 256 ########
 
hash = hashlib.sha256('898oaFs09f'.encode('utf8'))
hash.update('alvin'.encode('utf8'))
print (hash.hexdigest())#e79e68f070cdedcfe63eaf1a2e92c83b4cfb1b5c6bc452d214c1b7e77cdfd1c7

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

import hmac
h = hmac.new('alvin'.encode('utf8'))
h.update('hello'.encode('utf8'))
print (h.hexdigest())#320df9832eab4c038b6c1d7ed73a5940

• 10、logging模块（重点）

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

import logging

logging.debug('debug message')

logging.info('info message')

logging.warning('warning message')

logging.error('error message')

logging.critical('critical message')

修改参数：

##--------------------------》  basicConfig 方式
import logging
logging.basicConfig(
    level=logging.DEBUG,          ##修改默认打印值
    filename= 'logging.log',     ##  追加模式，生成一个文件logging.log
    filemode='w',        ##  从追加模式改为覆盖模式
    format = '%(asctime)s %(filename)s [%(lineno)d] %(message)s'     ##  添加参数 lineno-->显示第几行
)
logging.debug('debug message')
logging.info('info message')
logging.warning('warning message')    ##  默认会打印到warning级别，想要全部打印就需要修改默认值
logging.error('error message')
logging.critical('critical message')

生成的文件：

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

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

#------------------------------->       logger 对象
def logger():
    logger = logging.getLogger()

    fh = logging.FileHandler('test_log')        ##  文件修改
    ch = logging.StreamHandler()        ##  屏幕打印

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

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

    logger.addHandler(fh)
    logger.addHandler(ch)
    logger.setLevel('DEBUG')        ##  修改默认值
    # logger.filemode('w')
    return logger
##  logger对象的设定

##------------------------------------

##  logger对象的调用
logger = logger()
logger.debug('debug')
logger.info('info')
logger.warning('warning')
logger.error('error')
logger.critical('critical')

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