15-常用模块

Posted 2020-09-22

目录:

time,random,os,sys,shutil,json&pickle,shelve,xml,configparser,hashlib,suprocess,logging,re,

 

常用模块

 

常见模块的分类：

内置模块

自定义模块

第三方模块

 

random

随机数

random.random():

random.randint():

random.randrange():

random.choice():

random.sample():

random.uniform():

random.shuffle():

1. import random
3. print(random.random()) # 随机显示大于0且小于1之间的某个小数
5. print(random.randint(1, 3)) # 随机显示一个大于等于1且小于等于3之间的整数
7. print(random.randrange(1, 3)) # 随机显示一个大于等于1且小于3之间的整数
9. print(random.choice([1, ‘23‘, [4, 5]])) # 随机选择列表中的元素，1或者23或者[4,5]
11. print(random.sample([1, ‘23‘, [4, 5]], 2)) # 随机选择列表元素任意2个组合，拼成一个新的列表
13. print(random.uniform(1, 3)) # 随机选择大于1小于3的小数，如1.927109612082716
15. item = [1, 3, 5, 7, 9]
16. random.shuffle(item) # 打乱item的顺序,相当于"洗牌"
17. print(item)
19. 运行结果#->
20. 0.8411519662343422
21. 2
22. 1
23. 1
24. [[4, 5], ‘23‘]
25. 1.1835899789185504
26. [9, 7, 1, 3, 5]

 

应用示例：随机验证码

1. import random
2. def v_code(n=5):
3. res=‘‘
4. for i in range(n):
5. num=random.randint(0,9) # 随机选择数字
6. s=chr(random.randint(65,90)) # 随机选择字母,chr()转换数字为ASCII码对应的字母
7. add=random.choice([num,s])
8. res+=str(add) #res = res + str(add) 字符串拼接
9. return res
10. print(v_code(4))
12. 运行结果:
13. 91W2

 

 

 

time

 

在Python中，通常有这几种方式来表示时间：

1-时间戳(timestamp)：通常来说，时间戳表示的是从1970年1月1日00:00:00开始按秒计算的偏移量。我们运行“type(time.time())”，返回的是float类型。

2-格式化的时间字符串(Format String)

3-结构化的时间(struct_time)：struct_time元组共有9个元素共九个元素:(年，月，日，时，分，秒，一年中第几周，一年中第几天，夏令时)

1. import time #我们先以当前时间为准，快速认识三种形式的时间
2. print(time.time()) # 时间戳:1487130156.419527,计算机用的时间
3. print(time.strftime("%Y-%m-%d %X")) #格式化的时间字符串:‘2017-02-15 11:40:53‘
5. print(time.localtime()) #本地时区的struct_time，结构化的时间
6. print(time.gmtime()) #UTC时区的struct_time，标准时间
8. 运行结果：
9. 1496747605.4952035
10. 2017-06-06 19:13:25
11. time.struct_time(tm_year=2017, tm_mon=6, tm_mday=6, tm_hour=19, tm_min=13, tm_sec=25, tm_wday=1, tm_yday=157, tm_isdst=0)
12. time.struct_time(tm_year=2017, tm_mon=6, tm_mday=6, tm_hour=11, tm_min=13, tm_sec=25, tm_wday=1, tm_yday=157, tm_isdst=0)

其中计算机认识的时间只能是‘时间戳‘格式，而程序员可处理的或者说人类能看懂的时间有: ‘格式化的时间字符串‘，‘结构化的时间‘ ，于是有了下图的转换关系：

 

转换示例：

1. print(time.localtime(time.time())) #将当前时间戳转换成结构化的时间
2. #->time.struct_time(tm_year=2017, tm_mon=6, tm_mday=6, tm_hour=21, tm_min=0, tm_sec=25, tm_wday=1, tm_yday=157, tm_isdst=0)
3.  
4. print(time.mktime(time.localtime())) #将当前的结构化时间转换为时间戳格式的时间
5. #->1496754025.0
6.  
7. print(time.strftime(‘%Y-%m-%d %X‘, time.localtime())) #将当前的结构化的时间转换为格式化的字符串时间
8. #->2017-06-06 21:00:25
9.  
10. print(time.strptime(‘2017-06-06 11:59:59‘, ‘%Y-%m-%d %X‘)) #将字符串时间转换为结构化的时间
11. #->time.struct_time(tm_year=2017, tm_mon=6, tm_mday=6, tm_hour=11, tm_min=59, tm_sec=59, tm_wday=1, tm_yday=157, tm_isdst=-1)
13. print(time.ctime(time.time())) #将当前时间戳转换成linux形式的时间格式
14. #->Tue Jun 6 21:07:21 2017
16. print(time.asctime(time.localtime())) #将当前结构化的时间转换为linux形式的时间格式
17. #->Tue Jun 6 21:07:21 2017

 

 

print(time.asctime()) #linux默认形式的时间格式

1. print(time.asctime())
2. print(time.strftime(‘%a %b %d %H:%M:%S %Y‘, time.localtime()))
4. 运行结果#->
5. Tue Jun 6 21:04:54 2017
6. Tue Jun 06 21:04:54 2017

 

其他用法：

time.sleep(t): 线程推迟指定的时间运行,单位秒，就是睡几秒在往下执行

 

 

os 

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

 

os.sep:显示当前操作系统平台特定的路径分隔符,win为‘\\‘,linux为‘/‘

os.linesep:给出当前平台的行终止符。例如，Windows使用‘\r\n‘，Linux使用‘\n‘，而Mac使用‘\r‘

os.name:指示你正在使用的工作平台。比如对于Windows，它是‘nt‘，而对于Linux/Unix用户，它是‘posix‘。

os.pathsep:输出用于分割文件路径的字符串,win下为‘;‘,linux下为‘:‘

os.getcwd:得到当前工作目录，即当前python脚本工作的目录路径。

os.chdir(‘dirname‘):改变当前工作目录到dirname,相当于shell下的cd

os.curdir:返回当前目录（‘.‘）

os.pardir:获取当前目录的父目录字符串名(‘..‘)

os.mkdir(‘dirname‘):创建单级目录,相当于shell下mkdir dirname

os.makedirs(‘dirname1/dirname2‘):递归创建多层目录

os.removedirs（‘dirname‘）:删除多级目录,若目录为空，则删除，并递归到上级目录，若也为空，也删除

os.listdir(‘dirname‘):列出指定目录下的所有文件和子目录，包括隐藏文件，生成列表形式

os.remove(‘filename‘):删除一个文件

os.rename(‘oldname‘,‘newname‘):重命名文件或目录

os.stat（‘path/filename‘）:获得文件或目录属性信息

os.getenv()和os.putenv:分别用来读取和设置环境变量

os.chmod(‘filename‘):修改文件权限和时间戳

os.rmdir(‘dirname‘):删除目录

os.system(‘bash command‘):运行shell命令,直接显示

os.exit():终止当前进程

 

os.path.abspath(name):获得绝对路径

os.path.getsize(name):获取文件大小，如果name是目录返回0L

os.path.getatime(path):获取path指向的文件或目录的最后存取时间

