Python 高级特性

 切片 对这种经常取指定索引范围的操作，用循环十分繁琐，因此，Python 提供了切片（Slice）操作符，能大大简化这种操作。 通常一个切片操作要提供三个参数 [start_index: stop_index: step] start_index 是切片的起始位置。

stop_index 是切片的结束位置（不包括） step 可以不提供，默认值是 1，步长值不能为 0，不然会报错 ValueError。

>>> m = list(range(100))#通过 range 函数创建一个 0-99 的数列，组成一个 list 赋值给 m

>>> m

[0, 1, 2, 3, 4, 5, 6, „„,99]

>>> m[:10]#取前十个数

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

>>> m[-10:]#取后十个数 [90, 91, 92, 93, 94, 95, 96, 97, 98, 99]

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

>>> m[:10:2]#前十个数中，每 2 个数取一个 [0, 2, 4, 6, 8]

>>> m[5:15:3]#第 6-15 个数中，每 3 个数取一个 [5, 8, 11, 14]

>>> m[::10]#所有的数中，每 10 个数取一个 [0, 10, 20, 30, 40, 50, 60, 70, 80, 90]

>>> m[:]#什么都不写，可以原样复制一个 list [0, 1, 2, 3, 4, 5, 6, 7,„„,99]

 迭代 如果给定一个 list 或 tuple，可以通过 for ... in 来实现循环遍历，这个循环我们就叫做迭代，Python 中，只要是可迭代对象，无论有无下标，都可以迭代

>>> d = {'a': 1, 'b': 2, 'c': 3}

>>> for key in d: ... print(key)

 列表生成式

列表生成式即 List Comprehensions，是快速生成一个列表的一些公式。

1、基础语法格式:[exp iter_var in iterable]

工作过程：

 迭代 iterable 中的每个元素；

 每次迭代都先把结果赋值给 iter_var，然后通过 exp 得到一个新的计算值；

 最后把所有通过 exp 得到的计算值以一个新列表的形式返回。

>>> [x * x for x in range(1, 11)]

