Python类特殊成员

python
字数统计: 10k   |   阅读时长≈ 40 分钟

new()

__new__() 是一种负责创建类实例的静态方法，它无需使用staticmethod装饰器修饰，且该方法会优先__init__()初始化方法被调用。

一般情况下，覆写__new__()的实现将会使用合适的参数调用其超类的super().__new__()，并在返回之前修改实例。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
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)

输出结果为：

1
2
3
4
5
6
__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 的某些内置类型）的创建行为），利用这一点会事半功倍。

1
2
3
4
5
6
7
8
9
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)))

运行结果为：

1
2
3
__init__()
<class '__main__.nonZero'>
<class 'NoneType'>

那么，什么情况下使用__new__()呢？答案很简单，在__init__()不够用的时候。

例如，前面例子中对 Python 不可变的内置类型（如int、str、float等）进行了子类化，这是因为一旦创建了这样不可变的对象实例，就无法在__init__()方法中对其进行修改。

有些读者可能会认为，__new__()对执行重要的对象初始化很有用，如果用户忘记使用super()，可能会漏掉这一初始化。虽然这听上去很合理，但有一个主要的缺点，即如果使用这样的方法，那么即便初始化过程已经是预期的行为，程序员明确跳过初始化步骤也会变得更加困难。不仅如此，它还破坏了“__init__()中执行所有初始化工作”的潜规则。

注意，由于__new__()不限于返回同一个类的实例，所以很容易被滥用，不负责任地使用这种方法可能会对代码有害，所以要谨慎使用。一般来说，对于特定问题，最好搜索其他可用的解决方案，最好不要影响对象的创建过程，使其违背程序员的预期。比如说，前面提到的覆写不可变类型初始化的例子，完全可以用工厂方法（一种设计模式）来替代。

Python中大量使用__new__()方法且合理的，就是MetaClass元类。

repr()方法：显示属性

我们经常会直接输出类的实例化对象，例如：

1
2
3
4
class CLanguage:
  pass
clangs = CLanguage()
print(clangs)

程序运行结果为：

1
<__main__.CLanguage object at 0x000001A7275221D0>

通常情况下，直接输出某个实例化对象，本意往往是想了解该对象的基本信息，例如该对象有哪些属性，它们的值各是多少等等。但默认情况下，我们得到的信息只会是“类名+object at+内存地址”，对我们了解该实例化对象帮助不大。

那么，有没有可能自定义输出实例化对象时的信息呢？答案是肯定，通过重写类的__repr__()方法即可。事实上，当我们输出某个实例化对象时，其调用的就是该对象的__repr__()方法，输出的是该方法的返回值。

以开头的程序为例，执行print(clangs)等同于执行print(clangs.__repr__())，程序的输出结果是一样的（输出的内存地址可能不同）。

和__init__(self)的性质一样，Python 中的每个类都包含__repr__()方法，因为object类包含__reper__()方法，而 Python 中所有的类都直接或间接继承自object类。

默认情况下，__repr__()会返回和调用者有关的 “类名+object at+内存地址”信息。当然，我们还可以通过在类中重写这个方法，从而实现当输出实例化对象时，输出我们想要的信息。

1
2
3
4
5
6
7
8
class CLanguage:
  def __init__(self):
    self.name = "小明"
    self.add = "xiaoming"
  def __repr__(self):
    return "CLanguage[name="+ self.name +",add=" + self.add +"]"
clangs = CLanguage()
print(clangs)

程序运行结果为：

1
CLanguage[name=小明,add=xiaoming]

由此可见，__repr__()方法是类的实例化对象用来做“自我介绍”的方法，默认情况下，它会返回当前对象的“类名+object at+内存地址”，而如果对该方法进行重写，可以为其制作自定义的自我描述信息。

del()方法：销毁对象

我们知道，Python 通过调用__init__()方法构造当前类的实例化对象，而__del__()方法，功能正好和__init__()相反，其用来销毁实例化对象。

