python入门day11（详解继承、类(self)、覆盖）

悠悠 2022-01-30 13:45 249阅读 0赞

首先我们先介绍一些常用的面向对象编程的词汇：  
**类(class)**：告诉python创建新类型的东西。  
**对象(object)**：最基本的东西或者某样东西的实例。  
**实例(instance)**：这是让python创建一个类的时候得到的东西。  
**def**：这是在类里面定义函数的方法。  
**self**：在类的函数中，self指代被访问的对象或者实例的一个变量。  
**继承(inheritance)**：指一个类可以继承另一个类的特性，和父子关系类似。  
**组合(composition)**：指一个类可以将别的类作为他的部件构建起来，有点像车子和车轮的关系。  
**属性(attribute)**：类的一个属性，它来自于组合，而且通常是一个变量。  
面向对象编程：他将对象作为一个程序设计的基本单元，一个对象包括数据和操作数据的函数，每个对象都可以接受来自其他对象的消息，并对这些消息进行处理，计算机程序的执行就是一系列消息在各个对象之间的传递；与面向对象编程相对的是面向过程编程（例如c语言），他将计算机程序视为一系列命令的集合即一组函数的集合。面向过程中，我们通过将大块函数切分成小块函数来进行系统复杂度的降低。  
（一）.面向对象入门：  
在c语言中，我们所采用的是面向过程进行编程，即如果需要我们将某个人的成绩进行打印，我们会写出如下代码

#include<stdio.h>
    int main()
    {
        float score;
        printf("请输入学生的成绩 ");
        scanf("%f", &score);
        printf("该学生的成绩为%f\n", score);
        
        return 0;
    }

如果采用面向对象的程序设计思想，我们首选思考的不是程序的执行流程，而是Student这种数据类型应该被视为一个对象，这个对象拥有name和score这两个属性（Property）。如果要打印一个学生的成绩，首先必须创建出这个学生对应的对象，然后，给对象发一个print\_score消息，让对象自己把自己的数据打印出来。

class Student(object):
    
        def __init__(self, name, score):
            self.name = name
            self.score = score
    
        def print_score(self):
            print('%s: %s' % (self.name, self.score))

给对象发消息实际上就是调用对象对应的关联函数，我们称之为对象的方法（Method）。面向对象的程序写出来就像这样：

bart = Student('Bart Simpson', 59)
    lisa = Student('Lisa Simpson', 87)
    bart.print_score()
    lisa.print_score()

1.类（Class）和实例（Instance）的概念是很自然的。Class是一种抽象概念，比如我们定义的Class——Student，是指学生这个概念，而实例（Instance）则是一个个具体的Student，比如，Bart Simpson和Lisa Simpson是两个具体的Student。

所以，面向对象的设计思想是抽象出Class，根据Class创建Instance。  
2.面向对象最重要的概念就是类（Class）和实例（Instance），必须牢记类是抽象的模板，比如Student类，而实例是根据类创建出来的一个个具体的“对象”，每个对象都拥有相同的方法，但各自的数据可能不同。  
3.由于**类可以起到模板的作用**，因此，可以在创建实例的时候，把一些我们认为必须绑定的属性强制填写进去。通过定义一个特殊的\_\_init\_\_方法，在创建实例的时候，就把name，score等属性绑上去：

class Student(object):
    
        def __init__(self, name, score):
            self.name = name
            self.score = score

**特殊方法“init”前后分别有两个下划线***并且，**init****方法的第一个参数永远是self，表示创建的实例本身**，因此，在\_\_init\_\_方法内部，就可以把各种属性绑定到self，因为self就指向创建的实例本身。*

>>> bart = Student('Bart Simpson', 59)
    >>> bart.name
    'Bart Simpson'
    >>> bart.score
    59

*有了\_\_init\_\_方法，在创建实例的时候，就不能传入空的参数了，必须传入与\_\_init\_\_方法匹配的参数，但self不需要传，Python解释器自己会把实例变量传进去*。  
与普通的函数相比，在**类中定义的函数只有一点不同，就是第一个参数永远是实例变量self，并且，调用时，不用传递该参数**。除此之外，类的方法和普通函数没有什么区别，所以，你仍然可以用默认参数、可变参数、关键字参数和命名关键字参数。  
小试牛刀：

class my_car():
        def __init__(self, name, color):
            self.name = name
            self.color = color
    the_car = my_car('lambogini', 'red')
    def print_score(abc):
         print('my car`s name is %s and it`s color is %s' % (abc.name, abc.color))
    
    print_score(the_car)

**在类定义的时候那个括号里面可以不加任何参数，或者加入参数object**，但是在定义函数的时候必须在括号中加上参数否则会报错。  
4. 类是创建实例的模板，而实例则是一个一个具体的对象，各个实例拥有的数据都互相独立，互不影响；  
方法就是与实例绑定的函数，和普通函数不同，方法可以直接访问实例的数据；  
通过在实例上调用方法，我们就直接操作了对象内部的数据，但无需知道方法内部的实现细节  
（二）1.继承：当我们在写代码的时候，对于已有的类，他们可以实现你所需的大部分的功能，如果已经存在的类不能满足我们的需求时，我们可以对这个类进行修改，有一个问题是，这样做可能会影响到我们原本的代码功能。鉴于此，我们可以使用**继承**，即从已有类中衍生出新的类，添加或更改部分功能，使用继承得到的新类会自动获得旧类的所有方法，而不需要进行任何复制。你只需要在新类里面定义自己额外需要的方法，或者按照需求对继承的方法进行修改即可，**修改得到的新方法会覆盖原有的方法**。  
习惯上我们将原始的类称为父类、超累或者基类，将新的类称作孩子类、子类或者衍生类。和类一样，继承我们也从最基础的什么也不做的代码开始，例程如下：

class Car():                #父类
        pass
    class Yugo(Car):            #子类
        pass
    give_me_a_car = Car()       #创建实例
    give_me_a_Yugo = Yugo()     #创建实例

2.隐式继承：我们在父类中定义了函数，但是在子类中不定义函数，此时在对子类进行任何调用的时候我们会发现父类的函数依旧可以起作用，示例如下：

class parent(object):
        def one(self):
            print('i love python')
    class child(parent):
        pass
    son = child()
    son.one()

结果如下：`i love python`  
我们在对子类进行调用的时候发现它调用了父类的打印函数，这就说明，如果我们将函数放到子类中，那么所有子类将会自动的获得这下函数的功能。  
3.覆盖：先来一段代码：

class car():
        def exclaim(self):
            print('i am a car')
        def caa(self):
            print('you see if i was printed')
    class yugo(car):
        def exclaim(self):
            print('i am a yugo')
    give_me_car = car()
    give_me_other_car = yugo()
    give_me_car.exclaim()

我们在子类当中覆盖了父类的exclaim()方法，在子类中，我们可以覆盖任何父类的方法。子类同时也可以添加父类中没有的方法。  
3.我们已经知道如何在子类中覆盖父类的方法，但如果想要调用父类的方法的话该怎么办呢？这里，我们可以**利用super()**，例程如下：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0NjE0NTI0_size_16_color_FFFFFF_t_70]  
继承与组合说到底还是为了解决代码复用的问题，应该是没有人愿意自己的代码里都是重复的代码，这样既不整洁也没有效率；继承通过创建一种让你在基类中隐含父类的功能的机制来解决这个问题，而组合则是利用模块和别的类中的函数调用达到了相同的目的。那么在具体的问题的时候我们应该怎么抉择呢？  
（1）尽可能避免多重继承，因为他太复杂以至于不可靠，如果非要用的话，他要求我们一定要准确的把握好代码的层次结构。  
（2）如果有一些代码会在不同的位置和场合用到，那就用组合将他们做成模块。  
（3）只有在代码的可复用部分之间有清楚的关联，可以通过一个单独的共性联系起来的时候，才使用继承，或者，现有代码或者别的不可抗因素所限费使用继承不可的时候那就用吧。  
第一部分出处：廖雪峰的官方网站

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0NjE0NTI0_size_16_color_FFFFFF_t_70]: /images/20220130/8ff018b2c68141bb8ed44cf3961dff63.png