[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

2、带过滤功能语法格式:[exp iter_var in iterable if_exp]

>>> [x * x for x in range(1, 11) if x % 2 == 0]

[4, 16, 36, 64, 100]

3、还可以使用两层循环，可以生成全排列：

>>> [m + n for m in 'ABC' for n in 'XYZ']

['AX', 'AY', 'AZ', 'BX', 'BY', 'BZ', 'CX', 'CY', 'CZ']

 生成器 列表元素可以按照某种算法推算出来，那我们是否可以在循环的过程中不断推算出后续的元素呢？这样就不必创建完整的 list，从而节省大量的空间。在 Python 中，这种一边循环一边计算的机制，称为生成器：generator,生成器保存的是 算法。要创建一个 generator，有很多种方法。

1、第一种方法，只要把一个列表生成式的[]改成()，就创建了一个 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>

创建 L 和 g 的区别仅在于最外层的[]和()，L 是一个 list，而 g 是一个 generator。

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

def fib(max):

        n, a, b = 0, 0, 1

        while n < max:

                print(b)

                a, b = b, a + b

                n = n + 1

        return 'done'

def fib(max):

        n, a, b = 0, 0, 1

        while n < max:

                yield b

                a, b = b, a + b

                n = n + 1

        return 'done'

>>> f = fib(6)

>>> f

<generator object fib at 0x104feaaa0>

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

>>> r = abs(6)

>>> r

6

generator 函数的“调用”实际返回一个 generator 对象：

>>> g = fib(6)

>>> g

<generator object fib at 0x1022ef948>

列表生成式和列表生成器区别：

 列表生成式： 会将所有的结果全部计算出来，把结果存放到内存中，如果列表中数据比较多，会占用过多的内存空间。

 列表生成器：会创建一个列表生成器对象，不会一次性的把所有结果都计算出来，如果需要序号获取数据，可以使用 next（）函数来获取，但要注意，一旦 next()函数获取不到数据，会导致出现 StopIteration 异常错误，可以使 用 for 循环遍历生成器对象，获取所有数据视情况而定，如果数据量比较大，推荐使用生成器；（生成器中的元素是 按照指定的算法推算出来的，只有调用时才生成相应的数据。这样就不必一次性地把所有数据都生成，从而节省了大 量的内存空间，这使得其生成的元素个数几乎是没有限制的，并且操作的返回时间也是非常快速的（仅仅是创建一个 变量而已））。

 迭代器

一、什么是迭代器

迭代，顾名思义就是重复做一些事很多次（就现在循环中做的那样）。迭代器是实现了__next__()方法的对象（这个方法 在调用时不需要任何参数），它是访问可迭代序列的一种方式，通常其从序列的第一个元素开始访问，直到所有的元素都被 访问才结束。 [注意]：迭代器只能前进不能后退

[迭代器的优点]:

使用迭代器不要求事先准备好整个迭代过程中的所有元素。迭代器仅仅在迭代到某个元素时才计算该元素，而在这之前或之 后元素可以不存在或者被销毁。因此迭代器适合遍历一些数量巨大甚至无限的序列。

二、创建迭代器

A、使用内建的工厂函数 iter(iterable)可以将可迭代序列转换为迭代器

1 a=[1,2,3,4]

2 b=(1,2,3)

3 str='Tomwenxing'

4 (iter(a))

5 (iter(b))

6 (iter(str))

B、自定义迭代器

Python 中迭代器的本质上每次调用__next__()方法都返回下一个元素或抛出 StopIteration 的容器对象 由于 Python 中没有“迭代器”这个类，因此具有以下两个特性的类都可以称为“迭代器”类：

1、有__next__()方法，返回容器的下一个元素或抛出 StopIteration 异常

2、有__iter__()方法，返回迭代器本身

#斐波那契数列

class Fabs():

        def __init__(self,max):

                self.max=max

                self.n,self.a,self.b=0,0,1

def __iter__(self):#定义__iter__方法

        return self

def __next__(self):#定义__next__方法

if self.n<self.max:

        tmp=self.b

        self.a,self.b=self.b,self.a+self.b

        #等价于：

        #t=(self.a,self.a+self.b)

        #self.a=t[0]

        #self.b=t[1]

        self.n+=1

        return tmp

raise StopIteration

print(Fabs(5))

for item in Fabs(10):

        print(item,end=' ')

三、迭代器的方法

1.iter.__next__()：返回迭代器的下一个元素，但没有下一个元素时抛出 StopIteration 异常

 1 list=[1,2,3,4]

2 list=iter(list)

3 (list.__next__())

4 (list.__next__())

5 (list.__next__())

6 (list.__next__())

7 (list.__next__())

2.iter.__iter__():返回迭代器对象本身

        1 list=[1,2,3,4]

        2 list=iter(list)

        3 (list.__iter__())

四、迭代器的特点：

a）访问者不需要关心迭代器内部的结构，仅需通过 next()方法或不断去取下一个内容

b）不能随机访问集合中的某个值，只能从头到尾依次访问

c）访问到一半时不能往回退

d）便于循环比较大的数据集合，节省内存

e）也不能复制一个迭代器。如果要再次（或者同时）迭代同一个对象，只能去创建另一个迭代器对象。 实际上，Python 中的 Iterator 对象表示的是一个数据流，Iterator 可以被 next()函数调用被不断返回下一个数据， 直到没有数据可以返回时抛出 StopIteration 异常错误。可以把这个数据流看做一个有序序列，但我们无法提前知道这 个序列的长度。同时，Iterator 的计算是惰性的，只有通过 next()函数时才会计算并返回下一个数据。

五、Iterable、Iterator 与 generator 之间的关系

 生成器对象既是可迭代对象，也是迭代器： 我们已经知道，生成器不但可以作用与 for 循环，还可以被 next()函 数不断调用并返回下一个值，直到最后抛出 StopIteration 错误表示无法继续返回下一个值了。也就是说，生成器 同时满足可迭代对象和迭代器的定义；

 迭代器对象一定是可迭代对象，反之则不一定： 例如 list、dict、str 等集合数据类型是可迭代对象，但不是迭 代器，但是它们可以通过 iter()函数生成一个迭代器对象。

1、也就是说：迭代器、生成器和可迭代对象都可以用 for 循环去迭代，生成器和迭代器还可以被 next()方函数调用并返 回下一个值。

2、这些可以直接作用于 for 循环的对象统称为可迭代对象：Iterable，可以使用 isinstance()判断一个对象是否是 Iterable 对象，包括： 一类是集合数据类型，如 list、tuple、dict、set、str 等； 一类是 generator，包括生成器和带 yield 的 generator function。

3、生成器都是 Iterator 对象，但 list、dict、str 虽然是 Iterable，却不是 Iterator。不过可以通过 iter() 函数获得一个 Iterator 对象。