事实上在编写程序时，如果之前创建的类实例化对象后续不再使用，最好在适当位置手动将其销毁，释放其占用的内存空间（整个过程称为垃圾回收（简称GC））。
大多数情况下，Python 开发者不需要手动进行垃圾回收，因为 Python 有自动的垃圾回收机制（下面会讲），能自动将不需要使用的实例对象进行销毁。

无论是手动销毁，还是 Python 自动帮我们销毁，都会调用__del__()方法。

1
2
3
4
5
6
7
class CLanguage:
    def __init__(self):
        print("调用 __init__() 方法构造对象")
    def __del__(self):
        print("调用__del__() 销毁对象，释放其空间")
clangs = CLanguage()
del clangs

程序运行结果为：

1
2
调用 __init__() 方法构造对象
调用__del__() 销毁对象，释放其空间

但是，千万不要误认为，只要为该实例对象调用 del() 方法，该对象所占用的内存空间就会被释放。举个例子：

1
2
3
4
5
6
7
8
9
10
class CLanguage:
    def __init__(self):
        print("调用 __init__() 方法构造对象")
    def __del__(self):
        print("调用__del__() 销毁对象，释放其空间")
clangs = CLanguage()
#添加一个引用clangs对象的实例对象
cl = clangs
del clangs
print("***********")

程序运行结果为：

1
2
3
调用 __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）。在此基础上，又有一个 clang 变量引用 clangs（其实相当于引用 CLanguage()，此时 C 的计数器再 +1 ），这时如果调用del clangs语句，只会导致 C 的计数器减 1（值变为 1），因为 C 的计数器值不为 0，因此 C 不会被销毁（不会执行__del__()方法）。

如果在上面程序结尾，添加如下语句：

1
2
3
4
5
6
7
del cl
print("-----------")
则程序的执行结果为：
调用 __init__() 方法构造对象
***********
调用__del__() 销毁对象，释放其空间
-----------

可以看到，当执行 del cl 语句时，其应用的对象实例对象 C 的计数器继续 -1（变为 0），对于计数器为 0 的实例对象，Python 会自动将其视为垃圾进行回收。

需要额外说明的是，如果我们重写子类的 del() 方法（父类为非object的类），则必须显式调用父类的 del() 方法，这样才能保证在回收子类对象时，其占用的资源（可能包含继承自父类的部分资源）能被彻底释放。为了说明这一点，这里举一个反例：

1
2
3
4
5
6
7
8
class CLanguage:
    def __del__(self):
        print("调用父类 __del__() 方法")
class cl(CLanguage):
    def __del__(self):
        print("调用子类 __del__() 方法")
c = cl()
del c

程序运行结果为：

1
调用子类 __del__() 方法

dir()用法：列出对象的所有属性（方法）名

dir()函数，通过此函数可以某个对象拥有的所有的属性名和方法名，该函数会返回一个包含有所有属性名和方法名的有序列表。

1
2
3
4
5
6
7
8
class CLanguage:
  def __init__ (self,):
    self.name = "小明"
    self.add = "xiaoming"
  def say():
    pass
clangs = CLanguage()
print(dir(clangs))

程序运行结果为：

