标准库介绍

datetime

datetime.datetime.today()    -> 返回本地时区当前时间的datetime对象
datetime.datetime.now(tz=None)     
    -> 返回当前时间的datetime对象，微秒; 如果tz为None返回和today()一样
datetime.datetime.utcnow()  -> 没有时区的当前时间
datetime.datetime.fromtimestamp(timestamp, tz=None)
    -> 从一个时间戳返回一个datetime对象

datetime对象
    datetime.datetime.now().timestamp()
    时间戳：格式威治时间19700101 00:00到现在的秒数
    c = datetime.datetime.now()   -> datetime对象
    c.timestamp()

timedelta对象
    datetime2 = datetime1 + timedelta
    datetime2 = datetime1 - timedelta 
    timedelta = datetime1 - datetime2
    构造方法
    datetime.timedelta(days=0, seconds=0, microseconds=0, milliseconds=0,minutes=0, hours=0, weeks=0)
    year = datetime.timedelta(days=365)

    timedelta.total_seconds()  -> 返回时间差的总秒数

日期格式化
类方法

strptime(date_string, format)   -> datetime object

对象方法

strftime(format)   -> str object

字符串format方法

import datetime
dt = datetime.datetime.strptime("21/11/06 14:30", "%d/%m/%y %H:%M")
print(dt.strftime("%Y-%m-%d %H:%M:%S"))
print('{0:%Y}-{0:%m}-{0:%d} {0:%H}:{0:%M}:{0:%S}'.format(dt))
print('time is {}'.format(dt))

time 

time.sleep(secs)    # 将进程挂起指定的秒数

bookmark: 第二个需要掌握的python特性
bookmark: just do it
bookmark: 解析式、生成器

python解析式、生成器

列表解析式是一种语法糖，编译器会优化，不会因为简写而影响效率，反而因优化提高了效率。

列表解析式 list comprehension

[返回值 for 元素 in 可迭代对象 if 条件] -> list

[(i+1)**2 for i in range(10)]

even = []        # even = [x for x in range(10) if x%2==0]
for x in range(10):
     if x % 2 == 0:
         even.append(x)

[expr for item in iterable if cond1 if cond2]
ret = []
for item in iterable:
    if cond1:
        if cond2:
            ret.append(expr)
[i for i in range(20) if i % 2 == 0 and i%3==0]

[expr for i in iterable for j in iterable2]
ret =[]
for i in iterable1:
    for j in iterable2:
        ret.append(expr)
[(x, y) for x in 'abcde' for y in range(3)]
[[x, y] for x in 'abcde' for y in range(3)]
[{x: y} for x in 'abcde' for y in range(3)]

生成器表达式 generator expression

(返回值 for 元素 in 可迭代对象 if 条件) -> generator

生成器表达式是按需计算(惰性求值、延迟计算), 需要的时候才计算值
列表解析式是立即求值
生成器
    可迭代对象
    迭代器

g = ('{:04}'.format(i) for i in range(1, 11))
next(g)         # next函数获取生成器下一个数
for x in g:
    print(x)
print('~'*20)
for x in g:
    print(x)

g = ['{:04}'.format(i) for i in range(1, 11)]
for x in g:
    print(x)
print('~'*20)
for x in g:
    print(x)

it = (print('{}'.format(i+1)) for i in range(2))    # print语句返回None
first = next(it)    # 返回了None 
second = next(it)
val = first + second
# TypeError: unsupported operand type(s) for +: 'NoneType' and 'NoneType'

it  = (x for x in range(10) if x % 2)
first = next(it)
second = next(it)
val = first + second
next(it)

生成器表达式、列表解析式对比

计算方式

生成器表达式延迟计算，列表解析式立即计算

内存占用

从返回值来说，生成器省内存，列表解析式返回新的列表
生成器没有数据，内存占用极少，但是使用的时候，虽然一个个返回数据，但是合起来占用的内存也差不多
列表解析式构造新的列表需要占用内存

计算速度

单看计算时间，生成器表达式耗时非常短，列表解析式耗时长
但是生成器本身并没有返回任何值，只返回了一个生成器对象
列表解析式构造并返回了一个新的列表

In [14]: %timeit [x for x in range(50000)]
2.03 ms ± 37.7 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)

In [15]: %timeit (x for x in range(50000))
712 ns ± 13.8 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)

集合解析式

{返回值 for 元素 in 可迭代对象 if 条件} -> set()

{(x, x+1) for x in range(10) }
{[x] for x in range(10)}    
# TypeError: unhashable type: 'list'   列表不可hash, 不可以做key

字典解析式

{返回值 for 元素 in 可迭代对象 if 条件} -> dict
注意:使用key:value

{x:(x, x+1) for x in range(10)}
{x:[x, x+1] for x in range(10)}
{(x,):[x, x+1] for x in range(10)}
{[x]:[x, x+1] for x in range(10)}   # TypeError: unhashable type: 'list'
{chr(0x41+x):x**2 for x in range(10)   }
{str(x):y for x in range(3) for y in range(4) }

ret = {}
for x in range(3):
    for y in range(4):
        ret[str(x)] =y

总结

python2 引入列表解析式
python2.4 引入生成器表达式
pytohn3  引入集合、字典解析式，并迁移到2.7 
生成器和迭代器是不同的对象，但是都是可迭代的对象

python解析式对比

列表解析式       [返回值 for 元素 in 可迭代对象 if 条件] -> list         python2+
生成器表达式      (返回值 for 元素 in 可迭代对象 if 条件) -> generator   python2.4+
集合解析式       {返回值 for 元素 in 可迭代对象 if 条件} -> set()        python2.7+
字典解析式       {返回值 for 元素 in 可迭代对象 if 条件} -> dict         python2.7+

python内置函数

isinstance(obj, class_or_tuple)         isinstance(True, int)
issubclass(cls, class_or_tuple)         issubclass(bool, int)
abs(x)
max()
min()
round(x)  四舍六入五取最近的偶数
divmod(x, y)  等价 tuple(x//y, x%y)
sum(iterable[, start])  返回start起始的iterable对象的和
chr(97) -> 'a'  返回指定数的对应的字符
ord('c') -> 99  返回对应字符的整数   ordinal 序数
str()
repr()
ascii()

迭代器

生成器、迭代器对比

random.sample(population, k) 从样本空间或者总体（序列或者集合类型）中随机取出k个不同的元素，返回一个新的列表