① time
必要说明：
1.time模块提供各种时间相关的功能
与时间相关的模块有：time,datetime,calendar
2.这个模块的功能不是适用于所有的平台
这个模块中定义的大部分函数是调用C平台上的同名函数实现
3.一些术语和约定的解释：
Ⅰ.时间戳(timestamp)的方式：通常来说，时间戳表示的是从1970年1月１日开始按秒计算的偏移量(time.gmtime(0))此模块中 的函数无法处理1970纪元年以前的时间或太遥远的未来(处理极限取决于C函数库，对于32位系统而言，是2038年)
Ⅱ.UTC(Coordinated Universal Time,世界协调时)也叫格林威治天文时间，是世界标准时间．在我国为UTC+8
Ⅲ.DST(Daylight Saving Time)即夏令时
Ⅳ.一些实时函数的计算精度可能不同
时间元祖(time.struct_time):
gmtime(),localtime()和strptime()以时间元祖(struct_time)的形式返回
image.png
time.altzone
返回格林威治西部的夏令时地区的偏移秒数，如果该地区在格林威治东部会返回负值(如西欧，包括英国)，对夏令时启用地区才能使用
time.asctime([t])
接受时间元组并返回一个可读的形式"Tue May 30 17:17:30 2017"(2017年5月30日周二17时17分30秒)的24个字符的字符串
time.clock()
用以浮点数计算的秒数返回当前的CPU时间，用来衡量不同程序的耗时，比time.time()更有用
python3.3以后不被推荐使用，该方法依赖操作系统，建议使用per_counter(返回系统运行时间)或process_time(返回进程运行时间)代替
time.ctime([secs])
作用相当于asctime(localtime(secs)),未给参数相当于asctime()
time.gmtime([secs])
接收时间辍(1970纪元年后经过的浮点秒数)并返回格林威治天文时间下的时间元组t(t.tm_isdst始终为０)
time.daylight
如果夏令时被定义，则该值为非零
time.localtime([secs])
接收时间辍(1970纪元年后经过的浮点秒数)并返回当地时间下的时间元组t(t.tm_isdst可取为０或１，取决于当地当时是不是夏令时)
time.mktime(t)
接受时间元组并返回时间辍(1970纪元年后经过的浮点秒数)
time.perf_counter()
返回计时器的精准时间(系统的运行时间)，包含整个系统的睡眠时间．由于返回值的基准点是未定义的，所以，只有连续调用的结果之间的差才是有效的
time.process_time()
返回当前进程执行CPU的时间总和，不包含睡眠时间．由于返回值的基准点是未定义的，所以只有连续调用的结果之间的差才是有效的
time.sleep(secs)
推迟调用线程的运行，secs的单位是秒
time.strftime(format[,t])
把一个代表时间的元组或者struct_time(如由time.localtime()和time.gmtime()返回)转化为格式化
的时间字符串．如果t未指定，将传入time.localtime()，如果元组中任命一个元素越界，将会抛出
ValueError异常
format格式如下：
%a 本地(local)简化星期名称
%A 本地完整星期名称
%b 本地简化月份名称
%B 本地完整月份名称
%c 本地相应的日期和时间表示
%d 一个月中的第几天(01-31)
%H 一天中的第几个小时(24小时制，00-23)
%l 一天中的第几个小时(12小时制，01-12)
%j 一年中的第几天(01-366)
%m 月份(01-12)
%M 分钟数(00-59)
%p 本地am或者pm的相应符
%S 秒(01-61)
%U 一年中的星期数(00-53,星期天是一个星期的开始,第一个星期天之前的所有天数都放在第０周)
%w 一个星期中的第几天(0-6,0是星期天)
%W 和%U基本相同，不同的是%W以星期一为一个星期的开始
%x 本地相应日期
%X 本地相应时间
%y 去掉世纪的年份(00-99)
%Y 完整的年份
%z 用+HHMM或者-HHMM表示距离格林威治的时区偏移(H代表十进制的小时数，M代表十进制的分钟数)
%Z 时区的名字(如果不存在为空字符)
%% %号本身
%p只有与%I配合使用才有效果
当使用strptime()函数时，只有当在这年中的周数和天数被确定的时候%U和%W才会被计算
time.strptime(string[,format])
把一个格式化时间字符串转化为struct_time,实际上它和strftie()是逆操作
time.time()
返回当前时间的时间戳(1970元年后的浮点秒数)
time.timezone()
是当地时区(未启动夏令时)距离格林威治的偏移秒数(美洲＞０，欧洲大部分，亚洲，非洲<＝０)
time.tzname
包含两个字符串的元组，第一是当地夏令时区的名称，第二是当地的DST时区的名称
下面是一些经常会用到的例子:
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import time
def parse_timestr(time_str, flag=True):
"""
把时间字符串转换为时间戳格式
:param time_str: 时间字符串,格式为：2019-01-01 12:12:12 或 2019-01-01
:param flag: 标志位，决定输入时间字符串的格式
:return: 时间戳格式
"""
if flag:
struct_time = time.strptime(time_str, "%Y-%m-%d %H:%M:%S") # 2019-01-01 12:12:12
else:
struct_time = time.strptime(time_str, "%Y-%m-%d") # 2019-01-01
return time.mktime(struct_time)
def parse_timestamp(time_stamp, flag=True):
"""
把时间戳转换为时间字符串
:param time_stamp: 时间戳
:param flag: 标志位，可以指定输出时间字符串的格式
:return: 时间字符串,格式为：2019-01-01 12:12:12 或 2019-01-01
"""
localtime = time.localtime(time_stamp)
if flag:
time_str = time.strftime("%Y-%m-%d %H:%M:%S", localtime)
else:
time_str = time.strftime("%Y-%m-%d", localtime)
return time_str
def day_range(interval_day):
"""
获取指定天内的时间字符串的列表
:return:
"""
c_time = (int(time.time() / (24 * 3600)) + 1) * 24 * 3600
day_range_str = c_time - 24 * 3600 * interval_day
day_list = [parse_timestamp(t, flag=False) for t in range(day_range_str, c_time, 3600 * 24)]
return day_list
def is_workday(time_str):
"""
传入时间字符串，判断传入时间字符串是否是工作日
:param time_str: 必须是时间字符串类型，比如："2019-01-21 14:30:31"
:return: True/False，是否为非工作日
"""
tmp = time.strptime(time_str, "%Y-%m-%d %H:%M:%S")
workday_list = ["Mon", "Tue", "Wed", "Thu", "Fri"]
week = time.strftime("%a", tmp)
if week in workday_list:
return True
else:
return False
def is_holiday(time_str):
"""
传入时间字符串，判断传入时间字符串是否是工作日
:param time_str: 必须是时间字符串类型，比如："2019-01-21 14:30:31"
:return: True/False，是否为非工作日
"""
tmp = time.strptime(time_str, "%Y-%m-%d %H:%M:%S")
holiday_list = ["Sat", "Sun"]
week = time.strftime("%a", tmp)
if week in holiday_list:
return True
else:
return False
def get_day_list(start_timestamp, end_timestamp, flag = True):
"""
传入开始时间戳和结束时间戳，获取时间段内的日期列表
:param start_timestamp: 开始时间戳
:param end_timestamp: 结束时间戳
:param flag: 标志位
:return: 日期列表
"""
tmp = range(int(start_timestamp), int(end_timestamp) + 3600, 3600 * 24)
if flag:
tmp_range = [{"day_str": parse_timestamp(i, flag=False)} for i in tmp]
else:
tmp_range = [parse_timestamp(i, flag=False) for i in tmp]
return tmp_range
def covert_time(time_str):
"""
把时间段转换为秒数
:param time_str:
:return:
"""
if time_str.endswith("h"):
stamp = float(time_str.strip("h")) * 3600
elif time_str.endswith("m"):
stamp = float(time_str.strip("m")) * 60
else:
stamp = float(time_str)
return stamp
② datetime
获取当前日期和时间:
>>> from datetime import datetime
>>> now = datetime.now() # 获取当前datetime
>>> print(now)
2015-05-18 16:28:07.198690
>>> print(type(now))
获取指定日期和时间:
>>> from datetime import datetime
>>> dt = datetime(2015, 4, 19, 12, 20) # 用指定日期时间创建datetime
>>> print(dt)
2015-04-19 12:20:00
datetime转换为timestamp:
>>> from datetime import datetime
>>> dt = datetime(2015, 4, 19, 12, 20) # 用指定日期时间创建datetime
>>> dt.timestamp() # 把datetime转换为timestamp
1429417200.0
timestamp转换为datetime
>>> from datetime import datetime
>>> t = 1429417200.0
>>> print(datetime.fromtimestamp(t))
2015-04-19 12:20:00
timestamp转换为UTC标准时区的时间
>>> from datetime import datetime
>>> t = 1429417200.0
>>> print(datetime.fromtimestamp(t)) # 本地时间
2015-04-19 12:20:00
>>> print(datetime.utcfromtimestamp(t)) # UTC时间
2015-04-19 04:20:00
str转换为datetime
>>> from datetime import datetime
>>> cday = datetime.strptime('2015-6-1 18:19:59', '%Y-%m-%d %H:%M:%S')
>>> print(cday)
2015-06-01 18:19:59
datetime转换为str
>>> from datetime import datetime
>>> now = datetime.now()
>>> print(now.strftime('%a, %b %d %H:%M'))
Mon, May 05 16:28
datetime加减
>>> from datetime import datetime, timedelta
>>> now = datetime.now()
>>> now
datetime.datetime(2015, 5, 18, 16, 57, 3, 540997)
>>> now + timedelta(hours=10)
datetime.datetime(2015, 5, 19, 2, 57, 3, 540997)
>>> now - timedelta(days=1)
datetime.datetime(2015, 5, 17, 16, 57, 3, 540997)
>>> now + timedelta(days=2, hours=12)
datetime.datetime(2015, 5, 21, 4, 57, 3, 540997)
本地时间转换为UTC时间
>>> from datetime import datetime, timedelta, timezone
>>> tz_utc_8 = timezone(timedelta(hours=8)) # 创建时区UTC+8:00
>>> now = datetime.now()
>>> now
datetime.datetime(2015, 5, 18, 17, 2, 10, 871012)
>>> dt = now.replace(tzinfo=tz_utc_8) # 强制设置为UTC+8:00
>>> dt
datetime.datetime(2015, 5, 18, 17, 2, 10, 871012, tzinfo=datetime.timezone(datetime.timedelta(0, 28800)))
时区转换
# 拿到UTC时间，并强制设置时区为UTC+0:00:
>>> utc_dt = datetime.utcnow().replace(tzinfo=timezone.utc)
>>> print(utc_dt)
2015-05-18 09:05:12.377316+00:00
# astimezone()将转换时区为北京时间:
>>> bj_dt = utc_dt.astimezone(timezone(timedelta(hours=8)))
>>> print(bj_dt)
2015-05-18 17:05:12.377316+08:00
# astimezone()将转换时区为东京时间:
>>> tokyo_dt = utc_dt.astimezone(timezone(timedelta(hours=9)))
>>> print(tokyo_dt)
2015-05-18 18:05:12.377316+09:00
# astimezone()将bj_dt转换时区为东京时间:
>>> tokyo_dt2 = bj_dt.astimezone(timezone(timedelta(hours=9)))
>>> print(tokyo_dt2)
2015-05-18 18:05:12.377316+09:00
③ collections
namedtuple:
>>> from collections import namedtuple
>>> Point = namedtuple('Point', ['x', 'y'])
>>> p = Point(1, 2)
>>> p.x
1
>>> p.y
2
>>> isinstance(p, Point)
True
>>> isinstance(p, tuple)
True
deque
>>> from collections import deque
>>> q = deque(['a', 'b', 'c'])
>>> q.append('x')
>>> q.appendleft('y')
>>> q
deque(['y', 'a', 'b', 'c', 'x'])
defaultdict
>>> from collections import defaultdict
>>> dd = defaultdict(lambda: 'N/A')
>>> dd['key1'] = 'abc'
>>> dd['key1'] # key1存在
'abc'
>>> dd['key2'] # key2不存在，返回默认值
'N/A'
OrderedDict
>>> from collections import OrderedDict
>>> d = dict([('a', 1), ('b', 2), ('c', 3)])
>>> d # dict的Key是无序的
{'a': 1, 'c': 3, 'b': 2}
>>> od = OrderedDict([('a', 1), ('b', 2), ('c', 3)])
>>> od # OrderedDict的Key是有序的
OrderedDict([('a', 1), ('b', 2), ('c', 3)])
>>> od = OrderedDict()
>>> od['z'] = 1
>>> od['y'] = 2
>>> od['x'] = 3
>>> list(od.keys()) # 按照插入的Key的顺序返回
['z', 'y', 'x']
OrderedDict可以实现一个FIFO（先进先出）的dict，当容量超出限制时，先删除最早添加的Key：
from collections import OrderedDict
class LastUpdatedOrderedDict(OrderedDict):
def __init__(self, capacity):
super(LastUpdatedOrderedDict, self).__init__()
self._capacity = capacity
def __setitem__(self, key, value):
containsKey = 1 if key in self else 0
if len(self) - containsKey >= self._capacity:
last = self.popitem(last=False)
print('remove:', last)
if containsKey:
del self[key]
print('set:', (key, value))
else:
print('add:', (key, value))
OrderedDict.__setitem__(self, key, value)
ChainMap
from collections import ChainMap
a = {"x":1, "z":3}
b = {"y":2, "z":4}
c = ChainMap(a,b)
print(c)
print("x: {}, y: {}, z: {}".format(c["x"], c["y"], c["z"]))
输出：
ChainMap({'x': 1, 'z': 3}, {'y': 2, 'z': 4})
x: 1, y: 2, z: 3
[Finished in 0.1s]
In [6]: a = {"x":1, "z":3}
In [7]: b = {"y":2, "z":4}
In [8]: c = ChainMap(a, b)
In [9]: c
Out[9]: ChainMap({'z': 3, 'x': 1}, {'z': 4, 'y': 2})
In [10]: c["z"]
Out[10]: 3
In [11]: c["z"] = 4
In [12]: c
Out[12]: ChainMap({'z': 4, 'x': 1}, {'z': 4, 'y': 2})
In [13]: c.pop('z')
Out[13]: 4
In [14]: c
Out[14]: ChainMap({'x': 1}, {'z': 4, 'y': 2})
In [15]: del c["y"]
---------------------------------------------------------------------------
KeyError Traceback (most recent call last)
。。。。。。
KeyError: "Key not found in the first mapping: 'y'"
In [4]: a = ChainMap()
In [5]: a["x"]=1
In [6]: a
Out[6]: ChainMap({'x': 1})
In [7]: b = a.new_child()
In [8]: b
Out[8]: ChainMap({}, {'x': 1})
In [9]: b["x"] = 2
In [10]: b
Out[10]: ChainMap({'x': 2}, {'x': 1})
In [11]: b["y"] = 3
In [12]: b
Out[12]: ChainMap({'x': 2, 'y': 3}, {'x': 1})
In [13]: a
Out[13]: ChainMap({'x': 1})
In [14]: c = a.new_child()
In [15]: c
Out[15]: ChainMap({}, {'x': 1})
In [16]: c["x"]
Out[16]: 1
In [17]: c["y"] = 1
In [18]: c
Out[18]: ChainMap({'y': 1}, {'x': 1})
In [19]: d = c.parents()
---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
in ()
----> 1 d = c.parents()
TypeError: 'ChainMap' object is not callable
In [20]: d = c.parents
In [21]: d
Out[21]: ChainMap({'x': 1})
In [22]: d is a
Out[22]: False
In [23]: d == a
Out[23]: True
In [24]: a = {"x":1, "z":3}
In [25]: b = {"y":2, "z":4}
In [26]: c = ChainMap(a,b)
In [27]: c
Out[27]: ChainMap({'x': 1, 'z': 3}, {'y': 2, 'z': 4})
In [28]: c.maps
Out[28]: [{'x': 1, 'z': 3}, {'y': 2, 'z': 4}]
In [29]: c.parents
Out[29]: ChainMap({'y': 2, 'z': 4})
In [30]: c.parents.maps
Out[30]: [{'y': 2, 'z': 4}]
In [31]: c.parents.parents
Out[31]: ChainMap({})
In [32]: c.parents.parents.parents
Out[32]: ChainMap({})
Counter
>>> from collections import Counter
>>> c = Counter()
>>> for ch in 'programming':
... c[ch] = c[ch] + 1
...
>>> c
Counter({'g': 2, 'm': 2, 'r': 2, 'a': 1, 'i': 1, 'o': 1, 'n': 1, 'p': 1})
④ base64
如果要编码的二进制数据不是3的倍数，最后会剩下1个或2个字节怎么办？Base64用\x00字节在末尾补足后，再在编码的末尾加上1个或2个=号，表示补了多少字节，解码的时候，会自动去掉:
>>> import base64
>>> base64.b64encode(b'binary\x00string')
b'YmluYXJ5AHN0cmluZw=='
>>> base64.b64decode(b'YmluYXJ5AHN0cmluZw==')
b'binary\x00string'
由于标准的Base64编码后可能出现字符+和/，在URL中就不能直接作为参数，所以又有一种"url safe"的base64编码，其实就是把字符+和/分别变成-和_：
>>> base64.b64encode(b'i\xb7\x1d\xfb\xef\xff')
b'abcd++//'
>>> base64.urlsafe_b64encode(b'i\xb7\x1d\xfb\xef\xff')
b'abcd--__'
>>> base64.urlsafe_b64decode('abcd--__')
b'i\xb7\x1d\xfb\xef\xff'
由于=字符也可能出现在Base64编码中，但=用在URL、Cookie里面会造成歧义，所以，很多Base64编码后会把=去掉
# 标准Base64:
'abcd' -> 'YWJjZA=='
# 自动去掉=:
'abcd' -> 'YWJjZA'
去掉=后怎么解码呢？因为Base64是把3个字节变为4个字节，所以，
Base64编码的长度永远是4的倍数，因此，需要加上=把Base64字符串的
长度变为4的倍数，就可以正常解码了。比如定义下面的函数：
def safe_base64_decode(s):
num = len(s)%4
s += b'='*(4-num)
return base64.b64decode(s)
⑤ struct
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
import struct
# 把任意数据类型变成bytes
# >表示字节顺序是big-endian，也就是网络序，I表示4字节无符号整数。
p1 = struct.pack('>I', 10240099)
print(p1) >>> b'\x00\x9c@c'
# 把bytes变成相应的数据类型
p2 = struct.unpack('>I', b'\x00\x9c@c')
print(p2) >>> (10240099,)
# 根据>IH的说明，后面的bytes依次变为I：4字节无符号整数和H：2字节无符号整数。
p3 = struct.unpack('>IH', b'\xf0\xf0\xf0\xf0\x80\x80')
print(p3) >>> (4042322160, 32896)
\xf0\xf0\xf0\xf0按照I规则，\x80\x80按照H规则，但是不可以分开写，如下面这样写是错误的：
p3 = struct.unpack('>IH', b'\xf0\xf0\xf0\xf0',b'\x80\x80')
但是打包的时候却可以分开写来打包，如：
>>> pack('llh0l', 1, 2, 3)
b'\x00\x00\x00\x01\x00\x00\x00\x02\x00\x03\x00\x00'
字节顺序
image.png
本地字节顺序是大端或小端，取决于主机系统。例如，Intel x86和AMD64（x86-64）是小端字节序；摩托罗拉68000和PowerPC G5是大端； ARM和Intel Itanium特性可切换字节顺序（双字节顺序）。使用sys.byteorder来检查系统的字节序。
字节大小和对齐
image.png
示例（所有示例都假定本机字节顺序，大小和与big-endian机器的对齐。)
打包/解包三个整数的基本示例：
>>> from struct import *
>>> pack('hhl', 1, 2, 3)
b'\x00\x01\x00\x02\x00\x00\x00\x03'
>>> unpack('hhl', b'\x00\x01\x00\x02\x00\x00\x00\x03')
(1, 2, 3)
>>> calcsize('hhl')
8
可以通过将解压缩字段分配给变量或将结果包装在命名元组中来命名解压缩字段：
>>> record = b'raymond \x32\x12\x08\x01\x08'
>>> name, serialnum, school, gradelevel = unpack('<10sHHb', record)
>>> from collections import namedtuple
>>> Student = namedtuple('Student', 'name serialnum school gradelevel')
>>> Student._make(unpack('<10sHHb', record))
Student(name=b'raymond ', serialnum=4658, school=264, gradelevel=8)
格式字符的排序可能会对大小产生影响，因为满足对齐要求所需的填充是不同的：
>>> pack('ci', b'*', 0x12131415)
b'*\x00\x00\x00\x12\x13\x14\x15'
>>> pack('ic', 0x12131415, b'*')
b'\x12\x13\x14\x15*'
>>> calcsize('ci')
8
>>> calcsize('ic')
5
以下格式'llh0l'在末尾指定两个填充字节，假设long在4字节边界上对齐：
>>> pack('llh0l', 1, 2, 3)
b'\x00\x00\x00\x01\x00\x00\x00\x02\x00\x03\x00\x00'
⑥ pickle
pickle，用于python特有的类型 和 python的数据类型间进行转换
pickle模块提供了四个功能：dumps、dump、loads、load
pickle.dumps(obj)--把任意对象序列化成一个str，然后，把这个str写入文件
pickle.loads(string) --反序列化出对象
pickle.dump(obj,file) --直接把对象序列化后写入文件
pickle.load(file) --从文件中反序列化出对象
例子：
#!/usr/bin/env python
# -*- coding:utf-8 -*-
import pickle
accounts = {
1000: {
'name':'USERA',
'email': '[email protected]',
'passwd': 'abc123',
'balance': 15000,
'phone': 13651054608,
'bank_acc':{
'ICBC':14324234,
'CBC' : 235234,
'ABC' : 35235423
}
},
1001: {
'name': 'USERB',
'email': '[email protected]',
'passwd': 'abc145323',
'balance': -15000,
'phone': 1345635345,
'bank_acc': {
'ICBC': 4334343,
}
},
}
#把字典类型写入到文件中
f = open('accounts.db','wb')
f.write(pickle.dumps(accounts))
f.close()
#2，反序列出对象并修改其内容，并将修改内容重新写入文件
file_name = "accounts.db"
f = open(file_name,'rb')
account_dic = pickle.loads(f.read())
f.close()
account_dic[1000]['balance'] -= 500
f = open(file_name,'wb')
f.write(pickle.dumps(account_dic))
f.close()
#3,反序列化对象并查看其内容
f = open('accounts.db','rb')
acountdb = pickle.loads(f.read())
print(acountdb)
dic = {
'k1': [1,2],
'k2': [3,4]
}
#1.将对象写入文件
f = open('test','wb')
pickle.dump(dic,f)
f.close()
#2.将文件中内容反序列化，并读出
f = open('test','rb')
dic2 = pickle.load(f)
print(dic2)
f.close()
⑦ os
常用方法
os.getcwd() 获取当前工作目录，即当前python脚本工作的目录路径
os.chdir("dirname") 改变当前脚本工作目录；相当于shell下cd
os.curdir 返回当前目录: ('.')
os.pardir 获取当前目录的父目录字符串名：('..')
os.makedirs('dir1/dir2') 可生成多层递归目录
os.removedirs('dirname1') 若目录为空，则删除，并递归到上一级目录，如若也为空，则删除，依此类推
os.mkdir('dirname') 生成单级目录；相当于shell中mkdir dirname
os.rmdir('dirname') 删除单级空目录，若目录不为空则无法删除，报错；相当于shell中rmdir dirname
os.listdir('dirname') 列出指定目录下的所有文件和子目录，包括隐藏文件，并以列表方式打印
os.remove() 删除一个文件
os.rename("oldname","new") 重命名文件/目录
os.stat('path/filename') 获取文件/目录信息
os.sep 操作系统特定的路径分隔符，win下为"\\",Linux下为"/"
os.linesep 当前平台使用的行终止符，win下为"\t\n",Linux下为"\n"
os.pathsep 用于分割文件路径的字符串
os.name 字符串指示当前使用平台。win->'nt'; Linux->'posix'
os.system("bash command") 运行shell命令，直接显示
os.environ 获取系统环境变量
os.path.abspath(path) 返回path规范化的绝对路径
os.path.split(path) 将path分割成目录和文件名二元组返回
os.path.dirname(path) 返回path的目录。其实就是os.path.split(path)的第一个元素
os.path.basename(path) 返回path最后的文件名。如何path以／或\结尾，那么就会返回空值。即os.path.split(path)的第二个元素
os.path.exists(path) 如果path存在，返回True；如果path不存在，返回False
os.path.isabs(path) 如果path是绝对路径，返回True
os.path.isfile(path) 如果path是一个存在的文件，返回True。否则返回False
os.path.isdir(path) 如果path是一个存在的目录，则返回True。否则返回False
os.path.join(path1[, path2[, ...]]) 将多个路径组合后返回，第一个绝对路径之前的参数将被忽略
os.path.getatime(path) 返回path所指向的文件或者目录的最后存取时间
os.path.getmtime(path) 返回path所指向的文件或者目录的最后修改时间
⑧ hashlib
作用：用于加密相关的操作，代替了md5模块和sha模块，主要提供 SHA1, SHA224, SHA256, SHA384, SHA512 ，MD5 算法
例子：
import hashlib
# ######## md5 ########
hash = hashlib.md5()
# help(hash.update)
hash.update(bytes('admin', encoding='utf-8'))
print(hash.hexdigest())
print(hash.digest())
######## sha1 ########
hash = hashlib.sha1()
hash.update(bytes('admin', encoding='utf-8'))
print(hash.hexdigest())
# ######## sha256 ########
hash = hashlib.sha256()
hash.update(bytes('admin', encoding='utf-8'))
print(hash.hexdigest())
# ######## sha384 ########
hash = hashlib.sha384()
hash.update(bytes('admin', encoding='utf-8'))
print(hash.hexdigest())
# ######## sha512 ########
hash = hashlib.sha512()
hash.update(bytes('admin', encoding='utf-8'))
print(hash.hexdigest())
加密算法缺陷，即：通过撞库可以反解。所以，有必要对加密算法中添加自定义key再来做加密
import hashlib
# ######## md5 ########
hash = hashlib.md5(bytes('898oaFs09f',encoding="utf-8"))
hash.update(bytes('admin',encoding="utf-8"))
print(hash.hexdigest())
⑨ random
作用：生成随机变量
import random
checkcode = ''
for i in range(4):
current = random.randrange(0,4)
if current != i:
temp = chr(random.randint(65,90))
else:
temp = random.randint(0,9)
checkcode += str(temp)
print checkcode
⑩ itertools
“无限”迭代器：
count()创建一个无限的迭代器，所以上述代码会打印出自然数序列，根本停不下来，只能按Ctrl+C退出
>>> import itertools
>>> natuals = itertools.count(1)
>>> for n in natuals:
... print(n)
...
1
2
3
...
cycle()会把传入的一个序列无限重复下去：
>>> import itertools
>>> cs = itertools.cycle('ABC') # 注意字符串也是序列的一种
>>> for c in cs:
... print(c)
...
'A'
'B'
'C'
'A'
'B'
'C'
...
repeat()负责把一个元素无限重复下去，不过如果提供第二个参数就可以限定重复次数：
>>> ns = itertools.repeat('A', 3)
>>> for n in ns:
... print(n)
...
A
A
A
无限序列虽然可以无限迭代下去，但是通常我们会通过
takewhile()等函数根据条件判断来截取出一个有限的序列：
>>> natuals = itertools.count(1)
>>> ns = itertools.takewhile(lambda x: x <= 10, natuals)
>>> list(ns)
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
itertools提供的几个迭代器操作函数更加有用：
chain()可以把一组迭代对象串联起来，形成一个更大的迭代器：
>>> for c in itertools.chain('ABC', 'XYZ'):
... print(c)
# 迭代效果：'A' 'B' 'C' 'X' 'Y' 'Z'
groupby()把迭代器中相邻的重复元素挑出来放在一起：
>>> for key, group in itertools.groupby('AAABBBCCAAA'):
... print(key, list(group))
...
A ['A', 'A', 'A']
B ['B', 'B', 'B']
C ['C', 'C']
A ['A', 'A', 'A']
实际上挑选规则是通过函数完成的，只要作用于函数的两个元素返回的值相等，这两个元素就被认为是在一组的，而函数返回值作为组的key。如果我们要忽略大小写分组，就可以让元素'A'和'a'都返回相同的key：
>>> for key, group in itertools.groupby('AaaBBbcCAAa', lambda c: c.upper()):
... print(key, list(group))
...
A ['A', 'a', 'a']
B ['B', 'B', 'b']
C ['c', 'C']
A ['A', 'A', 'a']