1.1 时间的格式

1) 时间戳(timestamp):

​ 从1970年到现在经过的秒数

​ 作用:

​ 用于时间间隔的计算

print(time.time())#1585550344.012155

2) 按照某种格式显示的时间(format string):

​ 作用 : 展示时间 2020-03-30 11:11:11

print(time.strftime('%Y-%m-%d %H:%M:%S %p'))
print(time.strftime('%Y-%m-%d %X'))
print(time.strftime('%Y-%m-%d %H %p'))

#2020-03-30 14:39:04 PM
#2020-03-30 14:39:04
#2020-03-30 14 PM

3) 结构化的时间(struct_time):

​ 作用 : 用于单独获取时间的某一部分

res = time.localtime()
print(res)  
# time.struct_time(tm_year=2020, tm_mon=3, tm_mday=30, tm_hour=14, tm_min=41, tm_sec=27, tm_wday=0, tm_yday=90, tm_isdst=0)
print(res.tm_year)  	# 年：2020
print(res.tm_yday)  	# 今年的第90天
print(res.tm_hour)  	# 时：14
print(res.tm_min)  		# 分：41
print(res.tm_sec)  		# 秒：27
print(res.tm_mday)  	# 这个月的第30天
print(res.tm_mon)  		# 月：3
print(res.tm_wday)  	# 星期(0-6):0(星期一)
print(res.tm_zone)  	# 当前的时间区域

2. datetime模块

print(datetime.datetime.now())
print(datetime.datetime.now() + datetime.timedelta(days=3))
#计算3天后的时间
print(datetime.datetime.now() + datetime.timedelta(weeks=1))
#计算7天后的时间

3. 时间模块需要掌握的操作

3.1 时间格式的转换

struct_time->时间戳

import time
s_time=time.localtime()
print(s_time)
print(time.mktime(s_time))

时间戳->struct_time

tp_time=time.time()
print(time.localtime(tp_time))

世界标准时间与本地时间

print(time.localtime())# 上海时区(东八区)
print(time.gmtime()) # 世界标准时间，了解
print(time.localtime(333333333))
print(time.gmtime(333333333))

struct_time->格式化的字符串形式的时间

s_time=time.localtime()
print(time.strftime('%Y-%m-%d %H:%M:%S',s_time))
#2020-03-30 14:58:30
print(time.strftime('%Y-%m-%d %H:%M:%S'))
#2020-03-30 14:58:30
print(time.strptime('1988-03-03 11:11:11','%Y-%m-%d %H:%M:%S'))
#time.struct_time(tm_year=1988, tm_mon=3, tm_mday=3, tm_hour=11, tm_min=11, tm_sec=11, tm_wday=3, tm_yday=63, tm_isdst=-1)

3.2 format string<------>timestamp

'1988-03-03 11:11:11'+7
# format string--->struct_time--->timestamp
struct_time=time.strptime('1988-03-03 11:11:11','%Y-%m-%d %H:%M:%S')
timestamp=time.mktime(struct_time)+7*86400
print(timestamp)#573966671.0

# format string<---struct_time<---timestamp
res=time.strftime('%Y-%m-%d %X',time.localtime(timestamp))
print(res)#1988-03-10 11:11:11

了解知识:

import time
print(time.asctime())# Mon Mar 30 15:03:54 常用于Linux操作系统

import datetime
print(datetime.datetime.now())
print(datetime.datetime.fromtimestamp(333333))
# 时间戳直接转成日期格式 1970-01-05 04:35:33

4. random模块

4.1 常用命令

import random

print(random.random())
#(0,1)----float    大于0且小于1之间的小数
print(random.randint(1, 3)) 
# [1,3]    大于等于1且小于等于3之间的整数

print(random.randrange(1, 3)) 
# [1,3)    大于等于1且小于3之间的整数

print(random.choice([111, 'aaa', [4, 5]])) 
# 1或者23或者[4,5]

print(random.sample([111, 'aaa', 'ccc','ddd'],2))#任意2个组合
print(random.sample([111, 'aaa', 'ccc','ddd'],3))#任意三个组合

print(random.uniform(1, 3)) 
# 大于1小于3的小数，如1.927109612082716

item = [1, 3, 5, 7, 9]
random.shuffle(item)  # 打乱item的顺序,相当于"洗牌"
print(item)

4.2 应用案例:随机验证码

