《从Python开始学编程》第6章 与对象的深入交往

第6章 与对象的深入交往

在本章的前半部分，我们将探索Python“一切皆对象”背后的含义。许多语法，如运算符、元素引用、内置函数中，其实都来自于一些特殊对象。这样设计即满足了Python多范式的需求，又能以简单的体系满足丰富的语法需求，如运算符重载与即时特性等。而在本章后半部分，我们将深入到对象相关的重要机制，如动态类型和垃圾回收。

6.1 一切皆对象

1. 运算符

list是列表的类。如果用dir(list)调查list的属性，能看到一个属性是__add__()。从样式上看，__add__()是特殊方法。它特殊在哪呢？这个方法定义了"+"运算符对于list对象的意义，两个list的对象相加时，会进行合并列表的操作。结果为合并在一起的列表：

print([1, 2, 3] + [5, 6, 9]) # 得到[1, 2, 3, 5, 6, 9]

运算符，比如+、-、>、<、and、or等，都是通过特殊方法实现的，比如：

"abc" + "xyz" # 连接字符串，获得"abcxyz"

实际执行了如下操作：

"abc".__add__("xyz")

两个对象能否进行加法运算，首先要看相应的对象是否有__add__()方法。一旦相应的对象有__add__()方法，即便这个对象从数学上不可加，我们也可以执行加法操作。而对于特殊方法，功能相同的运算符更加简洁，能够简化书写。下面的一些运算用特殊方法来写会有写麻烦。

尝试下面的操作，看看效果，在想想它对应的运算符：

(1.8).__mul__(2.0) # 1.8*2.0

True.__or__(False) # True or False

这些运算符相关的特殊方法还能改变执行运算的方式。比如，列表在Python中是不可以相减的。你可以测试下面的操作：

[1, 2, 3] - [3, 4]

会有错误信息，说明列表不能进行减法操作，即列表没有定义"-"运算符。我们可以创建一个列表的子类，通过__sub__()方法，来添加减法操作的定义，例如：

class SuperList(list):
	def __sub__(self, b):
        a = self[:]		# 由于继承于list，self可以利用[:]的引用来表示整个列表
        b = b[:]	# 由于继承于list, b可以利用[:]的引用来表示整个列表
        while len(b) > 0:
            element_b = b.pop()
            if element_b in a:
                a.remove(element_b)
        return a
    
print(SuperList([1, 2, 3]) - SuperList([3, 4]))    # 打印[1, 2]

上面的例子中，内置函数len()用来返回列表所包含的元素的总数。内置函数__sub__()定义了"-"的操作：从第一个表中去掉第二个表中出现的元素。于是，我们创建的两个SuperList对象，就可以执行减法操作了。即使__sub__()方法已经在父类中定义过，但在子类中重新定义后，子类中的方法会覆盖父类的同名方法。即运算符将被重新定义。

2. 元素引用

下面是我们常见的表元素引用方式：

li = [1, 2, 3, 4, 5, 6]

print(li[3]) # 打印4

上面的程序运行到li[3]的时候，Python发现并理解[]符号，然后调用__getitem__()方法。

li = [1, 2, 3, 4, 5, 6]
print(li.__getitem__(3))	# 打印4

看下面的操作，想想它的对应：

li = [1, 2, 3, 4, 5, 6]
li.__setitem__(3, 0)
print(li)	# 返回[1, 2, 3, 0, 5, 6]

example_dict = {
   "a":1, "b":2}
example_dict.__delitem__("a")
print(example_dict)		# 返回{"b":2}

3. 内置函数的实现

与运算符类似，许多内置函数也都是调用对象的特殊方法。比如：

len([1, 2, 3]) # 返回表中元素的总数

实际上做的是：

[1, 2, 3].__len__()

相对于__len__()，内置函数len()也起到了简化书写的作用。

尝试下面的操作，想一下它的对应内置函数：

(-1).__abs__()
(2.3).__int__()

6.2 属性管理

1. 属性覆盖的背后

我们在继承中，提到了Python中属性覆盖的机制。为了深入理解属性覆盖，我们有必要理解Python的__dict__属性。当我们调用对象的属性时，这个属性可能有很多来源。除了来自对象属性和类属性，这个属性还可能是从祖先类那里继承来的。一个类或对象有的属性，会记录在__dict__中。这个__dict__是一个词典，键为属性名，对应的值为某个属性。Python在寻找对象的属性时，会按照继承关系依次寻找__dict__。

我们看下面的类和对象，Chicken类继承自Bird类，而summer为Chicken类的一个对象：

class Bird(object):
    feather = True
    
    def chirp(self):
        print("some sound")
        
class Chicken(Bird):
    fly = False
    
    def __init__(self, age):
        self.age = age
        
	def chirp(self):
        print("ji")
        
summer = Chicken(2)
print("===> summer")
print(summer.__dict__)

print("===> Chicken")
print(Chicken.__dict__)

print("===> Bird")
print(Bird.__dict__)

print("===> object")
print(object.__dict__)