1
['__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__()方法：

1
2
3
4
5
6
7
8
class CLanguage:
    def __init__ (self,):
        self.name = "小明"
        self.add = "xiaoming"
    def say():
        pass
clangs = CLanguage()
print(clangs.__dir__())

程序运行结果为：

1
['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()函数输出的数据是相同，仅仅顺序不同。

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

在 Python 类的内部，无论是类属性还是实例属性，都是以字典的形式进行存储的，其中属性名作为键，而值作为该键对应的值。

为了方便用户查看类中包含哪些属性，Python 类提供了__dict__属性。需要注意的一点是，该属性可以用类名或者类的实例对象来调用，用类名直接调用__dict__，会输出该由类中所有类属性组成的字典；而使用类的实例对象调用__dict__，会输出由类中所有实例属性组成的字典。

1
2
3
4
5
6
7
8
9
10
11
class CLanguage:
  a = 1
  b = 2
  def __init__ (self):
    self.name = "小明"
    self.add = "xiaoming"
#通过类名调用__dict__
print(CLanguage.__dict__)
#通过类实例对象调用 __dict__
clangs = CLanguage()
print(clangs.__dict__)

程序输出结果为：

1
2
{'__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': '小明', 'add': 'xiaoming'}

不仅如此，对于具有继承关系的父类和子类来说，父类有自己的__dict__，同样子类也有自己的__dict__，它不会包含父类的__dict__。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
class CLanguage:
  a = 1
  b = 2
  def __init__ (self):
    self.name = "小明"
    self.add = "xiaoming"
       
class CL(CLanguage):
  c = 1
  d = 2
  def __init__ (self):
    self.na = "Python教程"
    self.ad = "xiaohong"
#父类名调用__dict__
print(CLanguage.__dict__)
#子类名调用__dict__
print(CL.__dict__)
#父类实例对象调用 __dict__
clangs = CLanguage()
print(clangs.__dict__)
#子类实例对象调用 __dict__
cl = CL()
print(cl.__dict__)

运行结果为：

1
2
3
4
{'__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': '小明', 'add': 'xiaoming'}
{'na': 'Python教程', 'ad': 'xiaohong'}

显然，通过子类直接调用的__dict__中，并没有包含父类中的a和b类属性；同样，通过子类对象调用的__dict__，也没有包含父类对象拥有的name和add实例属性。

除此之外，借助由类实例对象调用__dict__属性获取的字典，可以使用字典的方式对其中实例属性的值进行修改，例如：

1
2
3
4
5
6
7
8
9
10
11
class CLanguage:
  a = "aaa"
  b = 2
  def __init__ (self):
    self.name = "小明"
    self.add = "xiaoming"
#通过类实例对象调用 __dict__
clangs = CLanguage()
print(clangs.__dict__)
clangs.__dict__['name'] = "Python教程"
print(clangs.name)

程序运行结果为：

1
2
{'name': '小明', 'add': 'xiaoming'}
Python教程

注意，无法通过类似的方式修改类变量的值。

setattr()、getattr()、hasattr()

hasattr()函数

hasattr()函数用来判断某个类实例对象是否包含指定名称的属性或方法。

1
hasattr(obj, name)

其中obj指的是某个类的实例对象，name表示指定的属性名或方法名。同时，该函数会将判断的结果（True或者False）作为返回值反馈回来。

1
2
3
4
5
6
7
8
9
10
class CLanguage:
  def __init__ (self):
    self.name = "小明"
    self.add = "xiaoming"
  def say(self):
    print("我正在学Python")
clangs = CLanguage()
print(hasattr(clangs,"name"))
print(hasattr(clangs,"add"))
print(hasattr(clangs,"say"))

程序输出结果为：

1
2
3
True
True
True

显然，无论是属性名还是方法名，都在hasattr()函数的匹配范围内。因此，我们只能通过该函数判断实例对象是否包含该名称的属性或方法，但不能精确判断，该名称代表的是属性还是方法。

getattr() 函数

getattr()函数获取某个类实例对象中指定属性的值。没错，和hasattr()函数不同，该函数只会从类对象包含的所有属性中进行查找。

1
getattr(obj, name[, default])

其中，obj表示指定的类实例对象，name表示指定的属性名，而default是可选参数，用于设定该函数的默认返回值，即当函数查找失败时，如果不指定default参数，则程序将直接报AttributeError错误，反之该函数将返回default指定的值。

1
2
3
4
5
6
7
8
9
10
11
class CLanguage:
  def __init__ (self):
    self.name = "小明"
    self.add = "xiaoming"
  def say(self):
    print("我正在学Python")
clangs = CLanguage()
print(getattr(clangs,"name"))
print(getattr(clangs,"add"))
print(getattr(clangs,"say"))
print(getattr(clangs,"display",'nodisplay'))

程序执行结果为：

1
2
3
4
xiaoming
xiaoming
<bound method CLanguage.say of <__main__.CLanguage object at 0x000001FC2F2E3198>>
nodisplay

可以看到，对于类中已有的属性，getattr()会返回它们的值，而如果该名称为方法名，则返回该方法的状态信息；反之，如果该明白不为类对象所有，要么返回默认的参数，要么程序报AttributeError错误。

setattr()函数

setattr()函数的功能相对比较复杂，它最基础的功能是修改类实例对象中的属性值。其次，它还可以实现为实例对象动态添加属性或者方法。

1
setattr(obj, name, value)

首先，下面例子演示如何通过该函数修改某个类实例对象的属性值：

1
2
3
4
5
6
7
8
9
10
11
12
13
class CLanguage:
  def __init__ (self):
    self.name = "小明"
    self.add = "xiaoming"
  def say(self):
    print("我正在学Python")
clangs = CLanguage()
print(clangs.name)
print(clangs.add)
setattr(clangs,"name","小红")
setattr(clangs,"add","xiaohong")
print(clangs.name)
print(clangs.add)

程序运行结果为：

1
2
3
4
小明
xiaoming
小红
xiaohong

甚至利用setattr()函数，还可以将类属性修改为一个类方法，同样也可以将类方法修改成一个类属性。

1
2
3
4
5
6
7
8
9
10
11
def say(self):
  print("我正在学Python")
class CLanguage:
  def __init__ (self):
    self.name = "小明"
    self.add = "xiaoming"
clangs = CLanguage()
print(clangs.name)
print(clangs.add)
setattr(clangs,"name",say)
clangs.name(clangs)

程序运行结果为：

1
2
3
小明
xiaoming
我正在学Python

显然，通过修改name属性的值为say（这是一个外部定义的函数），原来的name属性就变成了一个name()方法。

使用setattr()函数对实例对象中执行名称的属性或方法进行修改时，如果该名称查找失败，Python 解释器不会报错，而是会给该实例对象动态添加一个指定名称的属性或方法。例如：

1
2
3
4
5
6
7
8
9
def say(self):
  print("我正在学Python")
class CLanguage:
  pass
clangs = CLanguage()
setattr(clangs,"name","小明")
setattr(clangs,"say",say)
print(clangs.name)
clangs.say(clangs)

程序执行结果为：

1
2
小明
我正在学Python

可以看到，虽然CLanguage为空类，但通过setattr()函数，我们为clangs对象动态添加了一个name属性和一个say()方法。

issubclass和isinstance函数：检查类型

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

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

通过使用上面两个函数，程序可以方便地先执行检查，然后才调用方法，这样可以保证程序不会出现意外情况。

如下程序示范了通过这两个函数来检查类型：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
# 定义一个字符串
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()两个函数的第二个参数都可使用元组。

1
2
3
4
5
6
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__属性，通过该属性可以查看该类的所有直接父类，该属性返回所有直接父类组成的元组。例如如下代码：

1
2
3
4
5
6
7
8
9
class A:
  pass
class B:
  pass
class C(A, B):
  pass
print('类A的所有父类:', A.__bases__)
print('类B的所有父类:', B.__bases__)
print('类C的所有父类:', C.__bases__)

运行上面程序，可以看到如下运行结果：

1
2
3
类A的所有父类: (<class 'object'>,)
类B的所有父类: (<class 'object'>,)
类C的所有父类: (<class '__main__.A'>, <class '__main__.B'>)

从上面的运行结果可以看出，如果在定义类时没有显式指定它的父类，则这些类默认的父类是object类。

Python 还为所有类都提供了一个__subclasses__()方法，通过该方法可以查看该类的所有直接子类，该方法返回该类的所有子类组成的列表。例如在上面程序中增加如下两行：

1
2
print('类A的所有子类:', A.__subclasses__())
print('类B的所有子类:', B.__subclasses__())

运行上面代码，可以看到如下输出结果：

1
2
类A的所有子类: [<class '__main__.C'>]
类B的所有子类: [<class '__main__.C'>]

call()

该方法的功能类似于在类中重载()运算符，使得类实例对象可以像调用普通函数那样，以“对象名()”的形式使用。

1
2
3
4
5
6
class CLanguage:
  # 定义__call__方法
  def __call__(self,name,add):
    print("调用__call__()方法",name,add)
clangs = CLanguage()
clangs("小明", "xiaoming")

程序执行结果为：

1
调用__call__()方法 小明 xiaoming

可以看到，通过在CLanguage类中实现__call__()方法，使的clangs实例对象变为了可调用对象。

Python 中，凡是可以将 () 直接应用到自身并执行，都称为可调用对象。可调用对象包括自定义的函数、Python 内置函数以及本节所讲的类实例对象。

对于可调用对象，实际上“名称()”可以理解为是“名称.call()”的简写。仍以上面程序中定义的 clangs 实例对象为例，其最后一行代码还可以改写为如下形式：

1
clangs.__call__("C语言中文网","http://c.biancheng.net")

运行程序会发现，其运行结果和之前完全相同。

1
2
3
4
def say():
  print("Python教程：http://c.biancheng.net/python")
say()
say.__call__()

程序执行结果为：

1
2
Python教程：http://c.biancheng.net/python
Python教程：http://c.biancheng.net/python

不仅如此，类中的实例方法也有以上 2 种调用方式。

用 call() 弥补 hasattr() 函数的短板

hasattr()函数的功能是查找类的实例对象中是否包含指定名称的属性或者方法，但该函数有一个缺陷，即它无法判断该指定的名称，到底是类属性还是类方法。

要解决这个问题，我们可以借助可调用对象的概念。要知道，类实例对象包含的方法，其实也属于可调用对象，但类属性却不是。

1
2
3
4
5
6
7
8
9
10
11
12
class CLanguage:
  def __init__ (self):
    self.name = "小明"
    self.add = "xiaoming"
  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__"))

程序执行结果为：

1
2
3
False
**********
True

可以看到，由于name是类属性，它没有以__call__为名的__call__()方法；而say是类方法，它是可调用对象，因此它有__call__()方法。

运算符重载

Python 中的各个序列类型，每个类型都有其独特的操作方法，例如列表类型支持直接做加法操作实现添加元素的功能，字符串类型支持直接做加法实现字符串的拼接功能，也就是说，同样的运算符对于不同序列类型的意义是不一样的，这是怎么做到的呢？

其实在 Python 内部，每种序列类型都是 Python 的一个类，例如列表是list类，字典是dict类等，这些序列类的内部使用了一个叫作“重载运算符”的技术来实现不同运算符所对应的操作。

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
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"

输出结果为：

1
2
3
4
5
name:Anna;age:42
name:Anna;age:42
name:Anna;age:42
False
name:Anna;age:65

这个例子中，MyClass 类中重载了repr、str、<、+运算符，并用MyClass实例化了两个对象myc和mycl。

通过将myc进行repr、str运算，从输出结果中可以看到，程序调用了重载的操作符方法__repr__和__str__。而令myc和mycl进行 < 号的比较运算以及加法运算，从输出结果中可以看出，程序调用了重载 < 号的方法__lt__和__add__方法。

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 “或”运算符
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 方法（常用于做一些清理、扫尾的工作）

迭代器

列表（list）、元组（tuple）、字典（dict）、集合（set）这些序列式容器，有一个共同的特性，它们都支持使用for循环遍历存储的元素，都是可迭代的，因此它们又有一个别称，即迭代器。

从字面来理解，迭代器指的就是支持迭代的容器，更确切的说，是支持迭代的容器类对象，这里的容器可以是列表、元组等这些 Python 提供的基础容器，也可以是自定义的容器类对象，只要该容器支持迭代即可。

如果要自定义实现一个迭代器，则类中必须实现如下 2 个方法：

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

例如，下面程序自定义了一个简易的列表容器迭代器，支持迭代：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
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)

程序执行结果为：

1
2
2
1

除此之外，Python 内置的iter()函数也会返回一个迭代器：

1
iter(obj[, sentinel])

其中，obj必须是一个可迭代的容器对象，而sentinel作为可选参数，如果使用此参数，要求 obj 必须是一个可调用对象。

可调用对象，指的是该类的实例对象可以像函数那样，直接以“对象名()”的形式被使用。通过在类中添加__call__()方法，就可以将该类的实例对象编程可调用对象。

我们常用的是仅有 1 个参数的iter()函数，通过传入一个可迭代的容器对象，我们可以获得一个迭代器，通过调用该迭代器中的__next__()方法即可实现迭代。例如；

1
2
3
4
5
6
7
# 将列表转换为迭代器
myIter = iter([1, 2, 3])
# 依次获取迭代器的下一个元素
print(myIter.__next__())
print(myIter.__next__())
print(myIter.__next__())
print(myIter.__next__())

运行结果为：

1
2
3
4
5
6
7
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__()方法的返回值。

例如，修改 listDemo 类如下所示：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
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__())

