Python 生成器 装饰器 闭包 迭代器 元类 gil log 协程 垃圾回收 描述符 property

迭代器和生成器

在 Python 中，迭代器（Iterator）是一种通过循环访问数据集合的方式，可以逐个访问集合中的元素，而不需要提前将整个集合加载到内存中。Python 中的迭代器通常是基于可迭代对象（Iterable）来实现的，例如列表、元组、字典、字符串等。

生成器（Generator）是一种特殊的迭代器，可以在每次循环中动态地生成数据，而不是一次性生成所有数据。生成器非常适合处理大量数据，因为它们只在必要时才计算并生成需要的数据，而不是一次性生成所有数据占用大量内存。

它们之间的区别在于，迭代器是一种通过定义类来实现的，必须实现 __iter__() 和 __next__() 两个方法，每个方法的含义、用法和返回值在实现时都需要考虑到所有细节。而生成器则比较简单，可以通过关键字 yield 来生成数据，每次调用生成器时会自动从上一个 yield 语句处继续执行，直到生成器结束或者遇到 return 语句。在 Python 中，生成器通常通过函数来定义，例如：

def my_generator(num):
    for i in range(num):
        yield i

该生成器函数用于生成 0 至 num - 1 的整数，可以通过 for 循环来访问生成器中的元素，例如：

for item in my_generator(10):
    print(item)

这里的 my_generator(10) 返回一个生成器对象，它会动态地生成 0 至 9 的整数，循环直到生成器结束或者遇到 return 语句。

迭代器

到目前为止，您可能已经注意到大多数容器对象都可以使用 for 语句:

for element in [1, 2, 3]:
    print(element)
for element in (1, 2, 3):
    print(element)
for key in {'one':1, 'two':2}:
    print(key)
for char in "123":
    print(char)
for line in open("myfile.txt"):
    print(line, end='')

这种访问风格清晰、简洁又方便。 迭代器的使用非常普遍并使得 Python 成为一个统一的整体。 在幕后，for 语句会在容器对象上调用 iter()。 该函数返回一个定义了 __next__() 方法的迭代器对象，此方法将逐一访问容器中的元素。 当元素用尽时，__next__() 将引发 StopIteration 异常来通知终止 for 循环。 你可以使用 next() 内置函数来调用 __next__() 方法；这个例子显示了它的运作方式:

s='abcd'
it=iter(s)
for i in range(5):
    print(next(it))
a
b
c
d
StopIteration

看过迭代器协议的幕后机制，给你的类添加迭代器行为就很容易了。 定义一个 __iter__() 方法来返回一个带有 __next__() 方法的对象。 如果类已定义了 __next__()，则 __iter__() 可以简单地返回 self:

class Reverse:
    """Iterator for looping over a sequence backwards."""
    def __init__(self, data):
        self.data = data
        self.index = len(data)

    def __iter__(self):
        return self

    def __next__(self):
        if self.index == 0:
            raise StopIteration
        self.index = self.index - 1
        return self.data[self.index]
rev=Reverse('abcd')
for i in rev:
    print(i)
d
c
b
a

迭代器
迭代器是一个可以记住遍历的位置的对象。迭代器对象从第一个元素开始访问，直到所有的元素被访问完结束。迭代器只能往前不会后退。

可迭代对象的本质
分析 可迭代对象 进行迭代的过程，发现每迭代一次（即在for...in...中每循环一次）都会返回对象中的下一条数据，一直向后读取数据直到迭代了所有数据后结束。

那么，在这个过程中就应该有一个“人”去记录每次访问到了第几条数据，以便每次迭代都可以返回下一条数据。我们把这个能帮助我们进行数据迭代的“人”称为迭代器(Iterator)

可迭代对象的本质就是可以向我们提供一个这样的中间“人”，即迭代器帮助我们对其进行迭代遍历使用。

list、tuple等都是可迭代对象，我们可以通过iter()函数获取这些可迭代对象的迭代器。然后我们可以对获取到的迭代器不断使用next()函数来获取下一条数据。

    
__next__方法
迭代器是用来帮助我们记录每次迭代访问到的位置，当我们对迭代器使用next()函数的时候，迭代器会向我们返回它所记录位置的下一个位置的数据。

• 凡是可作用于for 循环的对象都是 Iterable 类型；
• 凡是可作用于 next() 函数的对象都是 Iterator 类型
• 集合数据类型如 list 、dict、str等是 Iterable 但不是Iterator，不过可以通过 iter() 函数获得一个 Iterator 对象

生成器

生成器 是一个用于创建迭代器的简单而强大的工具。 它们的写法类似于标准的函数，但当它们要返回数据时会使用 yield 语句。 每次在生成器上调用 next() 时，它会从上次离开的位置恢复执行（它会记住上次执行语句时的所有数据值）。 一个显示如何非常容易地创建生成器的示例如下:

def reverse(data):
    for index in range(len(data)-1, -1, -1):
        yield data[index]
    # for i in range(8,-1,-1):
    #     yield i

for char in reverse('golf'):
    print(char)

可以用生成器来完成的操作同样可以用前一节所描述的基于类的迭代器来完成。 但生成器的写法更为紧凑，因为它会自动创建 __iter__() 和 __next__() 方法。

另一个关键特性在于局部变量和执行状态会在每次调用之间自动保存。 这使得该函数相比使用 self.index 和 self.data 这种实例变量的方式更易编写且更为清晰。

除了会自动创建方法和保存程序状态，当生成器终结时，它们还会自动引发 StopIteration。 这些特性结合在一起，使得创建迭代器能与编写常规函数一样容易。

生成器表达式

某些简单的生成器可以写成简洁的表达式代码，所用语法类似列表推导式，但外层为圆括号而非方括号。 这种表达式被设计用于生成器将立即被外层函数所使用的情况。 生成器表达式相比完整的生成器更紧凑但较不灵活，相比等效的列表推导式则更为节省内存。

sum(i*i for i in range(10))
xvec = [10, 20, 30]
yvec = [7, 5, 3]
sum(x*y for x,y in zip(xvec, yvec))
page='''a
bb
ccc'''
unique_words = set(word for line in page  for word in line.split())
print(unique_words)

# valedictorian = max((student.gpa, student.name) for student in graduates)
# list(data[i] for i in range(len(data)-1, -1, -1))

s='abc'
for i,si in enumerate(s):
    print(i,si)
{'c', 'a', 'b'}
0 a
1 b
2 c

私有变量

那种仅限从一个对象内部访问的“私有”实例变量在 Python 中并不存在。 但是，大多数 Python 代码都遵循这样一个约定：带有一个下划线的名称 (例如 _spam) 应该被当作是 API 的非公有部分 (无论它是函数、方法或是数据成员)。 这应当被视为一个实现细节，可能不经通知即加以改变。

class A:
    def __init__(self):
        self.data = []
        self.__a=1
        self.b=1
class B(A):
    def __int__(self):
        print(self.__a)
        print(self.b)
b=B()
仍然可以访问和修改

通过列表生成式，我们可以直接创建一个列表。但是，受到内存限制，列表容量肯定是有限的。而且，创建一个包含100万个元素的列表，不仅占用很大的存储空间，如果我们仅仅需要访问前面几个元素，那后面绝大多数元素占用的空间都白白浪费了。

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

通俗的理解：

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

有一个能具有迭代器的功能，且比它更加简单的方式：生成器(generator)

生成器是一类特殊的迭代器

创建生成器

1.只要把一个列表生成式的[ ] 改成( )

nums = [x for x in range(5)]
print(type(nums))
print(nums)

nums2 = (x for x in range(5))
print(type(nums2))
print(nums2)

class fibitetator():
    def __init__(self):
        self.num1=1
        self.num2=1
    def __next__(self):
        self.num1,self.num2=self.num2,self.num1+self.num2
        return self.num1
    def __iter__(self):
        return self
fi=fibitetator()
for i in range(10):
    print(fi.__next__(),end='\t')
print()

def fib_generator():
    '''代码2（是生成器，能实现斐波那契数列）'''
    num1 = 1
    num2 = 1
    while True:
        temp_num = num1
        num1, num2 = num2, num1+num2
        # return temp_num  # 方式1代码
        yield temp_num
fib = fib_generator()
print(next(fib))
print(next(fib))
print(next(fib))
print(next(fib))

<class 'list'>
[0, 1, 2, 3, 4]
<class 'generator'>
<generator object <genexpr> at 0x00000217EB940AC0>
1	2	3	5	8	13	21	34	55	89	
1
1
2
3

1. 区别仅在于最外层的[ ] 和( ) ， nums是一个列表，而 nums2是一个生成器

2. 可以直接打印出列表nums的每一个元素，而对于生成器nums2，我们可以按照迭代器的使用方法来使用，即可以通过next()函数、for循环、list()等方法使用

在使用生成器实现的方式中，我们将原本在迭代器__next__方法中实现的基本逻辑放到一个函数中来实现，但是将每次迭代返回数值的return换成了yield，此时新定义的函数便不再是函数，而是一个生成器了

简单来说：只要在def函数中有yield关键字的 就称为 生成器

此时按照调用函数的方式( fib = fib_generator() )就不再是执行函数体了，而是会返回一个生成器对象，然后就可以按照使用迭代器(因为生成器是一种特殊的迭代器)的方式来使用生成器了

1. return接收一个函数，且有返回值

2. yield暂停执行一个函数，且有返回值

def generator_test():