os.path.getmtime(path):获取path指向的文件或目录的最后修改时间

os.path.split():返回一个路径的目录名和文件名

os.path.normpath(path):规范path字符串形式

os.path.split(name):分割文件名与目录（事实上，如果你完全使用目录，它也会将最后一个目录作为文件名而分离，同时它不会判断文件或目录是否存在）

os.path.splitext():分离文件名和扩展名

os.path.join(path,name):连接目录与文件名或目录

os.path.basename(path):返回path最后的文件名,如果path以/或\结尾，则返回空值

os.path.dirname(path):返回文件路径

 

os.path.isfile()和os.path.isdir()分别检验给出的路径是一个目录还是文件

os.path.existe():检验给出的路径是否真的存在

os.path.isdir(name):判断name是不是目录，不是目录就返回false

os.path.isfile(name):判断name这个文件是否存在，不存在返回false

os.path.exists(name):判断是否存在文件或目录name

os.path.isabs():判断是否为绝对路径

 

os.path.normcase(‘path‘):在Linux和Mac平台上，该函数会原样返回path，在windows平台上会将路径中所有字符转换为小写，并将所有斜杠转换为饭斜杠。

 

 

1. os.path.normcase(‘c:/windows\\system32\\‘)   
2. #-> ‘c:\\windows\\system32\\‘

   

os.path.normpath(‘path‘):规范化路径，如‘..‘和‘/‘

1. os.path.normpath(‘c://windows\\System32\\../Temp/‘)   
2. #-> ‘c:\\windows\\Temp‘
4. a=‘/Users/jieli/test1/\\\a1/\\\\aa.py/../..‘
5. print(os.path.normpath(a))
6. #-> /Users/jieli/test1

 

路径处理：

1. os路径处理
2. #方式一：推荐使用
3. import os
4. #具体应用
5. import os,sys
6. possible_topdir = os.path.normpath(os.path.join(
7. os.path.abspath(__file__),
8. os.pardir, #上一级
9. os.pardir,
10. os.pardir
11. ))
12. sys.path.insert(0,possible_topdir)
15. #方式二：不推荐使用
16. os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))

 

 

目录操作

os.mkdir("file")                   

创建目录

 

复制文件:

 

shutil.copyfile("oldfile","newfile")       

oldfile和newfile都只能是文件

 

shutil.copy("oldfile","newfile")            

oldfile只能是文件夹，newfile可以是文件，也可以是目标目录

 

shutil.copytree("olddir","newdir")        

复制文件夹.olddir和newdir都只能是目录，且newdir必须不存在

 

os.rename("oldname","newname")       

重命名文件（目录）.文件或目录都是使用这条命令

 

shutil.move("oldpos","newpos")   

移动文件（目录）

 

os.rmdir("dir")

只能删除空目录

 

shutil.rmtree("dir")    

空目录、有内容的目录都可以删

 

 

 

sys

常见模块：

 

sys.argv:在外部向程序内部传递参数

例如：

1. #文件：argv.py
2. #!/usr/bin/enc python
3. #
4. import sys
5. print(sys.argv) #显示文件所在绝对路径,为列表的第0个元素
6. print(sys.argv[1]) #以空格为分隔符，将后面的字符串生成一个列表，显示列表第一个元素
7. print(sys.argv[2]) #显示第二个元素
8.  
9. #->在命令行终端执行:
10. >python F:\oldboy_python\objects\day06\练习\tmp.py --host 192.168.1.1 --port 8080
12. [‘F:\\oldboy_python\\objects\\day06\\\xc1\xb7\xcf\xb0\\tmp.py‘, ‘--host‘, ‘192.168.1.1‘, ‘--port‘, ‘8080‘]
13. --host
14. 192.168.1.1

 

sys.exit(n):退出程序，正常退出时exit(0)

执行到主程序末尾，解释器自动退出，但是如果需要中途退出程序，可以调用sys.exit函数，带有一个可选的整数参数返回给调用它的程序，表示你可以在主程序中捕获对sys.exit的调用。（0是正常退出，其他为异常）

 

sys.modules:sys.modules是一个全局字典，该字典是python启动后就加载在内存中。每当程序员导入新的模块，sys.modules将自动记录该模块。当第二次再导入该模块时，python会直接到字典中查找，从而加快了程序运行的速度。它拥有字典所拥有的一切方法

 

sys.version:获取python解释程序的版本信息

 

sys.getdefaultencoding():获取系统当前字符编码，一般默认为ASCII

 

sys.setdefaultencoding():设置系统默认编码,如果在解释器中执行 print(dir(sys))，找不到此方法，可以先执行reload(sys)

 

sys.getfilesystemencoding():获取文件系统使用的编码格式，win返回mbcs，mac返回utf-8

 

sys.maxint:最大的Int值

 

sys.path:返回模块的搜索路径，初始化时使用PYTHONPATH环境变量的值，可将自定义的模块放在此路径下，通过import可导入

 

sys.platform:返回操作系统平台名称

 

sys.stdin:标准输入

sys.stdout:标准输出

sys.stderr:标准错误输出

stdin , stdout , 以及stderr 变量包含与标准I/O 流对应的流对象. 如果需要更好地控制输出,而print 不能满足你的要求, 它们就是你所需要的. 你也可以替换它们, 这时候你就可以重定向输出和输入到其它设备( device ), 或者以非标准的方式处理它们。

 

应用实例：

打印#号进度条

 

