模块
time模块
time.sleep（second）
线程推迟指定时间后运行，单位秒
time.time()
获取时间戳
时间戳
时间戳表示从1970年1月1日00:00:00开始按秒计算的偏移量。获得的是浮点数（float）。
import time print(time.time()) # 1547807704.2873375
格式化时间
格式化的字符串时间
import time print(time.strftime("%Y-%m-%d %H:%M:%S")) # 2019-01-18 18:36:32
python中时间日期格式化符号
python中时间日期格式化符号: %y 两位数的年份表示（00-99） %Y 四位数的年份表示（000-9999） %m 月份（01-12） %d 月内中的一天（0-31） %H 24小时制小时数（0-23） %I 12小时制小时数（01-12） %M 分钟数（00=59） %S 秒（00-59） %a 本地简化星期名称 %A 本地完整星期名称 %b 本地简化的月份名称 %B 本地完整的月份名称 %c 本地相应的日期表示和时间表示 %j 年内的一天（001-366） %p 本地A.M.或P.M.的等价符 %U 一年中的星期数（00-53）星期天为星期的开始 %w 星期（0-6），星期天为星期的开始 %W 一年中的星期数（00-53）星期一为星期的开始 %x 本地相应的日期表示 %X 本地相应的时间表示 %Z 当前时区的名称 %% %号本身
结构化时间
元组（struct_time）,共有九个元素：
（tm_year年，tm_mon月，tm_mday日，tm_hour时，tm_min分，tm_sec秒，tm_wday(weekday)一年中第几周，tm_yday一年中第几天，tm_isdst夏令时）
import time #当前时区的struct_time
time_tuple = time.localtime()
print(time_tuple)
print(time_tuple[0])
print(time_tuple[4])
print(time.strftime("%Y-%m-%d %H:%M:%S"))
# time.struct_time(tm_year=2019, tm_mon=1, tm_mday=25, tm_hour=17, tm_min=40, tm_sec=33, tm_wday=4, tm_yday=25, tm_isdst=0)
# 2019
# 40
# 2019-01-25 17:40:33
import time #格林尼治时区的struct——time
print(time.gmtime())
# time.struct_time(tm_year=2019, tm_mon=1, tm_mday=18, tm_hour=10, tm_min=41, tm_sec=2, tm_wday=4, tm_yday=18, tm_isdst=0)
时间格式转换
字符串时间<>结构化时间<>时间戳
字符串时间与时间戳之间不能相互转换。
时间戳>>>结构化时间
time.localtime()
time_tuple = time.localtime(1560000000)
print(time_tuple)
# time.struct_time(tm_year=2019, tm_mon=6, tm_mday=8, tm_hour=21, tm_min=20, tm_sec=0, tm_wday=5, tm_yday=159, tm_isdst=0)
结构化时间>>>时间戳
time.mktime(结构化时间)
time_float = time.mktime(time_tuple) print(time_float) # 1560000000.0
结构化时间>>>字符串时间
time.strftime("格式"，"结构化时间")
time_str = time.strftime("%Y-%m-%d %H:%M:%S",time_tuple) print(time_str) # 2019-06-08 21:20:00
字符串时间>>>结构化时间
time.strptime('字符串时间'，"对应格式")
time_tuple = time.strptime(time_str,"%Y-%m-%d %H:%M:%S") print(time_tuple) # time.struct_time(tm_year=2019, tm_mon=6, tm_mday=8, tm_hour=21, tm_min=20, tm_sec=0, tm_wday=5, tm_yday=159, tm_isdst=-1)
asctime--ctime
#结构化时间 --> %a %b %d %H:%M:%S %Y串 #time.asctime(结构化时间) 如果不传参数，直接返回当前时间的格式化串 >>>time.asctime(time.localtime(1500000000)) 'Fri Jul 14 10:40:00 2017' >>>time.asctime() 'Mon Jul 24 15:18:33 2017' #时间戳 --> %a %b %d %H:%M:%S %Y串 #time.ctime(时间戳) 如果不传参数，直接返回当前时间的格式化串 >>>time.ctime() 'Mon Jul 24 15:19:07 2017' >>>time.ctime(1500000000) 'Fri Jul 14 10:40:00 2017'
日期和时间的标准库datetime
datetime是一个模块，还是一个datetime的类
导入时通过
导入datetime这个类 from datetime import datetime 如果 import datetime 导入的是模块，必须要datetime.datetime引用
from datetime import datetime
print(datetime.now())
# 2019-01-25 20:05:40.435979
获取时间和日期
from datetime import datetime print(datetime.now()) #获取当前时间 print(datetime(2018,12,31,23,59,59,999999)) #获取指定时间 # 2019-01-25 20:10:35.180838 # 2018-12-31 23:59:59.999999
格式转化
datetime转时间戳timestamp
from datetime import datetime time_dtm = datetime.now() print(time_dtm.timestamp()) # 1548419437.367599
时间戳转datetime
from datetime import datetime print(datetime.fromtimestamp(150000000))
datetime转字符串时间
from datetime import datetime print(datetime.now().strftime("%Y-%m-%d %H:%M:%S"))
字符串时间转datetime
from datetime import datetime
print(datetime.strptime("1974-10-03 10:40","%Y-%m-%d %H:%M"))
# 1974-10-03 10:40:00
datetime加减
from datetime import datetime
from datetime import timedelta
now = datetime.now() #当前时间
print(now)
#2019-01-25 21:18:23.152513
now1 = now + timedelta(hours=10) #加10小时
print(now1)
# 2019-01-26 07:18:23.152513
now2 = now + timedelta(days=10) #加10天
print(now2)
# 2019-02-04 21:18:23.152513
now3 = now + timedelta(weeks=10) #加10天
print(now3)
# 2019-04-05 21:18:23.152513
# days: float = ..., seconds: float = ..., microseconds: float = ...,
# milliseconds: float = ..., minutes: float = ..., hours: float = ...,
# weeks: float =
序列化
序列化的目的
以某种储存形式是自定义对象持久化；
将对象从一个地方传递到另一个地方
使过程更有维护性
json
json 模块提供了四个功能
dump 将对象转换成字符存储到文件中
load 将文件中的字符转换成对象
import json
f = open('json_file','w')
dic = {'k1':'v1','k2':'v2','k3':'v3'}
json.dump(dic,f)
#dump方法接收一个文件句柄，直接将字典转换成json字符串写入文件
f.close()
f = open('json_file')
dic2 = json.load(f)
#load方法接收一个文件句柄，直接将文件中的json字符串转换成数据结构返回
f.close()
print(type(dic2),dic2)
import json
dic = {'k1':1,2:'v2','k3':'v3'}
print(dic.get(2,0)) #v2
str_dic = json.dumps(dic)
print(type(str_dic),str_dic)
#<class 'str'> {"k1": 1, "2": "v2", "k3": "v3"}
dic2 = json.loads(str_dic)
print(dic2.get(2,0)) #0
print(type(dic2),dic2)
# <class 'dict'> {'k1': 1, '2': 'v2', 'k3': 'v3'}
dumps 将对象转换成字符串
loads 将字符串转换成对象
import json
dic = {'k1':'v1','k2':'v2','k3':'v3'}
str_dic = json.dumps(dic) #序列化：将一个字典转换成一个字符串
print(type(str_dic),str_dic) #<class 'str'> {"k3": "v3", "k1": "v1", "k2": "v2"}
#注意，json转换完的字符串类型的字典中的字符串是由""表示的
dic2 = json.loads(str_dic) #反序列化：将一个字符串格式的字典转换成一个字典
#注意，要用json的loads功能处理的字符串类型的字典中的字符串必须由""表示
print(type(dic2),dic2) #<class 'dict'> {'k1': 'v1', 'k2': 'v2', 'k3': 'v3'}
list_dic = [1,['a','b','c'],3,{'k1':'v1','k2':'v2'}]
str_dic = json.dumps(list_dic) #也可以处理嵌套的数据类型
print(type(str_dic),str_dic) #<class 'str'> [1, ["a", "b", "c"], 3, {"k1": "v1", "k2": "v2"}]
list_dic2 = json.loads(str_dic)
print(type(list_dic2),list_dic2) #<class 'list'> [1, ['a', 'b', 'c'], 3, {'k1': 'v1', 'k2': 'v2'}]
其他参数说明
Serialize obj to a JSON formatted str.(字符串表示的json对象)
Skipkeys：默认值是False，如果dict的keys内的数据不是python的基本类型(str,unicode,int,long,float,bool,None)，设置为False时，就会报TypeError的错误。此时设置成True，则会跳过这类key
ensure_ascii:，当它为True的时候，所有非ASCII码字符显示为\uXXXX序列，只需在dump时将ensure_ascii设置为False即可，此时存入json的中文即可正常显示。)
If check_circular is false, then the circular reference check for container types will be skipped and a circular reference will result in an OverflowError (or worse).
If allow_nan is false, then it will be a ValueError to serialize out of range float values (nan, inf, -inf) in strict compliance of the JSON specification, instead of using the JavaScript equivalents (NaN, Infinity, -Infinity).
indent：应该是一个非负的整型，如果是0就是顶格分行显示，如果为空就是一行最紧凑显示，否则会换行且按照indent的数值显示前面的空白分行显示，这样打印出来的json数据也叫pretty-printed json
separators：分隔符，实际上是(item_separator, dict_separator)的一个元组，默认的就是(‘,’,’:’)；这表示dictionary内keys之间用“,”隔开，而KEY和value之间用“：”隔开。
default(obj) is a function that should return a serializable version of obj or raise TypeError. The default simply raises TypeError.
sort_keys：将数据根据keys的值进行排序。
To use a custom JSONEncoder subclass (e.g. one that overrides the .default() method to serialize additional types), specify it with the cls kwarg; otherwise JSONEncoder is used.
json的格式化输出
import json
data = {'username':['李华','二愣子'],'sex':'male','age':16}
json_dic2 = json.dumps(data,sort_keys=True,indent=2,separators=(',',':'),ensure_ascii=False)
print(json_dic2)
pickle模块
json，用于字符串和python数据类型间进行转换；pickle，用于python特有的类型和python的数据类型间进行转换，pickle模块提供了四个功能：dumps、dump(序列化，存）、loads、load （反序列化，读）
pickle是python特有的模块（不仅可以序列化字典，列表...可以把python中任意的数据类型序列化）。
总结
json模块里
dumps 是将python的数据结构转换成字符串
loads 是将字符串类型转换成python的数据结构
dump 是将python的数据结构转换成字符串,然后存入到文件当中
load 是将文件中字符串类型转换成python的数据结构pickle模块dumps 是将python的数据结构转换成二进制的文件
loads 是将二进制的文件转换成python的数据结构
dump p是将python的数据结构转换成二进制然后存入到文件中
load 是将文件中的二进制文件转成pythond的数据结构,可写入多个
shelve
shelve是基于pickle实现的
import shelve d = shelve.open('dir') #创建一个文件（3个文档，不可手动更改，Apple电脑1个） d['name'] = 123 #在文件中添加一个"name"：123键值对 注：字典的键必须是字符串 print(d.get('na',0)) #可以用字典所有的操作
# 如果出现回写不成功的时候，在open('名',writeback) d = shelve.open('dir',writeback=True)
random 模块
random随机数模块
0-1之间的随机小数
import random
print(random.random())
指定范围内的随机浮点数
import random
print(random.uniform(1,4))
随机整数
import random
print(random.randint(1,5)
随机生成奇数和偶数
import random
print(random.randrange(1,5,2)) #随机生成1-5的奇数
print(random.randrange(0,5,2)) #随机生成0-5的偶数
随机抽取
import random# 《抽取1个》
lst = ["a","b","c","d","e","f","g"]
print(random.choice(lst))
import random 《抽取多个，有重复》
lst = ["a","b","c","d","e","f","g"]
print(random.choices(lst,k=2)) #['b','b']
import random 《抽取多个，无重复》
lst = ["a","b","c","d","e","f","g"]
print(random.sample(lst,k=2))
列表乱序
import random
lst = [1,2,3,4,5,6]
random.shuffle(lst)
print(lst)
os操作系统交互模块
文件夹相关
os.makedirs('a/b/c/d')
当前位置向下递归创建文件夹a/b/c/d
os.rmovedirs('a/b/c/d')
直接删除a/b/c文件夹，文件保护机制，当文件夹内存在文件时，不删除。
os.listdir("路径")
以列表形式展现路径下的所有内容。
os.mkdir('名')
当前位置创建一个文件夹
os.rmdir('名')
删除文件夹，里面有内容会报错，error：目录不是空的
文件相关
os.rename('旧名','新名')
修改文件名称
os.remove('名')
删除文件，（用with open("名")创建新文件）
操作系统差异相关
os.sep
输出操作系统特定的路径分隔符，win下为“\\”,Linux下为“/”
os.linesep
输出当前平台使用的行终止符，win下为“\r\n”,Linux下为“\n”，http请求时会用
os.pathsep
输出用于分割文件路径的字符串，win下为“；”，Linux下为“：”
os.name
输出字符串指示当前使用平台，win下为“nt”，Linux下为“posix”
执行系统命令相关
os.system()
通过代码向系统发出指令， 编码gbk，且不可改
os.popen().read()
通过代码向系统发出指令， 编码gbk，且不可改
os.environ
获取系统环境变量
路径相关
os.getcwd()
返回文件的绝对路径
os.chdir("路径")
改变脚本工作目录
os.curdir
返回当前目录：('.')
os.pardir
获取当前目录的父目录字符串名：("..")
os.path.abspath('路径')
返回正规的绝对路径
os.path.split('路径')
将“路径”以最后一个‘\’分成“文件路径”“文件名”的二元元组
os.path.basename('路径')
获取文件名==os.path.split('路径')[1]
os.path.dirname('路径')
获取文件的路径==os.path.dirsplit('路径')[0]
os.path.join('磁盘开始路径','路径或文件名')
指定一个盘符，显示这个盘符下的所有内容，让用户输入切换到用户输入的目录 print(os.listdir()) 显示当前路径下所有内容 url = input(">>>") os.chdir('路径\\'+url ) '路径'+'\\'+url 目录切换，把路径放进去 ret = os.getcwd() 获取当前路径 print(os.listdir(ret)) 打印新路径的内容
os.path.join(‘路径a’，‘路径b’，‘路径c’)可实现多上下路径的依次拼接a\b\c
__file__返回当前文件的路径
BASE_dir = os.path.abspath(__file__)《配置文件》 print(BASE_dir) print(os.path.join(BASE_dir,'文件'))
os.path.exists('路径')
路径存在返回True
os.path.isdir（路径）
判断是有效文件夹
os.path.isfile（‘路径’）
判断是有效文件
os.path.isabs（‘路径’）
判断是绝对路径
os.path.geiatime('路径')
文件或目录最后访问时间
os.path.getmtime('路径')
文件或目录最后的修改时间
os.path.getsize(‘路径’)
获取文件的大小（到文件夹时不准确）==os.stat('路径').st_size
st_mode:inode保护模式
st_ino:inode节点号
st_dev:inode主流的设备
st_nlink:inode的链接数
st_uid:所有者的用户ID
st_gid:所有者的组ID
st_size:普通文件以字节为单位的大小；包含等待某种特殊文件的数据
st_atime:上次访问的时间
st_mtime:最后一次修改的时间
st_ctime:由操作系统报告的“ctime”。在某些系统上（如Unix）是最新的元数据更改的时间，在其它系统上（如Windows）是创建时间
sys解释器交互模块
sys.path
返回模块的搜索路径，初始化时使用PYTHONPATH环境变量的值
python解释器找模块的一个环境变量
sys.platform
返回操作系统信息“win32”
sys.version
查看python解释器的版本号
sys.argv()
当前路径（）调用的时候可以传参
在terminal终端里用
sys.exit(n)
退出程序，正常退出时为0，错误退出时为1
hashlib摘要算法模块
摘要算法又称哈希算法、散列算法。它通过一个函数，把任意长度的数据转换为一个长度固定的数据串（通常用16进制的字符串表示）。
摘要算法时通过函数对任意长度的数据data计算出固定长度的摘要digest，目的是为了发现原始数据是否被篡改过。
摘要函数是单向函数，计算数据串很容易，但不能反推明文，而且，只要对原始数据做了1bit修改，最后的数字串完全不同。
MD5算法
import hashlib md5 = hashlib.md5() md5.update("明文".encode("utf-8")) print(md5.hexdigest()) # e6c2860f3a8fa2aa6224ab17e9fac946
分块多次调用
import hashlib md5= hashlib.md5() md5.update("明".encode("utf-8"))# md5.update("文".encode("utf-8"))# print(md5.hexdigest()) # e6c2860f3a8fa2aa6224ab17e9fac946
加盐
import hashlib md5 = hashlib.md5('salt'.encode('utf-8')) #加盐 md5.update("明文".encode("utf-8")) print(md5.hexdigest()) # 3f2d8a5a75e496b9185f676a15809579
SHA1算法
import hashlib sh1= hashlib.sha1() sh1.update("明文".encode("utf-8")) print(sh1.hexdigest()) #f69a12f88e24444eeab35f43568b194bf731ab8b import hashlib sh1= hashlib.sha1("a".encode("utf-8")) #加盐 sh1.update("明文".encode("utf-8")) print(sh1.hexdigest()) # 4935d3a3571b097da4be62b37e38dc780540f6ec
collections额外数据类型模块
namedtuple
命名元组
from collections import namedtuple t = namedtuple("Na",['a','b','c','d']) #列表中不能用数字 t1 = t(5,6,7,8) print(t1.a) #5
Counter
统计
from collections import Counter s_str = "aaabbbcccccdd" count = Counter(s_str) print(count) #Counter({'c': 5, 'a': 3, 'b': 3, 'd': 2})#统计元素出现的次数，按数量多少排序
defaultdict
带有默认值的字典
deque
双向队列
队列：FIFO,先进先出
栈：FILO,后进先出
import queue qe = queue.Queue() #创建队列 qe.put('a') #填 qe.put('b') #填 qe.put('c') #填 qe.put('d') #填 print(qe.get()) #取 print(qe.get()) #取 print(qe.get()) #取 print(qe.get()) #取 print(qe.get()) #取 全取出后阻塞 # a # b # c # d
# 阻塞
双向队列deque
from collections import deque deq = deque(['x','y']) #创建双向队列且有空列表deq deq.append("a") deq.append('b') deq.appendleft('c') deq.appendleft('d') print(deq) #可查看 deque(['d', 'c', 'x', 'y', 'a', 'b']) print(deq.pop()) #尾部提取 b print(deq.popleft()) #左侧提取 d
shutil高级文件操作模块
shutil.copyfile('源文件'，'新位置')#文件拷贝,目标必须存在
shutil.copyfileobj(open('句柄')，open('句柄'))
shutil.copymode('file1','file2')拷贝权限，内容、组、用户不变，目标必须存在
shutil.copystat('file1','file2')#拷贝状态信息mod\bits\aime\mtime\flags目标文件必须存在
shutil.copy2('file1','file2')#拷贝文件和权限
shutil.copytree('folder1','folder2',ignore=shutil.ignore_patterns('*.pyc','tmp*')) #递归拷贝文件夹 #目标目录不能存在，之一对fold而目录父级母要有可写权限，ignore的意思是排除
shutil.rmtree('folder')#递归删除文件
shutil.move('folder1','folder2')#递归的去移动文件
shutil.make_archive()创建压缩包并返回文件路径
import shutil shutil.make_archive(base_name='', #压缩文件名（保存到当前位置）或路径 format='', #压缩格式：“zip”，“tar”，“bztar”，“gztar” root_dir='', #要压缩的文件夹路径（默认当前路径） owner='', #用户，默认当前用户 group='', #组，默认当前组 logger='' #用于记录日志，通常是logging.Logger对象 )
shutil对压缩包的处理是调用ZipFile和TarFile两个模块来进行的
import zipfile 《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()
import tarfile 《tarfilr处理》 # 压缩 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('/meet') t.close()
模块
浙公网安备 33010602011771号