1 真 · 一切皆对象

之前讲述Python将面向过程、列表等数据结构均可以看做对象处理，在这一章，你会发现，Python原来已经将一切当做对象处理了！以后再看到Python的每一个元素，都要如同对象一般看待。为什么这么说呢？来看几个第一章就介绍的例子：

a = 1
b = 2
c = a+b
d = 'very' + ' good !'

这几行代码分别代表了最基础的赋值和加法运算。那么我们开始尝试，把他们全部看做对象。

第一行和第二行，1是一个对象，a这个变量也是一个对象，同理b、2也是对象。在这里1被创造出来后，利用等号（可以把它看成对象的方法），给予a引用。引用是个重要的概念，它和C语言的指针类似，1被创建好后会有一个地址，而a刚好指向这个地址，当我们print a时，实际上是引用该地址里面的值。Python中我们可以利用id()函数查看变量或值的地址：

print(id(a), id(b), id(1))

结果很明显，它们的值都是一样的。

第三行和第四行，a、b、c、d都可以看做对象，唯一的不同是多了一个运算符+，但是我们发现两个加号意思却不同。前者代表两个数相加，后者代表两个字符串连接。为什么同样对的符号，处理起来却不一样呢？如果把加号看做方法，一切就清楚了。整形数字和字符串是不同的对象，当然有不同的属性。加号对应Python内置函数的__add__()方法，其针对不同的类分别重写，而add方法的简写方式就是加号，两者是等价的:

'very'.__add__( ' good !')
# 简写后
'very' + ' good !'

我们甚至可以自己定义类，实现加号的其他用途。恰好序列是没有减号的方法，我们可以利用内置函数__sub__()重新定义一番：

class SuperList(object)
    def __sub__(self, b):
        a = self[:]
        b = b[:]
        while len(b)>0:
            ele_b = b.pop()
            if ele_b in a:
                a.remove(ele_b)
    return a

这里定义减号的算法是将前者列表与后者重名的元素剔除，那么我们现在实验一下：

print(SuperList([1,2,3]) - SuperList([3,4]))  # 输出[1,2]

从这里我们更可以看出，所谓的运算符，都是Python内置方法的简写。不光运算符，内置函数也是如此，比如绝对值函数abs()其实是__abs__()内置方法的简写，你所看到的一切符号均是如此。

2 对象属性的本质

属性是一个类内部的东西，我们定义一个类，就可以利用它创建对象，其实，这些类也同样统统是对象。它们就是一个个字典的集合，而字典本身就是对象。在Python中可以使用__ dict__()内置方法查看函数具体的字典内容。我们拿第四章的例子说说：

class Bird(object):
    feather = True
    def chrip(self):
        print('some sound')

print(Bird.__dict__)

我们看看输出如下图：

这里把Bird类中所有的属性利用字典结构列出，包括定义和未定义的。属性为键，定义内容为值。每当程序要调用某个类的方法，就会遍历该类的所有键，找到匹配结果后执行值的内容。出现继承关系，则从继承的最高层开始遍历，直到最底层。如果继承中出现属性覆盖也无妨，因为是从最顶层遍历(遍历顺序为Chicken->Bird->object)，所以永远最先遍历覆盖的属性。我们在上面例子基础上继续添加：

class Chicken(Bird):
    fly = False
    def __init__(self, age):
        self.age = age
    def chrip(self):
        print('ji')

spring = Chicken(2)
print(spring.__dict__)
print(object.__dict__)

输出结果请自行尝试，这里就不展示了。我们可看到，在重写方法或成员变量后，程序便会在继承的类重新出现一对键值。这种面向不同层级的键值对管理方式大大降低了内存空间，提高查找效率。

既然类可以定义永久性存在于类的属性，自然可以定义即时生成的方法，这种方法执行会随着依赖因素的改变而改变。Python把这种属性称为特征，可利用property函数对方法改造。该函数可以只有一个参数，也可以四个。举一个含有一个参数的例子在Chicken类中添加方法：

def get_adult(self, age):
    if self.age>1:
        return True
    else:
        return False

adult = property(get_adult)
spring = Chicken(2)
print(spring.adult)  # 返回Ture

这里我们利用property函数改造后，调用该类的对象即可直接使用，其会根据年龄判断鸡是否成年。对四个参数，第一个必须是获取函数，第二个是修改，第三个是删除函数，第四是说明作用，下面举例：

class num(object):
def __init__(self, value):
    self.value = value

def get_neg(self):
    return -self.value

def set_neg(self,value):
    self.value = -value

def del_neg(self):
    print('value alse deleted')
    del self.value

neg = property(get_neg, set_neg, del_neg, 'i am negative')
x = num(1.1)
print(x.neg)
x.neg = -22
print(x.value)
print(num.neg.__doc__)
del x.neg

在按照指定顺序利用property函数改造后，我们可以直接利用特性，使用简写方法达成目标。包括对num的获取、修改和删除。

