python高级特性之切片，迭代，列表推导式，生成器，迭代器

1.列表，字符串切片

注意 [a : b ] 包头不包尾

　　倒数第一个元素的索引值是-1

　　字符串'abc'也可以看成是一种list，每个元素就是一个字符。因此，字符串也可以用切片操作，结果仍是字符串：

例子

>>> L = list(range(100))
>>> L
[0, 1, 2, 3, ..., 99]

#前11-20个数
>>> L[10:20]
[10, 11, 12, 13, 14, 15, 16, 17, 18, 19]

#前10个数，每两个取一个：
>>> L[:10:2]
[0, 2, 4, 6, 8]

#字符串切片
>>> 'ABCDEFG'[::2]
'ACEG'

 

Python没有针对字符串的截取函数，只需要切片一个操作就可以完成。Python的切片非常灵活，一行代码就可以实现很多行循环才能完成的操作。有了切片操作，很多地方循环就不再需要了，例如借助负数索引。

2.迭代

如果给定一个list或tuple，我们可以通过for循环来遍历这个list或tuple，这种遍历我们称为迭代（Iteration）

Python的for循环抽象程度要高于C的for循环，因为Python的for循环不仅可以用在list或tuple上，还可以作用在其他可迭代对象上。

list这种数据类型虽然有下标，但很多其他数据类型是没有下标的，但是，只要是可迭代对象，无论有无下标，都可以迭代，比如dict就可以迭代：

>>> d = {'a': 1, 'b': 2, 'c': 3}
>>> for key in d:
...     print(key)
...
a
c
b

因为dict的存储不是按照list的方式顺序排列，所以，迭代出的结果顺序很可能不一样。

默认情况下，dict迭代的是key。如果要迭代value，可以用for value in d.values()，如果要同时迭代key和value，可以用for k, v in d.items()。

字符串也是可迭代对象，因此也可以作用于for循环：

所以，当我们使用for循环时，只要作用于一个可迭代对象，for循环就可以正常运行，而我们不太关心该对象究竟是list还是其他数据类型。

那么，如何判断一个对象是可迭代对象呢？方法是通过collections模块的Iterable类型判断：-----------------判断对象是否是iterable类的实例！isinstance

>>> #from collections import Iterable
>>>　　from collections.abc import Iterable    #弃用警告：从collections中导入ABCs已被弃用，并在python3.8中将停止工作，可使用collections.abc代替它进行使用>>> isinstance('abc', Iterable) # str是否可迭代
True
>>> isinstance([1,2,3], Iterable) # list是否可迭代
True
>>> isinstance(123, Iterable) # 整数是否可迭代
False

如果要对list实现类似Java那样的下标循环怎么办？Python内置的enumerate函数可以把一个list变成索引-元素对，这样就可以在for循环中同时迭代索引和元素本身：

>>> for i, value in enumerate(['A', 'B', 'C']):
...     print(i, value)
...
0 A
1 B
2 C

上面的for循环里，同时引用了两个变量，在Python里是很常见的~~~~~

3.列表生成式　　　List Comprehensions　　　　

是Python内置的非常简单却强大的可以用来创建list的生成式

range()函数

列表推导式是通过一个可迭代对象来生成列表的,range()可以说是列表推导式中最常用的可迭代对象了 ；对列表推导式来说,range()是其中的精髓之一

注意　　range(a , b)  包头不包尾

列表推导式

复杂点的列表推导式:

# in后面跟其他可迭代对象,如字符串
list_c = [7 * c for c in "python"]
print(list_c)
 
# 带if条件语句的列表推导式
list_d = [d for d in range(6) if d % 2 != 0]
print(list_d)
 
# 多个for循环
list_e = [(e, f * f) for e in range(3) for f in range(5, 15, 5)]
print(list_e)
 
# 嵌套列表推导式,多个并列条件                     　　　　　　　　　　　　　　　　　　　　　　　　 ------>>可以进行嵌套的列表推导,与嵌套for循环的原理相同.
list_g = [[x   for x in range(g - 3, g)] for g in range(22)   if g % 3 == 0 and g != 0] 
print(list_g)


#运行结果

