dumps 把任意对象序列化成一个bytes
loads 把任意bytes反序列化成原来数据
>>> import pickle >>> listvar = [1,2,3] >>> res = pickle.dumps(listvar) >>> res b'x80x03]qx00(Kx01Kx02Kx03e.' >>> >>> res = pickle.loads(res) >>> print(res,type(res)) [1, 2, 3] <class 'list'> >>>
序列化函数
>>> import pickle
>>> def func():
... print('func')
...
>>> res = pickle.dumps(func)
>>> print(res)
b'x80x03c__main__
func
qx00.'
>>>
>>> func = pickle.loads(res)
>>> func()
func
>>>
序列化迭代器
>>> import pickle >>> from collections import Iterator,Iterable >>> it = iter(range(5)) >>> print(isinstance(it,Iterator)) True >>> res = pickle.dumps(it) >>> print(res) b'x80x03cbuiltins iter qx00cbuiltins range qx01Kx00Kx05Kx01x87qx02Rqx03x85qx04Rqx05Kx00b.' >>> res = pickle.loads(res) >>> print(res) <range_iterator object at 0x0000023C8BE57F90> >>> for i in res: ... print(i) ... 0 1 2 3 4 >>>
dump 把对象序列化后写入到file-like Object(即文件对象)
def func2():
print("我是func2")
with open("test.txt",mode="wb") as fp:
# 参数1:要序列化的数据 参数2:对应的文件对象
pickle.dump(func2,fp)
load 把file-like Object(即文件对象)中的内容拿出来,反序列化成原来数据
with open("test.txt",mode="rb") as fp:
func = pickle.load(fp)
# 调用函数
func()
数学模块-math
使用方法：模块.方法()
ceil() 向上取整操作 (对比内置round)
>>> import math >>> print(math.ceil(3.01)) 4 >>> print(math.ceil(3.9)) 4 >>> print(math.ceil(3.000000000000000000000001)) 3 >>>
floor() 向下取整操作 (对比内置round)
>>> import math >>> print(math.floor(3.99)) 3 >>> print(math.floor(3.001)) 3 >>>
pow() 计算一个数值的N次方(结果为浮点数) (对比内置pow)
>>> print(math.pow(2,3)) # 对比内置pow，没有第三个参数 8.0 >>>
sqrt() 开平方运算(结果浮点数)
>>> import math >>> print(math.sqrt(9)) 3.0 >>>
fabs() 计算一个数值的绝对值 (结果浮点数) (对比内置abs)
>>> import math >>> print(math.fabs(-8)) 8.0 >>>
modf() 将一个数值拆分为整数和小数两部分组成元组
>>> import math >>> print(math.modf(5.12)) (0.1200000000000001, 5.0) >>>
copysign() 将参数第二个数值的正负号拷贝给第一个
>>> import math >>> print(math.copysign(5,-9)) -5.0 >>> print(math.copysign(-5,-9)) -5.0 >>>
fsum() 将一个容器数据中的数据进行求和运算 (结果浮点数)(对比内置sum)
>>> import math >>> listvar = [1,2,3,4,5] >>> print(math.fsum(listvar)) 15.0 >>>
圆周率常数 pi
>>> import math >>> print(math.pi) 3.141592653589793 >>>
random() 获取随机0-1之间的小数(左闭右开)
>>> import random >>> res = random.random() >>> res 0.47163878946605897 >>>
randrange() 随机获取指定范围内的整数(包含开始值,不包含结束值,间隔值)
>>> import random >>> print(random.randrange(3)) 2 >>>
randint() 随机产生指定范围内的随机整数 必须两个参数
>>> import random >>> print(random.randint(1,4)) 1 >>>
uniform() 获取指定范围内的随机小数(左闭右开)
>>> import random >>> print(random.uniform(1,3)) 1.9395628932781275 >>>
choice() 随机获取序列中的值(多选一)
>>> import random >>> listvar = [1,2,3,4,5] >>> print(random.choice(listvar)) 3 >>> # 自定义choice ... >>> def mychoice(): ... length = len(listvar) ... res = random.randrange(0,length) ... return listvar[res] ... >>> mychoice() 2 >>>
sample() 随机获取序列中的值(多选多) [返回列表]
>>> import random >>> listvar = [1,2,3,4,5] >>> listvar = random.sample(listvar,3) >>> print(listvar) [3, 2, 5] >>>
shuffle() 随机打乱序列中的值(直接打乱原序列)
>>> import random >>> listvar = [1,2,3,4,5] >>> random.shuffle(listvar) >>> print(listvar) [3, 1, 4, 2, 5] >>>
应用：随机验证码
# 随机验证码 def yanzhengma(): strvar = "" for i in range(4): # a~z 97 ~ 122 获取小写字母 res1 = chr(random.randrange(97,123)) # A~Z 65 ~ 90 获取大写字母 res2 = chr(random.randrange(65,91)) # 0~9 获取0~9 十个数字 res3 = random.randrange(0,10) # 把可能的字符放到列表当中 lst = [res1,res2,res3] # 拼接字符串 strvar += str(random.choice(lst)) # 返回字符串 return strvar res= yanzhengma() print(res)
时间模块-time
time() 获取本地时间戳
>>> import time >>> print(time.time()) 1564221298.0812767 >>>
mktime() 通过[时间元组]获取[时间戳] (参数是时间元组)
>>> import time >>> timevar = (2019,7,27,17,55,0,0,0,0) >>> print(time.mktime(timevar)) 1564221300.0 >>>
localtime() 通过[时间戳]获取[时间元组] (默认当前时间)
>>> import time >>> print(time.localtime()) time.struct_time(tm_year=2019, tm_mon=7, tm_mday=27, tm_hour=17, tm_min=56, tm_sec=58, tm_wday=5, tm_yday=208, tm_isdst=0) >>> print(time.localtime(1564221300.0)) time.struct_time(tm_year=2019, tm_mon=7, tm_mday=27, tm_hour=17, tm_min=55, tm_sec=0, tm_wday=5, tm_yday=208, tm_isdst=0) >>>
ctime() 通过[时间戳]获取[时间字符串] (默认当前时间)
>>> import time >>> print(time.ctime()) Sat Jul 27 17:58:08 2019 >>> print(time.ctime(1564221300.0)) Sat Jul 27 17:55:00 2019 >>>
asctime() 通过[时间元组]获取[时间字符串](参数是时间元组)
>>> timevar = (2019,7,27,17,55,0,0,0,0) >>> print(time.asctime(timevar)) Mon Jul 27 17:55:00 2019 >>> >>> timevar = (2019,7,27,17,55,0,0,0,0) >>> res = time.mktime(timevar) >>> starttime = time.ctime(res) >>> print(starttime) Sat Jul 27 17:55:00 2019 >>>
strftime() 通过[时间元组]格式化[时间字符串] (格式化字符串,[可选时间元组参数])
>>> import time
>>> res = time.strftime("%Y-%m-%d %H:%M:%S")
>>> print(res)
2019-07-27 18:02:34
>>> timevar =(2019,7,27,17,55,0,0,0,0)
>>> res = time.strftime("%Y-%m-%d %H:%M:%S",timevar)
>>> print(res)
2019-07-27 17:55:00
>>>
strptime() 通过[时间字符串]提取出[时间元组] (时间字符串,格式化字符串)
两个字符串之间除了格式化标签外，其它必须一模一样
>>> import time >>> strvara = "2019年7月27日18点55分30秒" >>> strvarb = "%Y年%m月%d日%H点%M分%S秒" >>> res = time.strptime(strvara,strvarb) >>> print(res) time.struct_time(tm_year=2019, tm_mon=7, tm_mday=27, tm_hour=18, tm_min=55, tm_sec=30, tm_wday=5, tm_yday=208, tm_isdst=-1) >>>
sleep() 程序睡眠等待
>>> def func(): ... starttime = time.time() ... time.sleep(3) ... endtime = time.time() ... print(endtime - starttime) ... >>> func() 3.0033180713653564 >>>
perf_counter() 用于计算程序运行的时间
>>> import time >>> starttime = time.perf_counter() >>> for i in range(1000000): ... pass ... >>> endtime = time.perf_counter() >>> res = endtime - starttime >>> print(res) 29.673176886111193 >>>
时间模块相关知识
时间戳指从1970年1月1日0时0分0秒到指定时间之间的秒数,时间戳是秒,可以使用到2038年的某一天
UTC时间: 世界约定的时间表示方式，世界统一时间格式，世界协调时间！
夏令时: 在夏令时时间状态下，时间会调块1个小时
时间元组是使用元祖格式表示时间的一种方式
格式1(自定义):
(年，月，日，时，分,秒，周几，一年中的第几天，是否是夏令时时间)
格式2(系统提供):
(tm_year = 年，tm_month = 月，tm_day = 日，tm _hour = 时， tm_min = 分, tm _sec = 秒， tm _wday = 周几， tm _yday = 一年中的第几天，tm_isdst = 是否是夏令时时间)
0 年 4位数完整年份 四位数1997
1 月 1-12月 1 - 12
2 日 1-31天 1 - 31
3 时 0-23时 0 - 23
4 分 0-59分 0 - 59
5 秒 0-61秒 0 - 61
6 周几 周一-周天 0 - 6
7 年中第几天 共366天 1 - 366
8 夏令时 两种 0,1 0是 其他都不是
格式化时间字符串:
格式 含义
%a 本地（locale）简化星期名称
%A 本地完整星期名称
%b 本地简化月份名称
%B 本地完整月份名称
%c 本地相应的日期和时间表示
%d 一个月中的第几天（01 - 31）
%H 一天中的第几个小时（24 小时制，00 - 23）
%I 一天中的第几个小时（12 小时制，01 - 12）
%j 一年中的第几天（001 - 366）
%m 月份（01 - 12）
%M 分钟数（00 - 59）
%p 本地 am 或者 pm 的相应符
%S 秒（01 - 61）
%U 一年中的星期数（00 - 53 星期天是一个星期的开始）第一个星期天之前的所有天数都放在第 0 周
%w 一个星期中的第几天（0 - 6，0 是星期天）
%W 和 %U 基本相同，不同的是 %W 以星期一为一个星期的开始
%X 本地相应时间
%y 去掉世纪的年份(00 - 99)
%Y 完整的年份
%z 用 +HHMM 或 -HHMM 表示距离格林威治的时区偏移（H 代表十进制的小时数，M 代表十进制的分钟数）
%% %号本身
--不常用的属性函数(了解)
*gmtime() 获取UTC时间元祖(世界标准时间)
*time.timezone 获取当前时区(时区的时间差)
*time.altzone 获取当前时区(夏令时)
*time.daylight 获取夏令时状态
日历模块-calendar(了解内容)
--calendar 日历模块 import calendar
calendar() 获取指定年份的日历字符串 (年份,w日期间的宽度,l日期间的高度,c月份间的间距,m一行显示几个月)
calendar.calendar(2018,w=2,l=2,c=20,m=1)
month() 获取指定年月的日历字符串 (年份,月份,w日期之间的宽度,l日期之间的高度)
calendar.month(2018,9,w = 2,l = 2)
monthcalendar() 获取指定年月的信息列表 (年份,月份) 0从周一开始排
calendar.monthcalendar(2018,9)
isleap() 检测是否是润年(能被4整除不能被100整除或能被400整除)
calendar.isleap(2004)
leapdays() 指定从某年到某年范围内的润年个数
calendar.leapdays(1970,2038)
monthrange() 获取某年某月的信息 周一是0
calendar.monthrange(2018,8)
weekday() 指定某年某月某日是星期几
calendar.weekday(2018,8,18)
timegm() 将时间元组转化为时间戳
ttp = (2018,10,1,13,23,34,0,0,0)
calendar.timegm(ttp)
system() 在python中执行系统命令
>>> import os
>>> print(os.system("ipconfig"))
popen() 执行系统命令返回对象,通过read方法读出字符串
>>> import os
>>> obj = os.popen("ipconfig")
>>> obj
<os._wrap_close object at 0x0000023C8DD2F940>
>>> print(obj.read())
listdir() 获取指定文件夹中所有内容的名称列表
>>> import os
>>> res = os.listdir(".")
>>> print(res)
getcwd() 获取当前文件所在的默认路径
>>> import os >>> res = os.getcwd() >>> print(res)
mkdir 创建目录
os.mkdir('test')
rmdir 删除目录
os.rmdir('test')
rename 目录重命名
os.rename('testa','testb')
copy 复制文件权限和内容
chdir() 修改当前文件工作的默认路径
environ 获取或修改环境变量
--os 模块属性
name 获取系统标识 linux,mac ->posix windows -> nt
sep 获取路径分割符号 linux,mac -> / window->
linesep 获取系统的换行符号 linux,mac ->
window->
或
>>> print(os.name) nt >>> print(os.sep) >>> print(repr(os.linesep)) ' ' >>>
os路径模块 -os.path
abspath() 将相对路径转化为绝对路径
>>> print(os.path.abspath("."))
C:Userslenovo
>>>
basename() 返回文件名部分
>>> pathvar = r"c:userlenovo est.txt" >>> print(os.path.basename(pathvar)) test.txt >>>
dirname() 返回路径部分
>>> pathvar = r"c:userlenovo est.txt" >>> print(os.path.dirname(pathvar)) c:userlenovo >>>
split() 将路径拆分成单独的文件部分和路径部分 组合成一个元组
>>> pathvar = r"c:userlenovo est.txt"
>>> print(os.path.split(pathvar))
('c:\user\lenovo', 'test.txt')
>>>
join() 将多个路径和文件组成新的路径 可以自动通过不同的系统加不同的斜杠 linux / windows
>>> patha = "lesson" >>> pathb = "filename.py" >>> print(os.path.join(patha,pathb)) lessonfilename.py >>>
splitext() 将路径分割为后缀和其他部分
>>> pathvar = r"c:userlenovo est.txt"
>>> print(os.path.splitext(pathvar))
('c:\user\lenovo\test', '.txt')
>>>
getsize() 获取文件的大小
>>> pathvar = r"E:python-lessonpythonL0065.os.path.py" >>> print(os.path.getsize(pathvar)) 2962 >>>
isdir() 检测路径是否是一个文件夹
>>> pathvar = r"E:python-lessonpythonL006" >>> print(os.path.isdir(pathvar)) True >>>
isfile() 检测路径是否是一个文件
>>> pathvar = r"E:python-lessonpythonL0065.os.path.py" >>> print(os.path.isfile(pathvar)) True >>>
islink() 检测路径是否是一个链接
getctime() [windows]文件的创建时间,[linux]权限的改动时间(返回时间戳)
getmtime() 获取文件最后一次修改时间(返回时间戳)
getatime() 获取文件最后一次访问时间(返回时间戳)
>>> pathvar = r"E:python-lessonpythonL0065.os.path.py" >>> print(os.path.getctime(pathvar)) 1564310636.182642 >>> import time >>> stime = time.ctime(os.path.getctime(pathvar)) >>> stime 'Sun Jul 28 18:43:56 2019' >>> print(time.ctime(os.path.getmtime(pathvar))) Sun Jul 28 12:18:28 2019 >>> print(time.ctime(os.path.getatime(pathvar))) Tue Aug 6 21:17:26 2019 >>>
exists() 检测指定的路径是否存在
isabs() 检测一个路径是否是绝对路径
>>> pathvar = r"E:python-lessonpythonL0065.os.path.py" >>> print(os.path.exists(pathvar)) True >>> print(os.path.isabs(pathvar)) True >>>
os 与 shutil 模块 都具备对文件的操作
-- os模块具有 新建/删除/
os.mknod 创建文件
os.remove 删除文件
os.mkdir 创建目录(文件夹)
os.rmdir 删除目录(文件夹)
os.rename 对文件,目录重命名
os.makedirs 递归创建文件夹
os.removedirs 递归删除文件夹（空文件夹）
shutil模块
-- shutil模块 复制/移动/
copyfileobj(fsrc, fdst[, length=16*1024]) 复制文件 (length的单位是字符(表达一次读多少字符))
copyfile(src,dst) #单纯的仅复制文件内容 , 底层调用了 copyfileobj
copymode(src,dst) #单纯的仅复制文件权限 , 不包括内容 (虚拟机共享目录都是默认777)
copystat(src,dst) #复制所有状态信息,包括权限，组，用户，修改时间等,不包括内容
copy(src,dst) #复制文件权限和内容
copy2(src,dst) #复制文件权限和内容,还包括权限，组，用户，时间等
copytree(src,dst) #拷贝文件夹里所有内容(递归拷贝)
rmtree(path) #删除当前文件夹及其中所有内容(递归删除)
move(path1,paht2) #移动文件或者文件夹
json模块
所有编程语言都能够识别的数据格式叫做json,是字符串
dumps 把任意对象序列化成一个str
loads 把任意str反序列化成原来数据
1.序列化时的参数 ensure_ascii=True 是否显示中文；sort_keys=True 对字典的健按ascii排序
>>> import json
>>> dictvar = {"b":2,"a":1,"c":3}
>>> res = json.dumps(dictvar,ensure_ascii=False,sort_keys=True)
>>> print(res,type(res))
{"a": 1, "b": 2, "c": 3} <class 'str'>
>>> print(repr(res))
'{"a": 1, "b": 2, "c": 3}'
>>> dictvar = json.loads(res)
>>> print(dictvar,type(dictvar))
{'a': 1, 'b': 2, 'c': 3} <class 'dict'>
>>>
dump 把对象序列化后写入到file-like Object(即文件对象)
load 把file-like Object(即文件对象)中的内容拿出来,反序列化成原来数据
1.json可以连续dump，但不能连续load，可以用loads解决
dic1 = {'a':1,"b":2}
dic2 = {"c":3,"d":4}
with open("test.json",mode="w",encoding="utf-8") as fp:
json.dump(dic1,fp)
fp.write("
")
json.dump(dic2,fp)
fp.write("
")
解决方式
with open("test.json",mode="r",encoding="utf-8") as fp:
for line in fp:
res = json.loads(line)
print(res)
json 和 pickle 两个模块的区别:
(1)json序列化之后的数据类型是str,所有编程语言都识别,
但是仅限于(int float bool)(str list tuple dict None)
json不能连续load,只能一次性拿出所有数据
(2)pickle序列化之后的数据类型是bytes,
所有数据类型都可转化,但仅限于python之间的存储传输.
pickle可以连续load,多套数据放到同一个文件中
压缩模块-zipfile (后缀为zip)
zipfile.ZipFile(file[, mode[, compression[, allowZip64]]])
ZipFile(路径包名,模式,压缩or打包,可选allowZip64)
功能：创建一个ZipFile对象,表示一个zip文件.
参数：
-参数file表示文件的路径或类文件对象(file-like object)
-参数mode指示打开zip文件的模式，默认值为r
r 表示读取已经存在的zip文件
w 表示新建一个zip文档或覆盖一个已经存在的zip文档
a 表示将数据追加到一个现存的zip文档中。
-参数compression表示在写zip文档时使用的压缩方法
zipfile.ZIP_STORED 只是存储模式，不会对文件进行压缩，这个是默认值
zipfile.ZIP_DEFLATED 对文件进行压缩
-如果要操作的zip文件大小超过2G，应该将allowZip64设置为True。
压缩文件
1.ZipFile() 写模式w打开或者新建压缩文件
2.write(路径,别名) 向压缩文件中添加文件内容
3.close() 关闭压缩文件
解压文件
1.ZipFile() 读模式r打开压缩文件
2.extractall(路径) 解压所有文件到某个路径下
extract(文件,路径) 解压指定的某个文件到某个路径下
3.close() 关闭压缩文件
追加文件(支持with写法)
ZipFile() 追加模式a打开压缩文件
查看压缩包中的内容
namelist()
压缩模块-tarfile(后缀为.tar | .tar.gz | .tar.bz2) (了解)
bz2模式的压缩文件较小 根据电脑的不同会差生不同的结果 (理论上:bz2压缩之后更小,按实际情况为标准)
w 单纯的套一个后缀 打包
w:bz2 采用bz2算法 压缩
w:gz 采用gz算法 压缩
压缩文件
1.open('路径包名','模式','字符编码') 创建或者打开文件
2.add(路径文件,arcname="别名") 向压缩文件中添加文件
3,close() 关闭文件
解压文件
1.open('路径包名','模式','字符编码') 读模式打开文件
2.extractall(路径) 解压所有文件到某个路径下
extract(文件,路径) 解压指定的某个文件到某个路径下
3.close() 关闭压缩文件
追加文件
open() 追加模式 a: 打开压缩文件 正常添加即可
查看压缩包中的内容
getnames()
计算一个文件夹所有文件的大小
# ### 计算一个文件夹所有文件的大小 import os path1 = os.getcwd() # print(path1) pathvar = os.path.join(path1,"test") # D:L006 est print(pathvar) # part1 基本操作 lst = os.listdir(pathvar) print(lst) # 初始化变量size = 0 size = 0 for i in lst: # 拼接成完整的绝对路径 pathnew = os.path.join(pathvar,i) # 判定它是不是文件 if os.path.isfile(pathnew): print(i,"是一个[文件]") # 如果是文件,计算大小 getsize 只能算文件的大小 size += os.path.getsize(pathnew) # 判定它是不是文件夹 elif os.path.isdir(pathnew): print(i,"是一个[文件夹]") print(size) # 4834 # part2 递归方法计算文件夹里所有内容大小 def getallsize(pathvar): size = 0 lst = os.listdir(pathvar) for i in lst: pathnew = os.path.join(pathvar,i) if os.path.isfile(pathnew): print(pathnew) # 统计文件大小 size += os.path.getsize(pathnew) elif os.path.isdir(pathnew): print(pathnew) # D:L006 est esta # 递归统计文件夹里面的文件名称 size += getallsize(pathnew) return size res = getallsize(pathvar) print(res) # 6882 + 953 2048 4834