python中的迭代器，生成器，闭包，装饰器，@property
一.迭代器
迭代器在Python中无处不在。它们在for循环，理解，生成器等中优雅地实现，但却隐藏在眼皮底下。
Python中的Iterator只是一个可以迭代的对象。一个将返回数据的对象，一次返回一个元素。
从技术上讲，Python 迭代器对象必须实现两个特殊方法，iter()和__next__()统称为迭代器协议。
如果我们可以从对象获得迭代器，则该对象称为可迭代。Python中的大多数内置容器（例如：list，tuple，string等）都是可迭代的。
iter()函数（也就是__iter__()方法）从它们返回一个迭代器。
1示例
my_list = [4, 7, 0, 3]
# 使用iter()获得迭代器
my_iter = iter(my_list)
#输出 4
print(next(my_iter))
#输出 7
print(next(my_iter))
## next（obj）与obj .__ next __()相同
#输出 0
print(my_iter.__next__())
2for循环
在正常编码中，我们常常使用for循环来迭代
for element in iterable:
# 对元素做点什么
其真实 for 循环 内部代码为
# 创建一个迭代器对象iterable
iter_obj = iter(iterable)
# 无限循环
while True:
try:
# 获取下一项
element = next(iter_obj)
# 对元素做点什么
except StopIteration:
# 如果引发StopIteration，则从循环中断
break
因此，在内部，for循环通过在iterable上调用iter（）创建一个迭代器对象iter_obj。
具有讽刺意味的是，这个for循环实际上是一个无限的while循环。
在循环内部，它调用next()来获取下一个元素，并使用这个值执行for循环的主体。当所有的项都用完后，StopIteration被抛出，它在内部被捕获，循环结束。注意，任何其他类型的异常都会通过。
3构建自己的迭代器
在Python中从头开始构建迭代器很容易。我们只需要实现这些方法__iter__()和__next__()。
iter()方法返回迭代器对象本身。如果需要，可以执行一些初始化。
next()方法必须返回序列中的下一项。在到达终点时，以及在随后的调用中，它必须引发StopIteration。
这里，我们展示了一个示例，它将在每次迭代中为我们提供2的次幂。幂指数从0到用户设置的数字。
class PowTwo:
"""实现迭代器的类
二的幂"""
def __init__(self, max = 0):
self.max = max
def __iter__(self):
self.n = 0
return self
def __next__(self):
if self.n <= self.max:
result = 2 ** self.n
self.n += 1
return result
else:
raise StopIteration
a = PowTwo(4)
print(a.__iter__())
print(a.__next__())
print(a.__next__())
print(a.__next__())
print(a.__next__())
print(a.__next__())
print(a.__next__())
二.生成器
1什么是生成器
用Python构建迭代器有很多开销; 我们必须使用__iter__()和__next__()方法实现一个类，跟踪内部状态，在没有要返回的值时触发StopIteration等等。
这既冗长又违反直觉。生成器在这种情况下可以派上用场。
Python生成器是创建迭代器的简单方法。我们上面提到的所有开销都由Python的生成器自动处理。
简而言之，生成器是一个函数，它返回一个对象（迭代器），我们可以对其进行迭代（一次一个值）。
2如何创建生成器
在Python中创建生成器非常简单。 就像使用yield语句而不是return语句定义普通函数一样容易。
如果一个函数包含至少一个yield语句(它可能包含其他yield或return语句)，那么它就成为一个生成器函数。yield和return都将从函数返回一些值。
不同之处在于，当return语句完全终止一个函数时，yield语句会暂停该函数保存其所有状态，然后在后续调用时继续执行。
3生成器函数和普通函数区别
生成器函数包含一个或多个yield语句。
调用时，它返回一个对象（迭代器），但不会立即开始执行。
像__iter__()和__next__()这样的方法会自动实现。因此，我们可以使用next()来遍历项目。
一旦函数产生了结果，函数就会暂停，控制就会转移给调用者。
局部变量及其状态在连续调用之间被记住。
最后，当函数终止时，在进一步调用时会自动引发StopIteration。
4代码
# 一个简单的生成器函数
def my_gen():
n = 1
print('这是第一次打印')
# 生成器函数包含yield语句
yield n
n += 1
print('这是第二次打印')
yield n
n += 1
print('这是最后一次打印')
yield n
a=my_gen()
print(a.__next__())
print(a.__next__())
print(next(a))
print(next(a))
5生成器表达式
使用生成器表达式可以轻松地动态创建简单的生成器。它使建造生成器变得容易。
与lambda函数创建匿名函数相同，生成器表达式创建匿名生成器函数。
生成器表达式的语法类似于Python中的列表理解语法。但是将方括号替换为圆括号。
列表理解与生成器表达式之间的主要区别在于，虽然列表理解生成整个列表，但生成器表达式一次生成一个项目。
他们有点懒，只在需要时才生成项目。由于这个原因，生成器表达式比等价的列表理解的内存效率要高得多。
# 初始化列表
my_list = [1, 3, 6, 10]
# 使用列表理解对每个项目进行平方
# 输出: [1, 9, 36, 100]
print('[x**2 for x in my_list]:',[x**2 for x in my_list])
# 同样的事情可以使用生成器表达式来完成
# 输出: at 0x0000000002EBDAF8>
a=(x**2 for x in my_list)
print('a:',a)
print('next(a):',next(a))
三.闭包
1嵌套函数中的非局部变量
在了解闭包是什么之前，我们必须首先了解什么是嵌套函数和非局部变量。
在另一个函数内部定义的函数称为嵌套函数。嵌套函数可以访问封闭范围的变量。
在Python中，默认情况下，这些非本地变量是只读的，并且我们必须将它们明确声明为非本地变量（使用nonlocal关键字）才能进行修改。
以下是访问非局部变量的嵌套函数的示例。
def print_msg(msg):
# 这是外部封闭函数
def printer():
# 这是嵌套函数
print(msg)
printer()
# 我们执行这个函数
# 输出: Hello
print_msg("Hello")
2定义闭包函数
在上面的示例中，如果函数print_msg()的最后一行返回了printer()函数而不是调用它，将会发生什么？ 这意味着功能定义如下。
def print_msg(msg):
# 这是外部封闭函数
def printer():
# 这是嵌套函数
print(msg)
return printer # 这变了
# 现在，让我们尝试调用此函数。
# 输出: Hello
another = print_msg("Hello")
another()
这很不寻常。
print_msg()函数用字符串调用，"Hello"返回的函数绑定到另一个名称。在调用时another()，尽管我们已经完成了print_msg()函数的执行，但仍然记得该消息。
这种将一些数据（“Hello”）附加到代码上的技术在Python中称为闭包。
即使变量超出范围或函数本身已从当前命名空间中删除，也会记住封闭范围中的这个值。
3闭包的条件
从上面的实例可以看出，在Python中，当嵌套的函数在其封闭的范围内引用一个值时，我们有一个闭包。
以下几点总结了在Python中创建闭包必须满足的条件。
- 我们必须有一个嵌套函数（函数在函数内部）。
- 嵌套函数必须引用在封闭函数中定义的值。
- 封闭函数必须返回嵌套函数。
4何时使用闭包
那么，闭包有什么用呢？
闭包可以避免使用全局值，并提供某种形式的数据隐藏。它还可以为该问题提供面向对象的解决方案。
当在一个类中实现的方法很少（大多数情况下是一个方法）时，闭包可以提供另一种更优雅的解决方案。但是，当属性和方法的数量变大时，最好实现一个类。
这是一个简单的示例，其中闭包可能比定义类和创建对象更可取。
def make_multiplier_of(n):
def multiplier(x):
return x * n
return multiplier
# 3的乘数
times3 = make_multiplier_of(3)
# 5的乘数
times5 = make_multiplier_of(5)
# 输出: 27
print(times3(9))#此时x=9
# 输出: 15
print(times5(3))#此时x=3
# 输出: 30
print(times5(times3(2)))#times3(2)=6，x=times3(2)
四.装饰器
1.什么是装饰器
装饰器接受一个函数，添加一些功能并返回它。
Python有一个有趣的功能，称为装饰器，可将功能添加到现有代码中。
这也称为元编程，因为程序的一部分试图在编译时修改程序的另一部分。
2学习装饰器的先决条件
为了了解装饰器，我们必须首先了解Python的一些基本知识。
我们必须接受这样一个事实，即Python中的所有内容都是对象。我们定义的名称只是绑定到这些对象的标识符。函数也不例外，它们也是对象（带有属性）。可以将各种不同的名称绑定到同一功能对象。
这是一个实例。
def first(msg):
print(msg)
first("Hello")
second = first
second("Hello")
当您运行代码时，这两个函数first和second给出相同的输出。在此，名称first和second指代相同的功能对象。
现在情况是不是感觉变复杂了点，可以将函数作为参数传递给另一个函数。
如果您在Python中使用过map，filter和reduce之类的函数，那么您已经知道这一点。
这种以其他函数为参数的函数也称为高阶函数。这是这种函数的一个实例。
def inc(x):
return x + 1
def dec(x):
return x - 1
def operate(func, x):
result = func(x)
return result
operate(inc,3)#4
operate(dec,3)#2
此外，一个函数可以返回另一个函数。 即闭包
def is_called():
def is_returned():
print("Hello")
return is_returned
new = is_called()
#输出 "Hello"
new()
3回到装饰器
函数和方法被称为可调用的，因为它们可以被调用。
实际上，任何实现特殊方法__call __()的对象都称为可调用的。 因此，从最基本的意义上讲，装饰器是可调用的，可返回可调用的。
基本上，装饰器接受一个函数，添加一些功能并返回它。
def make_pretty(func):
def inner():
print("我被装饰了")
func()
return inner
def ordinary():
print("我是普通的函数")
ordinary()
print('.....')
pretty = make_pretty(ordinary)
pretty()
在上面显示的示例中，make_pretty()是一个装饰器。在分配步骤中。
pretty = make_pretty(ordinary)
函数ordinary()被修饰，返回的函数被命名为pretty。
我们可以看到decorator函数在原来的函数中添加了一些新功能。这类似于包装礼物。装饰器充当包装器。被装饰的物品(里面的礼物)的性质不会改变。但是现在，它看起来很漂亮(自从装饰之后)。
通常，我们装饰一个函数并将其重新分配为
ordinary = make_pretty(ordinary).
这是一个常见的构造，因此，Python具有简化此语法的语法。
我们可以将@符号与装饰器函数的名称一起使用，并将其放置在要装饰的函数的定义上方。例如，
def make_pretty(func):
def inner():
print("我被装饰了")
func()
return inner
@make_pretty
def ordinary():
print("我是普通的函数")
ordinary()
相当于
def ordinary():
print("我是普通的函数")
ordinary = make_pretty(ordinary)
4.带参数的装饰器
装饰器里有很多闭包知识
def smart_divide(func):
def inner(a,b):
print("我要做除法",a,"和",b)
if b == 0:
print("哎呀!不能除")
return
return func(a,b)
return inner
@smart_divide
def divide(a,b):
return a/b
print(divide(2,5))
通过这种方式，我们可以装饰带有参数的函数。
敏锐的观察者会注意到，inner()装饰器内部的嵌套函数的参数与其装饰的函数的参数相同。考虑到这一点，现在我们可以使通用装饰器可以使用任意数量的参数。
在Python中，此魔术是通过完成的function(*args, **kwargs)。这样，args是位置参数的元组，kwargs而是关键字参数的字典。这样的装饰器的一个实例是。
def works_for_all(func):
def inner(*args, **kwargs):
print("我可以装饰任何函数")
return func(*args, **kwargs)
return inner
5.链接装饰器
可以在Python中链接多个装饰器。
这就是说，一个函数可以用不同（或相同）的装饰器多次装饰。我们只需将装饰器放置在所需函数之上。
def star(func):
def inner(*args, **kwargs):
print("*" * 30)
func(*args, **kwargs)
print("*" * 30)
return inner
def percent(func):
def inner(*args, **kwargs):
print("%" * 30)
func(*args, **kwargs)
print("%" * 30)
return inner
@star
@percent
def printer(msg):
print(msg)
printer("Hello")
五.@property
在定义和详细了解@property是什么之前，让我们了解为什么首先需要使用它。、
一个实例开始
假设您决定创建一个以摄氏度为单位存储温度的类。它还将实现一种将温度转换为华氏温度的方法。其中一种方法如下。
class Celsius:
def __init__(self, temperature = 0):
self.temperature = temperature
def to_fahrenheit(self):
return (self.temperature * 1.8) + 32
# 创建新对象
man = Celsius()
# 设定温度
man.temperature = 37
# 获得华氏度
print(man.to_fahrenheit())
如上所示，每当我们分配或检索任何对象属性（如temperature）时，Python都会在对象的__dict__字典中进行搜索。
man.dict
{‘temperature’: 37}
现在，让我们进一步假设我们的课程在客户中很受欢迎，并且他们开始在程序中使用它。 他们对对象进行了各种分配。
有一天，一个值得信赖的客户来找我们，建议温度不能低于-273摄氏度(热力学专业的学生可能会说实际上是-273.15摄氏度)，也被称为绝对零度。他进一步要求我们实现这个值约束。作为一家追求客户满意度的公司，我们很高兴地听取了这个建议，并发布了1.01版本(对现有类的升级)。
1 使用getter和setter
解决上述约束的一个明显方法是隐藏属性temperature（将其设为私有），并定义新的getter和setter接口以对其进行操作。这可以如下进行。
class Celsius:
def __init__(self, temperature = 0):
self.set_temperature(temperature)
def to_fahrenheit(self):
return (self.get_temperature() * 1.8) + 32
# new update
def get_temperature(self):
return self._temperature
def set_temperature(self, value):
if value < -273:
raise ValueError("-273度是不可能的")
self._temperature = value
我们在上面可以看到get_temperature()，set_temperature()已经定义了新方法，此外，用_temperature替换了temperature。下划线(_)开头表示Python中的私有变量。
c = Celsius(-277)
Traceback (most recent call last):
ValueError: Temperature below -273 is not possible
c = Celsius(37)
c.get_temperature()
37
c.set_temperature(10)
c.set_temperature(-300)
Traceback (most recent call last):
ValueError: Temperature below -273 is not possible
但这不是一个大问题。上述更新的最大问题在于，所有在程序中实现了上一类的客户端都必须将其代码从obj.temperature修改为obj.get_temperature()，并将所有分配（例如obj.temperature = val修改为obj.set_temperature（ val）)。
这种重构会给客户带来数十万行代码的麻烦。
总而言之，我们的新更新不向后兼容。这是@property发挥作用的地方。
2@property的力量
python处理上述问题的方法是使用property。我们可以这样来实现它。
class Celsius:
def __init__(self, temperature = 0):
self.temperature = temperature
def to_fahrenheit(self):
return (self.temperature * 1.8) + 32
def get_temperature(self):
print("获得的值")
return self._temperature
def set_temperature(self, value):
if value < -273:
raise ValueError("零下273度是不可能的")
print("设定值")
self._temperature = value
temperature = property(get_temperature,set_temperature)
c = Celsius()
同样，任何访问如c.temperature都会自动调用get_temperature()。 这就是属性的作用。 这里还有一些实例。
同样，任何设定.temperature都会自动调用set_temperature()。 这就是属性的作用。
任何检索温度值的代码都将自动调用get_temperature()而不是字典(dict)查找。 同样，任何为温度分配值的代码都会自动调用set_temperature()。 这是Python中的一项很酷的功能。
我们可以在上面看到即使创建对象时也会调用set_temperature()。
3深入了解property
在Python中，property()是一个内置函数，用于创建并返回属性对象。该函数的签名是
property(fget=None, fset=None, fdel=None, doc=None)
其中，fget为获取属性值的函数，fset为设置属性值的函数，fdel为删除属性的函数，doc为字符串(如注释)。从实现中可以看出，这些函数参数是可选的。因此，可以简单地按照以下方式创建属性对象。
属性对象有三个方法，getter()、setter()和deleter()，用于稍后指定fget、fset和fdel。这意味着
temperature = property(get_temperature,set_temperature)
也可以分解为
创建空属性
temperature = property()
设置 fget
temperature = temperature.getter(get_temperature)
#设置 fset
temperature = temperature.setter(set_temperature)
熟悉Python中装饰器的程序员可以认识到上述构造可以实现为装饰器。
我们可以更进一步，不定义名称get_temperature，set_temperature，因为它们是不必要的，并且会影响类命名空间。为此，我们在定义getter和setter函数时重用了名称temperature。这是可以做到的。
class Celsius:
def __init__(self, temperature = 0):
self._temperature = temperature
def to_fahrenheit(self):
return (self.temperature * 1.8) + 32
@property
def temperature(self):
print("获得值")
return self._temperature
@temperature.setter
def temperature(self, value):
if value < -273:
raise ValueError("零下273度是不可能的")
print("设定值")
self._temperature = value
电气工程的计算机萌新：余登武。
写博文不容易，如果你觉得本文对你有用，请点个赞支持下，谢谢。
