解析式/推导式, 生成器 datetime 内建函数

列表解析式(List Comprehension)

       语法:

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

       使用中括号[],内部是for循环,if条件可选.

       返回一个新的列表.

    列表解析式的作用:

       编译器会优化,不会因为简写而影响效率,反而因优化提高了效率.

       减少程序员工作量,减少出错.

       简化代码,增强可读性.

    注意:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33

In [26]: newlist = [print(i) for i in range(10)] 0 1 2 3 4 5 6 7 8 9   In [27]: newlist Out[27]: [None, None, None, None, None, None, None, None, None, None]   In [28]: newlist = [i for i in range(10)]   In [29]: newlist Out[29]: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]   -----------------------------------------------------------------------------------------------------------------------   In [30]: [i for i in range(20) if i%2 == 0 elif i%3 == 0]  # 列表解析式里面不包括else, elif.   File "<ipython-input-30-9cc81af30c39>", line 1     [i for i in range(20) if i%2 == 0 elif i%3 == 0]                                          ^ SyntaxError: invalid syntax     In [31]: [i for i in range(20) if i%2 == 0 and i%3 == 0] Out[31]: [0, 6, 12, 18]   In [32]:

       举例: 生成一个列表,元素0~9,对每一个元素自增1后求平方并返回新列表.

   

1 2 3 4 5 6 7 8

In [23]: for i in range(10):     ...:     lst.append((i+1)**2)     ...:   In [24]: lst Out[24]: [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]   In [25]:

使用列表解析式:  

1 2 3 4

In [25]: [(i+1)**2 for i in range(10)] Out[25]: [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]   In [26]:

列表解析式进阶

       [返回值 for 元素 in 可迭代对象 if 条件1 if 条件2]

    [返回值 for 元素 in 可迭代对象 for 元素1 in 可迭代对象1]

列表解析式练习

       xxx

生成器表达式(Generator expression)

       语法: (返回值 for 元素 in 可迭代对象 if 条件).

    使用小括号(). 

    返回一个生成器.

   

    和列表解析/推导式的区别:

       生成器表达式是按需计算(或称惰性求值,延迟计算),需要的时候才计算值.

       列表解析式是立即返回值.

    生成器:

       可迭代对象

       迭代器

    生成器表达式和列表解析式比较:  

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27

In [32]: g = ("{:04}".format(i) for i in range(1, 5))   In [33]: g Out[33]: <generator object <genexpr> at 0x000001D487ECA570>   In [34]: next(g) Out[34]: '0001'   In [35]: for x in g:     ...:     print(x)     ...: 0002 0003 0004   In [36]: for x in g:     ...:     print(x)     ...:   In [37]:   总结: 延迟计算. 返回迭代器,可以迭代. 从前到后走完一遍后,不能回头.

In [39]: g = ["{:04}".format(i) for i in range(1, 5)]   In [40]: g Out[40]: ['0001',  '0002',  '0003',  '0004',]   In [41]: for x in g:     ...:     print(x)     ...: 0001 0002 0003 0004   In [42]: ...       总结: 立即计算. 返回的不是迭代器,返回可迭代对象列表. 从前到后走完一遍后,可以重新回头迭代.

    总结:

生成器表达式 vs 列表解析式: 

计算方式:

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

内存占用:

        从返回值本身:生成器表达式省内存,列表解析式返回新的列表.

        生成器没有数据,内存占用极少,但是使用时,虽然一个个返回返回数据,但是合起来占用内存和列表解析式也差不多.

       列表解析式构造新的列表需要占用内存.

    计算速度:

       但看计算时间,生成器表达式耗时非常短,列表解析式耗时长.

       生成器本身并没返回任何值,只返回了一个生成器对象.

       列表解析式构造并返回了一个新的列表.

集合解析式

       语法: {返回值 for 元素 in 可迭代对象 if 条件}

    使用大括号{}.

    立即返回一个集合. 

    用法:

       {(x,x+1) for x in range(10)}

       {[x] for x in range(10)}

字典解析式

       语法: {返回值 for 元素 in 可迭代对象 if 条件}

    使用大括号{}. 

    使用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)}

{chr(0x41+x):x**2 for x in range(10)}

    注:

1 2 3 4 5 6 7 8 9 10 11 12 13

In [45]: {str(x):y for x in range(3) for y in range(4)} Out[45]: {'0': 3, '1': 3, '2': 3}   # 等价于:   dic = {} for x in range(3):     for y in range(4):         dic[str(x)] = y print(dic)

    总结:

       python2引入列表解析式.

       python2.4引入生成器表达式.

       python3引入集合,字典解析式,并迁移到2.7

       一般来说,应多用解析式,简短高效.

       如果一个解析式非常复杂,难读懂,要考虑拆解for循环.

       生成器和迭代器都是不同的对象,但都是可迭代对象.

