Python __new__()方法
__new__() 是一种负责创建类实例的静态方法,它无需使用 staticmethod 装饰器修饰,且该方法会优先 __init__() 初始化方法被调用
一般情况下,覆写 __new__() 的实现将会使用合适的参数调用其超类的 super().__new__(),并在返回之前修改实例
class demoClass:
instances_created = 0
def __new__(cls,*args,**kwargs):
print("__new__():",cls,args,kwargs)
instance = super().__new__(cls)
instance.number = cls.instances_created
cls.instances_created += 1
return instance
def __init__(self,attribute):
print("__init__():",self,attribute)
self.attribute = attribute
test1 = demoClass("abc")
test2 = demoClass("xyz")
print(test1.number,test1.instances_created)
print(test2.number,test2.instances_created)
运行结果:
__new__(): <class '__main__.demoClass'> ('abc',) {}
__init__(): <__main__.demoClass object at 0x0000026FC0DF8080> abc
__new__(): <class '__main__.demoClass'> ('xyz',) {}
__init__(): <__main__.demoClass object at 0x0000026FC0DED358> xyz
0 2
1 2
__new__() 通常会返回该类的一个实例,但有时也可能会返回其他类的实例,如果发生了这种情况,则会跳过对 __init__() 方法的调用。而在某些情况下(比如需要修改不可变类实例(Python 的某些内置类型)的创建行为),利用这一点会事半功倍
class nonZero(int):
def __new__(cls,value):
return super().__new__(cls,value) if value != 0 else None
def __init__(self,skipped_value):
#此例中会跳过此方法
print("__init__()")
super().__init__()
print(type(nonZero(-12)))
print(type(nonZero(0)))
运行结果:
__init__()
<class '__main__.nonZero'>
<class 'NoneType'>
什么情况下使用 __new__() 呢?答案很简单,在 __init__() 不够用的时候
注意,由于 __new__() 不限于返回同一个类的实例,所以很容易被滥用,不负责任地使用这种方法可能会对代码有害,所以要谨慎使用
Python __repr__()方法:显示属性
直接输出类的实例化对象
class CLanguage:
pass
clangs = CLanguage()
print(clangs)
运行结果:
<__main__.CLanguage object at 0x000001A7275221D0>
通常情况下,直接输出某个实例化对象,本意往往是想了解该对象的基本信息,例如该对象有哪些属性,它们的值各是多少等等。但默认情况下,得到的信息只会是“类名+object at+内存地址”,对了解该实例化对象帮助不大
有没有可能自定义输出实例化对象时的信息呢?答案是肯定,通过重写类的 __repr__() 方法即可。事实上,当我们输出某个实例化对象时,其调用的就是该对象的 __repr__() 方法,输出的是该方法的返回值
执行 print(clangs) 等同于执行 print(clangs.__repr__()),程序的输出结果是一样的(输出的内存地址可能不同)
和 __init__(self) 的性质一样,Python 中的每个类都包含 __repr__() 方法,因为 object 类包含 __repr__() 方法,而 Python 中所有的类都直接或间接继承自 object 类
默认情况下,__repr__() 会返回和调用者有关的 “类名+object at+内存地址”信息。当然,还可以通过在类中重写这个方法,从而实现当输出实例化对象时,输出想要的信息
class CLanguage:
def __init__(self):
self.name = "C语言中文网"
self.add = "http://c.biancheng.net"
def __repr__(self):
return "CLanguage[name="+ self.name +",add=" + self.add +"]"
clangs = CLanguage()
print(clangs)
运行结果:
CLanguage[name=C语言中文网,add=http://c.biancheng.net]
__repr__() 方法是类的实例化对象用来做“自我介绍”的方法,默认情况下,它会返回当前对象的“类名+object at+内存地址”,而如果对该方法进行重写,可以为其制作自定义的自我描述信息
Python __del__()方法:销毁对象
Python 通过调用 __init__() 方法构造当前类的实例化对象,而 __del__() 方法,功能正好和 __init__() 相反,其用来销毁实例化对象
事实上在编写程序时,如果之前创建的类实例化对象后续不再使用,最好在适当位置手动将其销毁,释放其占用的内存空间(整个过程称为垃圾回收(简称GC))
大多数情况下,Python 开发者不需要手动进行垃圾回收,因为 Python 有自动的垃圾回收机制,能自动将不需要使用的实例对象进行销毁
无论是手动销毁,还是 Python 自动销毁,都会调用 __del__() 方法
class CLanguage:
def __init__(self):
print("调用 __init__() 方法构造对象")
def __del__(self):
print("调用__del__() 销毁对象,释放其空间")
clangs = CLanguage()
del clangs
运行结果:
调用 __init__() 方法构造对象
调用__del__() 销毁对象,释放其空间
class CLanguage:
def __init__(self):
print("调用 __init__() 方法构造对象")
def __del__(self):
print("调用__del__() 销毁对象,释放其空间")
clangs = CLanguage()
#添加一个引用clangs对象的实例对象
cl = clangs
del clangs
print("***********")
运行结果:
调用 __init__() 方法构造对象
***********
调用__del__() 销毁对象,释放其空间
注意,最后一行输出信息,是程序执行即将结束时调用 __del__() 方法输出的
当程序中有其它变量(比如这里的 cl)引用该实例对象时,即便手动调用 __del__() 方法,该方法也不会立即执行。这和 Python 的垃圾回收机制的实现有关
Python 采用自动引用计数(简称 ARC)的方式实现垃圾回收机制。该方法的核心思想是:每个 Python 对象都会配置一个计数器,初始 Python 实例对象的计数器值都为 0,如果有变量引用该实例对象,其计数器的值会加 1,依次类推;反之,每当一个变量取消对该实例对象的引用,计数器会减 1。如果一个 Python 对象的的计数器值为 0,则表明没有变量引用该 Python 对象,即证明程序不再需要它,此时 Python 就会自动调用 __del__() 方法将其回收
以上面程序中的 clangs 为例,实际上构建 clangs 实例对象的过程分为 2 步,先使用 CLanguage() 调用该类中的 __init__() 方法构造出一个该类的对象(将其称为 C,计数器为 0),并立即用 clangs 这个变量作为所建实例对象的引用( C 的计数器值 + 1)。在此基础上,又有一个 cl变量引用 clangs(其实相当于引用 CLanguage(),此时 C 的计数器再 +1 ),这时如果调用del clangs
语句,只会导致 C 的计数器减 1(值变为 1),因为 C 的计数器值不为 0,因此 C 不会被销毁(不会执行 __del__() 方法)
如果在上面程序结尾,添加如下语句
del cl
print("-----------")
运行结果:
调用 __init__() 方法构造对象
***********
调用__del__() 销毁对象,释放其空间
-----------
当执行 del cl 语句时,其应用的对象实例对象 C 的计数器继续 -1(变为 0),对于计数器为 0 的实例对象,Python 会自动将其视为垃圾进行回收
如果重写子类的 __del__() 方法(父类为非 object 的类),则必须显式调用父类的 __del__() 方法,这样才能保证在回收子类对象时,其占用的资源(可能包含继承自父类的部分资源)能被彻底释放
反例
class CLanguage:
def __del__(self):
print("调用父类 __del__() 方法")
class cl(CLanguage):
def __del__(self):
print("调用子类 __del__() 方法")
c = cl()
del c
运行结果:
调用子类 __del__() 方法
Python __dir__()方法:列出对象的所有属性(方法)名
dir() 函数,通过此函数可以查看某个对象拥有的所有的属性名和方法名,该函数会返回一个包含有所有属性名和方法名的有序列表
class CLanguage:
def __init__ (self,):
self.name = "C语言中文网"
self.add = "http://c.biancheng.net"
def say():
pass
clangs = CLanguage()
print(dir(clangs))
运行结果:
['__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__', 'add', 'name', 'say']
注意,通过 dir() 函数,不仅仅输出本类中新添加的属性名和方法(最后 3 个),还会输出从父类(这里为 object 类)继承得到的属性名和方法名
dir() 函数的内部实现,其实是在调用参数对象 __dir__() 方法的基础上,对该方法返回的属性名和方法名做了排序
所以,除了使用 dir() 函数,完全可以自行调用该对象具有的 __dir__() 方法
class CLanguage:
def __init__ (self,):
self.name = "C语言中文网"
self.add = "http://c.biancheng.net"
def say():
pass
clangs = CLanguage()
print(clangs.__dir__())
运行结果:
['name', 'add', '__module__', '__init__', 'say', '__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__']
使用 __dir__() 方法和 dir() 函数输出的数据是相同,仅仅顺序不同
Python __dict__属性:查看对象内部所有属性名和属性值组成的字典
在 Python 类的内部,无论是类属性还是实例属性,都是以字典的形式进行存储的,其中属性名作为键,而值作为该键对应的值
为了方便用户查看类中包含哪些属性,Python 类提供了 __dict__ 属性。需要注意的一点是,该属性可以用类名或者类的实例对象来调用,用类名直接调用 __dict__,会输出该由类中所有类属性组成的字典;而使用类的实例对象调用 __dict__,会输出由类中所有实例属性组成的字典
class CLanguage:
a = 1
b = 2
def __init__ (self):
self.name = "C语言中文网"
self.add = "http://c.biancheng.net"
#通过类名调用__dict__
print(CLanguage.__dict__)
#通过类实例对象调用 __dict__
clangs = CLanguage()
print(clangs.__dict__)
运行结果:
{'__module__': '__main__', 'a': 1, 'b': 2, '__init__': <function CLanguage.__init__ at 0x0000022C69833E18>, '__dict__': <attribute '__dict__' of 'CLanguage' objects>, '__weakref__': <attribute '__weakref__' of 'CLanguage' objects>, '__doc__': None}
{'name': 'C语言中文网', 'add': 'http://c.biancheng.net'}
对于具有继承关系的父类和子类来说,父类有自己的 __dict__,同样子类也有自己的 __dict__,它不会包含父类的 __dict__
class CLanguage:
a = 1
b = 2
def __init__ (self):
self.name = "C语言中文网"
self.add = "http://c.biancheng.net"
class CL(CLanguage):
c = 1
d = 2
def __init__ (self):
self.na = "Python教程"
self.ad = "http://c.biancheng.net/python"
#父类名调用__dict__
print(CLanguage.__dict__)
#子类名调用__dict__
print(CL.__dict__)
#父类实例对象调用 __dict__
clangs = CLanguage()
print(clangs.__dict__)
#子类实例对象调用 __dict__
cl = CL()
print(cl.__dict__)
运行结果:
{'__module__': '__main__', 'a': 1, 'b': 2, '__init__': <function CLanguage.__init__ at 0x000001721A853E18>, '__dict__': <attribute '__dict__' of 'CLanguage' objects>, '__weakref__': <attribute '__weakref__' of 'CLanguage' objects>, '__doc__': None}
{'__module__': '__main__', 'c': 1, 'd': 2, '__init__': <function CL.__init__ at 0x000001721CD15510>, '__doc__': None}
{'name': 'C语言中文网', 'add': 'http://c.biancheng.net'}
{'na': 'Python教程', 'ad': 'http://c.biancheng.net/python'}
通过子类直接调用的 __dict__ 中,并没有包含父类中的 a 和 b 类属性;同样,通过子类对象调用的 __dict__,也没有包含父类对象拥有的 name 和 add 实例属性
借助由类实例对象调用 __dict__ 属性获取的字典,可以使用字典的方式对其中实例属性的值进行修改
class CLanguage:
a = "aaa"
b = 2
def __init__ (self):
self.name = "C语言中文网"
self.add = "http://c.biancheng.net"
#通过类实例对象调用 __dict__
clangs = CLanguage()
print(clangs.__dict__)
clangs.__dict__['name'] = "Python教程"
print(clangs.name)
运行结果:
{'name': 'C语言中文网', 'add': 'http://c.biancheng.net'}
Python教程
注意,无法通过类似的方式修改类变量的值
Python setattr()、getattr()、hasattr()函数
Python hasattr()函数
hasattr() 函数用来判断某个类实例对象是否包含指定名称的属性或方法
hasattr(obj, name)
obj 指的是某个类的实例对象,name 表示指定的属性名或方法名。同时,该函数会将判断的结果(True 或者 False)作为返回值反馈回来
class CLanguage:
def __init__ (self):
self.name = "C语言中文网"
self.add = "http://c.biancheng.net"
def say(self):
print("我正在学Python")
clangs = CLanguage()
print(hasattr(clangs,"name"))
print(hasattr(clangs,"add"))
print(hasattr(clangs,"say"))
运行结果:
True
True
True
无论是属性名还是方法名,都在 hasattr() 函数的匹配范围内
只能通过该函数判断实例对象是否包含该名称的属性或方法,但不能精确判断,该名称代表的是属性还是方法
Python getattr() 函数
getattr() 函数获取某个类实例对象中指定属性的值。没错,和 hasattr() 函数不同,该函数只会从类对象包含的所有属性中进行查找
getattr(obj, name[, default])
obj 表示指定的类实例对象,name 表示指定的属性名,而 default 是可选参数,用于设定该函数的默认返回值,即当函数查找失败时,如果不指定 default 参数,则程序将直接报 AttributeError 错误,反之该函数将返回 default 指定的值
class CLanguage:
def __init__ (self):
self.name = "C语言中文网"
self.add = "http://c.biancheng.net"
def say(self):
print("我正在学Python")
clangs = CLanguage()
print(getattr(clangs,"name"))
print(getattr(clangs,"add"))
print(getattr(clangs,"say"))
print(getattr(clangs,"display",'nodisplay'))
运行结果:
C语言中文网
http://c.biancheng.net
<bound method CLanguage.say of <__main__.CLanguage object at 0x000001FC2F2E3198>>
nodisplay
对于类中已有的属性,getattr() 会返回它们的值,而如果该名称为方法名,则返回该方法的状态信息;反之,如果不为类对象所有,要么返回默认的参数,要么程序报 AttributeError 错误
Python setattr()函数
setattr() 函数的功能相对比较复杂,它最基础的功能是修改类实例对象中的属性值。其次,它还可以实现为实例对象动态添加属性或者方法
setattr(obj, name, value)
class CLanguage:
def __init__ (self):
self.name = "C语言中文网"
self.add = "http://c.biancheng.net"
def say(self):
print("我正在学Python")
clangs = CLanguage()
print(clangs.name)
print(clangs.add)
setattr(clangs,"name","Python教程")
setattr(clangs,"add","http://c.biancheng.net/python")
print(clangs.name)
print(clangs.add)
运行结果:
C语言中文网
http://c.biancheng.net
Python教程
http://c.biancheng.net/python
利用 setattr() 函数,还可以将类属性修改为一个类方法,同样也可以将类方法修改成一个类属性
def say(self):
print("我正在学Python")
class CLanguage:
def __init__ (self):
self.name = "C语言中文网"
self.add = "http://c.biancheng.net"
clangs = CLanguage()
print(clangs.name)
print(clangs.add)
setattr(clangs,"name",say)
clangs.name(clangs)
运行结果:
C语言中文网
http://c.biancheng.net
我正在学Python
通过修改 name 属性的值为 say(这是一个外部定义的函数),原来的 name 属性就变成了一个 name() 方法
使用 setattr() 函数对实例对象中执行名称的属性或方法进行修改时,如果该名称查找失败,Python 解释器不会报错,而是会给该实例对象动态添加一个指定名称的属性或方法
def say(self):
print("我正在学Python")
class CLanguage:
pass
clangs = CLanguage()
setattr(clangs,"name","C语言中文网")
setattr(clangs,"say",say)
print(clangs.name)
clangs.say(clangs)
运行结果:
C语言中文网
我正在学Python
Python issubclass和isinstance函数:检查类型
Python 提供了如下两个函数来检查类型
- issubclass(cls, class_or_tuple):检查 cls 是否为后一个类或元组包含的多个类中任意类的子类
- isinstance(obj, class_or_tuple):检查 obj 是否为后一个类或元组包含的多个类中任意类的对象
# 定义一个字符串
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))
issubclass() 和 isinstance() 两个函数的用法差不多,区别只是 issubclass() 的第一个参数是类名,而 isinstance() 的第一个参数是变量,这也与两个函数的意义对应:issubclass 用于判断是否为子类,而 isinstance() 用于判断是否为该类或子类的实例
issubclass() 和 isinstance() 两个函数的第二个参数都可使用元组
data = (20, 'fkit')
print('data是否为列表或元组: ', isinstance(data, (list, tuple))) # True
# str不是list或者tuple的子类,输出False
print('str是否为list或tuple的子类: ', issubclass(str, (list, tuple)))
# str是list或tuple或object的子类,输出True
print('str是否为list或tuple或object的子类 ', issubclass(str, (list, tuple, object)))
Python 为所有类都提供了一个 __bases__ 属性,通过该属性可以查看该类的所有直接父类,该属性返回所有直接父类组成的元组
class A:
pass
class B:
pass
class C(A, B):
pass
print('类A的所有父类:', A.__bases__)
print('类B的所有父类:', B.__bases__)
print('类C的所有父类:', C.__bases__)
运行结果:
类A的所有父类: (<class 'object'>,)
类B的所有父类: (<class 'object'>,)
类C的所有父类: (<class '__main__.A'>, <class '__main__.B'>)
如果在定义类时没有显式指定它的父类,则这些类默认的父类是 object 类
Python 还为所有类都提供了一个 __subclasses__() 方法,通过该方法可以查看该类的所有直接子类,该方法返回该类的所有子类组成的列表
print('类A的所有子类:', A.__subclasses__())
print('类B的所有子类:', B.__subclasses__())
运行结果:
类A的所有子类: [<class '__main__.C'>]
类B的所有子类: [<class '__main__.C'>]
Python __call__()方法
__call__(),该方法的功能类似于在类中重载 () 运算符,使得类实例对象可以像调用普通函数那样,以“对象名()”的形式使用
class CLanguage:
# 定义__call__方法
def __call__(self,name,add):
print("调用__call__()方法",name,add)
clangs = CLanguage()
clangs("C语言中文网","http://c.biancheng.net")
运行结果:
调用__call__()方法 C语言中文网 http://c.biancheng.net
通过在 CLanguage 类中实现 __call__() 方法,使的 clangs 实例对象变为了可调用对象
Python 中,凡是可以将 () 直接应用到自身并执行,都称为可调用对象
对于可调用对象,实际上“名称()”可以理解为是“名称.__call__()”的简写
clangs.__call__("C语言中文网","http://c.biancheng.net")
其运行结果和之前完全相同
def say():
print("Python教程:http://c.biancheng.net/python")
say()
say.__call__()
运行结果:
Python教程:http://c.biancheng.net/python
Python教程:http://c.biancheng.net/python
用 __call__() 弥补 hasattr() 函数的短板
hasattr() ,该函数的功能是查找类的实例对象中是否包含指定名称的属性或者方法,但该函数有一个缺陷,即它无法判断该指定的名称,到底是类属性还是类方法
class CLanguage:
def __init__ (self):
self.name = "C语言中文网"
self.add = "http://c.biancheng.net"
def say(self):
print("我正在学Python")
clangs = CLanguage()
if hasattr(clangs,"name"):
print(hasattr(clangs.name,"__call__"))
print("**********")
if hasattr(clangs,"say"):
print(hasattr(clangs.say,"__call__"))
运行结果:
False
**********
True
由于 name 是类属性,它没有以 __call__ 为名的 __call__() 方法;而 say 是类方法,它是可调用对象,因此它有 __call__() 方法
Python可重载运算符
在 Python 内部,每种序列类型都是 Python 的一个类,例如列表是 list 类,字典是 dict 类等,这些序列类的内部使用了一个叫作“重载运算符”的技术来实现不同运算符所对应的操作
所谓重载运算符,指的是在类中定义并实现一个与运算符对应的处理方法,这样当类对象在进行运算符操作时,系统就会调用类中相应的方法来处理
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"
运行结果:
name:Anna;age:42
name:Anna;age:42
name:Anna;age:42
False
name:Anna;age:65
重载运算符 | 含义 |
__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__ 方法(常用于做一些清理、扫尾的工作) |
Python迭代器
从字面来理解,迭代器指的就是支持迭代的容器,更确切的说,是支持迭代的容器类对象,这里的容器可以是列表、元组等这些 Python 提供的基础容器,也可以是自定义的容器类对象,只要该容器支持迭代即可
自定义实现一个迭代器,则类中必须实现如下 2 个方法
- __next__(self):返回容器的下一个元素
- __iter__(self):该方法返回一个迭代器(iterator)
class listDemo:
def __init__(self):
self.__date=[]
self.__step = 0
def __next__(self):
if self.__step <= 0:
raise StopIteration
self.__step -= 1
#返回下一个元素
return self.__date[self.__step]
def __iter__(self):
#实例对象本身就是迭代器对象,因此直接返回 self 即可
return self
#添加元素
def __setitem__(self,key,value):
self.__date.insert(key,value)
self.__step += 1
mylist = listDemo()
mylist[0]=1
mylist[1]=2
for i in mylist:
print (i)
运行结果:
2
1
Python 内置的 iter() 函数也会返回一个迭代器
iter(obj[, sentinel])
obj 必须是一个可迭代的容器对象,而 sentinel 作为可选参数,如果使用此参数,要求 obj 必须是一个可调用对象
可调用对象,指的是该类的实例对象可以像函数那样,直接以“对象名()”的形式被使用。通过在类中添加 __call__() 方法,就可以将该类的实例对象编程可调用对象
# 将列表转换为迭代器
myIter = iter([1, 2, 3])
# 依次获取迭代器的下一个元素
print(myIter.__next__())
print(myIter.__next__())
print(myIter.__next__())
print(myIter.__next__())
运行结果:
1
2
3
Traceback (most recent call last):
File "C:\Users\mengma\Desktop\demo.py", line 7, in <module>
print(myIter.__next__())
StopIteration
也可以使用 next() 内置函数来迭代,即 next(myIter),和 __next__() 方法是完全一样的
当迭代完存储的所有元素之后,如果继续迭代,则 __next__() 方法会抛出 StopIteration 异常
iter() 函数第 2 个参数的作用,如果使用该参数,则要求第一个 obj 参数必须传入可调用对象(可以不支持迭代),这样当使用返回的迭代器调用 __next__() 方法时,它会通过执行 obj() 调用 __call__() 方法,如果该方法的返回值和第 2 个参数值相同,则输出 StopInteration 异常;反之,则输出 __call__() 方法的返回值
class listDemo:
def __init__(self):
self.__date=[]
self.__step = 0
def __setitem__(self,key,value):
self.__date.insert(key,value)
self.__step += 1
#是该类实例对象成为可调用对象
def __call__(self):
self.__step-=1
return self.__date[self.__step]
mylist = listDemo()
mylist[0]=1
mylist[1]=2
#将 mylist 变为迭代器
a = iter(mylist,1)
print(a.__next__())
print(a.__next__())
运行结果:
2
Traceback (most recent call last):
File "D:\python3.6\1.py", line 20, in <module>
print(a.__next__())
StopIteration
之所以最终抛出 StopIteration 异常,是因为这里原本要输出的元素 1 和 iter() 函数的第 2 个参数相同
Python生成器
生成器本质上也是迭代器,不过它比较特殊
以 list 容器为例,在使用该容器迭代一组数据时,必须事先将所有数据存储到容器中,才能开始迭代;而生成器却不同,它可以实现在迭代的同时生成元素
也就是说,对于可以用某种算法推算得到的多个数据,生成器并不会一次性生成它们,而是什么时候需要,才什么时候生成
生成器的创建方式也比迭代器简单很多,大体分为以下 2 步
- 定义一个以 yield 关键字标识返回值的函数
- 调用刚刚创建的函数,即可创建一个生成器
def intNum():
print("开始执行")
for i in range(5):
yield i
print("继续执行")
num = intNum()
显然,和普通函数不同,intNum() 函数的返回值用的是 yield 关键字,而不是 return 关键字,此类函数又成为生成器函数
和 return 相比,yield 除了可以返回相应的值,还有一个更重要的功能,即每当程序执行完该语句时,程序就会暂停执行。不仅如此,即便调用生成器函数,Python 解释器也不会执行函数中的代码,它只会返回一个生成器(对象)
要想使生成器函数得以执行,或者想使执行完 yield 语句立即暂停的程序得以继续执行,有以下 2 种方式
- 通过生成器(上面程序中的 num)调用 next() 内置函数或者 __next__() 方法
- 通过 for 循环遍历生成器
#调用 next() 内置函数
print(next(num))
#调用 __next__() 方法
print(num.__next__())
#通过for循环遍历生成器
for i in num:
print(i)
运行结果:
开始执行
0
继续执行
1
继续执行
2
继续执行
3
继续执行
4
继续执行
- 首先,在创建有 num 生成器的前提下,通过其调用 next() 内置函数,会使 Python 解释器开始执行 intNum() 生成器函数中的代码,因此会输出“开始执行”,程序会一直执行到
yield i
,而此时的 i==0,因此 Python 解释器输出“0”。由于受到 yield 的影响,程序会在此处暂停 - 然后,使用 num 生成器调用 __next__() 方法,该方法的作用和 next() 函数完全相同(事实上,next() 函数的底层执行的也是 __next__() 方法),它会是程序继续执行,即输出“继续执行”,程序又会执行到
yield i
,此时 i==1,因此输出“1”,然后程序暂停 - 最后,使用 for 循环遍历 num 生成器,之所以能这么做,是因为 for 循环底层会不断地调用 next() 函数,使暂停的程序继续执行,因此会输出后续的结果
注意,在 Python 2.x 版本中不能使用 __next__() 方法,可以使用 next() 内置函数,另外生成器还有 next() 方法(即以 num.next() 的方式调用)
还可以使用 list() 函数和 tuple() 函数,直接将生成器能生成的所有值存储成列表或者元组的形式
num = intNum()
print(list(num))
num = intNum()
print(tuple(num))
运行结果:
开始执行
继续执行
继续执行
继续执行
继续执行
继续执行
[0, 1, 2, 3, 4]
开始执行
继续执行
继续执行
继续执行
继续执行
继续执行
(0, 1, 2, 3, 4)
list() 和 tuple() 底层实现和 for 循环的遍历过程是类似的
相比迭代器,生成器最明显的优势就是节省内存空间,即它不会一次性生成所有的数据,而是什么时候需要,什么时候生成
Python @函数装饰器
函数装饰器的工作原理是怎样的呢?假设用 funA() 函数装饰器去装饰 funB() 函数
#funA 作为装饰器函数
def funA(fn):
#...
fn() # 执行传入的fn参数
#...
return '...'
@funA
def funB():
#...
上面程序完全等价于下面的程序
def funA(fn):
#...
fn() # 执行传入的fn参数
#...
return '...'
def funB():
#...
funB = funA(funB)
使用函数装饰器 A() 去装饰另一个函数 B(),其底层执行了如下 2 步操作
- 将 B 作为参数传给 A() 函数
- 将 A() 函数执行完成的返回值反馈回 B
#funA 作为装饰器函数
def funA(fn):
print("C语言中文网")
fn() # 执行传入的fn参数
print("http://c.biancheng.net")
return "装饰器函数的返回值"
@funA
def funB():
print("学习 Python")
运行结果:
C语言中文网
学习 Python
http://c.biancheng.net
如果在程序末尾添加如下语句
print(funB)
运行结果:
装饰器函数的返回值
被“@函数”修饰的函数不再是原来的函数,而是被替换成一个新的东西(取决于装饰器的返回值),即如果装饰器函数的返回值为普通变量,那么被修饰的函数名就变成了变量名;同样,如果装饰器返回的是一个函数的名称,那么被修饰的函数名依然表示一个函数
实际上,所谓函数装饰器,就是通过装饰器函数,在不修改原函数的前提下,来对函数的功能进行合理的扩充
带参数的函数装饰器
当 funB() 函数无参数时,可以直接将 funB 作为 funA() 的参数传入。但是,如果被修饰的函数本身带有参数,那应该如何传值呢?
比较简单的解决方法就是在函数装饰器中嵌套一个函数,该函数带有的参数个数和被装饰器修饰的函数相同
def funA(fn):
# 定义一个嵌套函数
def say(arc):
print("Python教程:",arc)
return say
@funA
def funB(arc):
print("funB():", a)
funB("http://c.biancheng.net/python")
运行结果:
Python教程: http://c.biancheng.net/python
def funA(fn):
# 定义一个嵌套函数
def say(arc):
print("Python教程:",arc)
return say
def funB(arc):
print("funB():", a)
funB = funA(funB)
funB("http://c.biancheng.net/python")
它的输出结果和上面程序相同
通过 funB() 函数被装饰器 funA() 修饰,funB 就被赋值为 say。这意味着,虽然在程序显式调用的是 funB() 函数,但其实执行的是装饰器嵌套的 say() 函数
如果当前程序中,有多个(≥ 2)函数被同一个装饰器函数修饰,这些函数带有的参数个数并不相等,怎么办呢?
最简单的解决方式是用 *args 和 **kwargs 作为装饰器内部嵌套函数的参数,*args 和 **kwargs 表示接受任意数量和类型的参数
def funA(fn):
# 定义一个嵌套函数
def say(*args,**kwargs):
fn(*args,**kwargs)
return say
@funA
def funB(arc):
print("C语言中文网:",arc)
@funA
def other_funB(name,arc):
print(name,arc)
funB("http://c.biancheng.net")
other_funB("Python教程:","http://c.biancheng.net/python")
运行结果:
C语言中文网: http://c.biancheng.net
Python教程: http://c.biancheng.net/python
函数装饰器可以嵌套
Python 也支持多个装饰器
@funA
@funB
@funC
def fun():
#...
上面程序的执行顺序是里到外,所以它等效于下面这行代码
fun = funA( funB ( funC (fun) ) )