在Python可以用__getattr__()方法查询即时生成的属性。如果利用dict方法看不到，程序就会自动调用getattr方法。比如我们现在把get_adult方法改一下，将方法换成getattr：

def __getattri__(self, name):
    if name=='adult':
        if self.age>1:
          return True
        else:
          return False

这时不需要用property函数。因为其找不到adult属性，所以会利用getattr方法查找。此外，我们还可以使用__setsattr__()和__delattr__()方法设置和删除任意的属性。

3 错综复杂的对象关系

我们在第一部分讲到了引用。其实这种引用在Python的对象中大量存在，一个复杂的程序关系的复杂程度不亚于现实生活的三角对象关系。正是Python拥有这种无与伦比的引用，才会有动态语言这一特点。可不要小看，这省了程序员不少代码行数。一般在C语言若想赋值，首先要定义一个变量的数据类型，才可以赋值，而且赋值必须和定义的数据类型一样，而Python直接一行搞定，无论任何赋值都可以，这就要归功于引用了。这一部分，我们将更加详细的了解引用究竟如何产生动态类型。

引用指向的对象不同，其影响也不同。比如：

a = [1], b = a

这两个赋值，a指向1，b同样指向1，而不是a。这就意味着他们两个指向同一对象。如果直接更改对象，那么a和b的输出会同时改变，如果改变对象的引用（可以用等号改变）则不会同时改变。举个例子：

a.append(2)  # 两者同时改变
a = 3  # 仅改变a

在Python中，我们把能同时改变的称为可变对象，比如列表等数据结构；把不能同时改变的称为不可变对象，比如单个值、元组等。这个与原理同样适用于函数，举个例子：

def f(x):
    print(id(x))
    x = 100
    print(id(x))
    a = 1
    print(id(a))

f(a)
print(a)

这里如果x是不可变对象，则传入的值如果没有return是不会出来的，这和从形参实参的特点角度看也是等价的。如果传入x的是可变对象，比如列表，那么如果列表在函数内被修改，尽管没有return，这个列表在函数外确实被修改了。举个例子：

def f():
    x[0] = 100
    print(x)

a = [1,2,3]
f(a)
print(a)

最终结果为[100,2,3]，符合预期结果。

4 内存管理

内存管理是程序语言很重要的一部分。每当程序出现一次赋值语句，就会出现新的引用，这些都必须暂时储存在内存里，待程序结束后清除缓存。如果占用内存过多，会影响程序性能。Python是基于引用的对象管理，所以Python通过记录每个对象引用的次数从而监管内存的情况，也即引用计数器。我们可以使用sys库的getrefcount函数查看：

from sys import getrefcount

a = [1,2,3]
print(getrefcount(a))
b = a
print(getrefcount())

因为对象传递给该函数时也需要一次引用，所以每次计算都会比实际多一。我们从前面几节可以总结出，等号后面就是引用，也就是说不光单个值，像序列等对象也可以被引用，这大大提高了对象间的复杂度。我们可以利用objgraph库的封装函数绘制引用关系图：

import objgraph

x = [1,2,3]
y = [x, dict(key1 = x)]
z = [y, (x, y)]
objgraph.show_refs([z], filename = 'ref_topo.png')

如果应用的对象相同，有可能构成闭环，又称引用环：

a = []
b = [a]
a.append(b)

让引用计数减少的办法就是使用del关键字删除对象或将引用改至其他对象，那么其被引用的所有对象计数器都会减一。

Python正是利用引用计数器进行内存回收，当对象的引用计数为0时代表其不可能再被引用，就会将其删除。为了减少检测次数，提高内存管理效率，Python以“内存占用时间越长越不易删除引用”为判则，将对象分成0 1 2三级，通过三个参数来删除内存，我们可以利用gc库中的get_threshold()函数得到，系统默认是（700， 10, 10），分别意为阈值为700，当检测10次0级别时检测1次1级别，当检测10次1级别时检测1次2级别。这种分层的管理方式大大提高了内存的回收利用率和程序运行效率。

那么我们现在要说说闭环了，如果出现孤立引用环，程序将用法无法把这些变量置零。因为如果是环状，其至少会和本身的循环产生引用，所以引用数至少为一，无法清除，如下图。那么Python如何解决这个问题呢？

其实Python将每个引用存储，对每个对象遍历的遍历后，将另一个对象的计数减一，这样就不会出现等于1的情况了。从下图中，我们可以看到，其所在闭环原本为一，经过减法计算后变为零，可以被系统清除。

Python作为动态类型的语言，其将对象和应用完全分离。为了释放内存，Python有设置了内存回收机制，同时解决了引用环的问题。在Python运行速度本就较慢的情况下，掌握了更多的对象，以及对象内存的管理方法，可以有效的提高Python代码运行的性能。

实例代码请看我的码云：第六章样例代码

[sss](1 真 · 一切皆对象)