《零基础入门学习Python》第039讲：类和对象：拾遗

短命女 2022-04-21 14:46 300阅读 0赞

## 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，叫做混入的意思，有兴趣的可以参见-> [Python Mixin 编程机制][Python Mixin]。

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

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

>>> 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，如图：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNTU2MzE4_size_16_color_FFFFFF_t_70][]

类定义到类对象，还有实例对象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 "<pyshell#48>", line 1, in <module>
        c.x()
    TypeError: 'int' object is not callable

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

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

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

**（三）到底什么是绑定？**

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

--------------------

# **测试题** #

## 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 "<pyshell#20>", 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 "<pyshell#8>", line 1, in <module>
        bb.printBB()
    TypeError: printBB() takes 0 positional arguments but 1 was given

答：因为 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 C:
            count = 0
            
            def __init__(self):
                    C.count += 1
    
            def __del__(self):
                    C.count -= 1
    
    >>> a = C()
    >>> b = C()
    >>> c = C()
    >>> C.count
    3
    >>> del a
    >>> C.count
    2
    >>> del b, c
    >>> C.count
    0

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

至少需要有以下方法：

![231413ce3np00e90bow0fu.jpg][]

<table style="width:700px;"> 
 <tbody> 
  <tr> 
   <td><strong>方法名</strong></td> 
   <td><strong>含义</strong></td> 
  </tr> 
  <tr> 
   <td>isEmpty()</td> 
   <td>判断当前栈是否为空（返回 True 或 False）</td> 
  </tr> 
  <tr> 
   <td>push()</td> 
   <td>往栈的顶部压入一个数据项</td> 
  </tr> 
  <tr> 
   <td>pop()</td> 
   <td>从栈顶弹出一个数据项（并在栈中删除）</td> 
  </tr> 
  <tr> 
   <td>top()</td> 
   <td>显示当前栈顶的一个数据项</td> 
  </tr> 
  <tr> 
   <td>bottom()</td> 
   <td>显示当前栈底的一个数据项</td> 
  </tr> 
 </tbody> 
</table>

class Stack:
        def __init__(self, start=[]):
            self.stack = []
            for x in start:
                self.push(x)
    
        def isEmpty(self):
            return not self.stack
        
        def push(self, obj):
            self.stack.append(obj)
    
        def pop(self):
            if not self.stack:
                print('警告：栈为空！')
            else:
                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]

[Python Mixin]: https://blog.csdn.net/qq_41556318/article/details/84526165
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNTU2MzE4_size_16_color_FFFFFF_t_70]: /images/20220414/5e7aa0468b054980b7d9886d3ed2ad93.png
[231413ce3np00e90bow0fu.jpg]: /images/20220414/3d67c81f57a54f778b40606392d938f8.png