程序执行结果为：

1
2
3
4
5
2
Traceback (most recent call last):
  File "D:\python3.6\1.py", line 20, in <module>
    print(a.__next__())
StopIteration

输出结果中，之所以最终抛出StopIteration异常，是因为这里原本要输出的元素 1 和iter()函数的第 2 个参数相同。

迭代器本身是一个底层的特性和概念，在程序中并不常用，但它为生成器这一更有趣的特性提供了基础。

生成器

生成器本质上也是迭代器，不过它比较特殊。

以list容器为例，在使用该容器迭代一组数据时，必须事先将所有数据存储到容器中，才能开始迭代；而生成器却不同，它可以实现在迭代的同时生成元素。
也就是说，对于可以用某种算法推算得到的多个数据，生成器并不会一次性生成它们，而是什么时候需要，才什么时候生成。

不仅如此，生成器的创建方式也比迭代器简单很多，大体分为以下 2 步：

  • 定义一个以yield关键字标识返回值的函数；
  • 调用刚刚创建的函数，即可创建一个生成器。
1
2
3
4
5
6
def intNum():
  print("开始执行")
  for i in range(5):
    yield i
    print("继续执行")
num = intNum()

由此，我们就成功创建了一个num生成器对象。显然，和普通函数不同，intNum()函数的返回值用的是 yield关键字，而不是return关键字，此类函数又成为生成器函数。