import random
#随机生成4位大写字母+数字的验证码
def make_code(size=4):
    res=''
    for i in range(size):
        s1=chr(random.randint(65,90))#从26大写字母中随机取出一个
        s2=str(random.randint(0,9))#从10个数字中随机取出一个
        res+=random.choice([s1,s2])#随机取出一个,加到res中
    return res
print(make_code(6))

ps:
    小写字母则加入:s2 = chr(random.randint(97,122))

5. os模块

5.1 常用命令

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

5.2 常用命令解析

os.listdir() 获取某一个文件夹下的子文件和文件名

# 获取某一个文件夹下所有的子文件以及子文件夹的名字
res=os.listdir('../../week4')
['day16', 'day17', 'day18', 'day19', 'day20']
res=os.listdir('.')
#['01 时间模块.py', '02 random模块.py', '03 os模块.py', '04 sys模块.py', 'day21 笔记.md', 'run.py', '作业(3).txt', '笔记.txt']
print(res)

os.path.getsize() 查看文件大小

size=os.path.getsize(r'作业(3).txt')#218
print(size)

os.remove()  #删除一个文件
os.rename("作业(3).txt","作业.txt")  #重命名文件/目录

print(os.listdir('.'))
['01 时间模块.py', '02 random模块.py', '03 os模块.py', '04 sys模块.py', 'day21 笔记.md', 'run.py', '作业.txt', '笔记.txt']

os.environ 获取系统环境变量

# 规定：key与value必须都为字符串

os.environ['aaaaaaaaaa']='111'
print(os.environ)

文件相关操作

print(__file__)
#E:/python学习/week5/day21/03 os模块.py
print(os.path.abspath(__file__)) #返回path规范化的绝对路径
#E:老男孩python学习week5day21 3 os模块.py

print(os.path.dirname(r'/a/b/c/d.txt'))#路径的文件夹
print(os.path.basename(r'/a/b/c/d.txt'))#路径的文件名
#/a/b/c
#d.txt
print(os.path.split('/a/b/c/d.txt'))        
# 会把路径和文件切分开：('/a/b/c', 'd.txt')
print(os.path.split(__file__))              
# 会把路径和文件切分开：('E:/python学习/week5/day21', '03 os模块.py')

print(os.path.isabs(r'../week5'))    # 判断是否为绝对路径

print(os.path.isfile(r'笔记.txt'))
print(os.path.isfile(r'aaa'))
print(os.path.isdir(r'aaa'))
#True
#False
#True
print(os.path.join('a','s','b','c','d'))#文件拼接
print(os.path.join('a','/','b','c','d'))
print(os.path.join('a','C:','b','c','d'))
#ascd
#/bcd
#C:bcd

规定起始目录

# 推荐用这种
BASE_DIR=os.path.dirname(os.path.dirname(__file__))
print(BASE_DIR)
# 不推荐用这种
BASE_DIR=os.path.normpath(os.path.join(
    __file__,
    '..',
    '..'
))
print(BASE_DIR)
# 在python3.5之后，推出了一个新的模块pathlib  
#模块功能清晰,但版本太新,不推荐
from pathlib import Path

res = Path(__file__).parent.parent
print(res)
res=Path('/a/b/c') / 'd/e.txt'
print(res)#acde.txt

print(res.resolve())# 格式规范化，把 / 变成 ：E:acde.txt

6. sys模块

6.1 常用命令

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

6.2 常用命令解析

sys.argv 命令行参数List，第一个元素是程序本身路径

# python3.8 run.py 1 2 3
# sys.argv在Python解释器内,接受外界传来的值,获取的是解释器后参数值
print(sys.argv)
#['E:/python学习/week5/day21/run.py','1','2','3']

文件拷贝的原始方法

src_file = input('原文件路径：').strip()
dst_file = input('新文件路径：').strip()

with open(r'%s'%src_file, mode='rb') as read_f,
    open(r'%s'%dst_file, mode='wb') as write_f:
    for line in read_f:
        write_f.write(line)

文件拷贝的新方法

src_file = sys.argv[1]
dst_file = sys.argv[2]
['E:/python学习/week5/day21/run.py','a.txt','b.txt']
with open(r'%s'%src_file, mode='rb') as read_f,
    open(r'%s'%dst_file, mode='wb') as write_f:
    for line in read_f:
        write_f.write(line)
# 在run.py所在的文件夹下，按住shift，右键，选择“在此处打开power shell”,输入
# 格式：python3 run.py 原文件路径 新文件路径
# python3 run.py D:1.docx D:2.docx   #拷贝成功