['ppppppp', 'yyyyyyy', 'ttttttt', 'hhhhhhh', 'ooooooo', 'nnnnnnn']
[1, 3, 5]
[(0, 25), (0, 100), (1, 25), (1, 100), (2, 25), (2, 100)]
[[0, 1, 2], [3, 4, 5], [6, 7, 8], [9, 10, 11], [12, 13, 14], [15, 16, 17], [18, 19, 20]]    

for循环其实可以同时使用两个甚至多个变量，比如dict的items()可以同时迭代key和value：

>>> d = {'x': 'A', 'y': 'B', 'z': 'C' }
>>> for k, v in d.items():
...     print(k, '=', v)
...
y = B
x = A
z = C

因此，列表生成式也可以使用两个变量来生成list：

>>> d = {'x': 'A', 'y': 'B', 'z': 'C' }
>>> [k + '=' + v for k, v in d.items()]
['y=B', 'x=A', 'z=C']

if ... else

跟在for后面的if是一个筛选条件，不能带else，否则如何筛选？

for前面的部分是一个表达式，它必须根据x计算出一个结果。因此，表达式：x   if x % 2 == 0，它无法根据x计算出结果，因此缺少else，必须加上else 

总结：在一个列表生成式中，for前面的if ... else是表达式，而for后面的if是过滤条件，不能带else

注意

列表推导式有自己的局部作用域,就像函数似的.表达式内部的变量和赋值只在局部起作用，表达式的上下文里的同名变量还可以被正常引用，局部变量并不会影响到它们.

也就是说,列表推导不会有变量泄漏的问题,在列表推导中的赋值操作不可能会影响到列表推导上下文中的同名变量.

也不是所有场景都推荐使用列表推导式.比如说:如果列表推导的代码超过了两行,就要考虑改成用for循环了.超过了两行的列表推导式就真的没有可读性了.通常的原则是，只用列表推导来创建新的列表，并且尽量保持简短.

字典推导式

# 因为key唯一,所以最后value都是1 被最后一个值覆盖
dict_a = {key: value for key in 'python' for value in range(2)}
print(dict_a)
 
# 可以根据键来构造值
dict_b = {key: key * key for key in range(6)}
print(dict_b)
 
# 遍历一个有键值关系的可迭代对象
list_phone = [('HUAWEI', '华为'), ('MI', '小米'), ('OPPO', 'OPPO'), ('VIVO', 'VIVO')]
dict_c = {key: value for key, value in list_phone}
print(dict_c)


#输出结果

{'p': 1, 'y': 1, 't': 1, 'h': 1, 'o': 1, 'n': 1}
{0: 0, 1: 1, 2: 4, 3: 9, 4: 16, 5: 25}
{'HUAWEI': '华为', 'MI': '小米', 'OPPO': 'OPPO', 'VIVO': 'VIVO'}

集合推导式

# 遍历一个可迭代对象生成集合
set_a = {value for value in '有人云淡风轻,有人负重前行'}
print(set_a)

#结果
{'负', '有', '人', '轻', '前', '云', '重', ',', '淡', '风', '行'}

集合是无序且不重复的,所以会自动去掉重复的元素,并且每次运行显示的顺序不一样.

参考　　https://blog.csdn.net/weixin_43790276/article/details/90247423

　　　　

4.生成器 generator  --生成器就是一类特殊的迭代器

如果列表元素可以按照某种算法推算出来，那我们是否可以在循环的过程中不断推算出后续的元素呢？这样就不必创建完整的list，从而节省大量的空间。

在Python中，这种一边循环一边计算的机制，称为生成器：generator。

创建一个generator：

第一种方法很简单，只要把一个列表生成式的[]改成()，就创建了一个generator：

>>> L = [x * x for x in range(10)]
>>> L
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
>>> g = (x * x for x in range(10))
>>> g
<generator object <genexpr> at 0x1022ef630>

我们可以直接打印出list的每一个元素，但怎么打印出generator的每一个元素呢？

如果要一个一个打印出来，可以通过next()函数获得generator的下一个返回值：

>>> next(g)
0
>>> next(g)
1
>>> next(g)
4
>>> next(g)
9
>>> next(g)
16
>>> next(g)
25
>>> next(g)
36
>>> next(g)
49
>>> next(g)
64
>>> next(g)
81
>>> next(g)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
StopIteration

generator保存的是算法，每次调用next(g)，就计算出g的下一个元素的值，直到计算到最后一个元素，没有更多的元素时，抛出StopIteration的错误。