2. import sys, time
4. for i in range(100):
5.     sys.stdout.write(‘%s\r‘, %(‘#‘*i))
6.     sys.stdout.flush()
7.     time.sleep(0.1)

 

shutil

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

 

shutil.copyfileobj(‘old_file‘, ‘new_file‘):将文件内容拷贝到另一个文件中

 

 

1. import shutil
2. shutil.copyfileobj(open(‘old_file‘, ‘r‘), open(‘new_file‘, ‘w‘))

 

shutil.copyfile(src, dst):拷贝文件,dst文件无需存在，会自动创建,存在则覆盖

 

shutil.copymode(src, dst): 仅拷贝权限，内容、组、所有者都不变,dst文件必须事先存在

 

shutil.copystat(src, dst):仅拷贝文件状态信息，包括mode bits, atime, mtime, flags,dst文件需事先存在

 

shutil.copy(src, dst):拷贝文件和权限

 

shutil.copy2(src, dst):拷贝文件和状态信息

 

shutil.ignore_patterns(‘*patterns‘):

 

shutil.copytree(src, dst, symlinks=False|True, ignore=None):递归拷贝目录

--symlinks=False|True:为False表示将软链接文件拷贝成硬链接,就是说对软链接来说，创建新的文件,为True表示拷贝软链接

1. import shutil
2. shutil.copytree(‘folder1‘, ‘folder2‘, ignore=shutil.ignore_patterns(‘*.pyc‘, ‘tmp*‘))
4. # 递归拷贝folder1中的所有目录和文件，排除‘*.pyc‘, ‘tmp*‘文件,folder2事前不能存在，且对folder2的父目录有可写权限

 

shutil.rmtree(‘path/to/file‘, [ignore_errors]):递归删除文件

 

shutil.move(src, dst): 递归移动文件，类似mv，重命名

 

shutil.make_archive(‘base_name‘, ‘format‘, root_dir=r‘path/to/file‘, ...):归档压缩

创建压缩包并返回文件路径，例如：zip、tar

创建压缩包并返回文件路径，例如：zip、tar

--base_name： 压缩包的文件名，也可以是压缩包的路径。只是文件名时，则保存至当前目录，否则保存至指定路径，
-->如 data_bak=>保存至当前路径
-->如：/tmp/data_bak =>保存至/tmp/
--format：压缩包种类，“zip”, “tar”, “bztar”，“gztar”
--root_dir：要压缩的文件夹路径（默认当前目录）
--owner：用户，默认当前用户
--group：组，默认当前组

--logger：用于记录日志，通常是logging.Logger对象

1. #将 /data 下的文件打包放置当前程序目录
2. import shutil
3. ret = shutil.make_archive("data_bak", ‘gztar‘, root_dir=‘/data‘)
6. #将 /data下的文件打包放置 /tmp/目录
7. import shutil
8. ret = shutil.make_archive("/tmp/data_bak", ‘gztar‘, root_dir=‘/data‘)

 

shutil 对压缩包的处理是调用 ZipFile 和 TarFile 两个模块来进行的，详细：

1. import zipfile
3. # 压缩
4. z = zipfile.ZipFile(‘laxi.zip‘, ‘w‘)
5. z.write(‘a.log‘)
6. z.write(‘data.data‘)
7. z.close()
9. # 解压
10. z = zipfile.ZipFile(‘laxi.zip‘, ‘r‘)
11. z.extractall(path=‘.‘)
12. z.close()

压缩和解压示例：

1. import tarfile
3. # 压缩
4. >>> t=tarfile.open(‘/tmp/egon.tar‘,‘w‘)
5. >>> t.add(‘/test1/a.py‘,arcname=‘a.bak‘)
6. >>> t.add(‘/test1/b.py‘,arcname=‘b.bak‘)
7. >>> t.close()
10. # 解压
11. >>> t=tarfile.open(‘/tmp/egon.tar‘,‘r‘)
12. >>> t.extractall(‘/egon‘)
13. >>> t.close()

 

json&pickle

 

什么是序列化？

--我们把对象(变量)从内存中变成可存储或传输的过程称之为序列化，在Python中叫pickling，在其他语言中也被称之为serialization，marshalling，flattening等等，都是一个意思，

 

为什么要序列化？

1：持久保存状态

需知一个软件/程序的执行就在处理一系列状态的变化，在编程语言中，‘状态‘会以各种各样有结构的数据类型(也可简单的理解为变量)的形式被保存在内存中。

内存是无法永久保存数据的，当程序运行了一段时间，我们断电或者重启程序，内存中关于这个程序的之前一段时间的数据（有结构）都被清空了。

在断电或重启程序之前将程序当前内存中所有的数据都保存下来（保存到文件中），以便于下次程序执行能够从文件中载入之前的数据，然后继续执行，这就是序列化。

具体的来说，你玩使命召唤闯到了第13关，你保存游戏状态，关机走人，下次再玩，还能从上次的位置开始继续闯关。

或如，虚拟机状态的挂起等。

 

2：跨平台数据交互

序列化之后，不仅可以把序列化后的内容写入磁盘，还可以通过网络传输到别的机器上，如果收发的双方约定好实用一种序列化的格式，那么便打破了平台/语言差异化带来的限制，实现了跨平台数据交互。

反过来，把变量内容从序列化的对象重新读到内存里称之为反序列化，即unpickling。

 

json

 

如果我们要在不同的编程语言之间传递对象，就必须把对象序列化为标准格式，比如XML，但更好的方法是序列化为JSON，因为JSON表示出来就是一个字符串，可以被所有语言读取，也可以方便地存储到磁盘或者通过网络传输。JSON不仅是标准格式，并且比XML更快，而且可以直接在Web页面中读取，非常方便。

 

JSON还定死了字符集必须是UTF-8，表示多语言就没有问题了。为了统一解析，JSON的字符串规定必须用双引号""，Object的键也必须用双引号""

 

JSON表示的对象就是标准的javascript语言的对象，JSON和Python内置的数据类型对应如下：

 

import json

json.dumps():编码，把一个python对象编码转换成json字符串

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

 

注意：在json的数据格式中必须是双引号开头的

 

下面通过示例来说明使用json的好处：

 

使用eval(),不能转换python不支持的数据类型格式，如null,true,false等

1. import json
2. x="[null,true,false,1]"
3. print(eval(x))
4. print(json.loads(x))
6. 运行结果：
7. print(eval(x)) #报错，无法解析null类型，而json就可以
8. File "<string>", line 1, in <module>
9. NameError: name ‘null‘ is not defined

使用json()

1. import json
2. x="[null,true,false,1]"
3. print(json.loads(x))
5. 运行结果：
6. [None, True, False, 1]

 

使用json.dumps()进行序列化

过程:dic--> res=json.dumps(dic)-->f.write(res)

1. import json
2. dic = {
3. ‘name‘: ‘alex‘,
4. ‘age‘: 9000,
5. ‘height‘: ‘180cm‘
6. }
7. res = json.dumps(dic) #编码，把一个python对象编码转换成json字符串
8. print(res,type(res))
9.  
10. with open(‘a.json‘, ‘w‘) as f:
11. f.write(res)
12.  
13. 运行结果：
14. {"name": "alex", "age": 9000, "height": "180cm"} <class ‘str‘>
15. 写入文件a.json,内容为{"name": "alex", "age": 9000, "height": "180cm"}

使用json.loads()反序列化

过程:f.read()--truncate>res=json.loads(res)-->dic=res

1. with open(‘a.json‘, ‘r‘) as f:
2. dic = json.loads(f.read())
3. print(dic, type(dic))
5. 运行结果：
6. {‘age‘: 9000, ‘height‘: ‘180cm‘, ‘name‘: ‘alex‘} <class ‘dict‘>

 

json.dumps()的参数：

sort_keys:对dict对象进行排序

separators:压缩,移除多余空白

indent n :缩进n个空格

skipkeys: 默认False，dumps方法存储dict对象时，key必须是str类型，如果出现了其他类型的话，那么会产生TypeError异常，如果开启该参数，设为True的话，则会比较优雅的过度。

 

 

json的简单综合示例：

1. import json
3. json.dump(dic, open(‘b.json‘,‘w‘)) #序列化
5. res = json.load(open(‘b.json‘, ‘r‘)) #反序列化
6. print(res, type(res))
8. #->序列化结果：
9. 生成新的文件b.json，内容为：{"name": "alex", "age": 9000, "height": "180cm"}
11. #->反序列化结果：
12. {‘name‘: ‘alex‘, ‘age‘: 9000, ‘height‘: ‘180cm‘} <class ‘dict‘>

 

注意：dumps对应loads；dump对应load

 

 

pickle

 

Pickle的问题和所有其他编程语言特有的序列化问题一样，就是它只能用于Python，并且可能不同版本的Python彼此都不兼容，因此，只能用Pickle保存那些不重要的数据，不能成功地反序列化也没关系。

 

pickle将内存中的结构化的数据转换成bytes类型，然后用于存储或传输

例如：

1. import pickle
3. dic = {
4. ‘name‘: ‘alex‘,
5. ‘age‘: 9000,
6. ‘height‘: ‘180cm‘
7. }
9. print(pickle.dumps(dic))
11. #->运行结果：
12. b‘\x80\x03}q\x00(X\x04\x00\x00\x00nameq\x01X\x04\x00\x00\x00alexq\x02X\x03\x00\x00\x00ageq\x03M(#X\x06\x00\x00\x00heightq\x04X\x05\x00\x00\x00180cmq\x05u.‘

由于pickle转换成bytes格式，所以如果写入文件，需要以wb方式，读取文件以rb方式

pickle.dumps()与pickle.loads()

1. import pickle
2. dic = {
3. ‘name‘: ‘alex‘,
4. ‘age‘: 9000,
5. ‘height‘: ‘180cm‘
6. }
8. with open(‘a.pickle‘, ‘wb‘) as f:
9. f.write(pickle.dumps(dic))
12. with open(‘a.pickle‘, ‘rb‘) as f:
13. a = pickle.loads(f.read())
14. print(a, type(a))

pickle.dump()与pickle.load()

1. import pickle
2. pickle.dump(dic, open(‘b.pickle‘, ‘wb‘))
4. res = pickle.load(open(‘b.pickle‘, ‘rb‘))
5. print(res, type(res))

 

pickle可序列化函数，json不可以

1. import json,pickle
3. def func():
4.     print(‘from func...‘)
6. json.dumps(func)
8. #->运行结果：
9. #TypeError: <function func at 0x0000000000B7E1E0> is not JSON serializable
11. f = pickle.dumps(func)
12. print(f)
14. pickle.dump(func, open(‘c.pkl‘, ‘wb‘))
15. res = pickle.load(open(‘c.pkl‘, ‘rb‘))
16. print(res)
18. res()
20. #->运行结果：
21. b‘\x80\x03c__main__\nfunc\nq\x00.‘
22. <function func at 0x0000000000D9E1E0>
23. from func...

注意：序列化的函数如果不存在，则无法序列化，因为序列化的是一段内存地址，在内存中找不到其对应的名字

 

shelve

shelve模块比pickle模块简单，只有一个open函数，返回类似字典的对象，可读可写;

key必须为字符串，而值可以是python所支持的数据类型

1. import shelve
3. f=shelve.open(r‘sheve.txt‘)
4. f[‘stu1_info‘]={‘name‘:‘egon‘,‘age‘:18,‘hobby‘:[‘piao‘,‘smoking‘,‘drinking‘]}
5. f[‘stu2_info‘]={‘name‘:‘gangdan‘,‘age‘:53}
6. f[‘school_info‘]={‘website‘:‘http://www.pypy.org‘,‘city‘:‘beijing‘}
8. print(f[‘stu1_info‘][‘hobby‘])
9. f.close()
11. #->
12. 会生成3个文件：sheve.txt.bak,sheve.txt.dat,sheve.txt.dir
13. [‘piao‘, ‘smoking‘, ‘drinking‘]

 

logging

 

import logging

import sys

 

一:filename=‘access.log‘:如果不指定filename,则默认打印到终端，指定filename，则会将日志信息写入此文件

二:指定日志级别:

    指定方式:

        1:level=10

        2:level=logging.ERROR

 

    日志级别种类:

        CRITICAL = 50

        FATAL = CRITICAL

        ERROR = 40

        WARNING = 30

        WARN = WARNING

        INFO = 20

        DEBUG = 10

        NOTSET = 0

 

三:指定日志级别为ERROR,则只有ERROR及其以上级别的日志会被打印

1. logging.basicConfig(
2. format=‘%(asctime)s - %(name)s - %(levelname)s -%(module)s: %(message)s‘,
3. datefmt=‘%Y-%m-%d %H:%M:%S %p‘,
4. level=10)
5. logging.debug(‘debug‘)
6. logging.info(‘info‘)
7. logging.warning(‘warning‘)
8. logging.error(‘error‘)
9. logging.critical(‘critical‘)
10. logging.log(10,‘log‘) 
11. #如果level=40,则只有logging.critical和loggin.error的日志会被打印
13. #->
14. 2017-06-07 22:57:16 PM - root - DEBUG -tmp: debug
15. 2017-06-07 22:57:16 PM - root - INFO -tmp: info
16. 2017-06-07 22:57:16 PM - root - WARNING -tmp: warning
17. 2017-06-07 22:57:16 PM - root - ERROR -tmp: error
18. 2017-06-07 22:57:16 PM - root - CRITICAL -tmp: critical

 

可在logging.basicConfig()函数中通过具体参数来更改logging模块默认行为，可用参数有:

 

filename：用指定的文件名创建FiledHandler（后边会具体讲解handler的概念），这样日志会被存储在指定的文件中。

filemode：文件打开方式，在指定了filename时使用这个参数，默认值为“a”还可指定为“w”。

format：指定handler使用的日志显示格式。 

datefmt：指定日期时间格式。 

level：设置rootlogger（后边会讲解具体概念）的日志级别 

stream：用指定的stream创建StreamHandler。可以指定输出到sys.stderr,sys.stdout或者文件，默认为sys.stderr。若同时列出了filename和stream两个参数，则stream参数会被忽略

详细请参考：

http://blog.csdn.net/zyz511919766/article/details/25136485/

 

-------转载：http://python.jobbole.com/86887/-----------

 

 

基本用法

 

# 获取logger实例，如果参数为空则返回root logger

logger = logging.getLogger("AppName")

 

# 指定logger输出格式

formatter = logging.Formatter(‘%(asctime)s %(levelname)-8s: %(message)s‘)

 

# 文件日志

file_handler = logging.FileHandler("test.log")

file_handler.setFormatter(formatter)  # 可以通过setFormatter指定输出格式

 

# 控制台日志

console_handler = logging.StreamHandler(sys.stdout)

console_handler.formatter = formatter  # 也可以直接给formatter赋值

 

# 为logger添加的日志处理器

logger.addHandler(file_handler)

logger.addHandler(console_handler)

 

# 指定日志的最低输出级别，默认为WARN级别

logger.setLevel(logging.INFO)

 

# 输出不同级别的log

logger.debug(‘this is debug info‘)

logger.info(‘this is information‘)

logger.warn(‘this is warning message‘)

logger.error(‘this is error message‘)

logger.fatal(‘this is fatal message, it is same as logger.critical‘)

logger.critical(‘this is critical message‘)

 

# 2016-10-08 21:59:19,493 INFO    : this is information

# 2016-10-08 21:59:19,493 WARNING : this is warning message

# 2016-10-08 21:59:19,493 ERROR   : this is error message

# 2016-10-08 21:59:19,493 CRITICAL: this is fatal message, it is same as logger.critical

# 2016-10-08 21:59:19,493 CRITICAL: this is critical message

 

# 移除一些日志处理器

logger.removeHandler(file_handler)

 

 

格式化输出日志

 

# 格式化输出

service_name = "Booking"

logger.error(‘%s service is down!‘ % service_name)  # 使用python自带的字符串格式化，不推荐

logger.error(‘%s service is down!‘, service_name)  # 使用logger的格式化，推荐

logger.error(‘%s service is %s!‘, service_name, ‘down‘)  # 多参数格式化

logger.error(‘{} service is {}‘.format(service_name, ‘down‘)) # 使用format函数，推荐

# 2016-10-08 21:59:19,493 ERROR   : Booking service is down!

 

记录异常信息

当你使用logging模块记录异常信息时，不需要传入该异常对象，只要你直接调用logger.error() 或者 logger.exception()就可以将当前异常记录下来。

 

try:

    1 / 0

except:

    # 等同于error级别，但是会额外记录当前抛出的异常堆栈信息

    logger.exception(‘this is an exception message‘)

 

# 2016-10-08 21:59:19,493 ERROR   : this is an exception message

# Traceback (most recent call last):

#   File "D:/Git/py_labs/demo/use_logging.py", line 45, in 

#     1 / 0

# ZeroDivisionError: integer division or modulo by zero

 

Python 使用logging模块记录日志涉及四个主要类，使用官方文档中的概括最为合适：

logger提供了应用程序可以直接使用的接口；

handler将(logger创建的)日志记录发送到合适的目的输出；

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

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

 

 

logger

每个程序在输出信息之前都要获得一个Logger。Logger通常对应了程序的模块名，比如聊天工具的图形界面模块可以这样获得它的Logger：

LOG=logging.getLogger(”chat.gui”)

 

而核心模块可以这样：

LOG=logging.getLogger(”chat.kernel”)

 

Logger.setLevel(lel):指定最低的日志级别，低于lel的级别将被忽略。debug是最低的内置级别，critical为最高

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

Logger.addHandler(hdlr)、Logger.removeHandler(hdlr)：增加或删除指定的handler

Logger.debug()、Logger.info()、Logger.warning()、Logger.error()、Logger.critical()：可以设置的日志级别

 

Formatter日志格式

Formatter对象定义了log信息的结构和内容，构造时需要带两个参数：

一个是格式化的模板fmt，默认会包含最基本的level和 message信息

一个是格式化的时间样式datefmt，默认为 2003-07-08 16:49:45,896 (%Y-%m-%d %H:%M:%S)

fmt中允许使用的变量可以参考下表：

 

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

 

 

SetLevel 日志级别

Logging有如下级别: DEBUG，INFO，WARNING，ERROR，CRITICAL

默认级别是WARNING，logging模块只会输出指定level以上的log。这样的好处, 就是在项目开发时debug用的log，在产品release阶段不用一一注释，只需要调整logger的级别就可以了，很方便。

 

 

 

handler

handler对象负责发送相关的信息到指定目的地。Python的日志系统有多种Handler可以使用。有些Handler可以把信息输出到控制台，有些Logger可以把信息输出到文件，还有些 Handler可以把信息发送到网络上。如果觉得不够用，还可以编写自己的Handler。可以通过addHandler()方法添加多个多handler

Handler.setLevel(lel):指定被处理的信息级别，低于lel级别的信息将被忽略

Handler.setFormatter()：给这个handler选择一个格式

Handler.addFilter(filt)、Handler.removeFilter(filt)：新增或删除一个filter对象

 

 

每个Logger可以附加多个Handler。接下来我们就来介绍一些常用的Handler：

1) logging.StreamHandler

使用这个Handler可以向类似与sys.stdout或者sys.stderr的任何文件对象(file object)输出信息。它的构造函数是：

StreamHandler([strm])

其中strm参数是一个文件对象。默认是sys.stderr

 

 

2) logging.FileHandler

和StreamHandler类似，用于向一个文件输出日志信息。不过FileHandler会帮你打开这个文件。它的构造函数是：

FileHandler(filename[,mode])

filename是文件名，必须指定一个文件名。

mode是文件的打开方式。参见Python内置函数open()的用法。默认是’a‘，即添加到文件末尾。

 

3) logging.handlers.RotatingFileHandler

这个Handler类似于上面的FileHandler，但是它可以管理文件大小。当文件达到一定大小之后，它会自动将当前日志文件改名，然后创建 一个新的同名日志文件继续输出。比如日志文件是chat.log。当chat.log达到指定的大小之后，RotatingFileHandler自动把 文件改名为chat.log.1。不过，如果chat.log.1已经存在，会先把chat.log.1重命名为chat.log.2。。。最后重新创建 chat.log，继续输出日志信息。它的构造函数是：

RotatingFileHandler( filename[, mode[, maxBytes[, backupCount]]])

其中filename和mode两个参数和FileHandler一样。

maxBytes用于指定日志文件的最大文件大小。如果maxBytes为0，意味着日志文件可以无限大，这时上面描述的重命名过程就不会发生。

backupCount用于指定保留的备份文件的个数。比如，如果指定为2，当上面描述的重命名过程发生时，原有的chat.log.2并不会被更名，而是被删除。

 

 

4) logging.handlers.TimedRotatingFileHandler