和return相比，yield除了可以返回相应的值，还有一个更重要的功能，即每当程序执行完该语句时，程序就会暂停执行。不仅如此，即便调用生成器函数，Python 解释器也不会执行函数中的代码，它只会返回一个生成器（对象）。

要想使生成器函数得以执行，或者想使执行完yield语句立即暂停的程序得以继续执行，有以下 2 种方式：

  • 通过生成器（上面程序中的num）调用next()内置函数或者__next__()方法；
  • 通过for循环遍历生成器。

例如，在上面程序的基础上，添加如下语句：

1
2
3
4
5
6
7
#调用 next() 内置函数
print(next(num))
#调用 __next__() 方法
print(num.__next__())
#通过for循环遍历生成器
for i in num:
  print(i)

程序执行结果为：

1
2
3
4
5
6
7
8
9
10
11
开始执行
0
继续执行
1
继续执行
2
继续执行
3
继续执行
4
继续执行

一个程序的执行流程：

  1. 首先，在创建有num生成器的前提下，通过其调用next()内置函数，会使 Python 解释器开始执行intNum()生成器函数中的代码，因此会输出“开始执行”，程序会一直执行到yield i，而此时的i==0，因此 Python 解释器输出“0”。由于受到yield的影响，程序会在此处暂停。
  2. 然后，我们使用 num 生成器调用__next__()方法，该方法的作用和next()函数完全相同（事实上，next()函数的底层执行的也是 __next__()方法），它会是程序继续执行，即输出“继续执行”，程序又会执行到yield i，此时i==1，因此输出“1”，然后程序暂停。
  3. 最后，我们使用for循环遍历num生成器，之所以能这么做，是因为for循环底层会不断地调用next()函数，使暂停的程序继续执行，因此会输出后续的结果。