当然，上面这种不断调用next(g)实在是太变态了，正确的方法是使用for循环来迭代打印，因为generator也是可迭代对象：

>> g = (x * x for x in range(10))
>>> for n in g:
          print(n)

0
1
4
9
16
25
36
49
64
81    

所以，我们创建了一个generator后，基本上永远不会调用next()，而是通过for循环来迭代它，并且不需要关心StopIteration的错误！！

用函数实现生成器：（定义generator的另一种方法）

如果推算的算法比较复杂，用类似列表生成式的for循环无法实现的时候，还可以用函数来实现。

比如，著名的斐波拉契数列（Fibonacci），除第一个和第二个数外，任意一个数都可由前两个数相加得到：

1, 1, 2, 3, 5, 8, 13, 21, 34, ...

斐波拉契数列用列表生成式写不出来，但是，用函数把它的前N个数打印出来却很容易：

def fib(max):
    n, a, b = 0, 0, 1
    while n < max:
        print(b)
        a, b = b, a + b
        n = n + 1
    return 'done'

注意其中的赋值语句

a, b = b, a + b

#相当于

t = (b, a + b)     # t是一个tuple
a = t[0]　　　　　　
b = t[1]    

#但不必显式写出临时变量t就可以赋值。~

仔细观察，可以看出，fib函数实际上是定义了斐波拉契数列的推算规则，可以从第一个元素开始，推算出后续任意的元素，这种逻辑其实非常类似generator。

也就是说，上面的函数和generator仅一步之遥。要把fib函数变成generator，只需要把print(b)改为yield b就可以了：

def fib(max):
    n, a, b = 0, 0, 1
    while n < max:
        yield b
        a, b = b, a + b
        n = n + 1
    return 'done'

如果一个函数定义中包含yield关键字，那么这个函数就不再是一个普通函数，而是一个generator：

>>> f = fib(6)
>>> f
<generator object fib at 0x104feaaa0>

注意：最难理解的就是generator和函数的执行流程不一样。函数是顺序执行，遇到return语句或者最后一行函数语句就返回。而变成generator的函数，在每次调用next()的时候执行，遇到yield语句返回，再次执行时从上次返回的yield语句处继续执行。

举个例子，定义一个generator，依次返回数字1，3，5：

def odd():
    print('step 1')
    yield 1
    print('step 2')
    yield(3)
    print('step 3')
    yield(5)

调用该generator时，首先要生成一个generator对象，然后用next()函数不断获得下一个返回值

>>> o = odd()
>>> next(o)
step 1
1
>>> next(o)
step 2
3
>>> next(o)
step 3
5
>>> next(o)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
StopIteration

回到fib的例子，我们在循环过程中不断调用yield，就会不断中断；当然要给循环设置一个条件来退出循环，不然就会产生一个无限数列出来

同样的，把函数改成generator后，我们基本上从来不会用next()来获取下一个返回值（太变态了TAT），而是直接使用for循环来迭代：

>>> for n in fib(6):
...     print(n)
...
1
1
2
3
5
8

但是用for循环调用generator时，得不到generator的return语句的返回值。(没有更多的元素时，抛出StopIteration的错误)如果想要拿到返回值，必须捕获StopIteration错误，因为返回值包含在StopIteration的value中：

.......



>>> g = fib(6)
>>> while True:
...     try:　　　　　　　　　　　　　　　　　　　　　　　　　　#捕获StopIteration错误
...         x = next(g)
...         print('g:', x)
...     except StopIteration as e:
...         print('Generator return value:', e.value)
...         break

g: 1
g: 1
g: 2
g: 3
g: 5
g: 8
Generator return value: done

练习：杨辉三角

          1
         / 
        1   1
       /  / 
      1   2   1
     /  /  / 
    1   3   3   1
   /  /  /  / 
  1   4   6   4   1
 /  /  /  /  / 
1   5   10  10  5   1

把每一行看做一个list，试写一个generator，不断输出下一行的list(输出前10行)：

# 期待输出:
# [1]
# [1, 1]
# [1, 2, 1]
# [1, 3, 3, 1]
# [1, 4, 6, 4, 1]
# [1, 5, 10, 10, 5, 1]
# [1, 6, 15, 20, 15, 6, 1]
# [1, 7, 21, 35, 35, 21, 7, 1]
# [1, 8, 28, 56, 70, 56, 28, 8, 1]
# [1, 9, 36, 84, 126, 126, 84, 36, 9, 1]