这个Handler和RotatingFileHandler类似，不过，它没有通过判断文件大小来决定何时重新创建日志文件，而是间隔一定时间就 自动创建新的日志文件。重命名的过程与RotatingFileHandler类似，不过新的文件不是附加数字，而是当前时间。它的构造函数是：

TimedRotatingFileHandler( filename [,when [,interval [,backupCount]]])

其中filename参数和backupCount参数和RotatingFileHandler具有相同的意义。

interval是时间间隔。

when参数是一个字符串。表示时间间隔的单位，不区分大小写。它有以下取值：

S 秒

M 分

H 小时

D 天

W 每星期（interval==0时代表星期一）

midnight 每天凌晨

 

通过文件配置logging

如果你希望通过配置文件来管理logging，可以参考这个官方文档。在log4net或者log4j中这是很常见的方式。

 

 

1. # logging.conf
2. [loggers]
3. keys=root
4.  
5. [logger_root]
6. level=DEBUG
7. handlers=consoleHandler
8. #,timedRotateFileHandler,errorTimedRotateFileHandler
9.  
10. #################################################
11. [handlers]
12. keys=consoleHandler,timedRotateFileHandler,errorTimedRotateFileHandler
13.  
14. [handler_consoleHandler]
15. class=StreamHandler
16. level=DEBUG
17. formatter=simpleFormatter
18. args=(sys.stdout,)
19.  
20. [handler_timedRotateFileHandler]
21. class=handlers.TimedRotatingFileHandler
22. level=DEBUG
23. formatter=simpleFormatter
24. args=(‘debug.log‘, ‘H‘)
25.  
26. [handler_errorTimedRotateFileHandler]
27. class=handlers.TimedRotatingFileHandler
28. level=WARN
29. formatter=simpleFormatter
30. args=(‘error.log‘, ‘H‘)
31.  
32. #################################################
33. [formatters]
34. keys=simpleFormatter, multiLineFormatter
35.  
36. [formatter_simpleFormatter]
37. format= %(levelname)s %(threadName)s %(asctime)s:   %(message)s
38. datefmt=%H:%M:%S
39.  
40. [formatter_multiLineFormatter]
41. format= ------------------------- %(levelname)s -------------------------
42.  Time:      %(asctime)s
43.  Thread:    %(threadName)s
44.  File:      %(filename)s(line %(lineno)d)
45.  Message:
46.  %(message)s
47.  
48. datefmt=%Y-%m-%d %H:%M:%S

