Python常用模块
-
常用模块的介绍
-
time，datetime
-
time：和时间相关
- time.time()，获取时间戳（从时间原点（1970年1.1 00.00.00）到现在经过的秒数）
- time.gmtime()，GMT时间，获取格式化时间对象，可以给时间戳，若不给则使用现在的时间戳
- time.localtime()，当地时间，可以给时间戳，若不给则使用现在的时间戳
- 格式化时间对象和字符串进行转换
- str=time.strftime("%Y-%m-%d %H:%M%S",[time_obj])，将时间对象格式化为字符串。
- obj=time.strptime("2020-05-20","%Y-%m-%d")，将字符串解析为时间对象。
- time模块的三大对象：
- 格式化时间对象
- 转化为时间戳
- time.mktime()
- 格式化为时间字符串
- time.strftime(format)
- 转化为时间戳
- 时间字符串
- 解析为格式化时间对象
- time.strptime(str,format)
- 解析为格式化时间对象
- 时间戳：从时间元年开始的秒数
- 获取：
- time.time()
- 转化为格式化时间对象：
- time.gmtime()
- time.localtime()
- 获取：
- 格式化时间对象
- time.sleep(XXX)，暂停（睡眠）当前的进程XXX秒
-
datetime，日期时间模块
-
封装了一些和日期时间相关的类：
-
date类：
- 创建date类
d=datetime.date(2010,10,10)
- 获取date对象的各个属性
print(d.year)print(d.mouth)print(d.day)
- 创建date类
-
time
- 创建time类
t=datetime.time(10,48,59)
- 获取date对象的各个属性
print(t.hour)print(t.minute)print(t.second)
- 创建time类
-
datetime
- 创建datetime类
dt=datetime.datetime(2010,11,11,11,11,11)
- 获取datetime各个属性同上面两个类一样
- 创建datetime类
-
timedelta
- datetime中的类，主要用于科学计算（只能与date,datetime,timetelta进行运算）
- 创建datedelta对象
td=datetime.timedelta(days=1)
- 参与时间运算
d=datetime.date(2010,10,10)res=d+tdprint(res) # 2010-10-11
- 时间变化量的计算是否会产生进位（会）
t=datetime.datetime(2010,10,10,10,10,59)td=datetime.timedelta(seconds=3)res=t+tdprint(res) # 会产生进位
-
练习：计算某一年的二月份有多少天
-
普通算法：根据年份计算是否是闰年，是：29，否：28
-
用datetime模块
""" 首先创建出指定年份的3月1号，然后让他往前走一天 """ import datetime year=int(input("输入年份")) # 创建指定年份的date对象 d=datetime.date(year,3,1) # 创建一天 时间段 td=datetime.timedelta(days=1) res=d-td print(res.day)
-
-
和时间段进行运算的结果类型
- datetime.timedelta和什么类型进行运算，结果就是什么类型（结果数据类型和操作数类型保持一致）
-
-
-
-
os，sys
-
os：和操作系统相关的操作被封装在这个模块中
-
和文件操作相关的，重命名，删除：在程序中删除，不会放进回收站
import os os.remove(f'a.txt') # 删除 os.rename('a.xtx','b.txt') # 重命名 os.removedirs('aa') # 删除目录（仅限空目录） -
和路径相关的操作，被封装到另一个子模块中：os.path
- dirname(path)，返回path的父路径，不判断路径是否存在
- basename(path)，和dirname相反，取得路径的最后一层（文件名）
- split(path)，上面两个功能的结合，把路径中的路径名和文件名切分开，返回的结果是元组
- join(str1,str2,str3,filename)，拼接路径
- exists(path)，判断路径是是否存在 ，返回bool值
- isdir(s)，判断是否是个目录，真实去找，找到返回bool值，若不存在False
- isfile(s)，，判断是否是个文件，真实去找，找到返回bool值，若不存在False
- isabs(path)，判断是否为绝对路径
- abspath(path)，将括号中的路径转化为绝对路径
- 如果是/开头的路径，默认是在当前盘符下。
- 如果没有/那么是以当前文件所在位置路径进行拼接
- os.islink(path)，判断是否为快捷方式
-
-
shutil：可以删除带内容的目录(自动化运维必看)
shutil.retree('aa')
-
sys：和Python解释器相关的操作
-
获取命令行方式运行的脚本后面的参数（主要作用）
import sys print(sys.argv[0])# 脚本名 print(sys.argv[1])# 第一个参数 print(sys.argv[2])# 第二个参数 -
sys.path，解释器寻找模块的路径
-
sys.modules()，返回已经加载的模块
-
-
-
json，pickle
-
简介：JavaScript Object Notation ：Java脚本兑现标记语言。已经成为一种简单的数据交换格式。
-
python中set不能使用json表示出来
-
序列化（serialization）：结构化数据和线性数据之间的转换就叫序列化
- 将内存中的数据转换成字符串用以包存在文件或通过网络传输，称为序列化过程
- 从文件中，网络中获取的数据转换成内存中原来的数据类型格式，称为反序列化过程
-
json模块
-
将数据转换成字符串，是一种不完全的序列化格式，用于存储或网络传输，虽然不太彻底，但是简单易用易懂
-
json文件通常是一次性写，一次性读，使用另一种方式可以实现多次写，多次读
- dumps：序列化，把指定的对象转换成json格式的字符串，继续存储在内存中
- dump：序列化，把指定的对象转换成json格式的字符串，写入文件
- loads：反序列化，把
- load：反序列化
序列化
dumps
import json s=json.dumps([1,2,3]) print(type(s)) # str print(s) # '[1,2,3]' -------------------- # 元组序列化后，变成列表 s=json.dumps((1,2,3)) print(s) # '[1,2,3]' -------------------- res=json.dumps(10) print(res) # '10' -------------------- res=json.dumps({'name':'Andy','age':10}) print(res) # '{'name':'Andy','age':10}'dump
# 将json结果写到文件中 import json with open('a.txt',mode='w',encoding='utf-8') as f : json.dump([1,2,3],f)反序列化
loads
import json res=json.dumps([1,2,3]) lst=json.loads(res) # 反序列化 print(type(lst)) # list print(lst) # [1,2,3] ---------------------------- # 元组会变成列表 res=json.dumps((1,2,3)) lst=json.loads(res) # 反序列化 print(type(lst)) # list print(lst) # [1,2,3]load
import json with open('a.txt',encoding='utf-8') as f: res=json.load(f) print(type(res)) # list print(res) # [1,2,3]通过另一种方法实现多次写多次读
import json with open('json.txt',mode='at',encoding='utf-8') as f: f.write(json.dumps([1,2,3])+'\n') f.write(json.dumps([1,2,3])+'\n') ------------------------------------------------------- # 把分次序列化的json字符串，反序列化回来 with open('json.txt',mode='rt',encoding='utf-8') as f: res=json.loads(f.readline().strip()) print(res) res2=json.loads(f.readline().strip()) print(res2) ------------------- for x in f: print(json.loads(x.strip()))
-
-
pickle模块：
-
将Python所有的数据类型直接转换成字节串，序列化过程
-
将字节串转换成Python中的数据类型，反序列化过程
-
保存了原有的数据类型，所有的数据类型都可以进行序列化
序列化
import pickle bys=pickle.dumps([1,2,3]) print(type(bys)) # bytes print(bys) # b'\x80\x04\x95\x0b\x00\x00\x00\x00\x00\x00\x00]\x94(K\x01K\x02K\x03e.' ----------------------- bys=pickle.dumps((1,2,3)) print(bys) res=pickle.loads(bys) # <class 'tuple'> print(type(res)) ---------------------- bys=pickle.dumps(set('abc')) res=pickle.loads(bys) # <class 'tuple'> print(type(res))操作文件
import pickle with open('a.txt',mode='wb') as f: pickle.dump([1,2,3],f) pickle.dump([1,2,3],f) pickle.dump([1,2,3],f) ------------------------------- # 从文件中反序列化pickle数据 with open('c.txt',mode='rb') as f: ''' res=pickle.load(f) print(type(res)) # list print(res) # [1,2,3] ''' for x in range(3): res=pickle.load(f) print(res)json和pickle的比较
json：
- 不是所有的数据类型都可以序列化，结果是字符串
- 不能多次对同一个文件序列化
- json数据可以跨语言
pickle：
- 所有的python类型都能序列化，结果是字节串，
- 可以多次对同一个文件序列化
- 不能跨语言
-
-
-
hashlib，colletions
-
hashlib模块
封装一些用于加密的类
-
加密的目的：用于判断和验证，而非解密。
- 给一个数据加密
- 验证：用另一个数据加密的结果和第一次加密的结果对比
- 如果结果相同，说明原文相同，若果不同，说明原文不同
-
特点：
- 把一个大的数据切分成不同的小块，分别对不同的块进行加密，再汇总的结果，和直接对整体数据加密的结果是一致的。
- 单向加密，不可逆。
- 原始数据的一点小的变化，将导致结果非常大的差异。雪崩效应
-
使用方式
''' md5加密算法 给一个数据加密的三大步骤： 1.获取一个加密对象 2.使用加密对象的update，进行加密，update方法可以调用多次 3.通常通过hexdigest获取加密结果，或digest()方法 ''' import hashlib # 获取一个加密对象 m=hashlib.md5() # 使用加密对象的update，进行加密 m.update('abc'.encode('utf-8')) # 通过hexdigest获取加密的结果 res=m.hexdigest() print(res) # 900150983cd24fb0d6963f7d28e17f72不同加密算法：实际上就是加密结果的长度不同
''' hashlib.sha224 ''' import hashlib # 获取一个加密对象 m=hashlib.sha224() # 使用加密对象的update，进行加密 m.update('abc'.encode('utf-8')) # 通过hexdigest获取加密的结果 res=m.hexdigest() print(res) # 23097d223405d8228642a477bda255b32aadbce4bda0b3f7e36c9da7在创建对象时，可以指定参数，称为salt(加盐)
''' hashlib.sha224 ''' import hashlib # 获取一个加密对象 m=hashlib.md5('abc'.encode('utf-8')) m.update('efg'.encode('utf-8')) # 通过hexdigest获取加密的结果 res=m.hexdigest() print(res) # fbd7809b1f99a5b790068736a1c62cf0 ----------------------------------------------- m=hashlib.md5('abcefg'.encode('utf-8')) res=m.hexdigest() print(res) # fbd7809b1f99a5b790068736a1c62cf0注册，登录程序
import hashlib # 获取一个加密对象 def get_md5(username,passwd): m=hashlib.md5() m.update(username.encode('utf-8')) m.update(passwd.encode('utf-8')) return m.hexdigest() def register(username,passwd): # 加密 res=get_md5(username,passwd) # 写入文件 with open('login',mode='at',encoding='utf-8') as f: f.write(res+'\n') def login(username,passwd): # 获取当前登录信息的加密结果 res=get_md5(username,passwd) # 读文件，和其中的数据进行对比 with open('login',mode='rt',encoding='utf-8') as f: for line in f: if res==line.strip(): return True else: return False while True: op = int(input('1.注册 2.登录 3.退出\n')) if op==3: break elif op==1: username=input("请输入用户名：") passwd=input('输入密码：') register(username,passwd) elif op==2: username=input("请输入用户名：") passwd=input('输入密码：') res=login(username,passwd) if res: print('登陆成功') else: print("登陆失败")
-
-
-
collections模块
-
namedtuple()：命名元组
from collections import namedtuple Rectangle=namedtuple('Rectangleclass',['lenght','width']) r=Rectangle(10,5) # 公国属性访问元组的元素 print(r.lenght) # 10 # 通过索引的方式访问元素 print(r[0]) -
defaultdict()：默认值字典
from collections import namedtuple from collections import defaultdict # 创建一个字典的方式 # d={'name':'Andy','age':10} # d=dict([('name','Andy'),('age',10),]) # d={k:v for k in [(1,2),(3,4)]] } # 可以自定义函数充当地一个参数 # 要求，不能有参数 def f(): return 'hello' d=defaultdict(f,name="Andy",age=10) print(d['name']) # Andy print(d['age']) # 10 print(d['addr']) # 0 {'addr':0} 也会被添加 print(d) -
Counter()：计数器,统计可迭代对象中元素出现的次数
from collections import Counter c=Counter('assadfasdfasdgfdfgsadf') print(c) # Counter({'a': 5, 's': 5, 'd': 5, 'f': 5, 'g': 2}) print(c.most_common(3)) # [('a', 5), ('s', 5), ('d', 5)]
-
-
-
总结
- 自定义模块
- random
- time
- datetime
- os
- sys
- json，pickle
- hashlib
- collections
浙公网安备 33010602011771号