注意，在 Python 2.x 版本中不能使用__next__()方法，可以使用next()内置函数，另外生成器还有next()方法（即以 num.next() 的方式调用）。

除此之外，还可以使用list()函数和tuple()函数，直接将生成器能生成的所有值存储成列表或者元组的形式。

1
2
3
4
num = intNum()
print(list(num))
num = intNum()
print(tuple(num))

程序执行结果为：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
开始执行
继续执行
继续执行
继续执行
继续执行
继续执行
[0, 1, 2, 3, 4]
开始执行
继续执行
继续执行
继续执行
继续执行
继续执行
(0, 1, 2, 3, 4)

通过输出结果可以判断出，list()和tuple()底层实现和for循环的遍历过程是类似的。

相比迭代器，生成器最明显的优势就是节省内存空间，即它不会一次性生成所有的数据，而是什么时候需要，什么时候生成。

@函数装饰器

Python 内置的 3 种函数装饰器，分别是＠staticmethod、＠classmethod和@property，其中staticmethod()、classmethod()和property()都是 Python 的内置函数。

那么，函数装饰器的工作原理是怎样的呢？假设用funA()函数装饰器去装饰funB()函数，如下所示：

1
2
3
4
5
6
7
8
9
#funA 作为装饰器函数
def funA(fn):
  #...
  fn() # 执行传入的fn参数
  #...
  return '...'