假设以上的配置文件放在和模块相同的目录，代码中的调用如下：

 

 

1. import os
2. filepath = os.path.join(os.path.dirname(__file__), ‘logging.conf‘)
3. logging.config.fileConfig(filepath)
4. return logging.getLogger()

 

日志重复输出的坑

你有可能会看到你打的日志会重复显示多次，可能的原因有很多，但总结下来无非就一个，日志中使用了重复的handler。

 

第一坑

 

 

1. import logging
2.  
3. logging.basicConfig(level=logging.DEBUG)
4.  
5. fmt = ‘%(levelname)s:%(message)s‘
6. console_handler = logging.StreamHandler()
7. console_handler.setFormatter(logging.Formatter(fmt))
8. logging.getLogger().addHandler(console_handler)
9.  
10. logging.info(‘hello!‘)
11.  
12. # INFO:root:hello!
13. # INFO:hello!

上面这个例子出现了重复日志，因为在第3行调用basicConfig()方法时系统会默认创建一个handler，如果你再添加一个控制台handler时就会出现重复日志。

 

第二坑

 

 

1. import logging
2.  
3. def get_logger():
4.     fmt = ‘%(levelname)s:%(message)s‘
5.     console_handler = logging.StreamHandler()
6.     console_handler.setFormatter(logging.Formatter(fmt))
7.     logger = logging.getLogger(‘App‘)
8.     logger.setLevel(logging.INFO)
9.     logger.addHandler(console_handler)
10.     return logger
11.  
12. def call_me():
13.     logger = get_logger()
14.     logger.info(‘hi‘)
15.  
16. call_me()
17. call_me()
18.  
19. # INFO:hi
20. # INFO:hi
21. # INFO:hi

