类特殊成员(属性和方法)

Python下划线命名模式 - 小结

以下是一个简短的小结，即"速查表"，罗列了我在本文中谈到的五种Python下划线模式的含义：

因为python中所有类默认继承object类。而object类提供了了很多原始的内建属性和方法，所以用户自定义的类在Python中也会继承这些内建属性。可以使用dir()函数可以查看，虽然python提供了很多内建属性但实际开发中常用的不多。而很多系统提供的内建属性实际开发中用户都需要重写后才会使用。对于python来说，属性或者函数都可以被理解成一个属性

[root@kube method]# cat demo2.py 
class Person:
    pass

print(dir(Person))   #使用dir 函数查看内建属性
[root@kube method]# py demo2.py 
['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__']
[root@kube method]# 

1.常用内建属性：__init__和__new__

1.__init__方法使用与功能：
  1.用来构造初始化函数,用来给类的实例进行初始化属性，所以可以不需要返回值
  2.在创建类的实例时系统自动调用
  3.自定义类如果不定义的话，默认调用父类object的，同理继承也是，子类若无，调用父类，若有，调用自己的
class Student(object):
    def __init__(self,name):
        self.name = name
        print("这是__init__方法")
 
s = Student("tom")  
'''
这是__init__方法

2.__new__方法使用与功能
  1.__new__功能：用所给类创建一个对象，并且返回这个对象。
  2.因为是给类创建实例，所以至少传一个参数cls,参数cls，代表要实例化的类，此参数在实例化时由Python解释器自动提供
  3.在类实例化时内部创建类实例的函数，并且返回这个实例，所以它是类实例时最先被调用的方法，一般不要人为定义该方法。
  4.因为要创建实例返回实例，所以要有返回值。return父类__new__出来的实例，或者直接是object的__new__出来的实例   
 
 
class Student(object):
    def __init__(self,name):
        self.name = name
        print("这是__init__方法")
 
    def __new__(cls, *args, **kwargs):
        print("这是__new__方法")
        return object.__new__(cls)
 
s = Student("tom")
'''结果如下：注意__new__的执行顺序在__init__之前
这是__new__方法
这是_init__方法
'''
 
3.__init__和__new__使用的联系
  1.__init__第一个参数是self，表示需要初始的实例，由python解释器自动传入，而这个实例就是这个__new__返回的实例
#那么理解就是在类实例化的过程中需要先通过__new__  进行实列化返回一个实例，然后这个实例再有 __init__进行实例初始化

[root@kube method]# cat demo5.py 
#coding:utf-8

class test:
    def __new__(cls,name,age):    #先通过__new__ 内置属性定义实列，然后交给 init 初始化实例，如果__new__ 没有完成后面就不会进行
        if 0 < age < 50:
            return object.__new__(cls)
        else:
            return None

    def __init__(self,name,age):
        
        print('__init__ age:', age)

a = test('aaa',30)
b = test('aaifffa',100)
[root@kube method]# py demo5.py 
__init__ age: 30
[root@kube method]# 

3.__init__和__new__使用的联系
  1.__init__第一个参数是self，表示需要初始的实例，由python解释器自动传入，而这个实例就是这个__new__返回的实例
  2.然后 __init__在__new__的基础上可以完成一些其它初始化的动作
 
class Student(object):
    def __init__(self,name):
        self.name = name
        print("这是__init__方法")
 
    def __new__(cls, *args, **kwargs):
        print("这是__new__方法")
        id =object.__new__(cls)
        print(id) #打印这个__new__创建并返回的实例在内存中的地址
        return id
s1 = Student("JACK")
print(s1)
'''
这是__new__方法
<__main__.Student object at 0x000001EC6C8C8748>
这是__init__方法
<__main__.Student object at 0x000001EC6C8C8748>
'''
 

Python __repr__()方法：显示属性

[root@kube method]# cat demo6.py 
class Item:
    def __init__ (self, name, price):
        self.name = name
        self.price = price
# 创建一个Item对象，将之赋给im变量
im = Item('鼠标', 29.8)
# 打印im所引用的Item对象
print(im)
print(im.__repr__)
[root@kube method]# py demo6.py 
<__main__.Item object at 0x7f7628881290>
<method-wrapper '__repr__' of Item object at 0x7f7628881290>
[root@kube method]# 

[root@kube method]# cat demo7.py 
#coding:utf-8

class Apple:
    def __init__(self,color,weight):
        self.color = color
        self.weight = weight
    def __repr__(self):
        return 'Apple class'+self.color+str(self.weight)

a = Apple('red',8.88)
print(a)
[root@kube method]# py demo7.py 
Apple classred8.88
[root@kube method]# 
#__repr__() 是一个非常特殊的方法，它是一个“自我描述”的方法，该方法通常用于实现这样一个功能：当程序员直接打印该对象时，系统将会输出该对象的“自我描述”信息，用来告诉外界该对象具有的状态信息。

Python __del__方法：销毁对象

与 __init__() 方法对应的是 __del__() 方法，__init__() 方法用于初始化 Python 对象，而 __del__() 则用于销毁 Python 对象，即在任何 Python 对象将要被系统回收之时，系统都会自动调用该对象的 __del__() 方法。

当程序不再需要一个 Python 对象时，系统必须把该对象所占用的内存空间释放出来，这个过程被称为垃圾回收（GC，Garbage Collector），Python 会自动回收所有对象所占用的内存空间，因此开发者无须关心对象垃圾回收的过程。
Python 采用自动引用计数（ARC）方式来回收对象所占用的空间，当程序中有一个变量引用该 Python 对象时，Python 会自动保证该对象引用计数为 1；当程序中有两个变量引用该 Python 对象时，Python 会自动保证该对象引用计数为 2，依此类推，如果一个对象的引用计数变成了 0，则说明程序中不再有变量引用该对象，表明程序不再需要该对象，因此 Python 就会回收该对象。

大部分时候，Python 的 ARC 都能准确、高效地回收系统中的每个对象。但如果系统中出现循环引用的情况，比如对象 a 持有一个实例变量引用对象 b，而对象 b 又持有一个实例变量引用对象 a，此时两个对象的引用计数都是 1，而实际上程序已经不再有变量引用它们，系统应该回收它们，此时 Python 的垃圾回收器就可能没那么快，要等专门的循环垃圾回收器（Cyclic Garbage Collector）来检测并回收这种引用循环。

当一个对象被垃圾回收时，Python 就会自动调用该对象的 __del__ 方法。需要说明的是，不要以为对一个变量执行 del 操作，该变量所引用的对象就会被回收，只有当对象的引用计数变成 0 时，该对象才会被回收。因此，如果一个对象有多个变量引用它，那么 del 其中一个变量是不会回收该对象的。

[root@kube method]# cat demo8.py 
class Item:
    def __init__ (self, name, price):
        self.name = name
        self.price = price
    # 定义析构函数
    def __del__ (self):
        print('del删除对象')
# 创建一个Item对象，将之赋给im变量
im = Item('鼠标', 29.8)
x = im   # ①
# 打印im所引用的Item对象
del im
print('--------------')
[root@kube method]# py demo8.py 
--------------
del删除对象
[root@kube method]# 

从上面程序的输出结果可以看到，del im 执行之后，程序并没有回收 Item 对象，只有等到程序执行将要结束时（系统必须回收所有对象），系统才会回收 Item 对象。

Python __dir__用法：列出对象的所有属性（方法）名

对象的 __dir__ 方法用于列出该对象内部的所有属性（包括方法）名，该方法将会返回包含所有属性（方法）名的序列。

当程序对某个对象执行 dir(object） 函数时，实际上就是将该对象的 __dir__() 方法返回值进行排序，然后包装成列表。

[root@kube method]# cat demo9.py 
class Item:
    def __init__ (self, name, price):
        self.name = name
        self.price = price
    def info ():
        pass
# 创建一个Item对象，将之赋给im变量
im = Item('鼠标', 29.8)
print(im.__dir__())  # 返回所有属性（包括方法）组成列表
print('----------------------------------------------------------------')
print(dir(im))  # 返回所有属性（包括方法）排序之后的列表
[root@kube method]# py demo9.py 
['name', 'price', '__module__', '__init__', 'info', '__dict__', '__weakref__', '__doc__', '__repr__', '__hash__', '__str__', '__getattribute__', '__setattr__', '__delattr__', '__lt__', '__le__', '__eq__', '__ne__', '__gt__', '__ge__', '__new__', '__reduce_ex__', '__reduce__', '__subclasshook__', '__init_subclass__', '__format__', '__sizeof__', '__dir__', '__class__']
----------------------------------------------------------------
['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'info', 'name', 'price']
[root@kube method]# 

Python __dict__属性：查看对象内部所有属性名和属性值组成的字典

__dict__ 属性用于查看对象内部存储的所有属性名和属性值组成的字典，通常程序直接使用该属性即可。

程序使用 __dict__ 属性既可查看对象的所有内部状态，也可通过字典语法来访问或修改指定属性的值。例如如下程序：

[root@kube method]# cat demo10.py 
#coding:utf-8

class Item:
    def __init__(self, name ,price):
        self.name = name
        self.price = price
im = Item('computer',10000)

print(im.__dict__)
print(im.__dict__['name'])

im.__dict__['name'] = '鼠标'
print(im.__dict__['name'])

[root@kube method]# py demo10.py 
{'name': 'computer', 'price': 10000}
computer
鼠标
[root@kube method]# 

Python setattr()、getattr()、hasattr()函数用法详解

在动态检查对象是否包含某些属性（包括方法〉相关的函数有如下几个：
hasattr(obj, name)：检查 obj 对象是否包含名为 name 的属性或方法。
getattr(object, name[, default])：获取 object 对象中名为 name 的属性的属性值。
setattr(obj, name, value，/)：将obj 对象的 name 属性设为 value。

下面程序示范了通过以上函数来动态操作 Python 对象的属性：

[root@kube method]# cat demo11.py 
class Comment:
    def __init__ (self, detail, view_times):
        self.detail = detail
        self.view_times = view_times
    def info ():
        print("一条简单的评论，内容是%s" % self.detail)
       
c = Comment('疯狂Python讲义很不错', 20)
# 判断是否包含指定的属性或方法
print(hasattr(c, 'detail')) # True
print(hasattr(c, 'view_times')) # True
print(hasattr(c, 'info')) # True
# 获取指定属性的属性值
print(getattr(c, 'detail')) # '疯狂Python讲义很不错'
print(getattr(c, 'view_times')) # 20
# 由于info是方法，故下面代码会提示：name 'info' is not defined
#print(getattr(c, info, '默认值'))
# 为指定属性设置属性值
setattr(c, 'detail', '天气不错')
setattr(c, 'view_times', 32)
# 输出重新设置后的属性值
print(c.detail)
print(c.view_times)
[root@kube method]# py demo11.py 
True
True
True
疯狂Python讲义很不错
20
天气不错
32
[root@kube method]# 

Python issubclass和isinstance函数：检查类型

Python 提供了如下两个函数来检查类型：

• issubclass(cls, class_or_tuple)：检查 cls 是否为后一个类或元组包含的多个类中任意类的子类。
• isinstance(obj, class_or_tuple)：检查 obj 是否为后一个类或元组包含的多个类中任意类的对象。

[root@kube method]# cat demo12.py 
# 定义一个字符串
hello = "Hello";
# "Hello"是str类的实例，输出True
print('"Hello"是否是str类的实例: ', isinstance(hello, str))
# "Hello"是object类的子类的实例，输出True
print('"Hello"是否是object类的实例: ', isinstance(hello, object))
# str是object类的子类，输出True
print('str是否是object类的子类: ', issubclass(str, object))
# "Hello"不是tuple类及其子类的实例，输出False
print('"Hello"是否是tuple类的实例: ', isinstance(hello, tuple))
# str不是tuple类的子类，输出False
print('str是否是tuple类的子类: ', issubclass(str, tuple))
# 定义一个列表
my_list = [2, 4]
# [2, 4]是list类的实例，输出True
print('[2, 4]是否是list类的实例: ', isinstance(my_list, list))
# [2, 4]是object类的子类的实例，输出True
print('[2, 4]是否是object类及其子类的实例: ', isinstance(my_list, object))
# list是object类的子类，输出True
print('list是否是object类的子类: ', issubclass(list, object))
# [2, 4]不是tuple类及其子类的实例，输出False
print('[2, 4]是否是tuple类及其子类的实例: ', isinstance([2, 4], tuple))
# list不是tuple类的子类，输出False
print('list是否是tuple类的子类: ', issubclass(list, tuple))
[root@kube method]# py demo12.py 
"Hello"是否是str类的实例:  True
"Hello"是否是object类的实例:  True
str是否是object类的子类:  True
"Hello"是否是tuple类的实例:  False
str是否是tuple类的子类:  False
[2, 4]是否是list类的实例:  True
[2, 4]是否是object类及其子类的实例:  True
list是否是object类的子类:  True
[2, 4]是否是tuple类及其子类的实例:  False
list是否是tuple类的子类:  False
[root@kube method]# 

__bases__    和__subclasses__()

[root@kube method]# cat demo13.py 
#coding:utf-8

class A:
    pass
class B(A):
    pass
class C(A):
    pass
#类的 __bases__ 属性查看该类的直接父类
print('类A 的所有父类:',A.__bases__)
print('类B 的所有父类:',B.__bases__)
print('类C 的所有父类:',C.__bases__)
#类的 __subclasses_() 方法。查看该类的所有直接子类

print('类A 的子类：',A.__subclasses__())
print('类B 的子类：',B.__subclasses__())
[root@kube method]# py demo13.py 
类A 的所有父类: (<class 'object'>,)
类B 的所有父类: (<class '__main__.A'>,)
类C 的所有父类: (<class '__main__.A'>,)
类A 的子类： [<class '__main__.B'>, <class '__main__.C'>]
类B 的子类： []
[root@kube method]# 

Python __call__方法（详解版）

前面章节中，我们用 hasattr() 函数判断指定属性（或方法）是否存在，但到底是属性还是方法，则需要进一步判断它是否可调用。程序可通过判断该属性（或方法）是否包含 __call__ 属性来确定它是否可调用

[root@kube method]# cat demo14.py 
#coding:utf-8

class User:
    def __init__(self, name , passwd):
        self.name = name
        self.passwd = passwd
    def valid_login(self):
        print('验证%s 的登录' % self.name)

u = User('jojo','123.com')
#判断 u.name 是否包含__call__方法，及判断是够可调用
print(hasattr(u.name,'__call__'))
print(hasattr(u.passwd,'__call__'))
print(hasattr(u.valid_login ,'__call__'))

[root@kube method]# py demo14.py 
False
False
True
[root@kube method]# 

实际上，一个函数（甚至对象）之所以能执行，关键就在于 __call__() 方法。实际上 x(arg1, arg2,...) 只是 x.__call__(arg1, arg2, ...) 的快捷写法，因此我们甚至可以为自定义类添加 __call__ 方法，从而使得该类的实例也变成可调用的。例如如下代码：

[root@kube method]# cat demo15.py 
# 定义Role类
class Role:
    def __init__ (self, name):
        self.name = name
    # 定义__call__方法
    def __call__(self):
        print('执行Role对象')
r = Role('管理员')
# 直接调用Role对象，就是调用该对象的__call__方法
r()
[root@kube method]# py demo15.py 
执行Role对象
[root@kube method]# 

__str__ 是一个类的内置方法，用于类的说明

例如：

[root@kube method]# cat demo16.py 
class person(object):

    def __init__(self, id, name):
        self.id = id
        self.name = name

    def __str__(self):
        return "{}---{}".format(self.id, self.name)  # .format()格式化输出



p = person(1, 'test1') 
print(p)
[root@kube method]# py demo16.py 
1---test1
[root@kube method]# 

　

什么是运算符重载，Python可重载运算符有哪些？

所谓重载运算符，指的是在类中定义并实现一个与运算符对应的处理方法，这样当类对象在进行运算符操作时，系统就会调用类中相应的方法来处理。

表 1 Python 常用重载运算符

重载运算符	含义
__new__	创建类，在 __init__ 之前创建对象
__init__	类的构造函数，其功能是创建类对象时做初始化工作。
__del__	析构函数，其功能是销毁对象时进行回收资源的操作
__add__	加法运算符 +，当类对象 X 做例如 X+Y 或者 X+=Y 等操作，内部会调用此方法。但如果类中对 __iadd__ 方法进行了重载，则类对象 X 在做 X+=Y 类似操作时，会优先选择调用 __iadd__ 方法。
__radd__	当类对象 X 做类似 Y+X 的运算时，会调用此方法。
__iadd__	重载 += 运算符，也就是说，当类对象 X 做类似 X+=Y 的操作时，会调用此方法。
__or__	“或”运算符 |，如果没有重载 __ior__，则在类似 X|Y、X|=Y 这样的语句中，“或”符号生效
__repr__，__str__	格式转换方法，分别对应函数 repr(X)、str(X)
__call__	函数调用，类似于 X(*args, **kwargs) 语句
__getattr__	点号运算，用来获取类属性
__setattr__	属性赋值语句，类似于 X.any=value
__delattr__	删除属性，类似于 del X.any
__getattribute__	获取属性，类似于 X.any
__getitem__	索引运算，类似于 X[key]，X[i:j]
__setitem__	索引赋值语句，类似于 X[key], X[i:j]=sequence
__delitem__	索引和分片删除
__get__, __set__, __delete__	描述符属性，类似于 X.attr，X.attr=value，del X.attr
__len__	计算长度，类似于 len(X)
__lt__，__gt__，__le__，__ge__，__eq__，__ne__	比较，分别对应于 <、>、<=、>=、=、!= 运算符。
__iter__，__next__	迭代环境下，生成迭代器与取下一条，类似于 I=iter(X) 和 next()
__contains__	成员关系测试，类似于 item in X
__index__	整数值，类似于 hex(X)，bin(X)，oct(X)
__enter__，__exit__	在对类对象执行类似 with obj as var 的操作之前，会先调用 __enter__ 方法，其结果会传给 var；在最终结束该操作之前，会调用 __exit__ 方法（常用于做一些清理、扫尾的工作）

[root@kube method]# cat demo17.py    #其中 __str__ , __lt__ , __add__ 都是重载运算符   ，使用相对应的运算符就会调用这些方法
class MyClass: #自定义一个类
    def __init__(self, name , age): #定义该类的初始化函数                     
        self.name = name #将传入的参数值赋值给成员交量
        self.age = age
    def __str__(self): #用于将值转化为字符串形式，等同于 str(obj)
        return "name:"+self.name+";age:"+str(self.age)
   
    __repr__ = __str__ #转化为供解释器读取的形式
   
    def __lt__(self, record): #重载 self<record 运算符
        if self.age < record.age:
            return True
        else:
            return False
   
    def __add__(self, record): #重载 + 号运算符
        return MyClass(self.name, self.age+record.age)
myc = MyClass("Anna", 42) #实例化一个对象 Anna，并为其初始化
mycl = MyClass("Gary", 23) #实例化一个对象 Gary，并为其初始化
print(repr(myc)) #格式化对象 myc，
print(myc) #解释器读取对象 myc，调用 repr
print (str (myc)) #格式化对象 myc ，输出"name:Anna;age:42"
print(myc < mycl) #比较 myc<mycl 的结果，输出 False
print (myc+mycl) #进行两个 MyClass 对象的相加运算，输出 "name:Anna;age:65"
[root@kube method]# py demo17.py 
name:Anna;age:42
name:Anna;age:42
name:Anna;age:42
False
name:Anna;age:65
[root@kube method]# 

Python重载运算符实现自定义序列

 Python 可重载的运算符中，有如下几个和序列操作相关的特殊方法：

• __len__(self)：该方法的返回值决定序列中元素的个数。
• __getitem__(self, key)：该方法获取指定索引对应的元素。该方法的 key 应该是整数值或 slice 对象，否则该方法会引发 KeyError 异常。
• __contains__(self, item)：该方法判断序列是否包含指定元素。
• __setitem__(self, key, value)：该方法设置指定索引对应的元素。该方法的 key 应该是整数值或 slice 对象，否则该方法会引发 KeyError 异常。
• __delitem__(self, key)：该方法删除指定索引对应的元素。

在此基础上，如果根据特定的需求对这些方法进行重载，即可实现自定义一个序列类。

什么是迭代器，Python迭代器及其用法

 前面介绍了使用 for 循环遍历列表、元组和字典等，这些对象都是可迭代的，因此它们都属于迭代器。迭代器其实就是一个实现了迭代器协议的容器类对象。

简单的理解容器，就是用来存放各种元素的，是各种元素的集合。常用的容器包括元组、列表、字典、集合等。

迭代器基于以下两个方法实现：

1. __next__(self)：返回容器的下一个元素。
2. __iter__(self)：该方法返回一个迭代器（iterator）。

迭代器可以利用 Python 内置的 iter() 函数和一个序列来创建。例如：

[root@kube method]# cat demo18.py 
#coding:utf-8

my_iter = iter([1,'abc','jojo'])
print(my_iter.__next__())
print(my_iter.__next__())
print(my_iter.__next__())
print(my_iter.__next__())
[root@kube method]# py demo18.py 
1
abc
jojo
Traceback (most recent call last):
  File "demo18.py", line 7, in <module>
    print(my_iter.__next__())
StopIteration
[root@kube method]# 

可以看到，当遍历完序列之后如果继续遍历，会引发 StopIteration 异常，这样迭代器就可以与循环兼容，因为可以捕获这个异常并停止循环。例如：

[root@kube method]# cat demo18.py 
#coding:utf-8

my_iter = iter([1,'abc','jojo'])
for i in my_iter:
    print(i)
[root@kube method]# py demo18.py 
1
abc
jojo
[root@kube method]# 

Python 也允许我们自定义一个迭代器，只需要实现 __next__() 和 __iter__() 特殊方法即可。例如：

[root@kube method]# cat demo19.py 
#coding:utf-8

class countDown:
    def __init__(self,step):
        self.step = step
    def __iter__(self):    #将类转换为迭代器
        return self
    def __next__(self):     #使用 __next__ 进行迭代
        if self.step <= 0:
            raise StopIteration
        self.step -= 1 
        return self.step

for i in countDown(9):
    print(i, end= ' ')
[root@kube method]# py demo19.py 
8 7 6 5 4 3 2 1 0 [root@kube method]# 

Python项目实战之迭代器实现字符串的逆序输出

[root@kube method]# cat demo20.py 
#coding:utf-8

class Reverse:
    def __init__(self, string):
        self.__string = string
        self.__index = len(string)
    def __iter__(self):
        return self
    def __next__(self):
        if self.__index == 0:
            raise(StopIteration)
        self.__index -= 1
    
        return self.__string[self.__index]

for i in Reverse('Python'):
    print(i , end= ' ')
[root@kube method]# py demo20.py 
n o h t y P [root@kube method]# 

Python生成器详解

生成器和迭代器的功能非常相似，它也会提供 __next__() 方法，这意味着程序同样可调用内置的 next() 函数来获取生成器的下一个值，也可使用 for 循环来遍历生成器。

生成器与迭代器的区别在于，迭代器通常是先定义一个迭代器类，然后通过创建实例来创建迭代器；而生成器则是先定义一个包含 yield 语句的函数，然后通过调用该函数来创建生成器。

生成器是一种非常优秀的语法，Python 使用生成器可以让程序变得很优雅。

创建生成器

创建生成器需要两步操作：

1. 定义一个包含 yield 语句的函数。
2. 调用第 1 步创建的函数得到生成器。

[root@kube method]# cat demo21.py 
#coding:utf-8

def test(val):
    for i in range(val):
        yield i      #创建一个包含 yield 语句的函数

t = test(10)
print(t)
print(next(t))    #使用next() 方法调用 函数 ，每次执行只得到一个返回结果
for i in t:
    print(i ,end=' ')
[root@kube method]# py demo21.py 
<generator object test at 0x7fac02d3e9d0>
0
1 2 3 4 5 6 7 8 9 [root@kube method]# 

 系统学习本教程的读者应该知道，前面章节还介绍过使用 for 循环来创建生成器（将 for 表达式放在圆括号里）。可见，Python 主要提供了以下两种方式来创建生成器：

1. 使用 for 循环的生成器推导式。
2. 调用带 yield 语句的生成器函数。

生成器是 Python 的一个特色功能，在其他语言中往往没有对应的机制，因此很多 Python 开发者对生成器机制不甚了解。但实际上生成器是一种非常优秀的机制，以我们实际开发的经验来看，使用生成器至少有以下几个优势：

• 当使用生成器来生成多个数据时，程序是按需获取数据的，它不会一开始就把所有数据都生成出来，而是每次调用 next() 获取下一个数据时，生成器才会执行一次，因此可以减少代码的执行次数。比如前面介绍的示例，程序不会一开始就把生成器函数中的循环都执行完成，而是每次调用 next() 时才执行一次循环体。
• 当函数需要返回多个数据时，如果不使用生成器，程序就需要使用列表或元组来收集函数返回的多个值，当函数要返回的数据量较大时，这些列表、元组会带来一定的内存开销。如果使用生成器就不存在这个问题，生成器可以按需、逐个返回数据。
• 使用生成器的代码更加简洁。

Python @函数装饰器及用法（超级详细）

 前面章节中，我们已经讲解了 Python 内置的 3 种函数装饰器，分别是 ＠staticmethod、＠classmethod 和 @property，其中 staticmethod、classmethod 和 property 都是 Python 的内置函数。那么，我们是否可以开发自定义的函数装饰器呢？

答案是肯定的。当程序使用“＠函数”（比如函数 A）装饰另一个函数（比如函数 B）时，实际上完成如下两步：

1. 将被修饰的函数（函数 B）作为参数传给 ＠ 符号引用的函数（函数 A）。
2. 将函数 B 替换（装饰）成第 1 步的返回值。

从上面介绍不难看出，被“＠函数”修饰的函数不再是原来的函数，而是被替换成一个新的东西（取决于装饰器的返回值）。其实所谓的装饰器，就是通过装饰器函数，来修改原函数的一些功能，使得原函数不需要修改。

[root@kube method]# cat demo24.py 
#coding:utf-8

def A(fn):
    print('a_fun')
    fn()   　　　　　　#执行传入的函数fn
    print('a_END')
@A   　　　　　　　　#对函数B()进行修饰
def B():
    print('B_fun')

print(B)

[root@kube method]# py demo24.py 
a_fun
B_fun
a_END
None
[root@kube method]#

 别忘记了，被修饰的函数总是被替换成 ＠ 符号所引用的函数的返回值，因此被修饰的函数会变成什么，完全由于 ＠ 符号所引用的函数的返回值决定，换句话说，如果 ＠ 符号所引用的函数的返回值是函数，那么被修饰的函数在替换之后还是函数。

带参数的函数装饰器

[root@kube method]# cat demo24.py 
#coding:utf-8

def A(fn):
    print('a_fun')
    fn()   #执行传入的函数fn
    print('a_END')
@A
def B():
    print('B_fun')

print(B)

[root@kube method]# py demo25.py 
<function foo.<locals>.bar at 0x7f86d0705440>
==my_test函数== 90
***************
==my_test函数== 90
[root@kube method]# 

上面程序定义了一个装饰器函数 foo，该函数执行完成后并不是返回普通值，而是返回 bar 函数（这是关键），这意味着被该 ＠foo 修饰的 my_test() 函数最终都会被替换成 bar() 函数。

上面程序使用 ＠foo 修饰 my_test() 函数，因此程序同样会执行 foo(my_test)，并将 my_test 替换成 foo() 函数的返回值：bar 函数。所以，上面程序第 18 行代码在打印 my_test 函数时，实际上输出的是 bar 函数，这说明 my_test 已经被替换成 bar 函数。接下来程序调用 my_test() 函数，实际上就是调用 bar() 函数。

接收任意数量和类型的参数

[root@kube method]# cat demo26.py 
def foo(fn):
    # 定义一个嵌套函数
    def bar(*args,**kwargs):
        fn(*args,**kwargs)
    return bar
@foo
def my_test(a):
    print("==my_test函数==", a)
@foo
def new_test(a,b):
    print("==new_test函数==",a," ",b)
my_test(10)
new_test(6, 5)
[root@kube method]# py demo26.py 
==my_test函数== 10
==new_test函数== 6   5
[root@kube method]# 

带自定义参数的函数装饰器

，装饰器可以接受原函数任意类型和数量的参数，除此之外，它还可以接受自己定义的参数。

举个例子，比如要定义一个参数，来表示装饰器内部函数被执行的次数，那么就可以写成下面这种形式：

[root@kube method]# cat demo27.py 
def foo(num):
    def my_decorator(fn):
        def bar(*args,**kwargs):
            for i in range(num):
                fn(*args,**kwargs)
        return bar
    return my_decorator
@foo(3)
def my_test(a):
    print("==my_test函数==", a)
@foo(5)
def new_test(a,b):
    print("==new_test函数==",a," ",b)
my_test(10)
new_test(6, 5)
[root@kube method]# py demo27.py 
==my_test函数== 10
==my_test函数== 10
==my_test函数== 10
==new_test函数== 6   5
==new_test函数== 6   5
==new_test函数== 6   5
==new_test函数== 6   5
==new_test函数== 6   5
[root@kube method]# 

函数装饰器也可以嵌套

上面示例中，都是使用一个装饰器的情况，但实际上，Python 也支持多个装饰器，比如：
@decorator1
@decorator2
@decorator3
def func():
    ...
上面程序的执行顺序是里到外，所以它等效于下面这行代码：
decorator1( decorator2( decorator3(func) ) )