6.3 应用:进度条

#基础知识
# print('[%-50s]' %'#')
# print('[%-50s]' % '##')
# print('[%-50s]' % '###')

# 输出：
[#                                                 ]
[##                                                ]
[###                                               ]
import time
#进度条显示
res = ''
for i in range(50):
    res += '#'
    time.sleep(0.2)
    print('
 [%-50s]' % res, end='')
    
# 输出：  [##################################################]
    
#进阶
import time
recv_size = 0
total_size = 25600

while recv_size < total_size:
    # 模拟网速
    time.sleep(0.2)
    # 下载了1024个字节的数据
    recv_size += 1024
    # 打印进度条
    # print(recv_size)
    percent = recv_size / total_size    # 1024 / 25600
    if percent > 1:
        percent = 1
    res = int(50 * percent) * '>'
    print('
 [%-50s] %d%%' % (res,percent*100), end='')
    
#函数最终版
import time

def progress(percent):
    if percent > 1:
        percent = 1
    res = int(50 * percent) * '>'
    print('
 [%-50s] %d%%' % (res,percent*100), end='')

recv_size = 0
total_size = 25600

while recv_size < total_size:
    time.sleep(0.2)
    recv_size += 1024
    percent = recv_size / total_size    # 1024 / 25600
    progress(percent)

7. shutil模块

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

7.1 基本使用

import shutil
shutil.copyfile( src, dst)   #从源src复制到dst中去。 如果当前的dst已存在的话就会被覆盖掉

shutil.move( src, dst)  #移动文件或重命名

shutil.copymode( src, dst) #只是会复制其权限其他的东西是不会被复制的

shutil.copystat( src, dst) #复制权限、最后访问时间、最后修改时间

shutil.copy( src, dst)  #复制一个文件到一个文件或一个目录

shutil.copy2( src, dst)  #在copy上的基础上再复制文件最后访问时间与修改时间也复制过来了，类似于cp –p的东西

shutil.copy2( src, dst)  #如果两个位置的文件系统是一样的话相当于是rename操作，只是改名；如果是不在相同的文件系统的话就是做move操作

shutil.copytree( olddir, newdir, True/Flase) #把olddir拷贝一份newdir，如果第3个参数是True，则复制目录时将保持文件夹下的符号连接，如果第3个参数是False，则将在复制的目录下生成物理副本来替代符号连接

shutil.rmtree( src )   #递归删除一个目录以及目录内的所有内容

7.2 高级使用

shutil.copyfileobj(fsrc, fdst[, length])
将文件内容拷贝到另一个文件中

shutil.copyfileobj(open('old.xml','r'), open('new.xml', 'w'))

shutil.copyfile(src, dst)拷贝文件

shutil.copyfile('f1.log', 'f2.log') #目标文件无需存在

shutil.copymode(src, dst) 仅拷贝权限。内容、组、用户均不变

shutil.copymode('f1.log', 'f2.log') #目标文件必须存在

shutil.copystat(src, dst) 仅拷贝状态的信息，包括：mode bits, atime, mtime, flags

shutil.copystat('f1.log', 'f2.log') #目标文件必须存在

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

shutil.copy('f1.log', 'f2.log')

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

shutil.copy2('f1.log', 'f2.log')

shutil.ignore_patterns(*patterns)
shutil.copytree(src, dst, symlinks=False, ignore=None)
递归的去拷贝文件夹

shutil.copytree('folder1', 'folder2', ignore=shutil.ignore_patterns('*.pyc', 'tmp*')) 
#目标目录不能存在，注意对folder2目录父级目录要有可写权限，ignore的意思是排除 

shutil.copytree('f1', 'f2', symlinks=True, ignore=shutil.ignore_patterns('*.pyc', 'tmp*'))

'''
通常的拷贝都把软连接拷贝成硬链接，即对待软连接来说，创建新的文件
'''

shutil.rmtree(path[, ignore_errors[, onerror]]) 递归的去删除文件

shutil.rmtree('folder1')

shutil.move(src, dst) 递归的去移动文件，它类似mv命令，其实就是重命名。

shutil.move('folder1', 'folder3')

shutil.make_archive(base_name, format,...)

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

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

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

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

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

import zipfile

# 压缩
z = zipfile.ZipFile('laxi.zip', 'w')
z.write('a.log')
z.write('data.data')
z.close()

# 解压
z = zipfile.ZipFile('laxi.zip', 'r')
z.extractall(path='.')
z.close()

zipfile压缩解压缩

import tarfile

# 压缩
>>> t=tarfile.open('/tmp/egon.tar','w')
>>> t.add('/test1/a.py',arcname='a.bak')
>>> t.add('/test1/b.py',arcname='b.bak')
>>> t.close()


# 解压
>>> t=tarfile.open('/tmp/egon.tar','r')
>>> t.extractall('/egon')
>>> t.close()

tarfile压缩解压缩

8. json和pickle模块

8.1 什么是序列化和反序列化

内存中的数据类型---->序列化---->特定的格式（json格式或者pickle格式）
内存中的数据类型<----反序列化<----特定的格式（json格式或者pickle格式）

土办法：

 {'aaa':111}--->序列化str({'aaa':111})----->"{'aaa':111}"
 {'aaa':111}<---反序列化eval("{'aaa':111}")<-----"{'aaa':111}"

8.2 为何要序列化

序列化得到结果=>特定的格式的内容有两种用途
1、可用于存储=》用于存档
2、传输给其他平台使用=》跨平台数据交互
python java
列表 特定的格式 数组

强调：
针对用途1=》：可是一种专用的格式=》pickle只有python可以识别
针对用途2=》：应该是一种通用、能够被所有语言识别的格式=》json

8.3 如何序列化和反序列化

示范1

import json
# 序列化
json_res=json.dumps([1,'aaa',True,False])
# print(json_res,type(json_res)) # "[1, "aaa", true, false]"

# 反序列化
l=json.loads(json_res)
print(l,type(l))

示范2

# 序列化的结果写入文件的复杂方法
json_res=json.dumps([1,'aaa',True,False])
with open('test.json',mode='wt',encoding='utf-8') as f:
    f.write(json_res)

# 将序列化的结果写入文件的简单方法
with open('test.json',mode='wt',encoding='utf-8') as f:
    json.dump([1,'aaa',True,False],f)


# 从文件读取json格式的字符串进行反序列化操作的复杂方法
with open('test.json',mode='rt',encoding='utf-8') as f:
    json_res=f.read()
    l=json.loads(json_res)
    print(l,type(l))

# 从文件读取json格式的字符串进行反序列化操作的简单方法
with open('test.json',mode='rt',encoding='utf-8') as f:
    l=json.load(f)
    print(l,type(l))

8.4 json强调

json格式兼容的是所有语言通用的数据类型，不能识别某一语言的所独有的类型

一定要搞清楚json格式，不要与python混淆

json.dumps({1,2,3,4,5})#json中没有Python集合的概念
# 无论数据是怎样创建的，只要满足json格式，就可以json.loads出来,不一定非要dumps的数据才能loads
l=json.loads('[1, "aaa", true, false]')
l=json.loads("[1,1.3,true,'aaa', true, false]")
print(l[0])

8.5 json了解知识

#在python解释器2.7与3.6之后都可以json.loads(bytes类型)，但唯独3.5不可以
l = json.loads(b'[1, "aaa", true, false]')
print(l, type(l))

with open('test.json',mode='rb') as f:
    l=json.load(f)


res=json.dumps({'name':'哈哈哈'})
print(res,type(res))

res=json.loads('{"name": "u54c8u54c8u54c8"}')
print(res,type(res))

8.6 猴子补丁和ujson

什么是猴子补丁?

​ 猴子补丁的核心就是用自己的代码替换所用模块的源代码

猴子补丁的功能(一切皆对象)

　　拥有在模块运行时替换的功能, 例如: 一个函数对象赋值给另外一个函数对象(把函数原本的执行的功能给替换了)

猴子补丁的应用

#json 在dumps和loads的运行速度不如ujson，可以在程序入口处将两个方法替换为ujson中的dumps和loads方法
#在入口处打猴子补丁，即run.py
import json
import ujson

def monkey_patch_json():
    json.__name__ = 'ujson'
    json.dumps = ujson.dumps
    json.loads = ujson.loads

monkey_patch_json() # 在入口文件出运行

#import ujson as json # 不行，只需要替换两个方法，而不是全部替换

# 后续代码中的应用，使用不发生改变
json.dumps()
json.dumps()
json.loads()
json.loads()

8.7 pickle模块

import pickle
res=pickle.dumps({1,2,3,4,5})
print(res,type(res))

s=pickle.loads(res)
print(s,type(s))

9. xml和shelve模块（了解）

9.1 shelve模块

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

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

import shelve

f=shelve.open(r'sheve.txt')
# f['stu1_info']={'name':'egon','age':18,'hobby':['piao','smoking','drinking']}
# f['stu2_info']={'name':'gangdan','age':53}
# f['school_info']={'website':'http://www.pypy.org','city':'beijing'}

print(f['stu1_info']['hobby'])
f.close()

9.2 xml模块

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

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

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

import xml.etree.ElementTree as ET
 
tree = ET.parse("xmltest.xml")
root = tree.getroot()
print(root.tag)
 
#遍历xml文档
for child in root:
    print('========>',child.tag,child.attrib,child.attrib['name'])
    for i in child:
        print(i.tag,i.attrib,i.text)
 
#只遍历year 节点
for node in root.iter('year'):
    print(node.tag,node.text)
#---------------------------------------

import xml.etree.ElementTree as ET
 
tree = ET.parse("xmltest.xml")
root = tree.getroot()
 
#修改
for node in root.iter('year'):
    new_year=int(node.text)+1
    node.text=str(new_year)
    node.set('updated','yes')
    node.set('version','1.0')
tree.write('test.xml')
 
 
#删除node
for country in root.findall('country'):
   rank = int(country.find('rank').text)
   if rank > 50:
     root.remove(country)
 
tree.write('output.xml')

#在country内添加（append）节点year2
import xml.etree.ElementTree as ET
tree = ET.parse("a.xml")
root=tree.getroot()
for country in root.findall('country'):
    for year in country.findall('year'):
        if int(year.text) > 2000:
            year2=ET.Element('year2')
            year2.text='新年'
            year2.attrib={'update':'yes'}
            country.append(year2) #往country节点下添加子节点

tree.write('a.xml.swap')

10. configparser模块

用于读取某些特定格式的配置文件（例如：ini，cft结尾的）

#配置文件如下：
# 注释1： 注释2

[section1]
k1 = v1
k2:v2
user=egon
age=18
is_admin=true
salary=31
[section2]
k1 = v1

import configparser
#将配置文件加载到内存
config=configparser.ConfigParser()
config.read('test.ini')

# 1、获取sections
print(config.sections())
#['section1', 'section2']

# 2、获取某一section下的所有options
print(config.options('section1'))
#['k1', 'k2', 'user', 'age', 'is_admin', 'salary']

# 3、获取items
print(config.items('section1'))
# [('k1', 'v1'), ('k2', 'v2'), ('user', 'egon'), ('age', '18'), ('is_admin', 'true'), ('salary', '31')]

# 4、获取指定配置信息
res=config.get('section1','user')
print(res,type(res))

res=config.getint('section1','age')
print(res,type(res))

res=config.getboolean('section1','is_admin')
print(res,type(res))

res=config.getfloat('section1','salary')
print(res,type(res))

11. hashlib模块

1 什么是哈希hash

hash一类算法，该算法接受传入的内容，经过运算得到一串hash值

hash值的特点：

• I 只要传入的内容一样，得到的hash值必然一样
• II 不能由hash值返解成内容
• III 不管传入的内容有多大，只要使用的hash算法不变，得到的hash值长度是一定

2 hash的用途

用途1：特点II用于密码密文传输与验证
用途2：特点I、III用于文件完整性校验

3 如何用

hash算法就像一座工厂，工厂接收你送来的原材料（可以用m.update()为工厂运送原材料），经过加工返回的产品就是hash值

import hashlib

m=hashlib.md5()
m.update('hello'.encode('utf-8'))
m.update('world'.encode('utf-8'))
res=m.hexdigest() # 'helloworld'
print(res)

m1=hashlib.md5('he'.encode('utf-8'))
m1.update('llo'.encode('utf-8'))
m1.update('w'.encode('utf-8'))
m1.update('orld'.encode('utf-8'))
res=m1.hexdigest()# 'helloworld'
print(res)
'''
注意：把一段很长的数据update多次，与一次update这段长数据，得到的结果一样
但是update多次为校验大文件提供了可能。
'''

4 应用

示例1：模拟撞库

#alex3714的m5哈希值
cryptograph='aee949757a2e698417463d47acac93df'
import hashlib

# 制作密码字段
passwds=[
    'alex3714',
    'alex1313',
    'alex94139413',
    'alex123456',
    '123456alex',
    'a123lex',
]

dic={}
for p in passwds:
    res=hashlib.md5(p.encode('utf-8'))
    dic[p]=res.hexdigest()

# 模拟撞库得到密码
for k,v in dic.items():
    if v == cryptograph:
        print('撞库成功，明文密码是：%s' %k)
        break

示例2：提升撞库的成本=>密码加盐(对密码添加额外字段)

import hashlib

m=hashlib.md5()

m.update('天王'.encode('utf-8'))
m.update('alex3714'.encode('utf-8'))
m.update('盖地虎'.encode('utf-8'))
print(m.hexdigest())

#对于一个很大的文件，并不是将全部内容进行加密
#而是选取文件的几个部分组成的数据，进行加密，
#这样能很好的提升文件校验效率
#m.update(文件所有的内容)
#m.hexdigest()

f=open('a.txt',mode='rb')
f.seek()
f.read(2000) # 巨琳
m1.update(文见的一行)

m1.hexdigest()

12. subprocess模块

subprocess模块，主要执行子进程，用于执行系统命令的模块

注意：其返回值的编码类型，与所使用的操作系统有关，

windows -》gbk， mac-》utf-8

import subprocess

obj=subprocess.Popen('echo 123 ; ls / ; ls /root',shell=True,
                 stdout=subprocess.PIPE,
                 stderr=subprocess.PIPE,
                 )
# print(obj)
# res=obj.stdout.read()
# print(res.decode('utf-8'))

err_res=obj.stderr.read()
print(err_res.decode('utf-8'))

13. logging模块

1 日志级别和基本配置

import logging

# 一：日志配置
logging.basicConfig(
    # 1、日志输出位置：1、终端 2、文件
    # filename='access.log', # 不指定，默认打印到终端

    # 2、日志格式
    format='%(asctime)s - %(name)s - %(levelname)s -%(module)s:  %(message)s',

    # 3、时间格式
    datefmt='%Y-%m-%d %H:%M:%S %p',

    # 4、日志级别
    # critical => 50
    # error => 40
    # warning => 30
    # info => 20
    # debug => 10
    level=30,
)

# 二：输出日志
logging.debug('调试debug')
logging.info('消息info')
logging.warning('警告warn')
logging.error('错误error')
logging.critical('严重critical')

'''
# 注意下面的root是默认的日志名字
WARNING:root:警告warn
ERROR:root:错误error
CRITICAL:root:严重critical
'''

2 日志配置字典

"""
日志配置字典LOGGING_DIC
"""
# 1、定义三种日志输出格式，日志中可能用到的格式化串如下
# %(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用户输出的消息

# 2、强调：其中的%(name)s为getlogger时指定的名字
standard_format = '%(asctime)s - %(threadName)s:%(thread)d - 日志名字:%(name)s - %(filename)s:%(lineno)d -' 
                  '%(levelname)s - %(message)s'

simple_format = '[%(levelname)s][%(asctime)s][%(filename)s:%(lineno)d]%(message)s'

test_format = '%(asctime)s] %(message)s'

# 3、日志配置字典
LOGGING_DIC = {
    'version': 1,
    'disable_existing_loggers': False,
    #  多个日志格式
    'formatters': {
    #定制的日志格式的名字
        'standard': {
            'format': standard_format
        },
        'simple': {
            'format': simple_format
        },
        'test': {
            'format': test_format
        },
    },
    'filters': {},
    # handlers是日志的接收者，控制日志的输出位置，不同的handler会将日志输出到不同的位置
    'handlers': {
        #打印到终端的日志
        'console': {
            'level': 'DEBUG',#日志的级别，也可以写成数字
            'class': 'logging.StreamHandler',  # 打印到屏幕
            'formatter': 'simple'
        },
        'default': {
            'level': 'DEBUG',
            'class': 'logging.handlers.RotatingFileHandler',  # 保存到文件
            # 'maxBytes': 1024*1024*5,  # 日志大小 5M
            'maxBytes': 1000,
            'backupCount': 5,
            'filename': 'a1.log',  # os.path.join(os.path.dirname(os.path.dirname(__file__)),'log','a2.log')
            'encoding': 'utf-8',
            'formatter': 'standard',

        },
        #打印到文件的日志,收集info及以上的日志
        'other': {
            'level': 'DEBUG',
            'class': 'logging.FileHandler',  # 保存到文件
            'filename': 'a2.log', # os.path.join(os.path.dirname(os.path.dirname(__file__)),'log','a2.log')
            'encoding': 'utf-8',
            'formatter': 'test',

        },
    },
    # loggers是日志的产生者，产生不同级别的日志，产生的日志会传递给handler然后控制输出
    'loggers': {
        #logging.getLogger(__name__)拿到的logger配置
        'kkk': {
            'handlers': ['console','other'],  # 这里把上面定义的两个handler都加上，即log数据既写入文件又打印到屏幕
            'level': 'DEBUG', # loggers(第一层日志级别关限制)--->handlers(第二层日志级别关卡限制)
            'propagate': False,  # 默认为True，向上（更高level的logger）传递，通常设置为False即可，否则会一份日志向上层层传递
        },
        '终端提示': {
            'handlers': ['console',],  # 这里把上面定义的两个handler都加上，即log数据既写入文件又打印到屏幕
            'level': 'DEBUG',  # loggers(第一层日志级别关限制)--->handlers(第二层日志级别关卡限制)
            'propagate': False,  # 默认为True，向上（更高level的logger）传递，通常设置为False即可，否则会一份日志向上层层传递
        },
        #真对多种相同的输出，靠不同的日志名去区分功能的，可以填''
        '': {
            'handlers': ['default', ],  # 这里把上面定义的两个handler都加上，即log数据既写入文件又打印到屏幕
            'level': 'DEBUG',  # loggers(第一层日志级别关限制)--->handlers(第二层日志级别关卡限制)
            'propagate': False,  # 默认为True，向上（更高level的logger）传递，通常设置为False即可，否则会一份日志向上层层传递
        },
    },
}

3 logging的使用

import settings

# !!!强调!!!
# 1、logging是一个包，需要使用其下的config、getLogger，可以如下导入
# from logging import config
# from logging import getLogger

# 也可以使用如下导入
import logging.config # 这样连同logging.getLogger都一起导入了,然后使用前缀logging.config.

# logging.config.dictConfig(settings.LOGGING_DIC)
# print(logging.getLogger)

# 接下来要做的是：拿到日志的产生者即loggers来产生日志
# 第一个日志的产生者：kkk
# 第二个日志的产生者：bbb

# 但是需要先导入日志配置字典LOGGING_DIC
import settings
from logging import config,getLogger

config.dictConfig(settings.LOGGING_DIC)


# logger1=getLogger('kkk')
# logger1.info('这是一条info日志')

# logger2=getLogger('终端提示')
# logger2.info('logger2产生的info日志')

# logger3=getLogger('用户交易')
# logger3.info('logger3产生的info日志')

logger4=getLogger('用户常规')
logger4.info('logger4产生的info日志')

# 补充两个重要额知识
# 1、日志名的命名
#    日志名是区别日志业务归属的一种非常重要的标识

# 2、日志轮转
#    日志不能轻易的删除，不应该在一个文件里不断累加，
#    定期的将文件中的内容剪切走，（设置阈值，超过多少M执行）
#    日志记录着程序员运行过程中的关键信息

14. re模块

1 什么是正则？

　正则就是用一些具有特殊含义的符号组合到一起（称为正则表达式）来描述字符或者字符串的方法。或者说：正则就是用来描述一类事物的规则。****（在Python中）它内嵌在Python中，并通过 re 模块实现。正则表达式模式被编译成一系列的字节码，然后由用 C 编写的匹配引擎执行。

2 常用匹配模式(元字符)

http://blog.****.net/yufenghyc/article/details/51078107

# =================================匹配模式=================================
#一对一的匹配
# 'hello'.replace(old,new)
# 'hello'.find('pattern')

#正则匹配
import re
#w与W
print(re.findall('w','hello egon 123')) #['h', 'e', 'l', 'l', 'o', 'e', 'g', 'o', 'n', '1', '2', '3']
print(re.findall('W','hello egon 123')) #[' ', ' ']

#s与S
print(re.findall('s','hello  egon  123')) #[' ', ' ', ' ', ' ']
print(re.findall('S','hello  egon  123')) #['h', 'e', 'l', 'l', 'o', 'e', 'g', 'o', 'n', '1', '2', '3']

#
 	都是空,都可以被s匹配
print(re.findall('s','hello 
 egon 	 123')) #[' ', '
', ' ', ' ', '	', ' ']

#
与	
print(re.findall(r'
','hello egon 
123')) #['
']
print(re.findall(r'	','hello egon	123')) #['
']

#d与D
print(re.findall('d','hello egon 123')) #['1', '2', '3']
print(re.findall('D','hello egon 123')) #['h', 'e', 'l', 'l', 'o', ' ', 'e', 'g', 'o', 'n', ' ']

#A与
print(re.findall('Ahe','hello egon 123')) #['he'],A==>^
print(re.findall('123','hello egon 123')) #['he'],==>$

#^与$
print(re.findall('^h','hello egon 123')) #['h']
print(re.findall('3$','hello egon 123')) #['3']

# 重复匹配：| . | * | ? | .* | .*? | + | {n,m} |
#.:匹配除了
之外任意一个字符，指定re.DOTALL之后才能匹配换行符
print(re.findall('a.b','a1b')) #['a1b']
print(re.findall('a.b','a1b a*b a b aaab')) #['a1b', 'a*b', 'a b', 'aab']
print(re.findall('a.b','a
b')) #[]
print(re.findall('a.b','a
b',re.S)) #['a
b']
print(re.findall('a.b','a
b',re.DOTALL)) #['a
b']同上一条意思一样

#*：左侧字符重复0次或无穷次，性格贪婪
print(re.findall('ab*','bbbbbbb')) #[]
print(re.findall('ab*','a')) #['a']
print(re.findall('ab*','abbbb')) #['abbbb']

#?：左侧字符重复0次或1次，性格贪婪
print(re.findall('ab?','a')) #['a']
print(re.findall('ab?','abbb')) #['ab']
#匹配所有包含小数在内的数字
print(re.findall('d+.?d*',"asdfasdf123as1.13dfa12adsf1asdf3")) #['123', '1.13', '12', '1', '3']
#+：左侧字符重复1次或无穷次，性格贪婪
print(re.findall('ab+','a')) #[]
print(re.findall('ab+','abbb')) #['abbb']

#.*默认为贪婪匹配
print(re.findall('a.*b','a1b22222222b')) #['a1b22222222b']

#.*?为非贪婪匹配：推荐使用
print(re.findall('a.*?b','a1b22222222b')) #['a1b']


#{n,m}左侧字符重复n次到m次，性格贪婪
# {0,} => *
# {1,} => +
# {0,1} => ?
# {n}单独一个n代表只出现n次，多一次不行少一次也不行
print(re.findall('ab{2}','abbb')) #['abb']
print(re.findall('ab{2,4}','abbb')) #['abb']
print(re.findall('ab{1,}','abbb')) #'ab{1,}' ===> 'ab+'
print(re.findall('ab{0,}','abbb')) #'ab{0,}' ===> 'ab*'

#[]匹配指定字符一个
print(re.findall('a[1*-]b','a1b a*b a-b')) #[]内的都为普通字符了，且如果-没有被转意的话，应该放到[]的开头或结尾
print(re.findall('a[^1*-]b','a1b a*b a-b a=b')) #[]内的^代表的意思是取反，所以结果为['a=b']
print(re.findall('a[0-9]b','a1b a*b a-b a=b')) #[]内的^代表的意思是取反，所以结果为['a=b']
print(re.findall('a[a-z]b','a1b a*b a-b a=b aeb')) #[]内的^代表的意思是取反，所以结果为['a=b']
print(re.findall('a[a-zA-Z]b','a1b a*b a-b a=b aeb aEb')) #[]内的^代表的意思是取反，所以结果为['a=b']

## print(re.findall('a\c','ac')) #对于正则来说a\c确实可以匹配到ac,但是在python解释器读取a\c时，会发生转义，然后交给re去执行，所以抛出异常
print(re.findall(r'a\c','ac')) #r代表告诉解释器使用rawstring，即原生字符串，把我们正则内的所有符号都当普通字符处理，不要转义
print(re.findall('a\\c','ac')) #同上面的意思一样，和上面的结果一样都是['a\c']

# print(re.findall('adb','a1111111b a3b a4b a9b aXb a b a
b',re.DOTALL))
# print(re.findall('a[501234]b','a1111111b a3b a4b a9b aXb a b a
b',re.DOTALL))
# print(re.findall('a[0-5]b','a1111111b a3b a1b a0b a4b a9b aXb a b a
b',re.DOTALL))
# print(re.findall('a[0-9a-zA-Z]b','a1111111b axb a3b a1b a0b a4b a9b aXb a b a
b',re.DOTALL))
#
# print(re.findall('a[^0-9a-zA-Z]b','a1111111b axb a3b a1b a0b a4b a9b aXb a b a
b',re.DOTALL))
# print(re.findall('a-b','a-b aXb a b a
b',re.DOTALL))
print(re.findall('a[-0-9
]b','a-b a0b a1b a8b aXb a b a
b',re.DOTALL))