生成器、BIF

列表解析式

列表解析式是一种利用 [ 表达式 + for 循环 [ + if判断 ] ] 快速生成列表对象的python语法，方便使用者快速构建列表。
语法：

# 列表解析式   第一种效率会明显高于第二种
[(i,j) for i in range(1000) if i > 700 for j in range(1000) if j > 900]
[{i,j} for i in range(1000) for j in range(1000) if j>900 if i > 700]

集合解析式

#  注：其中的元素必须可哈希,不允许是列表，字典，set()等不可哈希对象，否则将会报错
{ (i,j) for i in range(1000) if i > 700 for j in range(1000) if j > 900 }

生成器表达式

it = (i for i in range(10))          #将会返回一个生成器对象

生成器对象

一个可以做指定操作，并在每次next()时返回一个值的对象，节省空间存放数据，但每次计算需要等待.

迭代器对象

一个可以被迭代的对象，for 将会全部迭代其中的元素，也可使用next()一个个取值返回，迭代器只可以使用一轮，无法反复使用，生成器也是一个迭代器

可迭代对象

可以被迭代的对象，例如元组，字典，集合，列表等容器，生成器和迭代器也是可迭代对象

内置函数(BIF)

# len()：返回集合类型的长度，注：无法计算生成器或迭代器的长度，可计算list，set，dict等集合的长度
# len((i for i in range(5)))       # ==> TypeError:object of type 'generator' has no len()  计算生成器的长度

isinstance(True, int), issubclass(bool, int) # 实例判断，子类判断
divmod(124,3)                       #  ==>   (124/3, 124%3)==(41, 1)
chr(97)                                  # ==>  int(0-255) --> char
ord("a")                                 # ==>  char  --> int
hex(ord("中"))                       # 中文使用的是unicode编码表对应关系, 两字节长度 '0x4e2d'

# 排序  迭代内部容器，默认升序并返回排序后的列表，set和dict也可排序，迭代器也可排序
sorted([1,2,3] + ['a'],reverse=True, key=str )   # 临时转化类型进行比较,原值不会改变，123还是int类型 ['a', 3, 2, 1]
a = iter("abcd")        # 对迭代器排序，会遍历整个迭代器，返回一个排序好的列表；
sorted(a)                 # ['a', 'b', 'c', 'd']

返回迭代器的BIF

# reversed(seq)                                    # 翻转一个有序容器，set和dict无法翻转 ==> 返回一个翻转后的迭代器，单个对象
[ i for i in reversed("abcd") ]                   # ==> ['d', 'c', 'b', 'a']
it = reversed(sorted({1,49,0,6,7,8,}))    # ==> <list_reverseiterator at 0x212dce3ccf8>
print( [ i for i in it ] )                                  # 遍历迭代器 [49, 8, 7, 6, 1, 0]

# 枚举：enumerate(seq, start=0) # ==> 返回一个迭代器，每次返回一个二元组==> (index, elem)
en = enumerate([1,2,3,4,5])
next(en)                           # ==> (0, 1)
next(en)                          # ==>(1, 2)
print([i for i in en])          #  [(2, 3), (3, 4), (4, 5)] 完全遍历

# 迭代器
iter(iterable)                                 # ==> 返回一个迭代器
iter(callable, sentinel)                  #   ==> iterator
def fun():
    x = 0 
    def fun1():
        nonlocal x
        x += 1
        return x
    return fun1
f = fun()
it = iter(f, 7)             # == > f 必须可调用，0参，当返回值等于 sentinel 结束
[i for i in it]               # == > [1,2,3,4,5,6] 

# 文件读取操作时的使用
with open('mydata.txt') as fp:
    for line in iter(fp.readline, ''):
        process_line(line)

from functools import partial
with open('somefile.data', 'rb') as f:
    records = iter(partial(f.read, RECORD_SIZE), b'')
    for r in records:
            pass
# iter() 函数有一个鲜为人知的特性，如果你给它传递一个可调用对象和一个标记值，它
# 会创建一个迭代器。这个迭代器会一直调用传入的可调用对象直到它返回标记值为止
# 可迭代对象，包括：set, dict, 生成器，string，range(), 

# in, not in 
# 执行in操作，对于线性顺序结构来说，本质上就是对其进行遍历
# 生成器和迭代器也可以进行 in 操作
a = iter("abcd")   
"a" in a             # ==> True， 遍历到第一个元素找到 "a", 迭代器为使用完，可以继续使用
next(a)             # ==> 继续使用返回下一个 ==>  'b'

# zip() 
for i in zip(range(5), "abcde"):
    print(i ,end=" ")       #==>  (0, 'a') (1, 'b') (2, 'c') (3, 'd') (4, 'e')输出结果使用enumerate()一样