第039讲：类和对象：拾遗

0. 请写下这一节课你学习到的内容：格式不限，回忆并复述是加强记忆的好方式！

（一）组合

上节课我们学习了继承和多继承，但是我们有时候发现，有些情况你用继承也不合适，用多继承也不是，例如：现在现在要求定义一个类，叫水池，水池里要有乌龟和鱼。那大家就很苦恼了，用多继承就显得很奇葩了，因为如果把水池继承乌龟和鱼，那显然就是不同物种。那怎样才能把它们组成一个和谐的类呢，这就是我们今天首先要讲的内容：组合。

组合的用法很简单，举例说明：

class Turtle:
        def __init__(self, x):
                self.num = x
class Fish:
        def __init__(self, x):
                self.num = x
class Pool:
        def __init__(self, x, y):
                self.turtle = Turtle(x)
                self.fish = Fish(y)
        def print_num(self):
                print("水池里有乌龟 %d 只，小鱼 %d 条！" %(self.turtle.num, self.fish.num))

 
>>> pool = Pool(1, 10)
>>> pool.print_num()
水池里有乌龟 1 只，小鱼 10 条！

所谓的组合，就是把类的实例化放到新类里面，那么它就把旧类给组合进去了，不用使用继承了，没有什么风险了。组合一般来说就是把几个没有继承关系，没有直线关系的几个类放在一起，就是组合。要实现纵向关系之间的类，就使用继承。

Python 的特性还支持另外一种很流行的编程模式，叫做 Mix-in，叫做混入的意思，有兴趣的可以参见

（二）类、类对象和实例对象

我们一开始就说了，类、类对象和实例对象是三个不同的物种。先看代码：

>>> class C:
	count = 0
 
	
>>> a = C()
>>> b = C()
>>> c = C()
>>> a.count
0
>>> b.count
0
>>> c.count
0
>>> c.count += 10
>>> c.count
10
>>> a.count
0
>>> b.count
0
>>> C.count
0
>>> C.count += 100
>>> C.count
100
>>> a.count
100
>>> b.count
100
>>> c.count
10

我们这里有一个 C 类，只有一个属性 count ，初始化为0。实例化一个 a，一个 b，一个 c，显然 a.count =0，b.count = 0，c.count = 0。如果对 c.count += 10，现在 c.count = 10，但是 a.count = 0，b.count = 0。因为 C 是一个类，在写完 C 之后就变成了一个类对象，因为Python无处不对象，所有的东西都是对象，方法也是对象，所以我们这里 C.count = 0 也是等于 0。此时我们对这个类对象加等于100 ， C.count += 100，此时 a.count = 100，b.count = 100，但是 c.count = 10。为什么会这样呢？
其实是因为 c.count += 10 这里 c.count 被赋值的时候，我们是对实例化对象 c 的属性进行赋值，相当于我们生成了一个
count 来覆盖类对象的 count，如图：

类定义到类对象，还有实例对象a，b，c，需要注意的是，类中定义的属性都是静态属性，就像 C 里面的count，类属性和类对象是相互绑定的，并不会依赖于下面的实例对象，所以当 c.count += 10 的时候，并不会影响到 C，只是改变了 c 自身，因为在 c.count += 10 的时候，是实例对象 c 多了一个count 的属性，也就是实例属性，它把类属性给覆盖了。这在以后还会继续讲解，在此之前，我们先谈一下：如果属性的名字和方法相同时，属性会把方法覆盖掉。举例说明：

>>> class C:
	def x(self):
		print("X-man")
 
		
>>> c = C()
>>> c.x()
X-man
>>> c.x = 1
>>> c.x
1
>>> c.x()
Traceback (most recent call last):
  File "", line 1, in <module>
    c.x()
TypeError: 'int' object is not callable

c.x = 1 是实例化后的 c ，创建了一个 x 的属性，这时如果要调用 它的函数 x() 就会报错，出错信息说：整型是不能被调用的。

这就是初学者容易发生的一个问题，如果属性的名字和方法名相同，属性会覆盖方法。为了避免名字上的冲突，大家应该遵守一些约定俗成的规矩：

• 不要试图在一个类里边定义出所有能想到的特征和方法，应该使用继承和组合机制来进行扩展。
• 用不同词性命名，如属性名用名词，方法名用动词。

（三）到底什么是绑定？

Python 严格要求方法需要有实例才能被调用，这种限制其实就是Python 所谓的绑定概念(self)。

测试题

0. 什么是组合（组成）？

