python中常用的模块
一、time
时间模块
封装了获取时间戳和字符串形式的时间的一些方法。
获取时间戳:
import time
# 时间戳:从时间元年(1970-1-1 00:00:00)到现在经过的秒数
print(time.time())
# 输出
1618916107.9363585
获取格式化时间对象:就是九个字段组成的。年、月、日、时、分、秒、夏令时
默认参数是当前系统的时间戳:
import time
print(time.gmtime(1)) # 时间元年过一秒后对应的时间对象
print(time.gmtime()) # GMT:格林尼治天文台时间,在欧洲,符合欧洲的时间。
print(time.localtime()) # 当地时间,也就是我现在的时间
# 输出
time.struct_time(tm_year=1970, tm_mon=1, tm_mday=1, tm_hour=0, tm_min=0, tm_sec=1, tm_wday=3, tm_yday=1, tm_isdst=0)
time.struct_time(tm_year=2021, tm_mon=4, tm_mday=20, tm_hour=11, tm_min=12, tm_sec=24, tm_wday=1, tm_yday=110, tm_isdst=0)
time.struct_time(tm_year=2021, tm_mon=4, tm_mday=20, tm_hour=19, tm_min=12, tm_sec=24, tm_wday=1, tm_yday=110, tm_isdst=0)
时间对象------>时间戳
time_obj = time.localtime() # 时间对象
# 把时间对象time_obj转换成时间戳
time_stamp = time.mktime(time_obj)
print(time_stamp)
# 输出
1618991181.0
格式化时间对象------>可读的时间字符串
import time
print(time.strftime('%Y %m %d %H:%M:%S')) # 年月日 时分秒
# 输出
2021 04 20 19:18:11
把时间字符串------>时间对象
import time
print(time.strptime('2021 4 20 19 25 2', '%Y %m %d %H %M %S'))
# 输出
time.struct_time(tm_year=2021, tm_mon=4, tm_mday=20, tm_hour=19, tm_min=25, tm_sec=2, tm_wday=1, tm_yday=110, tm_isdst=-1)
暂停当前程序,睡眠xxx秒
import time
time.sleep(2)
二、datetime
日期时间模块
封装了一些和日期,时间相关的类。
datetime
主要是用于数学计算的
data:类
包含年、月、日
import datetime
d = datetime.date(2020, 5, 12)
# 获取date对象的各个属性
print(d.year)
print(d.month)
print(d.day)
time:类
包含时、分、秒
import datetime
t = datetime.time(10, 20, 55)
print(t)
# 获取time对象的各个属性
print(t.hour)
print(t.minute)
print(t.second)
timedelta:类---主要是用于数学计算的
时间的变化量
只能和date、datetime进行运算
import datetime
td = datetime.timedelta(days=1)
d = datetime.date(2020, 11, 11)
res = d - td # 把2020-11-11给减去一天
print(res)
# 输出
2020-11-10
时间变化量的计算是否会产生进位?
time类不可以和timedelta进行运算
import datetime
td = datetime.datetime(2020, 11, 11, 11, 11, 59)
t = datetime.timedelta(seconds=3)
res = t + td # 给2020-11-11 11:11:59 加 3 秒
print(res)
# 输出
2020-11-11 11:12:02 # 时间变化量的计算是会产生进位的
练习:计算某一年的二月份有多少天。
普通算法:根据年份计算是否是闰年。是: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)
和时间段进行运算的结果类型是和前一个操作数相关:
import datetime
td = datetime.timedelta(days=1)
d1 = datetime.date(2020, 11, 11) # 和 date 一致
d2 = datetime.datetime(2020, 11, 11, 11, 11, 11)# 和datetime一致
res1 = d1 - td
res2 = d2 - td
print(type(res1), res1)
print(type(res2), res2)
# 输出
<class 'datetime.date'> 2020-11-10
<class 'datetime.datetime'> 2020-11-10 11:11:11
三、os
和操作系统相关的操作被封装到这个模块中。
和文件操作相关,
删除文件: os.remove ( )
import os
os.remove(r'目录\文件')
删除目录:os.removedirs ( ) 必须是空目录
import os
os.removedirs(r'目录') # 目录下不能有文件
使用 shutil 模块可以删除带内容的目录
shutil.rmtree ( )
import shutil
shutil.rmtree(r'目录或目录路径')
重命名: os.renames(a, b ) 把 a文件名 改成 b文件名目录名也可以修改
import os
os.renames('a.txt', 'b.txt')
和路径相关的操作,被封装到另一个子模块中:os.path
os.path.dirname():不判断路径是否存在,只拿走路径
import os
path = os.path.dirname(r'd:\aaa\bbb\ccc\a.txt')
print(path)
# 输出
d:\aaa\bbb\ccc
os.path.basename():不判断路径是否存在,只拿走文件名
import os
path = os.path.basename(r'd:\aaa\bbb\ccc\a.txt')
print(path)
# 输出
a.txt
os.path.split():不判断路径是否存在,把路径中的路径名和文件名切分开返回两个元素的元组
import os
path = os.path.split(r'd:\aaa\bbb\ccc\a.txt')
print(path)
# 输出
('d:\\aaa\\bbb\\ccc', 'a.txt')
os.path.join( 'd:/', 'aa', 'bb', 'cc.txt' ):拼接路径
import os
path = os.path.join('aaa', 'bbb', 'ccc', 'a.txt')
print(path)
# 输出
aaa\bbb\ccc\a.txt
os.path.abspath():返回绝对路径
import os
path = os.path.abspath(r'a.txt')
print(path)
# 输出
C:\Users\Administrator\Desktop\python\练习\a.txt
os.path.isabs():判断是否绝对路径,以盘符做为开头是绝对路径,
import os
path1 = os.path.isabs(r'a.txt')
path2 = os.path.isabs(r'D:\a.txt')
print(path1)
print(path2)
# 输出
False
True
os.path.isdir():判断是否是目录,目录或文件不存在是 False
import os
path1 = os.path.isdir(r'bb') #目录不存在也为False
path2 = os.path.isdir(r'a.txt')#文件不存在或不是目录都为False
print(path1)
print(path2)
# 输出
True
False
os.path.exists():判断文件或目录是否存在,不存在是 False
import os
path1 = os.path.exists(r'bb')
path2 = os.path.exists(r'a.txt')
print(path1)
print(path2)
# 输出
True
True
os.path.isfile():只能判断文件是否存在,不存在False,
import os
path1 = os.path.isfile(r'bb') # 目录返回False
path2 = os.path.isfile(r'a.txt')
print(path1)
print(path2)
# 输出
False
True
os.path.islink():判断是否是链接
四、sys
和python解释器相关的操作
sys.argv[ ] 获取命令行方式运行的脚步后面的参数
就是为了让程序以脚步方式运行时在cmd命令行传入的参数
import sys
print('脚本名:', sys.argv[0]) # 脚本名
a = sys.argv[1] # 第一个参数
b = sys.argv[2] # 第二个参数
c = int(a) + int(b)
print(f'{a}+{b}=', c)
# 在终端运行脚步时:传入参数 5 和 3
C:\Users\YS\Desktop\Python全栈\day16>python 练习.py 5 3
脚本名: 练习.py
5+3= 8
sys.path:解释器寻找模块的路径,可以增加路径让解释器去寻找我们指定路径下的模块
import sys
path = sys.path
print(path)
# 输出
['C:\\Users\\Administrator\\Desktop\\python\\练习', 'C:\\Users\\Administrator\\Desktop\\python',........]
sys.modules:返回系统已经加载的模块,以字典形式返回。
import sys
path = sys.modules
print(path)
# 输出
{'sys': <module 'sys' (built-in)>, 'builtins': <module 'builtins' (built-in)>, .......}
五、json
JavaScript object Notation:java脚本兑现标记语言。
是一种简单的数据交换格式。不完全的序列化
序列化:将内存中的数据,转换成字节用以保存在文件或通过网络传输,称为序列化过程。
json:将数据转换成字符串(不能转换set数据类型),用于存储或网络传输。(不太彻底转换到字节串的前一步字符串)
反序列化:从文件中,网络中获取的数据,转换成内存中原来的的数据类型,称为反序列化过程
json模块使用:
json.dumps:序列化,从内存----->内存
import json
obj = json.dumps([1, 2, 3, 4])
print(type(obj), obj)
# 输出
<class 'str'> [1, 2, 3, 4]
json.domp:序列化,将json结果写入文件中,内存------->文件
json.dump([1,2,3],文件句柄)
import json
with open('obj.txt', encoding='utf-8', mode='wt') as f:
json.dump([1, 2, 3, 4], f)
json.loads:反序列化,从内存------->内存,元组会变成列表。
import json
# 先序列化列表 [1, 2, 3, 4]为字符串
obj1 = json.dumps([1, 2, 3, 4])
print(type(obj1), obj1) # <class 'str'> [1, 2, 3, 4]
obj2 = json.loads(obj1) # 在反序列化为列表
print(type(obj2), obj2) # <class 'list'> [1, 2, 3, 4]
json.load:反序列化,从文件----->内存反序列化
json.load(文件句柄)
import json
with open('obj.txt', encoding='utf-8', mode='rt') as f:
# 将文件中的被序列化后的字符串反序列化回原来的字典类型
obj = json.load(f)
print(type(obj),obj)
# 输出
<class 'list'> [1, 2, 3, 4]
json文件通常是一次性写,一次性读,
使用另一种方式可以实现多次写,多次读。
把需要序列化的对象,通过多次序列化的方式,用文件的write方法,把多次序列化后的json字符串写到文件中
import json
with open('obj.txt', encoding='utf-8', mode='w') as f:
f.write(json.dumps([1, 2, 3, 4]) + '\n')
f.write(json.dumps([5, 6, 7, 8]) + '\n')
把分次序列化的json字符串反序列化回来
import json
with open('obj.txt', encoding='utf-8', mode='rt') as f1:
obj1 = json.loads(f1.readline().strip())
obj2 = json.loads(f1.readline().strip())
print(type(obj1), obj1)
print(type(obj2), obj2)
# 输出
<class 'list'> [1, 2, 3, 4]
<class 'list'> [5, 6, 7, 8]
六、pickle:
将python中所有的数据类型,直接转换成字节,这叫序列化过程,最彻底的序列化方式
将字节转换成python中数据类型,反序列化过程。
pickle:的用法
pickle.dumps:从内存-------> 内存的序列化
import pickle
obj = pickle.dumps([1, 2, 3, 4])
print(obj)
# 输出的是字节,bytes数据类型
b'\x80\x04\x95\r\x00\x00\x00\x00\x00\x00\x00]\x94(K\x01K\x02K\x03K\x04e.'
pickle.dump:从内存-------->文件的序列化
用 w 操作方式模式打开文件,用 b 为操作单位。
import pickle
# 二进制模式(b)不能使用编码参数 encoding
with open('obj.txt', mode='wb') as f:
pickle.dump([1, 2, 3, 4], f)
pickle.loabs:从内存------>内存的反序列化
import pickle
obj1 = pickle.dumps([1, 2, 3, 4]) # 先序列化成字节
print(type(obj1))
print(obj1)
obj2 = pickle.loads(obj1) # 在反序列化回我原有的数据类型
print(type(obj2))
print(obj2)
# 输出
<class 'bytes'>
b'\x80\x04\x95\r\x00\x00\x00\x00\x00\x00\x00]\x94(K\x01K\x02K\x03K\x04e.'
<class 'list'>
[1, 2, 3, 4]
pickle.load:从文件------>内存中反序列化
with open('obj.txt', mode='rb') as f:
obj = pickle.load(f)
print(type(obj), obj)
# 输出
<class 'list'> [1, 2, 3, 4]
pickle可以无限次数的操作同一个文件
import pickle
with open('obj.txt', mode='wb') as f1:
pickle.dump([1, 2, 3, 4], f1)
pickle.dump([5, 6, 7, 8], f1)
pickle.dump([9, 10, 11, 12], f1)
pickle.dump([13, 14, 15, 16], f1)
with open('obj.txt', mode='rb') as f2:
for i in range(4):
obj = pickle.load(f2)
print(type(obj), obj)
# 输出
<class 'list'> [1, 2, 3, 4]
<class 'list'> [5, 6, 7, 8]
<class 'list'> [9, 10, 11, 12]
<class 'list'> [13, 14, 15, 16]
pickle常用的场景,一次读入,一次写入
七、json,pickle的比较
json:
1、不是所有的数据类型都可以序列化,结果是字符串。
2、不能多次对同一个文件序列化。
3、json数据可以跨语言
pickle:
1、所有的python类型都能序列化,结果是字节。
2、可以多次对同一个文件序列化
3、不能跨语言。
八、hashlib
封装一些用于加密的类
md5()
sha系列:随之sha系列数字越高,加密越复杂,越不容易被破解,但是耗时越长
加密的目的:用于判断和验证,而并非解密。
给一个数据加密,
验证:用另一个数据加密的结果和第一次加密的结果对比。
如果结果相同,说明原文相同,如果不相同,说明原文不同
不同加密算法:实际上就是加密结果长度不同;
s = hashlib.sha224()
s.update('1中国'.encode('utf-8'))
ss = s.hexdigest()
print(ss)
# 输出
3e2005cdfbc101b06367b0a1d3c2a9d25fcbf391a0f67a4d0cc0dfe0
特点:
把一个大的数据,切分成不同的小块,分别对不同的块进行加密,在汇总的结果,和直接对数据加密的结果是一致的。
import hashlib
hash_obj1 = hashlib.md5()
hash_obj1.update('123abc小杨'.encode('utf-8'))
hash_obj1.update('opqlst'.encode('utf-8'))
obj1 = hash_obj1.hexdigest()
print(obj1)
hash_obj2 = hashlib.md5()
hash_obj2.update('123abc小杨opqlst'.encode('utf-8'))
obj2 = hash_obj2.hexdigest()
print(obj2)
# 输出
f6de00d04ded3774ae46e2fff7bbbd46
f6de00d04ded3774ae46e2fff7bbbd46
单向加密,不可逆。(山东大学,王教授,研究出了md5的破解,就是撞库)
原始数据的一点小的变化,将导致结果的非常大的差异(雪崩效应)
使用方式:
1、获取一个加密对象
2、使用加密对象的update,进行加密,可以调用多次进行累计加密
3、通过hexdiges获取加密结果
import hashlib
# 1、获取一个加密对象
hash_obj = hashlib.md5()
# 2、使用加密对象的update,进行加密,可以调用多次进行累计加密
hash_obj.update('123abc小杨'.encode('utf-8'))
# 第二次累积加密相当于对>>‘123abc小杨opqlst’进行加密
hash_obj.update('opqlst'.encode('utf-8'))
# 3、通过hexdiges获取加密结果
obj = hash_obj.hexdigest()
print(obj)
# 输出
f6de00d04ded3774ae46e2fff7bbbd46
在创建加密对象时,可以指定参数,称为加盐:
import hashlib
hash_obj = hashlib.md5('加的盐'.encode('utf-8'))
hash_obj.update('123abc小杨opqlst'.encode('utf-8'))
obj = hash_obj.hexdigest()
print(obj)
# 输出
5d81bdb5422fc66644f321ed6d254521
动态的盐
import hashlib
username = 'xiaoyang'
password = 'abcd123'
hash_obj = hashlib.md5(username[::2].encode('utf-8')) # 每个用户不一样动态的加盐
hash_obj.update(password.encode('utf-8'))
obj = hash_obj.hexdigest()
print(obj) # 7adce56715fda64e0e0c425d9b6dc0c7
md5文件的校验
linux中一切皆文件: 文本文件,非文本文件,音频,视频,图片....
无论你下载的视频,还是软件(国外的软件),往往都会有一个md5值
def file_md5(path):
ret = hashlib.sha256()
with open(path,mode='rb') as f1:
b1 = f1.read()
ret.update(b1)
return ret.hexdigest()
result = file_md5('校验的文件名')
print(result)
九、collections
namedtuple():命名元组
from collections import namedtuple
rectangle = namedtuple('字符串用于描述rectangle类的类名', ['length', 'width'])
r = rectangle(10, 5)
# 通过属性访问元组的元素
print(r.length)
print(r.width)
# 输出
10
5
defaultdict():默认值字典,在取到没有的键时,会返回你定义的函数值,并添加进去
defaultdict 是内置的 dict 的子类
和 dict 的构造函数相比,只是在前面添加了一个参数: default_factory ,其余的参数和 dict 一样.
第一个参数指定的是一个函数名,用来表示当字典对象中出现了不存在的键时,对应的值初始值是如何计算.
正因为这个函数是获取值的,所以,对这个函数规定:不能有参数.默认情况下,第一个参数是None,意味着不存在的键对应的值为None.
注意:一旦使用 defaultdict 时,指定了不存在的键,则会引发两件事情:
1、调用第一个参数指定的函数得到默认值.
2、把返回值赋值给这个新键.
from collections import defaultdict
def func():
return 'hello world'
d = defaultdict(func,name='Andy',age=10)
print(d['name']) # Andy
print(d['haha']) # hello world
print(d)
# defaultdict(<function func at 0x000002C9A0D71E18>, {'name': 'Andy', 'age': 10,'haha': 'hello world'})
counter():计数器
用于统计可哈希对象的数量.
是dict的子类.一种特殊的字典.
它的键是可哈希对象,值是这个对象的个数统计信息.个数可以是手动指定的,也可以是自动计算出来的,并且可以是负数和0.
创建Counter对象.
c = Counter() # 创建空的计数器
c = Counter('abcdefabc') # 使用可迭代对象创建计数器
c = Counter({'A':1,'B':3}) # 使用字典创建计数器
c = Counter(A=1,B=3,C=0) # 手动初始化计数器
查看计数器的统计结果,和使用字典的方式相同:
from collections import Counter
c = Counter('abcab')
print(c) # Counter({'a': 2, 'b': 2, 'c': 1})
print(c['a']) # 2
print(c['b']) # 2
print(c['name']) # 0
Counter常用方法:
most_common[n]:显示数量最多的前几名。
from collections import Counter
c = Counter('abcab')
print(c.most_common(2)) # [('a', 2), ('b', 2)]
十、random
此模块提供了随机数获取方法
random.random( ):获取 [ 0.0, 1.0) 范围内的浮点数(伪随机数,有规律的)
import random
print(random.random()) # 0.6291924643028873
random.randint(a, b):获取 [a, b] 范围内的一个整数
import random
print(random.randint(3, 10)) # 5
random.uniform(a,b):获取 [a, b ) 范围内的浮点数
import random
print(random.uniform(3, 10)) # 6.327077680813884
random.shuffle( x ):把参数指定的数据中的元素打乱洗。参数必须是可变的数据类型
import random
ll = list(range(10))
random.shuffle(ll)
print(ll) # [4, 8, 1, 6, 7, 9, 0, 3, 2, 5]
random.sample( x , k ):从 x 中随机抽取 k 个数据,组成一个列表返回
import random
t = (1, 2, 3, 4, 5, 6, 7, 8, 9)
ls = random.sample(t, len(t)) # 因为元组不可修改
print(ls) # [6, 4, 8, 1, 2, 7, 3, 9, 5]
本文来自博客园,作者:Mr-Yang`,转载请注明原文链接:https://www.cnblogs.com/XiaoYang-sir/p/14688382.html