def triangles():
    l =[ 1 ]
    while True:　#while True 循环是用来确保生成器函数永远也不会执行到函数末尾的。
　　　　　　　　　　只要调用 next() 这个生成器就会生成一个值。这是一个处理无穷序列的常见方法
        yield  l
        l = [0] + l + [0]
        l = [     l[:-1][i] + l[1:][i]   for i in range(len(l)-1 )    ]

小结

在Python中，可以简单地把列表生成式改成generator，也可以通过函数实现复杂逻辑的generator。

要理解generator的工作原理，它是在for循环的过程中不断计算出下一个元素，并在适当的条件结束for循环。对于函数改成的generator来说，遇到return语句或者执行到函数体最后一行语句，就是结束generator的指令，for循环随之结束。

5.迭代器（iterator）

可迭代对象：

可以直接作用于for循环的数据类型有以下几种：

 

一类是集合数据类型，如list、tuple、dict、set、str等；

 

一类是generator，包括生成器和带yield的生成器函数。

 

这些可以直接作用于for循环的对象统称为可迭代对象：Iterable。

可以使用isinstance()判断一个对象是否是Iterable对象：

>>> from collections.abc import Iterable
>>> isinstance([], Iterable)
True
>>> isinstance({}, Iterable)
True
>>> isinstance('abc', Iterable)
True
>>> isinstance((x for x in range(10)), Iterable)
True
>>> isinstance(100, Iterable)
False

迭代器:

生成器不但可以作用于for循环，还可以被next()函数不断调用并返回下一个值，直到最后抛出StopIteration错误表示无法继续返回下一个值了。

可以被next()函数调用并不断返回下一个值的对象称为迭代器：Iterator。

可以使用isinstance()判断一个对象是否是Iterator对象：

>>> from collections.abc import Iterator
>>> isinstance((x for x in range(10)), Iterator)
True
>>> isinstance([], Iterator)
False
>>> isinstance({}, Iterator)
False
>>> isinstance('abc', Iterator)
False

生成器都是Iterator可迭代对象，但list、dict、str虽然是Iterable，却不是Iterator生成器。

把list、dict、str等Iterable变成Iterator可以使用iter()函数：

>>> isinstance(iter([]), Iterator)
True
>>> isinstance(iter('abc'), Iterator)
True

为什么list、dict、str等数据类型不是Iterator??

因为Python的Iterator对象表示的是一个数据流，Iterator对象可以被next()函数调用并不断返回下一个数据，直到没有数据时抛出StopIteration错误。可以把这个数据流看做是一个有序序列，但我们却不能提

前知道序列的长度，只能不断通过next()函数实现按需计算下一个数据，所以Iterator的计算是惰性的，只有在需要返回下一个数据时它才会计算。

Iterator甚至可以表示一个无限大的数据流，例如全体自然数。而使用list是永远不可能存储全体自然数的!

实现一个迭代器：

• 利用iter（） 函数，把可迭代对象变成迭代器
• 在类中实现__iter__() 和__next__() 方法, ； 就可以用for迭代类对象

　　　　

小结:

• 凡是可作用于for循环的对象都是Iterable类型；
• 凡是可作用于next()函数的对象都是Iterator类型，它们表示一个惰性计算的序列；
• 集合数据类型如list、dict、str等是Iterable但不是Iterator，不过可以通过iter()函数获得一个Iterator对象。
• 迭代器就是实现了__next__()方法的对象（用于遍历容器中的数据）
• 生成器就是基于迭代器来实现的，生成器只需要一个 yield 语句即可，但它内部会自动创建 __iter__() 和 __next__() 方法
• Python的for循环本质上就是通过不断调用next()函数实现的，例如：

for x in [1, 2, 3, 4, 5]:
    pass　　　　　　　　　　　　#占位符

实际上完全等价于：

# 首先获得Iterator对象:
it = iter([1, 2, 3, 4, 5]) 　　#先用iter（）把可迭代对象变成一个迭代器，这样才能用next（）
# 循环:
while True:
    try:
        # 获得下一个值:
        x = next(it)
    except StopIteration:
        # 遇到StopIteration就退出循环
        break

 参考自： https://www.liaoxuefeng.com/wiki/1016959663602400/1017323698112640