标签：func 存在 inter 缺陷 名称 的区别 object abs sha1
模块的基本知识点：
1、定义：一个.py文件就是一个模块
2、模块的种类：
（1）Python标准库（内置模块）
（2）第三方模块
（3）应用程序自定义模块
3、调用模块的关键字：
import : 1、执行调用的文件。 2、引用。
补充：
package（包）的基本知识点：
包的两种调用方式：
## 第一种调用方式 from package1.package2 import test ## 第二种调用方式 from package1.package2.test import function
（1）下面介绍第三方模块的调用方式：
1 ## file_模块.py 文件的内容： 2 3 def add(a,b): 4 return a+b 5 def sub(a,b): 6 return a*b 7 8 if __name__ == ‘__main__‘: ## 注意：这里只有在文件内才能运行 9 c = add(1,2) 10 print(c)
1 import file_模块 2 c = file_模块.add(2,3) 3 print(c)
运行结果： 5
（2）Python的内置模块有：
下面逐一介绍各个模块的方法：
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
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)
JSON(JavaScript Object Notation, JS 对象标记) 是一种轻量级的数据交换格式。JSON的数据格式其实就是python里面的字典格式，里面可以包含方括号括起来的数组，也就是python里面的列表。
在python中，有专门处理json格式的模块—— json 和 picle模块
Json 模块提供了四个方法： dumps、dump、loads、load
（一） json模块
dumps 和 dump：
1 import json 2 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 import json 2 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例子：
1 import json 2 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 # <class ‘int‘> 2 # <class ‘list‘> 3 # {"name": "alex"} 4 # <class ‘dict‘>
1 import json 2 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‘} <class ‘dict‘>
（二）pickle模块
dumps 和 dump：
1 import pickle 2 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 # <class ‘bytes‘>
dump例子：
1 import pickle 2 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 反序列：
1 import pickle 2 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 import pickle 2 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
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下为"\t\n",Linux下为"\n" 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所指向的文件或者目录的最后修改时间
正则表达式本身是一种小型的、高度专业化的编程语言，而在python中，通过内嵌集成re模块，程序员们可以直接调用来实现正则匹配。正则表达式模式被编译成一系列的字节码，然后由用C编写的匹配引擎执行。
本小结需要掌握的知识点有：
一、元字符
二、正则表达式的函数
下面分别学习两大知识点：
一、元字符
元字符有 . ^ $ * + {} ? () [ ] | \
下面依次进行学习：
（1）.
进行匹配时，一个.可以代替一个换行符以外的任意字符串，下面例子：
1 import re 2 res = ‘jksdjaexxofjasklgoasdalexijgjasgiojwoijrwng‘ 3 ret = re.findall(‘j..d‘,res) ## 模糊匹配，这里(..)代替两个除了换行符以外的任意的字符串，假如条件一样，那么结果会出现多个 4 print(ret) 5 # 运行结果：[‘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次或者多次前面出现的正则表达式，下面例子：
1 import re 2 res = ‘dddddddddddddddddddddddijodjsgjjjjjjjjjjjjjjjjjj‘ 3 ret = re.findall(‘d*‘,res) ## 模糊匹配，返回一个列表，匹配 0-无穷次 的重复内容 4 print(ret) 5 ## 运行结果：[‘ddddddddddddddddddddddd‘, ‘‘, ‘‘, ‘‘, ‘d‘, ‘‘, ‘‘, ‘‘, ‘‘, ‘‘, ‘‘, ‘‘, ‘‘, ‘‘, ‘‘, ‘‘, ‘‘, ‘‘, ‘‘, ‘‘, ‘‘, ‘‘, ‘‘, ‘‘, ‘‘, ‘‘, ‘‘]
（5）+ （贪婪匹配）
匹配1次或者多次前面出现的正则表达式，下面例子：
1 import re 2 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 import re 2 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 import re 2 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 import re 2 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‘]
（9） [ ]
1、形式：[..] 匹配来自字符集的任意单个字符
2、形式：[x-y] 匹配x~y范围中的任意单个字符
3、形式：[^x-y] 匹配x~y范围以外的任意单个字符
例子：
1 import re 2 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 import re 2 ret = re.findall(‘ab|c‘,‘acabddbddcddab‘) 3 print(ret)
运行结果：
#[‘c‘, ‘ab‘, ‘c‘, ‘ab‘]
（11） \ 转义字符
1、转移符可以让无意义的字母变成有意义的符号，也就是下面的特殊功能
下面是转义字符的用法：
2、转移符也可以让有意义的元字符变成无意义的字符串，如 "." 加上 "\." 就可以让 "." 这个元字符变成一个普通的字符串
下面注意一个现象：
1 import re 2 ret = re.findall(‘c\b‘,‘abc abc‘) 3 print(ret) 4 # 运行结果：[]
分析一下：为什么这里会匹配不出来呢？"\b"不是代表空格吗？
原因是re只是一个模块，如果上述"c\b"直接交给re模块肯定没问题，但是我们是用Python解释器进行解释提交给re模块，而中间的过程由于反斜杠“\b”是有意义的，Python解释器提前把“\b”解释了，后面真正交给re模块的就只剩下“c”了，所以我们可以有两种方法来解决这个问题：
第一种方法：
1 import re 2 ret = re.findall(‘c\\b‘,‘abc abc‘) ## 在 \ 前加入一个 \ ，Python解释器先转义一层，再交给re 3 print(ret) 4 # 运行结果：[‘c‘, ‘c‘]
第二种方法：
转义前加入 r ，r 表示Python解释器不做任何转义
1 import re 2 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 import re 2 ##### 常用方法有： 3 # 1，findall：生成一个列表 4 # 2，search：返回值是一个对象，如果匹配不成功就返回一个None 5 ret = re.search(‘a‘,‘abc‘) 6 print(ret) 7 print(ret.group()) 8 # 运行结果： <re.Match object; span=(0, 1), match=‘a‘> 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)
|
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 返回操作系统平台名称 |
进度条：
1 import sys,time 2 for i in range(10): 3 sys.stdout.write(‘#‘) 4 time.sleep(1) 5 sys.stdout.flush()
xml是实现不同语言或程序之间进行数据交换的协议，跟json差不多，但json使用起来更简单，不过，古时候，在json还没诞生的黑暗年代，大家只能选择用xml呀，至今很多传统公司如金融行业的很多系统的接口还主要是xml。
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>
下面用xml模块对上面的xml文件进行增删改查：
1 import xml.etree.ElementTree as ET 2 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 in root: 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文件：
1 ################################## 生成一个xml的文件对象 #################################### 2 import xml 3 import xml.etree.ElementTree as ET 4 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‘)
config：配置。也就是说这个文件是为了配置文件而开发的
用configparser模块创建一个新的配置文件：
1 import configparser 2 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 import configparser 26 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‘))
生成的文件：
[DEFAULT] serveraliveinterval = 45 compression = yes compressionlevel = 9 forwardx11 = yes [bitbucket.org] user = hg [topsecret.server.com] forwardx11 = no [yuan] s1 = 11111111111111
用于加密相关的操作，3.x里代替了md5模块和sha模块，主要提供 SHA1, SHA224, SHA256, SHA384, SHA512 ，MD5 算法
1 ###################################### hashlib：加密 ################################### 2 import hashlib 3 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
以上加密算法虽然依然非常厉害，但时候存在缺陷，即：通过撞库可以反解。所以，有必要对加密算法中添加自定义key再来做加密。
1 import hashlib 2 3 # ######## 256 ######## 4 5 hash = hashlib.sha256(‘898oaFs09f‘.encode(‘utf8‘)) 6 hash.update(‘alvin‘.encode(‘utf8‘)) 7 print (hash.hexdigest())#e79e68f070cdedcfe63eaf1a2e92c83b4cfb1b5c6bc452d214c1b7e77cdfd1c7
python 还有一个 hmac 模块，它内部对我们创建 key 和 内容 再进行处理然后再加密:
1 import hmac 2 h = hmac.new(‘alvin‘.encode(‘utf8‘)) 3 h.update(‘hello‘.encode(‘utf8‘)) 4 print (h.hexdigest())#320df9832eab4c038b6c1d7ed73a5940
下面写一个简单的logging文件，并且分成了五个级别，约到后面等级越高
1 import logging 2 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‘)
修改参数：
1 ##--------------------------》 basicConfig 方式 2 import logging 3 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 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
如果需要多次使用日志功能，那么就可以写出一个日志功能的函数，直接调用就可以了，且这种方式是用的最多的
1 #-------------------------------> logger 对象 2 def logger(): 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 return logger 18 ## 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‘)
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用户输出的消息
标签：func 存在 inter 缺陷 名称 的区别 object abs sha1
原文地址：https://www.cnblogs.com/maoxinjueluo/p/12590408.html