标准库-datetime

datetime模块

       对日期,时间,时间戳的处理.

    datetime类:

       类方法:

           today() 返回本地时区当前时间的datetime对象.

           now(tz=None) 返回当前时间的datetime对象,时间到微妙,如果tz为None,返回和today()一样.

           utcnow() 没有时区的当前时间.

           fromtimestamp(timestamp,tz=None) 从一个时间戳返回一个datetime对象.

       datetime对象:

           timestamp()返回一个到微妙的时间戳.

              时间戳: 格林威治时间1970/01/01 0点到现在的秒数.

1 2 3 4 5 6 7

# datetime.datetime.now().timestamp() 返回带微秒的时间戳. In [47]: import datetime   In [48]: datetime.datetime.now().timestamp() Out[48]: 1507374681.008979   In [49]:

datetime对象

       构造方法: datetime.datetime(2016,12,6,16,29,43,79043)

    year, month, day, hour, minute, second, microsecond,取datetime对象的年月日时分秒及微妙.

    weekday() 返回星期的天, 周一0, 周日6.

    date() 返回日期date对象.

    time() 返回时间time对象.

    replace() 修改并返回新的时间. 

    isocalendar() 返回一个三元组(年,周数,周的天)

日期格式化

       类方法 strptime(date_string, format), 返回datetime对象.

    对象方法 strftime(format), 返回字符串.

    字符串format函数格式化.

time

time.sleep(secs) 将调用线程挂起来指定的秒数.

内建函数

    标识id: 返回对象的唯一标识,Cpython返回内存地址. 

    哈希hash(): 返回一个对象的哈希值.

    类型type(): 返回对象的类型.

    类型转换:float(),int(),bin(),hex(),oct(),bool(),list(),tuple(),dict(),set(),complex,bytes(),bytearray().

    输入input([prompt]): 接收用户输入,返回一个字符串.

    打印print(*object,sep='', end=' ',file=sys.stdout,flush=False)

       打印输出,默认使用空格分割,换行结尾,输出到控制台.

    对象长度len(s): 返回一个集合类型的元素个数.

    isinstance(obj,class_or_tuple): 判断对象obj是否属于某种类型或者元组中列出的某个类型.

       isinstance(True, int)

    issubclass(cls,class_or_tuple): 判断类型cls是否是某种类型的子类或元组中列出的耨个类型的子类.

       issubclass(bool, int)

    绝对值obs(x): x为数值.

    最大值max(), 最小值min()

       返回iterable对象中的最大或最小值.

       返回多个参数中的最大或最小值.

    round(x)

    pow(x, y): 等价于x**y.

    range()

    divmod(x, y): 等价于tuple(x//y,x%y)

    sum(iterable[,start]): 求和.

    chr(i): 给一个一定范围的整数返回对应的字符. 如chr(97), chr(2003).

    ord(c): 返回字符对应的整数. 如ord('a'), ord('中').

    str(), repr(), ascii()

    sorted(): 排序.

    reversed(): 翻转.

    enumerate(): 枚举.

    iter(iterable): 迭代器

    next(iterator): 从一个迭代器中取元素,如果元素都取过了,再次取会抛异常Stopiteration.

可迭代对象

            能够通过迭代一次次返回不同的元素的对象.所谓相同不是指值是否相同,二是元素在容器中是否是同一个,例如列表中值可以重复.

       可以迭代,但是未必有序,未必可索引.

       可迭代对象: list,tuple,str,bytes,bytearray,range,set,dict,iterator.

       可以使用成员操作符in和not in,in本质上就是在遍历对象.       

1 2 3 4 5 6 7 8 9 10 11 12

In [1]: p = (x for x in range(10)) In [2]: p Out[2]: <generator object <genexpr> at 0x00000178FEC46A98> In [3]: 3 in p Out[3]: True In [4]: 11 in p Out[4]: False In [5]:

迭代器

       特殊的对象,一定是可迭代对象,具备可迭代对象的特征.

       通过iter方法把一个可迭代对象封装成迭代器.

       通过next方法,迭代 迭代器对象.

       生成器对象,就是迭代器对象.

拉链函数-zip

    拉链函数zip(*iterables)

    像拉链一样,把多个可迭代对象合并在一起,返回一个迭代器.

    将每次从不同对象中渠道的元素合并成一个元组.

1 2 3 4

In [30]: list(zip(range(10), range(10), range(5), range(10))) Out[30]: [(0, 0, 0, 0), (1, 1, 1, 1), (2, 2, 2, 2), (3, 3, 3, 3), (4, 4, 4, 4)]   In [31]: