python学习笔记（七）类和面向对象

àì夳堔傛蜴生んèń 2023-07-11 06:26 20阅读 0赞

**目录**

（一）了解面向对象

面向过程

面向对象的三大特性：

（二）python中的类

1）定义类

新式类与经典类

2）初始化与实例化

3）类的属性

类属性与实例属性

私有属性

特殊属性

同名的类属性与实例属性

属性访问的特殊方法（反射）

属性包装

虚拟属性

4）类的方法

方法

静态方法

类方法

私有方法

类内方法相互调用

类方法总结

(三)继承

重载

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

# （一）了解面向对象 #

面向对象编程（Object Oriented Programming（简称OOP））是相对于面向过程编程来说的，所以要先理解一下面向过程编程。

## 面向过程 ##

面向过程是一种以“过程”为中心的编程思想，分析出解决问题所需的步骤，然后用函数把这些步骤一步步的实现，使用的时候一个个依次调用就好。

举个例子，我前面调试过的关于[模拟自动取款机的代码][Link 1]，就是按照面向过程的思路来实现的功能。

我也调试过一个应用面向对象思维来实现模拟自动取款机的项目。除此之外，还有游戏编程。。。。参见专栏。。。

优点：性能比面向对象好，因为类调用时需要实例化，开销比较大，比较消耗资源。  
缺点：不易维护、不易复用、不易扩展。

**面向对象**是一种以“对象”为中心的编程思想，把问题看成一个个对象，通过对象的属性和行为，将问题解决的。面向过程强调的是模块化，而面向对象强调的是把事物对象化。

## 面向对象的三大特性： ##

1.  **封装**：隐藏对象的属性和实现细节，仅对外提供公共访问方式，将变化隔离，便于使用，提高复用性和安全性。
2.  **继承**：复合自然界的分类规律，提高代码复用性。继承是多态的前提。
3.  **多态**：父类或接口定义的引用变量可以指向子类或具体实现类的实例对象。子类可以通过自定义来修改特性。多态提高了程序的拓展性。

优点：易维护、易复用、易扩展，由于面向对象有封装、继承、多态性的特性，可以设计出低耦合的系统，使系统 更加灵活、更加易于维护 .  
缺点：性能比面向过程差。

对于python，使用类来实现面向对象，下面我们简单了解一下python中的类。

# （二）python中的类 #

python中的类可用于保存数据和代码。python也是通过类来实现面向对象的。

## 1）定义类 ##

Python中的类（class）实际上就是数据类型。Python的所有内置数据类型都是类，Python提供了强大的工具，用于对类的所有行为进行控制。类可用class语句进行定义：

class MyClass:
        body

body部分是由一系列Python语句组成，通常包含变量赋值和函数定义语句。不过赋值和函数定义语句都不是必需的，body可以只包含一条pass语句。

为了能够让类标识符足够醒目，按惯例每个单词首字母应该大写。类定义完之后，只要将类名称作为函数进行调用，就可以创建该类的对象，即类的实例。

### 新式类与经典类 ###

对于Python2版本的，默认是经典类，继承object的为新式类。

对于Python3版本的，统一为新式类，不用继承object。

其中经典类继承为深度优先，新式类为广度优先。

## 2）初始化与实例化 ##

通过在类的定义中包含初始化方法\_\_init\_\_，可以实现对实例的字段进行自动初始化，这个类所用到的属性一般在\_\_init\_\_()方法中创建并且初始化，一般不建议在\_\_init\_\_()方法之外中创建和初始化实例属性，因为可能没有初始化就被调用了，这样程序就会报错。

一般不推荐类外定义和修改，修改可以单独定义方法。

类的**初始化**，是完成程序执行前的准备工作。在这个阶段，静态的（变量，方法，代码块）会被执行。同时在会开辟一块存储空间用来存放静态的数据。初始化只在类加载的时候执行一次。  
类的**实例化**，是指创建一个对象的过程。这个过程中会在堆中开辟内存，将一些非静态的方法，变量存放在里面。在程序执行的过程中，可以创建多个对象，既多次实例化。每次实例化都会开辟一块新的内存。

类就相当于一个模型（模子/印章），实例化类就是建立真实实物（产品/印章印出来的图案）。

每次创建类的新实例时，\_\_init\_\_函数都会运行，新建实例本身将作为函数的第一个参数self代入。Python的类只能包含一个\_\_init\_\_方法。下面的实例将会创建默认半径为1的圆：

>>> class Circle:
    	def __init__(self):
    		self.radius = 1
     
        
    >>> my_circle = Circle()
    >>> print(2 * 3.14 * my_circle.radius)
    6.28
    >>> my_circle.radius = 5
    >>> print(2 * 3.14 * my_circle.radius)
    31.400000000000002
     
    >>> class Circle:
    	def __init__(self):
    		self.radius = 1
    		print("自动调用吗？")
     
    		
    >>> my = Circle()
    自动调用吗？

按照惯例，\_\_init\_\_方法的第一个参数名始终是self，self指的是类实例化之后得类得本身。当\_\_init\_\_运行时，self会被置为新建的Circle实例。接下来就会用到类的定义。首先把Circle类赋值给my\_circle来创建一个Circle实例对象。下一行代码是基于radius属性已经被初始化这一事实。radius字段的值可以被覆盖，这就导致了最后一行打印出的结果与上一条print语句的不一样了。

第二个Circle类演示了\_\_init\_\_()方法自动实例化。

## 3）类的属性 ##

我们把实例化之后的类看作是一个对象，那么对象的属性就是对象具有的特点。

### 类属性与实例属性 ###

我们有一个房子对象，房子的长宽高是固定的，那么我们就说长宽高是房子对象的**类属性**；在我们编写房子类的时候，我们采用赋值语句，所以类属性又叫**类变量**。

类变量（class variable），是与类关联的变量，而不是与类的实例关联，并且可供类的所有实例访问。

类变量在类定义后就存在，而且不需要实例化。类变量使得类的不同实例中拥有相同的变量。

类变量是在类体中，函数之外定义的。

如果我们让房子的主人自己定义房子有几个窗户，几扇门，那么房子主人定义好的窗户和门也是房子对象的**实例属性**；在这里窗户和门的数量都是一个变量，所以也可以叫做**实例变量**。

实例变量是在类体中的函数内定义的。

class House:
        #定义类变量
        lengh = 13
        width = 7
        high = 3
        
        def __init__(self,windows,door):
            self.windows = windows
            self.door = door
            
    house = House(6,2)
    print("类House的类属性lengh、width、high分别为：{},{},{}".format(house.lengh,house.width,house.high))
    print("类House的实例变量windows、door分别为：{}{}".format(house.windows,house.door))

输出如下：

类House的类属性lengh、width、high分别为：13,7,3
    类House的实例变量windows、door分别为：62

类变量通过类定义代码中的赋值语句创建的，而不是在\_\_init\_\_函数中创建的。实例变量写在\_\_init\_\_中，系统会自动实例化，在其他函数中创建的实例变量，需要我们进行实例化之后才可以访问。类变量创建之后，就可以被类的所有实例看到。可以用类变量创建pi值，供Circle类的所有实例访问：

class Circle:
        pi = 3.14159
        def __init__(self,rad):
            self.radius = rad
            
        def area(self):
            return self.radius * self.radius * Circle.pi
        
        def manyround(self,number):
            return self.radius * 2 * Circle.pi *number
        
    c = Circle(5)
    print(c.pi)
    c.pi = 4
    print(c.pi)
    print(c.area())
    c.pi = 3.14159
    #实例化manyround（）之后，使用实例变量number：
    print(c.manyround(2))

输出：

类House的类属性lengh、width、high分别为：13,7,3
    类House的实例变量windows、door分别为：62
    3.14159
    4
    78.53975
    62.8318

\_\_class\_\_属性会返回实例所属的类，例如：

>>> Circle
    <class '__main__.Circle'>
    >>> c.__class__
    <class '__main__.Circle'>

名为Circle的类在系统内部是用一个抽象数据结构表示的，该数据结构正是从c的\_\_class\_\_属性获取的，c就是Circle类的一个实例。以下示例由c获取Circle.pi的值，而无须显式的引用Circle类名：

>>> c = Circle(3)
    >>> c.__class__.pi
    3.14159

再举个例子来理解一下类中的函数中如何实例化对象：

class TestClass:
        #设置类变量
        classa = "class-attribe"
        def __init__(self):
            self.a = 10
            self.b = 20
            
        def info(self):
            print('a = ',self.a,'b = ',self.b)
            
        def define_a(self):
            self.c = 19
            print('这是define_a方法有一个c属性，定义值为：{}'.format(self.c))
            
            
    if __name__ == '__main__':
        c1 = TestClass()
        print(c1.a)
        #运行以下代码将会报错如下：
        #AttributeError: 'TestClass' object has no attribute 'c'
        #c1.c
        
        #正常操作：
        c1.define_a()
        
        print(c1.c)
        print(c1.classa)

这里就是在调用实例变量c之前需要先对函数define\_a()进行实例化，才可以调用，否则会报错。

### 私有属性 ###

python不提供限制属性访问的关键字（无法限制类的各种属性在类外直接访问），而是使用\_\_（注意是**双下划线**）开头的变量名加以标志，只有类对象自己能访问。

class A:
        def __init__(self):
            self.__ab = 0
            
        def info(self):
            print(self.__ab)
            
    a = A()
    a.info()
    a.__ab = 3
    a.info()
    print(a.__ab)

输出:

0
    0
    3

这里类外面的a.\_\_ab和类A里面的a.\_\_ab是不同的。类外边的a.\_\_ab是对类A的实例化a定义了一个\_\_ab变量，而类A中的self.\_\_ab是定义了一个私有属性。

使用\_（单下划线）开头的变量加以标志，应该只有类对象及其子类能访问（非强制性）。

把上面代码的双下划线改成单下划线：

class A:
        def __init__(self):
            self._ab = 0
            
        def info(self):
            print(self._ab)
            
    a = A()
    a.info()
    a._ab = 3
    a.info()
    print(a._ab)

输出：

0
    3
    3

我们看到类外边的a.\_\_ab = 3起到了作用，所以我们说这是非强制性的。

下面的一些内容就有些高级了，可以先不深入了解，知道有这么个内容就可以。

### 特殊属性 ###

所谓特殊属性，就是python自带的一些有特殊作用的属性。比如我们前面提到的\_\_class\_\_属性，用来代替一个类。

以下是常见的python保留属性：

>>> Class1.__doc__ # 类型帮助信息 'Class1 Doc.' 
    >>> Class1.__name__ # 类型名称 'Class1' 
    >>> Class1.__module__ # 类型所在模块 '__main__' 
    >>> Class1.__bases__ # 类型所继承的基类 (<type 'object'>,) 
    >>> Class1.__dict__ # 类型字典，存储所有类型成员信息。 <dictproxy object at 0x00D3AD70> 
    >>> Class1().__class__ # 类型 <class '__main__.Class1'> 
    >>> Class1().__module__ # 实例类型所在模块 '__main__' 
    >>> Class1().__dict__ # 对象字典，存储所有实例成员信息。 {'i': 1234}

特殊属性我们初学者用到的不多，这也是一个比较高级的用法，可以先不去了解，等有一定python基础经验的时候，再来理解一下。

### 同名的类属性与实例属性 ###

>>> class A:
    	a = 1
    	def __init__(self):
    		self.a = 10
    		self.b = 20
     
    		
    >>> 
    >>> a = A()
    >>> a.a
    10
    >>> A.a
    1
    >>> a.b
    20
    >>> A.b
    Traceback (most recent call last):
      File "<pyshell#11>", line 1, in <module>
        A.b
    AttributeError: type object 'A' has no attribute 'b'

self.a和self.b是实例属性，也就是说必须在类实例化之后才可以访问，所以这里A.b会报错。

### 属性访问的特殊方法（反射） ###

反射是python提供用字符串来操作类的属性/方法的方式

获取a对象中的a属性的值
    >>> getattr(a,'a')
    10
    #设置a对象中的a属性的值为20
    >>> setattr(a,'a',20)
    >>> a.a
    20
    #测试a对象中是否有b属性
    >>> hasattr(a,'b')
    True
    >>> hasattr(a,'bbb')
    False
    >>>

### 属性包装 ###

所谓属性包装，就是将方法包装成属性，以隐藏相关实现。属性包装主要用来哦内阁制属性的类型和范围。

通过三种属性操作实现属性包装。

*  可读：@property
 *  可写：@<property-name>.setter
 *  可删：@<property-name>.seleter

Python内置的`@property`装饰器可以把类的方法伪装成属性调用的方式。也就是本来是`Foo.func()`的调用方法，变成`Foo.func`的方式。在很多场合下，这是一种非常有用的机制。

比如我们定义一个洗衣机类，在启动洗衣机前，需要加水、加洗涤剂。

这里我们不希望读取的时候直接引用water实例变量，因此我们设置water为私有变量，并且定义了water()函数，并且对water()函数进行属性包装。

我们也不希望用户随意的设置水量，这里可以在set\_water()里面进行验证，还可以像属性包装一样进行设置。

在通过w.water = 123进行修改的时候，就调用了water(self,water):进行检查，如果在这个范围内就对w.water进行修改，否则会返回错误。

class Washer:
        
        def __init__(self, water=10,score=2):
            self._water = water
            self.score = score
            self.year = 2010
            
        @property
        def water(self):
            return self._water
        
        @water.setter
        def water(self,water):
            if 0 < water <= 500:
                self._water = water
            else:
                print("set Failure")
                
        @property
        def total_year(self):
            return 2015 - self.year
        
        def set_water(self,water):
            self.water = water
            
        def set_scour(self,scour):
            self.scour = scour
            
        def add_water(self):
            print('Add water:', self.water)
            
        def add_scour(self):
            print('Add scour: ',self.score)
        
        def start_wash(self):
            self.add_water()
            self.add_scour()
            print('Start wash......')
            
    if __name__ == '__main__':
        w = Washer()
        print(w.water)  #water后面没有括号，不是方法
        w.water = 123
        print(w.water)
        print(w.total_year)

输出：

10
    123
    5

在外界看来就是一个属性，实际上在内部就是属性包装。

### 虚拟属性 ###

虚拟属性是指属性本身不存在，通过其他属性处理后得来的。

## 4）类的方法 ##

方法是与某个类关联的函数，是类自身包含或知道的数据能力，以方法体现，是类具有能动性的体现。

### 方法 ###

上面已经介绍了特殊的\_\_init\_\_方法，当创建实例时会对新实例调用该方法。在以下实例中，Circle类定义了另一个方法area，用于计算并返回Circle实例的面积。调用area采用的是方法调用（invocation）语法。

>>> class Circle:
    	def __init__(self):
    		self.radius = 1
    	def area(self):
    		return self.radius * self.radius * 3.14159
     
    	
    >>> c = Circle()
    >>> c.radius = 3
    >>> print(c.area())
    28.27431

方法调用语法包括实例名，加上一个点，再加上要在该实例上调用的方法。当以这种方式调用方法时，就是一种已绑定（bound）的方法调用。

与\_\_init\_\_类似，area方法被定义为类定义内部的函数。方法的第一个参数一定是发起调用的实例，按照惯例命名为self。

如果方法定义了能接受的参数，就可以在调用时使用。以下版本的Circle为\_\_init\_\_方法添加了一个参数，以便能创建给定半径的圆，而无须在对象创建之后再另行设置：

>>> class Circle:
    	def __init__(self, rad):
    		self.radius = rad
    	def area(self):
    		return self.radius * self.radius * 3.14159
     
    	
    >>> 
    >>> c = Circle(3)
    >>> c.area()
    28.27431

Python的所有标准函数特性，都可以用于方法，这些特性如参数默认值、不定参数、关键字参数等。比如可以给rad一个默认值1：

>>> class Circle:
    	def __init__(self, rad = 1):
    		self.radius = rad
    	def area(self):
    		return self.radius * self.radius * 3.14159
     
    	
    >>> 
    >>> c = Circle()
    >>> c.area()
    3.14159

### 静态方法 ###

与Java一样，即使没有创建类的实例，静态方法也是可以调用的，当然通过类的实例来调用也是可以的。需要用@staticmethod装饰器来创建静态方法。

创建如下类：

"""circle module: contains the Circle class."""
    class Circle:
        """Circle class"""
        all_circles = [ ]
        pi = 3.14159
        def __init__(self, r = 1):
            """Create a Circle with the given radius"""
            self.radius = r
            # 如果实例已经被初始化了，就把自己加入all_circle列表
            self.__class__.all_circles.append(self)
        def area(self):
            """determine the area of the Circle"""
            return self.__class__.pi * self.radius * self.radius
        
        @staticmethod
        def total_area():
            """Static method to total the areas of all Circles"""
            total = 0
            for c in Circle.all_circles:
                total = total + c.area()
            return total

然后在IDLE中输入：

>>> import circle   # 作为包导入
    >>> c1 = circle.Circle(1)
    >>> c2 = circle.Circle(2)
    >>> c2.area()
    12.56636
    >>> circle.Circle.total_area()
    15.70795
    >>> c2.radius = 3
    >>> circle.Circle.total_area()
    31.415899999999997

这里用到了文档字符串。在实际的模块代码中，还可能加入更多的信息字符串，可以通过\_\_doc\_\_方法读取：

>>> import circle
    >>> circle.__doc__
    'circle module: contains the Circle class.'
    >>> circle.Circle.__doc__
    'Circle class'
    >>> circle.Circle.area.__doc__
    'determine the area of the Circle'

注意，**静态方法中不能够引用实例属性**。

这里我们再对上面洗衣机的代码进行修改：

class Washer:
        
        company = "Le Xi"
        def __init__(self, water=10,score=2):
            self._water = water
            self.score = score
            self.year = 2010
            
        @staticmethod
        def spins_ml(spins):
            print('company:', Washer.company)
            return spins * 0.4
        
        @property
        def water(self):
            return self._water
        
        @water.setter
        def water(self,water):
            if 0 < water <= 500:
                self._water = water
            else:
                print("set Failure")
                
        @property
        def total_year(self):
            return 2015 - self.year
        
        def set_water(self,water):
            self.water = water
            
        def set_scour(self,scour):
            self.scour = scour
            
        def add_water(self):
            print('Add water:', self.water)
            
        def add_scour(self):
            print('Add scour: ',self.score)
        
        def start_wash(self):
            self.add_water()
            self.add_scour()
            print('Start wash......')
            
    if __name__ == '__main__':
        w = Washer()
        print(w.water)  #water后面没有括号，不是方法
        #w._water = 5000   #这种方式无法限制大小。
        w.water = -123
        print(w.water)
        print(w.total_year)
        print(Washer.spins_ml(8))
        print(w.spins_ml(8))
        q = Washer(200, Washer.spins_ml(9))
        q.start_wash()

输出如下：

10
    set Failure
    10
    5
    company: Le Xi
    3.2
    company: Le Xi
    3.2
    company: Le Xi
    Add water: 200
    Add scour:  3.6
    Start wash......

### 类方法 ###

类方法与静态方法很相像，都可以在类的对象被实例化之前进行调用，也都能通过类的实例来调用。但是类方法隐式地将所属类作为第一个参数进行传递，因此代码可以更简单。

类方法只能访问类属性，不能访问类的实例属性。实例属性在没有实例化之前是不存在的。

注意在类前面需要加上@classmethod装饰器。

"""circle__cm module: contains the Circle class."""
    class Circle:
        """Circle class"""
        all_circles = [ ]   # 该变量包含所有已创建实例的列表
        pi = 3.14159
        def __init__(self, r = 1):
            """Create a Circle with the given radius"""
            self.radius = r
            # 如果实例已经被初始化了，就把自己加入all_circle列表
            self.__class__.all_circles.append(self)
        def area(self):
            """determine the area of the Circle"""
            return self.__class__.pi * self.radius * self.radius
        
        @classmethod
        def total_area(cls):
            """Static method to total the areas of all Circles"""
            total = 0
            for c in cls.all_circles:
                total = total + c.area()
            return total

作为模块导入IDLE中进行测试：

>>> import circle__cm
    >>> c1 = circle__cm.Circle(1)
    >>> circle__cm.Circle.total_area()
    3.14159
    >>> circle__cm.Circle.total_area()
    3.14159
    >>> c2 = circle__cm.Circle(2)
    >>> circle__cm.Circle.total_area()
    15.70795

这里def方法前面加上了装饰器@classmethod。类作为参数，按惯例命名为cls，当然直接是类名也是可以的。然后就可以用cls代替self.\_\_class\_\_。

利用类方法而不是静态方法，可以不必将类名硬编码写入total\_area。这样，Circle的所有子类仍然可以调用total\_area，但引用的是自己的成员而不是Circle的成员。

再来看看洗衣机代码：

class Washer:
        
        company = "Le Xi"
        def __init__(self, water=10,score=2):
            self._water = water
            self.score = score
            self.year = 2010
            
        @staticmethod
        def spins_ml(spins):
            print('company:', Washer.company)
            return spins * 0.4
        
        @classmethod
        def get_washer(cls,water,scour):
            return cls(water,cls.spins_ml(scour))
        
        @property
        def water(self):
            return self._water
        
        @water.setter
        def water(self,water):
            if 0 < water <= 500:
                self._water = water
            else:
                print("set Failure")
                
        @property
        def total_year(self):
            return 2015 - self.year
        
        def set_water(self,water):
            self.water = water
            
        def set_scour(self,scour):
            self.scour = scour
            
        def add_water(self):
            print('Add water:', self.water)
            
        def add_scour(self):
            print('Add scour: ',self.score)
        
        def start_wash(self):
            self.add_water()
            self.add_scour()
            print('Start wash......')
            
    if __name__ == '__main__':
        w = Washer.get_washer(100,9)
        w.start_wash()

输出：

company: Le Xi
    Add water: 100
    Add scour:  3.6
    Start wash......

### 私有方法 ###

所谓私有方法，和私有属性一样，是指在定义它们的类的方法之外无法看到。

私有变量和私有方法的用途有两个：

*  一是可以通过由选择地拒绝对对象实现的重要或敏感部分的访问，以增强安全性和可靠性。
 *  二是可以防止由继承产生的名称冲突。类可以定义自己的私有变量，同时其父类也可以定义同名的私有变量，这完全没有问题，因为变量是私有的，可以保证拥有各自的副本。

大多数编程语言在定义私有变量时，都是通过类似'private'的关键字来实现。Python约定名称以双下划线“\_\_”开头但不以它结尾的方法或实例变量，都是私有的，其他则都不是私有部分。

### 类内方法相互调用 ###

还类内的方法是可以相互调用的，还是那个洗衣机的例子，可以看看上面的代码

class Washer:
        
        def __init__(self, water=10,score=2):
            self.water = water
            self.score = score
        
        def set_water(self,water):
            self.water = water
            
        def set_scour(self,scour):
            self.scour = scour
            
        def add_water(self):
            print('Add water:', self.water)
            
        def add_scour(self):
            print('Add scour: ',self.score)
        
        def start_wash(self):
            self.add_water()
            self.add_scour()
            print('Start wash......')
            
    if __name__ == '__main__':
        w = Washer()
        #w.set_water(200)
        #w.set_scour(2)
        w.start_wash()

前面已经用到了，这里只是提及一下。

### 类方法总结 ###

我们通过写一个类来总结以下前面的语法:

class Shape:
        # __init__方法的参数为实例self和两个坐标
        def __init__(self, x, y):
            # 通过self访问实例变量
            self.x = x
            self.y = y
        
        # move方法的参数为实例self和两个坐标的偏移量
        def move(self, delta_x, delta_y):
            # 在move方法中对实例变量赋值
            self.x = self.x + delta_x
            self.y = self.y + delta_y
            
    class Circle(Shape):
        # pi和all_ciecles都是Circle的类变量
        pi = 3.14159
        all_circles = []
        # Circle的__init__参数为实例self和3个带默认值的坐标
        def __init__(self, r = 1, x = 0, y = 0):
            # Circle的__init__通过super()调用Shape的__init__
            super().__init__(x, y)
            self.radius = r
            # 在__init__方法中将实例加入all_circles列表
            self.__class__.all_circles.append(self)
            
        @classmethod
        # total_area是类方法，参数为类本身cls
        def total_area(cls):
            area = 0
            for circle in cls.all_circles:
                # 通过参数cls访问静态方法circle_area
                area += cls.circle_area(circle.radius)
            return area
        
        @staticmethod
        # circle_area是不用self和cls做参数的静态方法
        def circle_area(radius):
            # 访问类变量pi，也可以用__class__.pi
            return Circle.pi * radius * radius

下面可以创建Circle类的一些实例，看看它们的表现如何。因为Circle的\_\_init\_\_方法的参数都带有默认值，所以创建Circle对象时可以不带任何参数：

>>> import conclusion
    >>> c1 = conclusion.Circle()
    >>> c1.radius, c1.x, c1.y
    (1, 0, 0)

如果给出了参数，那就会用来设置实例变量值：

>>> c2 = conclusion.Circle(2, 1, 1)
    >>> c2.radius, c2.x, c2.y
    (2, 1, 1)

在调用move()方法时，Python在Circle类中无法找到move(),因此会沿着继承架构向上查找，采用Shape的move()方法：

>>> c2.move(2, 2)
    >>> c2.radius, c2.x, c2.y
    (2, 3, 3)

同时，因为在\_\_init\_\_方法里已经把所有实例添加到一个列表（这是一个类变量）当中，所以可以获取到当前的Circle实例：

>>> conclusion.Circle.all_circles
    [<conclusion.Circle object at 0x000002A4F38B9BE0>, <conclusion.Circle object at 0x000002A4F38B0DD8>]
    >>> [c1, c2]
    [<conclusion.Circle object at 0x000002A4F38B9BE0>, <conclusion.Circle object at 0x000002A4F38B0DD8>]

通过Circle类本身或是其实例，也可以调用Circle类方法total\_area():

>>> conclusion.Circle.total_area()
    15.70795
    >>> c2.total_area()
    15.70795

通过类本身或其实例，也可以调用静态方法circle\_area()。作为一个静态方法，circle\_area没有用参数传递实例或类，它的行为更像是类命名空间内的独立函数。实际上，静态方法相当常见的用途，就是把工具函数与类绑定在一起：

>>> conclusion.Circle.circle_area(c2.radius)
    12.56636
    >>> c2.circle_area(c2.radius)
    12.56636

以上实例演示了Python的基本行为。

# (三)继承 #

继承、封装和多态是面向对象编程对象的特性，封装、多态在前面python类都有所体现，这里就不赘述了。

在Python3.几版本中，不定义继承哪个类的类，Python自动继承object类。

我么可以通过继承父类达到快速编写代码并且拓展类的目的。

用这个例子来说明继承的应用：

class Shape:  
    def \_\_init\_\_(self, x, y):  
        self.x = x  
        self.y = y

class Square(Shape):             \# 声明Square继承自Shape  
    def \_\_init\_\_(self, side = 1, x = 0, y = 0):  
        super().\_\_init\_\_(x, y)       \# Shape的\_\_init\_\_方法必须得调用  
        self.side = side

class Circle(Shape):  
    def \_\_init\_\_(self, r = 1, x = 0, y = 0):  
        super().\_\_init\_\_(x, y)        \# Shape的\_\_init\_\_方法必须得调用  
        self.radius = r

在Python中使用继承类通常有两个要求，在Circle类和Square类的绿色代码中可以看到这两个要求。

第一个是在类名后面的圆括号之中给出要继承的类名。

第二个是必须显式的调用被继承类的\_\_init\_\_方法。Python不会自动执行初始化操作，但可以用super函数让Python找到被继承的类。初始化的工作在示例中由super().\_\_init\_\_(x, y)这行代码来完成，这里将调用Shape的初始化函数，用适当的参数初始化实例。如果没有显式的调用父类的初始化方法，则本例中的Circle和Square的实例就不会给实例变量x和y赋值。

可以不用super来调用Shape的\_\_init\_\_，而是用Shape.\_\_init\_\_(self, x, y)显式给出被继承类的名字，同样能够实现在实例初始化完毕后调用Shape的初始化函数。从长远来看这种做法不够灵活，如果日后整体设计和继承架构发生变化，这就可能成为问题。

## 重载 ##

所谓重载，就是在子类中重新定义父类的方法，重新定义的方法将覆盖父类的方法。

在多重继承时，调用一个方法，按照继承类的顺序

**参考：**

1.  [http://c.biancheng.net/view/2283.html][http_c.biancheng.net_view_2283.html]
2.  [python特殊属性和方法的运用][python]
3.  [https://www.liaoxuefeng.com/wiki/897692888725344/923030547069856][https_www.liaoxuefeng.com_wiki_897692888725344_923030547069856]
4.  考鸡蛋[博客][Link 2]

[Link 1]: https://blog.csdn.net/weixin_45755966/article/details/104389572#%EF%BC%88%E4%B8%83%EF%BC%89%E5%BC%80%E5%A7%8B%E5%BE%AA%E7%8E%AF
[http_c.biancheng.net_view_2283.html]: http://c.biancheng.net/view/2283.html
[python]: https://blog.csdn.net/business122/article/details/7568446
[https_www.liaoxuefeng.com_wiki_897692888725344_923030547069856]: https://www.liaoxuefeng.com/wiki/897692888725344/923030547069856
[Link 2]: https://www.cnblogs.com/lijunjiang2015/p/7802410.html