在这个例子里hi居然打印了三次，如果再调用一次call_me()呢？我告诉你会打印6次。why? 因为你每次调用get_logger()方法时都会给它加一个新的handler，你是自作自受。正常的做法应该是全局只配置logger一次。

 

第三坑

 

 

1. import logging
2.  
3. def get_logger():
4.     fmt = ‘%(levelname)s: %(message)s‘
5.     console_handler = logging.StreamHandler()
6.     console_handler.setFormatter(logging.Formatter(fmt))
7.     logger = logging.getLogger(‘App‘)
8.     logger.setLevel(logging.INFO)
9.     logger.addHandler(console_handler)
10.     return logger
11.  
12. def foo():
13.     logging.basicConfig(format=‘[%(name)s]: %(message)s‘)
14.     logging.warn(‘some module use root logger‘)
15.  
16. def main():
17.     logger = get_logger()
18.     logger.info(‘App start.‘)
19.     foo()
20.     logger.info(‘App shutdown.‘)
21.  
22. main()
23.  
24. # INFO: App start.
25. # [root]: some module use root logger
26. # INFO: App shutdown.
27. # [App]: App shutdown.

为嘛最后的App shutdown打印了两次？所以在Stackoverflow上很多人都问，我应该怎么样把root logger关掉，root logger太坑爹坑妈了。只要你在程序中使用过root logger，那么默认你打印的所有日志都算它一份。上面的例子没有什么很好的办法，我建议你招到那个没有经过大脑就使用root logger的人，乱棍打死他或者开除他。

 

如果你真的想禁用root logger，有两个不是办法的办法：

logging.getLogger().handlers = []  # 删除所有的handler

logging.getLogger().setLevel(logging.CRITICAL)  # 将它的级别设置到最高

 

 

subprocess

subprocess的目的就是启动一个新的进程并且与之通信

 

subprocess模块中只定义了一个类: Popen

 

可以使用Popen来创建进程，并与进程进行复杂的交互

 

它的构造函数如下：

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)

 

类Popen的方法：

Popen.poll():用于检查子进程是否已经结束。设置并返回returncode属性。

Popen.wait():等待子进程结束。设置并返回returncode属性。

Popen.send_signal(signal):向子进程发送信号。

Popen.terminate():停止(stop)子进程。在windows平台下，该方法将调用Windows API TerminateProcess（）来结束子进程。

Popen.kill():杀死子进程。

Popen.pid：获取子进程的进程ID。

Popen.returncode：获取进程的返回值。如果进程还没有结束，返回None。

 

Popen.stdin，Popen.stdout ，Popen.stderr 

官方说明：

stdin, stdout and stderr specify the executed programs’ standard input, standard output and standard error file handles, respectively. Valid values are PIPE, an existing file descriptor (a positive integer), an existing file object, and None.

 

Popen.communicate(input=None):与子进程进行交互。向stdin发送数据，或从stdout和stderr中读取数据。可选参数input指定发送到子进程的参数。Communicate()返回一个元组：(stdoutdata, stderrdata)。注意：如果希望通过进程的stdin向其发送数据，在创建Popen对象的时候，参数stdin必须被设置为PIPE。同样，如果希望从stdout和stderr获取数据，必须将stdout和stderr设置为PIPE。

 

 

常用参数：

 

参数args可以是字符串或者序列类型（如：list，元组），用于指定进程的可执行文件及其参数。如果是序列类型，第一个元素通常是可执行文件的路径。我们也可以显式的使用executeable参数来指定可执行文件的路径。

 

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

 

如果参数shell设为true，程序将通过当前shell来执行，比如在python解释器中执行，就会显示到解释器中

 

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

 

subprocess.PIPE

管道，在创建Popen对象时，subprocess.PIPE可以初始化stdin, stdout或stderr参数。表示与子进程通信的标准流。

 

subprocess.STDOUT

创建Popen对象时，用于初始化stderr参数，表示将错误通过标准输出流输出。

 

----------------------------

简单用法示例：

1. p = subprocess.Popen(‘dir‘, shell=True)
3. #->
4. 列出的就是文件当前目录内容

 

stdout

如果想得到进程的输出，管道是个很方便的方法：

正确的命令：