答：Python
继承机制很有用，但容易把代码复杂化以及依赖隐含继承。因此，经常的时候，我们可以使用组合来代替。在Python里组合其实很简单，直接在类定义中把需要的类放进去实例化就可以了。

例子：

// 乌龟类
class Turtle:
    def __init__(self, x):
        self.num = x
// 鱼类
class Fish:
    def __init__(self, x):
        self.num = x
// 水池类
class Pool:
    def __init__(self, x, y):
        self.turtle = Turtle(x)        // 组合乌龟类进来
        self.fish = Fish(y)        // 组合鱼类进来
     
    def print_num(self):
        print("水池里总共有乌龟 %d 只，小鱼 %d 条！" % (self.turtle.num, self.fish.num))
 
>>> pool = Pool(1, 10)
>>> pool.print_num()

1. 什么时候用组合，什么时候用继承？

答：根据实际应用场景确定。简单的说，组合用于“有一个”的场景中，继承用于“是一个”的场景中。例如，水池里有一个乌龟，天上有一个鸟，地上有一个小甲鱼，这些适合使用组合。青瓜是瓜，女人是人，鲨鱼是鱼，这些就应该使用继承啦。

2. 类对象是在什么时候产生？

答：当你这个类 定义完的时候，类定义(类)就变成类对象，可以直接通过“类名.属性”或者“类名.方法名()”引用或使用相关的属性或方法。

3. 如果对象的属性跟方法名字相同，会怎样？

答：如果对象的属性跟方法名相同，属性会覆盖方法。

class C:
        def x(self):
                print('Xman')
 
>>> c = C()
>>> c.x()
Xman
>>> c.x = 1
>>> c.x
1
>>> c.x()
Traceback (most recent call last):
  File "", line 1, in <module>
    c.x()
TypeError: 'int' object is not callable

4. 请问以下类定义中哪些是类属性，哪些是实例属性？

class C:
        num = 0
        def __init__(self):
                self.x = 4
                self.y = 5
                C.count = 6

答：num 和 count 是类属性（静态变量）->(类被删除了仍然存在)，x 和 y 是实例属性->(实例变量删除后不存在)。大多数情况下，你应该考虑使用实例属性，而不是类属性（类属性通常仅用来跟踪与类相关的值）。

5. 请问以下代码中，bb 对象为什么调用 printBB() 方法失败？

class BB:
        def printBB():
                print("no zuo no die")

 
>>> bb = BB()
>>> bb.printBB()
Traceback (most recent call last):
  File "", line 1, in <module>
    bb.printBB()
TypeError: printBB() takes 0 positional arguments but 1 was given

答：因为 Python 严格要求方法需要有实例才能被调用，这种限制其实就是 Python 所谓的绑定概念。(任意一个实例对象调用函数都会传入自己作为参数 当然是python帮我们传入 我们不用写出来)所以 Python 会自动把 bb 对象作为第一个参数传入，所以才会出现 TypeError：“需要 0 个参数，但实际传入了 1 个参数“。

正确的做法应该是：

class BB:
        def printBB(self):
                print("no zuo no die")
 
>>> bb = BB()
>>> bb.printBB()
no zuo no die

动动手

0. 思考这一讲学习的内容，请动手在一个类中定义一个变量，用于跟踪该类有多少个实例被创建

（当实例化一个对象，这个变量+1，当销毁一个对象，这个变量自动-1）。

class A:
    x=0
    def __init__(self):
        A.x+=1
    def delInstance(self):
        del self
        A.x-=1

1. 定义一个栈（Stack）类，用于模拟一种具有后进先出（LIFO）特性的数据结构。

***至少需要有以下方法：***

方法名	含义
isEmpty()	判断当前栈是否为空（返回 True 或 False）
push()	往栈的顶部压入一个数据项
pop()	从栈顶弹出一个数据项（并在栈中删除）
top()	显示当前栈顶的一个数据项
bottom()	显示当前栈底的一个数据项

class Stack:
    def __init__(self, start=[]):
        self.stack = []
        self.count=0
        for x in start:
            self.stack.append(x)
            self.count+=1
    
    def isEmpty(self):
        if self.count==0:
            return True
        else:
            return False
        
    def push(self,x):
        self.stack.append(x)
        self.count+=1

    def pop(self):
        if self.isEmpty():
            print("栈空")
        else:
            self.count-=1
            return self.stack.pop()
    def top(self):
        if not self.stack:
            print('警告：栈为空！')
        else:
            return self.stack[-1]
 
    def bottom(self):
        if not self.stack:
            print('警告：栈为空！')
        else:
            return self.stack[0]
        

巧用负数索引获得栈顶元素