一，模块的概念
别人写好的功能放在一个文件里
内置模块：安装python解析器的时候一起装上的
第三方模块，扩展模式：需要自己安装
自定义模块：自己写的py文件
1.序列化模块
序列：列表，元祖，字符串，bytes
Q1:什么叫序列化
把一个数据类型转换成， 字符串，bytes类型的过程就是序列化
Q2:为什么要把一个数据类型序列化？
当需要把一个数据类型存储在文件中
当需要把一个数据类型通过网络传输的时候
json的优点：在所有语言中都通用
缺点：只支持非常少的数据类型，对数据类型的约束很苛刻：
字典的key必须是字符串，且所有的字符串都必须是用""表示
只支持：数字 字符串 列表 字典
应用场景：在网络操作中，以及多语言环境中，要传递字典、数字、字符串、列表等简单的数据类型的时候使用
import json stu = {'name':'小明','sex':'male'} ret = json.dumps(stu) #序列化过程 lis = [1,2,3,4,5,6] lst = json.dumps(lis) print(stu,type(stu)) print(ret,type(ret)) print(lst,type(lst)) a = json.loads(ret) #反序列化的过程 b = json.loads(lst) print('a-->',a,type(a)) print('b-->',b,type(b))
文件操作间的序列化与反序列化：
#dump和load比较适合存取单个数据量的较大的字典或列表，否则最好使用dumps和loads import json dic = {'name':'小明','sex':'male'} with open('json_file','w',encoding='utf-8') as f: json.dump(dic,f,ensure_ascii=False) #可以多次往一个文件中dump，但是不能多次load,否则报错 #ensure_ascii参数默认为True，传入False，中文字符默认以中文的形式传入文件 with open('json_file','r',encoding='utf-8') as f: dic = json.load(f) print(dic,dic['name'])
json格式化输出
#json格式化 import json data = {'username':['李华','二愣子'],'sex':'male','age':16} json_dic2 = json.dumps(data,sort_keys=True,indent=4,separators=(',',':'),ensure_ascii=False) print(json_dic2)
pickle的优点：
操作文件必须以+b模式打开
在load的时候，如果这个要被load的内容所在的类不在内存中，会报错
pickle支持多次dump和多次load(需要异常处理)
支持几乎所有的python数据类型
缺点：只有python语言支持
import pickle stu = {'name':'小明','sex':'male',1:('a','b')} ret = pickle.dumps(stu) #以bytes形式序列化 print(ret) d = pickle.loads(ret) #反序列化后，pickle几乎完全支持python的数据类型，所以int类型的键，和元组都能支持 print('d--->',d,type(d))
文件操作间的序列化与反序列化：
import pickle class Course(): def __init__(self,name,price): self.name = name self.price = price python = Course('python',29800) linux = Course('linux',25800) mysql = Course('mysql',18000) ret1 = pickle.dumps(python) ret2 = pickle.dumps(linux) ret3 = pickle.dumps(mysql) print(ret1) print(ret2) print(ret3) p = pickle.loads(ret1) a = pickle.loads(ret2) d = pickle.loads(ret3) print(p.name,p.price) print(a.name,a.price) print(d.name,d.price) with open('pickle_file','wb') as f: pickle.dump(python,f) #dump序列化对象，可传入一个文件句柄 # f.write(ret1) with open('pickle_file','rb') as f: course = pickle.load(f) #load反序列化对象，可传入一个文件句柄 # ret = f.read() # course = pickle.loads(ret) print(course.name)
#多次dump序列化传入对象，并多次load反序列化读取对象 import pickle class Course(): def __init__(self,name,price): self.name = name self.price = price python = Course('python',29800) linux = Course('linux',25800) mysql = Course('mysql',18000) def my_dump(course): with open('pickle_file','ab') as f: pickle.dump(course,f) my_dump(python) my_dump(linux) my_dump(mysql) with open('pickle','rb') as f: while 1: try: content = pickle.load(f) print(content.name) except EOFError: #若读取不到数据会报错，所以需要异常处理 break
2.时间模块(time)
格式化时间：str数据类型的时间，例：'2018年9月4日 9时10分20秒'
时间字符串是人能够看懂的时间
时间戳时间：浮点数，秒为单位
#1970 1.1 00:00:00 英国伦敦时间
#1970 1.1 00:00:00 东8时区（北京时间）
时间戳是计算机能够识别的时间
结构化时间：元组
是用来操作时间的
#时间戳-->结构化时间 #time.gmtime(时间戳) #UTC时间，与英国伦敦当地时间一致 #time.localtime(时间戳) #当地时间。例如我们现在在北京执行这个方法：与UTC时间相差8小时，UTC时间+8小时 print(time.gmtime(1500000000)) #可传入时间戳显示，该时间戳的结构化时间（UTC） print(time.localtime(1500000000)) #不传值，默认是当期时间 #结构化时间-->时间戳 time_tuple = time.localtime(1500000000) print(time.mktime(time_tuple))
#结构化时间-->字符串时间 #time.strftime("格式定义","结构化时间") 结构化时间参数若不传，则显示当前时间 print(time.strftime('%Y-%m-%d %X'))
#时间戳-->结构化时间-->字符串时间 print(time.strftime('%Y-%m-%d %H:%M:%S',time.localtime(1500000000)))
#字符串时间-->结构化时间-->时间戳
#time.strptime(时间字符串，字符串对应格式)
time.strptime('2018-9-1','%Y-%m-%d') #具体时间不传，默认为0
str_time = '2018-8-8'
struct_time = time.strptime(str_time,'%Y-%m-%d')
print(struct_time)
timestamp = time.mktime(struct_time)
print(timestamp)
#实例： # 写函数，计算本月1号的时间戳时间 # 通过我拿到的这个时间，能迅速的知道我现在所在时间的年 月 def get_timestamp(): fmt_time = time.strftime('%Y-%m-1') #结构化时间-->字符串时间 struct = time.strptime(fmt_time,'%Y-%m-%d') #字符串时间-->结构化时间 res = time.mktime(struct) #结构化时间-->时间戳 return res ret = get_timestamp() print(ret)
3.随机数模块
import random #取随机小数 * print(random.random()) #（0,1）0-1范围内，不包括0,1 print(random.uniform(2,3)) #（n,m）n-m范围内，不包括n,m #取随机整数 **** print(random.randint(1,2)) #[1,2] 闭区间，包括2 print(random.randrange(1,2)) #[1,2) 开区间 不包括2 print(random.randrange(1,100,2)) #隔一个取一个 #从一个列表中随机抽取 **** lst = [1,2,3,4,5,('a','b'),'cc','dd'] ret = random.choice(lst) print(ret) ret = random.choice(range(100)) print(ret) #从一个列表中随机抽3个 ret = random.sample(lst,3) print(ret) #返回一个列表 #乱序 *** random.shuffle(lst) #将有序对象乱序 print(lst)
#实例： import random def get_code(n=6,alph_flag = True): code = '' for i in range(n): c = str(random.randint(0,9)) if alph_flag: alpha_upper = chr(random.randint(65,90)) #大写字母的ascii码 alpha_lower = chr(random.randint(97,122)) #小写字母的ascii码 c = random.choice([c,alpha_upper,alpha_lower]) code += c return code ret = get_code() print(ret)
4.os模块：操作系统相关模块
import os os.mkdir('dirname') #创建目录 os.makedirs('dirname1/dirname') #创建递归目录 #只能删掉空文件夹 os.rmdir('dirname') os.removedirs('dirname1/dirname2') #先从最底的目录开始删除 print(os.listdir('file')) #显示文件中所有的文件夹和文件的名，包括隐藏文件 print(os.stat('file')) #主要用作查看文件最后修改时间 # 转换为绝对路径 print(os.path.abspath('file')) print(os.path.abspath('file')) #切分目录，和文件名 path = 'file' ret = os.path.split(path) print(ret) #切分目录，和文件名，并返回目录 ret1 = os.path.dirname(path) print(ret1) #切分目录，和文件名，并返回文件名 ret2 = os.path.basename(path) print(ret2) #判断目标文件是否存在，返回bool值 res = os.path.exists('file') print(res) #判断文件或目录，返回bool print(os.path.isfile('file')) print(os.path.isdir('file')) #目录拼接 ret = os.path.join('file') ret = os.path.abspath(ret) #规范化 print(ret) #获取文件最后访问时间 os.path.getatime('file') #获取文件最后修改的时间 os.path.getmtime('file') #获取文件创建时间 os.path.getctime('file') #获取文件的大小（字节） windows 4096文件的信息，扩一倍 # linux/mac 文件夹占的大小 32/64 size = os.path.getsize('file/dirname') print(size) size = os.path.getsize('file') #只能看文件的占用的空间，不是所有文件的大小 print(size) #以字符串的形式来执行操作系统的命令 os.system('bash command') #以字符串的形式来执行操作系统的命令，并返回 os.popen('bash command').read() #显示执行这个文件时所在的目录 os.getcwd() #切换目录 print(__file__) #当前的绝对目录 os.chdir('file')
5.sys模块：是与python解释器交互的一个接口
import sys #sys.argv print(sys.argv) #命令行参数List，第一个元素是程序本身路径 #sys.path print(sys.path) #import模块，遍历这个列表，寻址模块的路径 #一个模块能否被导入，就看这个模块所在的目录在不在sys.path路径中 #内置模块和第三方扩展模块都需要我们处理sys.path就可以直接使用 #自定义的模块的导入工作需要自己手动的修改sys.path? #内置模块目录 # 'C:\xxxx\Python36\lib' # 第三方模块目录 # 'D:xxx\lib\site-packages' #sys.modules {查看当前内存空间中所有的模块：和这个模块的内存空间}
6.collections模式：根据基础数据类做一些扩展
#内置的数据类型 # int float complex # str list tuple # dict set #基础数据类型 # int float complex # str list tuple # dict #set不是基础数据类型
有序字典：py3.6以后自动有序
# 有序字典 py3.6以后自动有序 dic = {'a':1} d = dict([('a',1),('k1','v1')]) #正常创建字典的写法 print(d) from collections import OrderedDict dd = OrderedDict([('a',1),('k1','v1')]) print(dd) for k in dd: print(k,dd[k]) dd['k2'] = 'v2' print(dd)
默认字典：
# 默认字典 from collections import defaultdict d = defaultdict(list) #传入一个可调用参数，并执行，返回的值作为value的值 print(d['a']) d['b'].append(123) #增加一个键值对，并在d['b']中的列表追加元素 print(d) d = {} d['a'] #增加一个键值对 func = lambda :'default' d = defaultdict(func) #自定义默认字典的默认value print(d['kkk']) d['k'] = 'vvvvv' #修改字典的value print(d)
可命名元组：
可命名元组非常类似一个只有属性没有方法的类型
#可命名元组 from collections import namedtuple birth = namedtuple('Struct_time',['year','month','day']) b1 = birth(2018,9,5) print(type(b1)) print(b1.year) print(b1.month) print(b1.day) print(b1) #可命名元组非常类似一个只有属性没有方法的类 #['year','month','day']是对象属性名 #Struct_time是类 的名字 #这个类最大的特点就是一旦实例化 不能修改属性的值
双端队列：双端队列可以弥补list的缺点
#双端队列
#数据结构：链表原理 from collections import deque dq = deque() #创建一个双端队列 dq.append(1) #从末尾添加一个值 dq.append(2) dq.appendleft(3) #从开头添加一个值 print(dq) print(dq.pop()) #从末位弹出一个值 print(dq.popleft()) #从开头弹出一个值
#队列：先进先出，后进后出
import queue
q = queue.Queue() # 创建队列
q.put(1) #存一个值
q.put(2)
q.put('aaa')
q.put([1,2,3])
q.put({'k':'v'})
print(q.get()) #取一个值
print(q.get())
Counter: Counter类的目的是用来跟踪值出现的次数。它是一个无序的容器类型，以字典的键值对形式存储，其中元素作为key，其计数作为value。计数值可以是任意的interger(包括0和负数)。Counter类和其他语言的bags或multisets很相似。
c = Counter('abcdeabcdabcaba') print c 输出：Counter({'a': 5, 'b': 4, 'c': 3, 'd': 2, 'e': 1})
7.hashlib模块：内部有不止一种算法的模块 *****
1.由于数据的不安全性，为了保证用户的信息绝对的安全，所以所有人的密码都不能以明文的形式存储，而应该经过适当的处理以密文的形式存起来。否则可能会被撞库破解
2.大家去计算这个密文，使用的是相同的算法
3.这个算法不可逆
4.不同的字符串通过这个算法的计算得到的密文总是不同的
5.相同的算法，相同的字符串，获得的结果总是相同（适用于不同的语言，不同的环境：操作系统，版本，时间）
#常规使用方式： md5_obj = hashlib.md5() #md5_obj不能重复使用 md5_obj.update('alex3714'.encode('utf-8')) ret = md5_obj.hexdigest()
hashlib摘要算法：具有多种算法，
md5算法：32位16进制的数学字符组成的字符串
应用最广大的摘要算法
效率高，相对不复杂，如果只是传统摘要不安全
sha算法：40位的16位进制的数字字符组成的字符串
sha算法要比md5算法更复杂
shan：n的数字越大算法越复杂，耗时越久，结果越长，越安全
sha_obj = hashlib.sha512() sha_obj.update('alex3714'.encode('utf-8')) ret = sha_obj.hexdigest() print(len(ret)) def get_md5(s): md5_obj = hashlib.md5() #md5_obj只能用一次，所有写成函数比较方便 md5_obj.update(s.encode('utf-8')) ret = md5_obj.hexdigest() return ret print(get_md5('alex3714'))
#多次update与一次性update结果是一样的 md51 = hashlib.md5() md51.update(b'666666') md51.update(b'999999') # 1ad2daed30c3862a267485c7cc9aacce print(md51.hexdigest()) md51 = hashlib.md5() md51.update(b'666666999999') # 1ad2daed30c3862a267485c7cc9aacce print(md51.hexdigest())
加盐：固定的盐，会导致恶意注册的用户密码泄露
def get_md5(s): md5_obj = hashlib.md5('盐'.encode('utf-8')) md5_obj.update(s.encode('utf-8')) ret = md5_obj.hexdigest() return ret
动态加盐：每个用户都有一个固定的并且互不相同的盐
def get_md5(user,s): md5_obj = hashlib.md5(user.encode('utf-8')) md5_obj.update(s.encode('utf-8')) ret = md5_obj.hexdigest() return ret print(get_md5('alex','alex3714')) #使用用户名作为盐
应用场景：
#登录验证
usr = input('username:').strip() passwd = input('passwd:').strip() def get_md5(s): md5_obj = hashlib.md5() md5_obj.update(s.encode('utf-8')) ret = md5_obj.hexdigest() return ret with open('userinfo',encoding='utf-8') as f: for line in f: u,p = line.strip().split('|') if u == usr and p == get_md5(passwd): print('登录成功') break else: print('用户或密码不正确')
# 文件的一致性校验 # 给一个文件中的所有内容进行摘要算法得到一个md5的结果
# 下载的是视频、或者大文件
# 应该是以rb的形式来读 读出来的都是bytes
# 并且不能按行读 也不能一次性读出来
import os import hashlib def get_file_md5(file_path,buffer = 1024): md5_obj = hashlib.md5() file_size = os.path.getsize(file_path) #先确认文件大小是否一致 with open(file_path,'rb') as f: while file_size: content = f.read(buffer) #默认每次取1024个字节 file_size -= len(content) md5_obj.update(content) return md5_obj.hexdigest() print(get_file_md5( r'file')) # 路径里不能有空格
8.配置文件：
当在开发环境的程序上线到生成环境或者生产环境时，往往需要修改文件，可以使用配置文件对需要操作的文件进行管理
#生成配置文件 import configparser config = configparser.ConfigParser() #相当于实例化一个对象 config["DEFAULT"] = {'ServerAliveInterval': '45', #添加属性 'Compression': 'yes', 'CompressionLevel': '9', 'ForwardX11':'yes' } config['bitbucket.org'] = {'User':'hg'} config['topsecret.server.com'] = {'Host Port':'50022','ForwardX11':'no'} with open('example.ini', 'w') as configfile: #写入：生成配置文件 config.write(configfile)
#查看配置文件 import configparser config = configparser.ConfigParser() print(config.sections()) # [] config.read('example.ini') #加载配置文件 print(config.sections()) # ['bitbucket.org', 'topsecret.server.com'] print('bytebong.com' in config) # False print('bitbucket.org' in config) # True print(config['bitbucket.org']["user"]) # hg print(config['DEFAULT']['Compression']) #yes print(config['topsecret.server.com']['ForwardX11']) #no print(config['bitbucket.org']) #<Section: bitbucket.org> for key in config['bitbucket.org']: # 注意,有default会默认default的键 print(key) print(config.options('bitbucket.org')) # 同for循环,找到'bitbucket.org'下所有键 print(config.items('bitbucket.org')) #找到'bitbucket.org'下所有键值对 print(config.get('bitbucket.org','compression')) # yes get方法Section下的key对应的value
#配置文件的增删改 import configparser config = configparser.ConfigParser() config.read('example.ini') config.add_section('yuan') config.remove_section('bitbucket.org') config.remove_option('topsecret.server.com',"forwardx11") config.set('topsecret.server.com','k1','11111') config.set('yuan','k2','22222') config.write(open('new2.ini', "w"))
9.logging模块
Q1:什么是日志？
无处不在的，所有的程序都必须记录日志
日志的主要应用： 例： # 1.给用户看的 # 购物软件 # 视频软件 # 银行卡 # 2.给内部人员看的 # 给技术人员看的 # 计算器 # 500个小表达式 # 一些计算过程、或者是一些操作过程需要记录下来 # 程序出现bug的时候 来帮助我们记录过程 排除错误 # 给非技术人员看的 # 学校、公司的软件 # 谁在什么时候做了什么事儿，删除操作
import logging logging.basicConfig(level=logging.INFO) #显示优先级 logging.debug('debug message') # 计算或者工作的细节 logging.info('info message') # 记录一些用户的增删改查的操作 logging.warning('input a string type') # 警告操作 logging.error('error message') # 错误操作 logging.critical('critical message') # 批判的 直接导致程序出错退出的
# 简单配置 logging.basicConfig(level=logging.INFO, format='%(asctime)s %(filename)s[line:%(lineno)d] %(levelname)s %(message)s', datefmt='%c', filename='test.log') logging.warning('input a string type') # 警告操作 logging.error('EOF ERROR ') # 警告操作 logging.info('6666') # 警告操作
# 对象的配置 # 解决简单配置的中文问题 # 可以同时向文件和屏幕输出内容 # 先创建一个log对象 logger logger = logging.getLogger() logger.setLevel(logging.DEBUG) # 还要创建一个控制文件输出的文件操作符 fh = logging.FileHandler('mylog.log') # 还要创建一个控制屏幕输出的屏幕操作符 sh = logging.StreamHandler() # 要创建一个格式 fmt = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s') fmt2 = logging.Formatter('%(asctime)s - %(name)s[line:%(lineno)d] - %(levelname)s - %(message)s') # 文件操作符 绑定一个 格式 fh.setFormatter(fmt) # 屏幕操作符 绑定一个 格式 sh.setFormatter(fmt2) sh.setLevel(logging.WARNING) # logger对象来绑定：文件操作符， 屏幕操作符 logger.addHandler(sh) logger.addHandler(fh) logger.debug('debug message') # 计算或者工作的细节 logger.info('info message') # 记录一些用户的增删改查的操作 logger.warning('input a string type') # 警告操作 logger.error('error message') # 错误操作 logger.critical('critical message') # 批判的 直接导致程序出错退出的