1. res=subprocess.Popen("dir", shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
2. print(res)
3.  
4. print(res.stdout.read())
5.  
6. print(res.stdout.read().decode(‘gbk‘))
8. #->
9. <subprocess.Popen object at 0x000000000067D438> #res
10.  
11. b‘ \xc7\xfd\xb6\xaf\xc6\xf7 F \xd.... #res.stdout.read()
12. b"‘dir45‘ \xb2\xbb\xca\xc7\xc4\xda\xb2.... #res.stderr.read()
14. 驱动器 F 中的卷是 Bak #res.stdout.read().decode(‘gbk‘),此处的gbk编码格式为当前系统编码格式
15. 卷的序列号是 AC2A-165F
16. F:\oldboy_python\objects\day06\练习 的目录
17. ...

错误的命令：

1. res=subprocess.Popen("dir456", shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
3. print(res)
5. print(res.stderr.read().decode(‘gbk‘))
7. #->
8. <subprocess.Popen object at 0x0000000000A1AA90>
9. ‘dir456‘ 不是内部或外部命令，也不是可运行的程序
10. 或批处理文件。

 

stdin

模拟一个管道示例：

1. #模拟 dir |grep txt$
2. res1=subprocess.Popen(r‘dir E:\wupeiqi\s17\day06‘,shell=True,stdout=subprocess.PIPE)
4. res=subprocess.Popen(r‘findstr txt*‘,shell=True,stdin=res1.stdout,stderr=subprocess.PIPE,stdout=subprocess.PIPE)

注意:管道的内容只能取一次，再取则为空。

 

 

configparser

常见的配置文件格式：

#config.conf

1. # 注释1
2. ; 注释2
4. [section1]
5. k1 = v1
6. k2:v2
7. user=egon
8. age=18
9. is_admin=true
10. salary=31
12. [section2]
13. k1 = v1

读取：

1. import configparser
3. config=configparser.ConfigParser()
4. config.read(‘a.cfg‘)
6. #查看所有的标题
7. res=config.sections() #[‘section1‘, ‘section2‘]
8. print(res)
10. #查看标题section1下所有key=value的key
11. options=config.options(‘section1‘)
12. print(options) #[‘k1‘, ‘k2‘, ‘user‘, ‘age‘, ‘is_admin‘, ‘salary‘]
14. #查看标题section1下所有key=value的(key,value)格式
15. item_list=config.items(‘section1‘)
16. print(item_list) #[(‘k1‘, ‘v1‘), (‘k2‘, ‘v2‘), (‘user‘, ‘egon‘), (‘age‘, ‘18‘), (‘is_admin‘, ‘true‘), (‘salary‘, ‘31‘)]
18. #查看标题section1下user的值=>字符串格式
19. val=config.get(‘section1‘,‘user‘)
20. print(val) #egon
22. #查看标题section1下age的值=>整数格式
23. val1=config.getint(‘section1‘,‘age‘)
24. print(val1) #18
26. #查看标题section1下is_admin的值=>布尔值格式
27. val2=config.getboolean(‘section1‘,‘is_admin‘)
28. print(val2) #True
30. #查看标题section1下salary的值=>浮点型格式
31. val3=config.getfloat(‘section1‘,‘salary‘)
32. print(val3) #31.0

 

改写：

1. import configparser
3. config=configparser.ConfigParser()
4. config.read(‘a.cfg‘)
7. #删除整个标题section2
8. config.remove_section(‘section2‘)
10. #删除标题section1下的某个k1和k2
11. config.remove_option(‘section1‘,‘k1‘)
12. config.remove_option(‘section1‘,‘k2‘)
14. #判断是否存在某个标题
15. print(config.has_section(‘section1‘))
17. #判断标题section1下是否有user
18. print(config.has_option(‘section1‘,‘‘))
21. #添加一个标题
22. config.add_section(‘egon‘)
24. #在标题egon下添加name=egon,age=18的配置
25. config.set(‘egon‘,‘name‘,‘egon‘)
26. config.set(‘egon‘,‘age‘,18) #报错,必须是字符串
29. #最后将修改的内容写入文件,完成最终的修改
30. config.write(open(‘a.cfg‘,‘w‘))

 

#test.ini

1. [DEFAULT]
2. ServerAliveInterval = 45
3. Compression = yes
4. CompressionLevel = 9
5. ForwardX11 = yes
7. [bitbucket.org]
8. User = hg
10. [topsecret.server.com]
11. Port = 50022
12. ForwardX11 = no

获取所有节点：

1. import configparser
2. config=configparser.ConfigParser()
3. config.read(‘test.ini‘,encoding=‘utf-8‘)
4. res=config.sections()
5. print(res)
7. ‘‘‘
8. 打印结果:
9. [‘bitbucket.org‘, ‘topsecret.server.com‘]
10. ‘‘‘

获取指定节点下所有的键值对

1. import configparser
2. config=configparser.ConfigParser()
3. config.read(‘test.ini‘,encoding=‘utf-8‘)
4. res=config.items(‘bitbucket.org‘)
5. print(res)
7. ‘‘‘
8. 打印结果:(包含DEFAULT以及bitbucket.org这俩标题下所有的items)
9. [(‘serveraliveinterval‘, ‘45‘), (‘compression‘, ‘yes‘), (‘compressionlevel‘, ‘9‘), (‘forwardx11‘, ‘yes‘), (‘user‘, ‘hg‘)]
10. ‘‘‘

获取指定节点下所有的键key

1. import configparser
2. config=configparser.ConfigParser()
3. config.read(‘test.ini‘,encoding=‘utf-8‘)
4. res=config.options(‘bitbucket.org‘)
5. print(res)
7. ‘‘‘
8. 打印结果:(包含DEFAULT以及bitbucket.org这俩标题下所有的键)
9. [‘user‘, ‘serveraliveinterval‘, ‘compression‘, ‘compressionlevel‘, ‘forwardx11‘]‘‘‘

获取指定节点下指定key的值

1. import configparser
2. config=configparser.ConfigParser()
3. config.read(‘test.ini‘,encoding=‘utf-8‘)
4. res1=config.get(‘bitbucket.org‘,‘user‘)
6. res2=config.getint(‘topsecret.server.com‘,‘port‘)
7. res3=config.getfloat(‘topsecret.server.com‘,‘port‘)
8. res4=config.getboolean(‘topsecret.server.com‘,‘ForwardX11‘)
10. print(res1)
11. print(res2)
12. print(res3)
13. print(res4)
15. ‘‘‘
16. 打印结果:
17. hg
18. 50022.0
19. False
20. ‘‘‘

检查删除添加节点：

1. import configparser
2. config=configparser.ConfigParser()
3. config.read(‘test.ini‘,encoding=‘utf-8‘)
5. #检查
6. has_sec=config.has_section(‘bitbucket.org‘)
7. print(has_sec) #打印True
9. #添加节点
10. config.add_section(‘egon‘) #已经存在则报错
11. config[‘egon‘][‘username‘]=‘gangdan‘
12. config[‘egon‘][‘age‘]=‘18‘
13. config.write(open(‘test.ini‘,‘w‘))
15. #删除节点
16. config.remove_section(‘egon‘)
17. config.write(open(‘test.ini‘,‘w‘))

检查删除设置指定组内的键值对

1. import configparser
2. config=configparser.ConfigParser()
3. config.read(‘test.ini‘,encoding=‘utf-8‘)
5. #检查
6. has_sec=config.has_option(‘bitbucket.org‘,‘user‘) #bitbucket.org下有一个键user
7. print(has_sec) #打印True
9. #删除
10. config.remove_option(‘DEFAULT‘,‘forwardx11‘)
11. config.write(open(‘test.ini‘,‘w‘))
13. #设置
14. config.set(‘bitbucket.org‘,‘user‘,‘gangdang‘)
15. config.write(open(‘test.ini‘,‘w‘))

基于上述方法添加一个ini模版文档

1. import configparser
3. config = configparser.ConfigParser()
4. config["DEFAULT"] = {‘ServerAliveInterval‘: ‘45‘,
5. ‘Compression‘: ‘yes‘,
6. ‘CompressionLevel‘: ‘9‘}
8. config[‘bitbucket.org‘] = {}
9. config[‘bitbucket.org‘][‘User‘] = ‘hg‘
10. config[‘topsecret.server.com‘] = {}
11. topsecret = config[‘topsecret.server.com‘]
12. topsecret[‘Host Port‘] = ‘50022‘ # mutates the parser
13. topsecret[‘ForwardX11‘] = ‘no‘ # same here
14. config[‘DEFAULT‘][‘ForwardX11‘] = ‘yes‘
15. with open(‘example.ini‘, ‘w‘) as configfile:
16. config.write(configfile)

 

 

 

 

xml

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

 

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

a.xml文件

1. <?xml version="1.0"?>
2. <data> #根节点
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. <country name="Singapore"> #子节点
11. <rank updated="yes">5</rank>
12. <year>2011</year>
13. <gdppc>59900</gdppc>
14. <neighbor name="Malaysia" direction="N"/>
15. </country>
16. <country name="Panama"> #子节点
17. <rank updated="yes">69</rank>
18. <year>2011</year>
19. <gdppc>13600</gdppc>
20. <neighbor name="Costa Rica" direction="W"/>
21. <neighbor name="Colombia" direction="E"/>
22. </country>
23. </data>
25. xml数据

 

xml协议在各个语言里的都 是支持的，在python中可以用以下模块操作xml：

1. print(root.iter(‘year‘)) #全文搜索
2. print(root.find(‘country‘)) #在root的子节点找，只找一个
3. print(root.findall(‘country‘)) #在root的子节点找，找所有

 

xml文档操作示例：

1. import xml.etree.ElementTree as ET
3. tree = ET.parse("xmltest.xml")
4. root = tree.getroot()
5. print(root.tag)
7. #遍历xml文档
8. for child in root:
9. print(‘========>‘,child.tag,child.attrib,child.attrib[‘name‘])
10. for i in child:
11. print(i.tag,i.attrib,i.text)
13. #只遍历year 节点
14. for node in root.iter(‘year‘):
15. print(node.tag,node.text)
16. #---------------------------------------
18. import xml.etree.ElementTree as ET
20. tree = ET.parse("xmltest.xml")
21. root = tree.getroot()
23. #修改
24. for node in root.iter(‘year‘):
25. new_year=int(node.text)+1
26. node.text=str(new_year)
27. node.set(‘updated‘,‘yes‘)
28. node.set(‘version‘,‘1.0‘)
29. tree.write(‘test.xml‘)
32. #删除node
33. for country in root.findall(‘country‘):
34. rank = int(country.find(‘rank‘).text)
35. if rank > 50:
36. root.remove(country)
38. tree.write(‘output.xml‘)
40. #在country内添加（append）节点year2
41. import xml.etree.ElementTree as ET
42. tree = ET.parse("a.xml")
43. root=tree.getroot()
44. for country in root.findall(‘country‘):
45. for year in country.findall(‘year‘):
46. if int(year.text) > 2000:
47. year2=ET.Element(‘year2‘)
48. year2.text=‘新年‘
49. year2.attrib={‘update‘:‘yes‘}
50. country.append(year2) #往country节点下添加子节点
52. tree.write(‘a.xml.swap‘)

 

创建一个xml文档：

1. import xml.etree.ElementTree as ET
4. new_xml = ET.Element("namelist")
5. name = ET.SubElement(new_xml,"name",attrib={"enrolled":"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‘
13. et = ET.ElementTree(new_xml) #生成文档对象
14. et.write("test.xml", encoding="utf-8",xml_declaration=True)
16. ET.dump(new_xml) #打印生成的格式

 

hashlib

hash：一种算法 ,3.x里代替了md5模块和sha模块，主要提供 SHA1, SHA224, SHA256, SHA384, SHA512 ，MD5 算法

 

三个特点：

1.内容相同则hash运算结果相同，内容稍微改变则hash值则变

2.不可逆推

3.相同算法：无论校验多长的数据，得到的哈希值长度固定。

1. import hashlib
2. m=hashlib.md5()
3. m.update(‘hello‘.encode(‘utf-8‘))
4. print(m.hexdigest())
6. #->运行结果：
7. 5d41402abc4b2a76b9719d911017c592

update多次，与update一次，得到的结果一样，但update多次为校验大文件提供了可能

 

对文件进行校验：

1. a.txt文件内容：12345
2.  
3. import hashlib
4. m = hashlib.md5()
5. with open(r‘F:\oldboy_python\objects\day06\练习\a.txt‘, ‘rb‘) as f:
6. for line in f:
7. m.update(line)
8. md5_num = m.hexdigest()
9. print(md5_num)
11. #->
12. 827ccb0eea8a706c4c34a16891f84e7b

 

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

例如：

对字符串‘hello‘进行sha256加密，得到一个结果

对字符串‘hello‘，添加一个key(‘123‘)，进行sha256加密

1. import hashlib
2. hash = hashlib.sha256()
3. hash.update(‘hello‘.encode(‘utf-8‘))
4. print(‘--->‘, hash.hexdigest())
6. hash = hashlib.sha256(‘hello‘.encode(‘utf-8‘))
7. hash.update(‘123‘.encode(‘utf8‘))
8. print(‘===>‘, hash.hexdigest())
10. #->
11. ---> 2cf24dba5fb0a30e26e83b2ac5b9e29e1b161e5c1fa7425e73043362938b9824
12. ===> 27cc6994fc1c01ce6659c6bddca9b69c4c6a9418065e612c69d110b3f7b11f8a

 

撞库模拟

库，可以理解为一个密码字典，里面记录了一些常用的密码，用于遍历每一个密码去检测密码是否匹配正确的密码

1. import hashlib
2. passwds=[
3. ‘alex3714‘,
4. ‘alex1313‘,
5. ‘alex94139413‘,
6. ‘alex123456‘,
7. ‘123456alex‘,
8. ‘a123lex‘,
9. ]
10. def make_passwd_dic(passwds):
11. dic = {}
12. for passwd in passwds:
13. m = hashlib.md5()
14. m.update(passwd.encode(‘utf-8‘))
15. dic[passwd] = m.hexdigest()
16. return dic
18. def break_code(cryptograph,passwd_dic):
19. """
20. cryptograph:为抓取到的密文密码
21. :param cryptograph:
22. :param passwd_dic:
23. :return:
24. """
25. for k, v in passwd_dic.items():
26. if v == cryptograph:
27. print(‘密码是===>\033[46m%s\033[0m‘ %k)
29. cryptograph = ‘aee949757a2e698417463d47acac93df‘ #此处模拟alex3714经过md5算法产生的密文密码
30. break_code(cryptograph, make_passwd_dic(passwds))
32. 运行结果：
33. 密码是===>alex3714