@funA
def funB():
  #...

实际上，上面程序完全等价于下面的程序：

1
2
3
4
5
6
7
8
def funA(fn):
  #...
  fn() # 执行传入的fn参数
  #...
  return '...'
def funB():
  #...
funB = funA(funB)

通过比对以上 2 段程序不难发现，使用函数装饰器A()去装饰另一个函数B()，其底层执行了如下 2 步操作：

  • 将B作为参数传给A()函数；
  • 将A()函数执行完成的返回值反馈回B。
1
2
3
4
5
6
7
8
9
#funA 作为装饰器函数
def funA(fn):
  print("小明")
  fn() # 执行传入的fn参数
  print("xiaoming")
  return "装饰器函数的返回值"
@funA
def funB():
  print("学习 Python")

程序执行流程为：

1
2
3
小明
学习 Python
xiaoming

在此基础上，如果在程序末尾添加如下语句：

1
print(funB)

其输出结果为：

1
装饰器函数的返回值

显然，被“＠函数”修饰的函数不再是原来的函数，而是被替换成一个新的东西（取决于装饰器的返回值），即如果装饰器函数的返回值为普通变量，那么被修饰的函数名就变成了变量名；同样，如果装饰器返回的是一个函数的名称，那么被修饰的函数名依然表示一个函数。
实际上，所谓函数装饰器，就是通过装饰器函数，在不修改原函数的前提下，来对函数的功能进行合理的扩充。

带参数的函数装饰器

在分析funA()函数装饰器和funB()函数的关系时，当funB()函数无参数时，可以直接将funB作为funA()的参数传入。但是，如果被修饰的函数本身带有参数，那应该如何传值呢？

比较简单的解决方法就是在函数装饰器中嵌套一个函数，该函数带有的参数个数和被装饰器修饰的函数相同。

1
2
3
4
5
6
7
8
9
def funA(fn):
    # 定义一个嵌套函数
    def say(arc):
        print("Python教程:",arc)
    return say
@funA
def funB(arc):
    print("funB():", a)
funB("http://c.biancheng.net/python")

程序执行结果为：

1
Python教程: http://c.biancheng.net/python

其实，它和如下程序是等价的：

1
2
3
4
5
6
7
8
9
10
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表示接受任意数量和类型的参数。

1
2
3
4
5
6
7
8
9
10
11
12
13
def funA(fn):
  # 定义一个嵌套函数
  def say(*args,**kwargs):
    fn(*args,**kwargs)
  return say
@funA
def funB(arc):
  print("百度：",arc)
@funA
def other_funB(name,arc):
  print(name,arc)
funB("http://www.baidu.com")
other_funB("测试：","http://www.test.com")

运行结果为：

1
2
百度： http://www.baidu.com
测试： http://www.test.com

函数装饰器可以嵌套

上面示例中，都是使用一个装饰器的情况，但实际上，Python 也支持多个装饰器，比如：

1
2
3
4
5
@funA
@funB
@funC
def fun():
  #...

上面程序的执行顺序是里到外，所以它等效于下面这行代码：

1
fun = funA(funB(funC(fun)))
打赏
  • Copyrights © 2017-2023 WSQ
  • 访问人数: | 浏览次数:

请我喝杯咖啡吧~

支付宝
微信