内置函数
标准库，namespace名称空间；
datetime，对日期、时间、时间戳的处理：
datetime类：类方法；datetime对象；
类方法：
today()，返回本地时区当前时间的datetime对象；
now(tz=None)，返回当前时间的datetime对象，时间到微秒，如果tz为None，返回和today()一样；
utcnow()，没有时区的当前时间；
fromtimestamp(timestamp,tz=None)，从一个时间戳返回一个datetime对象；
datetime对象：
timestamp()，返回一个到微秒的时间戳；
构造方法：
In [14]: a=datetime.datetime(2018,3,26,19,12,29,79043) #year,month,day,hour,minute,second,microsecond，取datetime对象的年月日时分秒微秒
In [15]: a
Out[15]: datetime.datetime(2018, 3, 26, 19, 12, 29, 79043)
In [16]: a=datetime.datetime(2018,3,26) #至少要给year,month,day，hour,minute会补0
In [17]: a
Out[17]: datetime.datetime(2018, 3, 26, 0, 0)
weekday()，返回星期的天，周一0，周日6，如a.weekday()；
isoweekday()，返回星期的天，周一1，周日7，如a.isoweekday()；
date()，返回日期date对象，a,date()；
time()，返回时间time对象，a.time()；
replace()，修改并返回新的时间；
isocalendar()，返回一个三元组（年、周数、周的天），a.isocalendar()；
注：
编程时一般都不设置时区；
时间戳，格林威治时间1970-1-1，0点到现在的秒数，与时区无关；
例：
In [1]: import datetime
In [2]: datetime.datetime.now()
Out[2]: datetime.datetime(2018, 3, 26, 19, 3, 12, 8146)
In [3]: datetime.datetime.today()
Out[3]: datetime.datetime(2018, 3, 26, 19, 3, 23, 298291)
In [4]: datetime.datetime.utcnow()
Out[4]: datetime.datetime(2018, 3, 26, 11, 3, 42, 720141)
In [5]: a=datetime.datetime.now()
In [6]: a.timestamp()
Out[6]: 1522062256.146931
In [7]: type(a)
Out[7]: datetime.datetime
In [8]: a=a.timestamp()
In [9]: type(a)
Out[9]: float
In [10]: b=datetime.datetime.fromtimestamp(a)
In [11]: b
Out[11]: datetime.datetime(2018, 3, 26, 19, 4, 16, 146931)
In [12]: b=datetime.datetime.fromtimestamp(int(a)) #微秒丢了
In [13]: b
Out[13]: datetime.datetime(2018, 3, 26, 19, 4, 16)
In [14]: a=datetime.datetime(2018,3,26,19,12,29,79043)
In [15]: a
Out[15]: datetime.datetime(2018, 3, 26, 19, 12, 29, 79043)
In [16]: a=datetime.datetime(2018,3,26)
In [17]: a
Out[17]: datetime.datetime(2018, 3, 26, 0, 0)
In [18]: a.weekday()
Out[18]: 0
In [19]: a.isoweekday()
Out[19]: 1
In [20]: a.date()
Out[20]: datetime.date(2018, 3, 26)
In [21]: a.time()
Out[21]: datetime.time(0, 0)
In [22]: a.isocalendar()
Out[22]: (2018, 13, 1)
日期格式化：
类方法，datetime.datetime.strptime(date_string,format)，返回datetime对象，new datetime parsed from a string；
对象方法，a.strftime(format)，返回字符串，string format；
字符串format函数格式化；
例：
In [37]: dt=datetime.datetime.strptime('27/3/18 9:30','%d/%m/%y %H:%M') #类方法，返回datetime对象，%y（小写短的），%Y（大写长的）
In [38]: dt
Out[38]: datetime.datetime(2018, 3, 27, 9, 30)
In [39]: dt.strftime('%Y-%m-%d %H:%M:%S') #对象方法
Out[39]: '2018-03-27 09:30:00'
In [40]: '{0:%Y}/{0:%m}/{0:%d} {0:%H}:{0:%M}:{0:%S}'.format(dt) #要加0，否则位置对不上
Out[40]: '2018/03/27 09:30:00'
In [41]: '{}/{}/{}'.format(dt.year,dt.month,dt.day) #常用
Out[41]: '2018/3/27'
timedelta对象，时间差对象：
构造方法：datetime.timedelta(days=0,seconds=0,microseconds=0,milliseconds=0,minutes=0,hours=0,weeks=0)
year=datetime.timedelta(days=365)
total_seconds()，返回时间差的总秒数；
例：
In [44]: d=datetime.timedelta(days=1) #构造时间差为1天
In [45]: d
Out[45]: datetime.timedelta(1)
In [46]: h=datetime.timedelta(hours=24) #构造时间差为1天
In [47]: h
Out[47]: datetime.timedelta(1)
In [48]: datetime.datetime.now()-d
Out[48]: datetime.datetime(2018, 3, 26, 10, 4, 0, 842544)
In [49]: d1=datetime.datetime.now()
In [50]: d2=datetime.datetime.now()
In [51]: td=d2-d1
In [52]: td.total_seconds()
Out[52]: 8.391767
In [53]: (datetime.datetime.now()-d1).total_seconds()
Out[53]: 72.024944
标准库，time；
id()，标识，返回对象的唯一标识，cpython返回内存地址；
hash()，哈希，返回一个对象的哈希值，散列值（定义域、值域、哈希空间、散列空间、根据哈希算法，哈希冲突少的算法好）；
type()，类型，返回对象的类型；
float(),int(),bin(),hex(),oct(),bool(),list(),tuple(),dict(),set(),complex(),bytes(),bytearray()，类型转换；
input([prompt])，输入，接收用户输入，返回一个字符串；
print(*objects,sep=' ',end='\n',file=sys.stdout,flush=False)，打印，打印输出，默认使用空格分割，换行结尾，输出到控制台；
len()，对象长度，返回一个集合类型的元素个数；
isinstance(obj,class_or_tuple)，判断对象是否属于某种类型或元组中列出某个类型；
issubclass(cls,class_or_tuple)，判断类型cls是否是某种类型的子类或元组中列出的某个类型的子类；
In [4]: issubclass(bool,int)
Out[4]: True
abs(num)，绝对值，num为数值；
max(),min()，返回可迭代对象中最大值和最小值，返回多个参数中最大值和最小值；
round(num)，四舍六入五取偶，银行家算法；
pow(x,y)，等价于x**y；
range(stop)，从0开始到stop-1的可迭代对象，不是迭代器；
range(start,stop[,step])，从start开始到stop-1结束步长为step的可迭代对象；
divmod(x,y)，等价于tuple(x//y,x%y)，divmod(3,5)；
sum(iterable[,start])，对可迭代对象的所有数值元素求和，sum(range(1,100,2)，累加；
chr(i)，给一个一定范围的整数返回对应的字符，Return a Unicode string of one character with ordinal i; 0 <= i <= 0x10ffff.；
ord(c)，返回字符对应的整数，Return the Unicode code point for a one-character string.；
str()，呈现字符串的表达形式，__str__()魔术方法；
repr(),ascii()；
例：
In [1]: isinstance(False,(bool,int,str))
Out[1]: True
In [2]: isinstance(False,int)
Out[2]: True
In [3]: isinstance(True,int)
Out[3]: True
In [5]: round(-0.5)
Out[5]: 0
In [6]: round(-0.6)
Out[6]: -1
In [7]: round(-0.4)
Out[7]: 0
In [8]: divmod(3,5)
Out[8]: (0, 3)
In [9]: sum(range(1,100,2))
Out[9]: 2500
In [10]: sum(range(1,100,2),50) #起始数先加进来
Out[10]: 2550
In [14]: chr(97)
Out[14]: 'a'
In [15]: chr(20013)
Out[15]: '中'
In [16]: ord('a')
Out[16]: 97
In [17]: ord('中')
Out[17]: 20013
In [18]: ord('国')
Out[18]: 22269
In [19]: hex(ord('国'))
Out[19]: '0x56fd'
In [20]: str(5)
Out[20]: '5'
In [21]: repr(5)
Out[21]: '5'
In [22]: ascii(5)
Out[22]: '5'
In [23]: ascii('a')
Out[23]: "'a'"
In [24]: str('a')
Out[24]: 'a'
In [25]: repr('a')
Out[25]: "'a'"
sorted(iterable[,key][,reverse])-->list，排序，返回一个新列表，默认升序，reverse反转；如果lst.sort()在列表上用sort()方法是就地修改，返回值为None，a=lst.sort()相当于a=None这样写没意义；
reversed(seq)-->list_reverseiterator，返回一个翻转元素的迭代器；
enumerate(seq,start=0)-->iterator for index,iterator for value，迭代一个序列，返回索引数字和元素构成的二元组，start索引开始的数字，默认0；
iter(iterable)，将一个可迭代对象封装成一个迭代器；
next(iterator)，取元素，对一个迭代器取下一个元素，如果元素全部取完，再next()会抛StopIteration异常；
zip(*iterables)，拉链函数，像拉链一样，把多个可迭代对象合并在一起，返回一个迭代器，将每次从不同对象中取到的元素合并成元组，一般用于dict，dict(zip('abcde',range(5)))木桶原理；
可迭代对象：
能够通过迭代一次次返回不同元素的对象，所谓相同不是指值是否相同，而是元素在容器中是否是同一个，如list中值可重复；
可以迭代，但是未必有序，未必可索引；
可迭代对象有，list,tuple,string,bytes,bytearray,range,set,dict,iterator等；
可用成员运算符in,not in，in本质上就是在遍历对象；
迭代器：
特殊的对象，一定是可迭代对象，具备可迭代对象的特征；
通过iter(iterable)把一个可迭代对象封装成迭代器；
通过next()迭代迭代器对象；
生成器对象，就是迭代器对象；
迭代器不一定是生成器；
例：
In [30]: lst=[3,1,5]
In [31]: sorted(lst)
Out[31]: [1, 3, 5]
In [32]: sorted(lst,reverse=True)
Out[32]: [5, 3, 1]
In [33]: a=sorted(lst,reverse=True)
In [34]: a
Out[34]: [5, 3, 1]
In [36]: sorted({'b':2,'a':1}) #只对dict的key排序
Out[36]: ['a', 'b']
In [37]: a=reversed([3,5,1])
In [38]: a
Out[38]: <list_reverseiterator at 0x7fa0dd064c50>
In [39]: next(a)
Out[39]: 1
In [40]: next(a)
Out[40]: 5
In [41]: next(a)
Out[41]: 3
In [42]: [reversed([3,5,1])] #不是列表解析，是list_reverseiterator
Out[42]: [<list_reverseiterator at 0x7fa0dd061518>]
In [43]: [i for i in reversed([3,5,1])] #列表解析
Out[43]: [1, 5, 3]
In [44]: {reversed((2,4))} #该集合元素几个？1个，仅list_reverseiterator对象本身
Out[44]: {<reversed at 0x7fa0dd064668>}
In [45]: (reversed(['c','b','a'])) #最外层()没用，reversed(seq)本身返回的就是迭代器对象
Out[45]: <list_reverseiterator at 0x7fa0dcfe9eb8>
In [49]: for i in reversed(sorted({1,5,9})): #反转中间结果
...: print(i)
...:
9
5
1
In [50]: for i in enumerate([2,4,6]):
...: print(i)
...:
(0, 2)
(1, 4)
(2, 6)
In [52]: for k,v in enumerate('mno'): #解构
...: print(k,v)
...:
...:
0 m
1 n
2 o
In [61]: it=iter(range(2))
In [62]: next(it)
Out[62]: 0
In [63]: next(it)
Out[63]: 1
In [64]: next(it)
---------------------------------------------------------------------------
StopIteration Traceback (most recent call last)
<ipython-input-64-bc1ab118995a> in <module>()
----> 1 next(it)
StopIteration:
In [65]: 3 in range(10)
Out[65]: True
In [66]: 3 in (x for x in range(10))
Out[66]: True
In [67]: 3 in {x:y for x,y in zip(range(4),range(4,10))} #匹配key
Out[67]: True
In [71]: {x:y for x,y in zip('abcd',range(4))}
Out[71]: {'a': 0, 'b': 1, 'c': 2, 'd': 3}
In [72]: {x:y for x,y in zip('abcd',range(5,20))} #zip()，木桶原理
Out[72]: {'a': 5, 'b': 6, 'c': 7, 'd': 8}
In [73]: for i in iter(range(3)): #可这样用
...: print(i)
...:
0
1
2
In [74]: g=(i for i in range(4))
In [75]: g
Out[75]: <generator object <genexpr> at 0x7fa0dda6dfc0>
In [76]: print(type(g))
<class 'generator'>
In [77]: list(zip('abcd',range(4)))
Out[77]: [('a', 0), ('b', 1), ('c', 2), ('d', 3)]
In [78]: list(zip('abcd',range(4),'efgh',range(5,9)))
Out[78]: [('a', 0, 'e', 5), ('b', 1, 'f', 6), ('c', 2, 'g', 7), ('d', 3, 'h', 8)]
In [79]: dict(zip('abcde',range(5)))
Out[79]: {'a': 0, 'b': 1, 'c': 2, 'd': 3, 'e': 4}
In [86]: {str(x):y for x,_,y in zip(range(10),range(10),range(10,20))}
Out[86]:
{'0': 10,
'1': 11,
'2': 12,
'3': 13,
'4': 14,
'5': 15,
'6': 16,
'7': 17,
'8': 18,
'9': 19}
In [87]: d=dict(zip('abcd',range(4)))
In [88]: d
Out[88]: {'a': 0, 'b': 1, 'c': 2, 'd': 3}
In [89]: d1=sorted(d.items(),reverse=True) #对二元组排序
In [90]: d1
Out[90]: [('d', 3), ('c', 2), ('b', 1), ('a', 0)]
注：
内置函数：map、filter、reversed、enumerate；
decorator；
generator；
mro中的mixin；
以上用的出神入化，中级水平；
