python面向对象（继承、父类、super()、多重继承、多态、（类、实例）属性和方法）

---

上一篇博客讲了有关封装的一些内容，这篇博客主要讲述python面向对象剩余的两个特点。

---

一.继承

1.什么是继承

• 继承是⾯向对象三⼤特点之⼀。
• 在面向对象中，继承其实就是类与类之间的一种关系。简单来讲，继承的类（当前类）称为子类（派生类），而被继承类称为父类（基类、超类）。

2.继承的作用

• 通过继承我们可以使⼀个类获取其他类中的属性和⽅法（包括特殊方法）。

• 在定义类时，可以在类名后⾯的括号中指定当前类的⽗类(超类、基类)。

• 继承提⾼了类的复⽤性。让类与类之间产⽣了关系。有了这个关系，才有了多态的特性。

• 举个栗子：

class Bravo(object):

    def motivation(self):
        print(' I am on my way to B 区域')

class Charlie(Bravo):

    pass

a = Charlie()
a.motivation()

• 由上述代码和图可得， Charlie是子类 ，而 父类是Bravo 。
• 值得一提的是：在创建类的时候，如果省略了父类，则 默认父类为object
• object是所有类的父类

2.issubclass（）

• issubclass（）的用途是： 判断当前类是否是另一个类的子类。

class Bravo(object):
    def motivation(self):
        print(' I am on my way to B 区域')

class Charlie(Bravo):
    pass

a = Charlie()
a.motivation()
#issubclass() ,判断当前类是否是另一个类的子类
print(issubclass(Charlie,Bravo))
print(issubclass(Bravo,object))
print(issubclass(Charlie,object))

• 大家还记得前面博客说的isinatance（）吗？，让我们再回顾一下。
• isinstance(),用来检查其中的对象是否是该类的实例。
  

3.方法的重写（覆盖）

• 如果在⼦类中有和⽗类同名的⽅法，则通过⼦类实例去调⽤⽅法时，会调⽤⼦类的⽅法⽽不是⽗类的⽅法，这个特点我们称之为⽅法的重写(覆盖)。
• 举例如下：

#创建了一个动物类
class Animals(object):
    def sleep(self):
        print('动物们都会睡觉')

    def run(self):
        print('动物们都会跑')

#定义了一个老虎，我们可以看出，tiger是子类，而Animals是父类
class Tiger(Animals):
    def sleep(self):
        print('我是动物，我也会睡觉')

    def run(self):
        print('我是动物，我也会跑')
a =Tiger()
a.run()

当我们调⽤⼀个对象的⽅法时：

• 首先会在当前对象中寻找是否具有该⽅法。如果有，则直接调⽤；如果没有，则去当前对象的⽗类中寻找。
• 如果⽗类中有则直接调⽤⽗类中的⽅法；如果没有，则去⽗类中的⽗类寻找，以此类推，直到找到object，如果依然没有找到，就会报错。

举个栗子：

class Alpha(object):

    def c4(self):
        print(' 我在A爆炸了')
    def motivation(self):
        print(' I am on my way to A 区域')

class Bravo(Alpha):

    def motivation(self):
        print(' I am on my way to B 区域')

class Charlie(Bravo):

    pass
a = Charlie()
a.motivation()
a.c4()
a.c1()   # AttributeError: 'Charlie' object has no attribute 'c1'

4.super（）

• 再说super（）的使用方法之前，有个栗子需要你去看一下。

#super()
#代码块一
class Person():
    def __init__(self,name,age):
        self._name = name
        self._age = age
    def speak(self):
        return '这是代码块一父类的输出。我是一名%s,我%s岁了'%(self._name,self._age)

class Doctor(Person):
    def Skills(self):
        print('我会治病')
#因为子类对象在继承父类时，把父类的所有属性和方法都继承了所以在使用子类创建实例对象时，需要加相应的参数(父类对象中的name，age）
p = Doctor('白衣天使',20)
print(p.speak())


#代码块二
#如果需要修改Doctor的name和age参数，我们需要进行方法的重写
class Person():
    def __init__(self,name,age):
        self._name = name
        self._age = age

    def speak(self):
        return '这是代码块二父类的输出。我是一名%s,我%s岁了'%(self._name,self._age)

class Doctor(Person):
    def __init__(self,name,age):
        self._name = name
        self._age = age

    def speak(self):
        return '这是代码块二子类的输出。我是一名%s,我%s岁了'%(self._name,self._age)

    def Skills(self):
        print('我会治病')

p = Doctor('最美逆行者',22)
print(p.speak())


#代码块三
class Person():
    def __init__(self,name,age):
        self._name = name
        self._age = age

    def speak(self):
        return '这是代码块三父类的输出。我是一名%s,我%s岁了'%(self._name,self._age)

class Doctor(Person):
    def __init__(self,name,age):
# 显而易见，self._XXX = XXX 这样的代码重写方式太繁琐，其实我们需要的就是调用父类的init改写方式如下
       Person.__init__(self,name,age)

    def speak(self):
        return '这是代码块三子类的输出。我是一名%s,我%s岁了'%(self._name,self._age)

    def Skills(self):
        print('我会治病')

p = Doctor('最美逆行者',22)
print(p.speak())

• 由代码块一可知：因为子类对象在继承父类时，把父类的所有属性和方法都继承了所以在使用子类创建实例对象时，需要加相应的参数(父类对象中的name，age）。
• 由代码块二可知：如果需要修改Doctor的name和age参数，我们需要进行方法的重写。
• 由代码块三可知：self._XXX = XXX 这样的代码重写方式太繁琐，其实我们需要的就是调用父类的init改写方式如下
  
  但是，细心的你是否发现，这样写代码其实是写死的。那么，终于，我们的super（）登场了。

#代码块四
class Person():
    def __init__(self,name,age):
        self._name = name
        self._age = age

    def speak(self):
        return '这是代码块四父类的输出。我是一名%s,我%s岁了'%(self._name,self._age)
class Doctor(Person):
    def __init__(self,name,age):
       super().__init__(name,age)

    def speak(self):
        return '这是代码块四子类的输出。我是一名%s,我%s岁了'%(self._name,self._age)

    def Skills(self):
        print('我会治病')

p = Doctor('最美逆行者',22)
print(p.speak())

(1).supper（）的作用

• supper()可以获取当前类的父类，能够获取父类所有的属性和方法，而且不需要传递self参数。

---

引用开始

引用结束

---

5.多重继承

• 在python中支持多重继承，即可以支持拥有多个父类
• 可以在类名的()后边添加多个类，来实现多重继承

#多重继承
class A(object):

    def motivation_1(self):
        print(' I am on my way to A 区域')
    # pass

class B(object):
    def motivation_1(self):
        print(' B中的motivation_1')
    def motivation_2(self):
        print(' I am on my way to B 区域')

class C(A,B):

    pass

a = C()
a.motivation_1()
a.motivation_2()

• 从图中我们可以看出 A和B 中都含有方法 motivation_1 ，但是输出的值却是 A 中的，其实如果多个父类出现同名的方法，则会在第一个父类中寻找，然后是第二个，以此类推… 。

类名.__bases__  #这个属性可以获得当前类的所有父类

• 在开发中没有特殊情况，应该尽量避免使⽤多重继承。因为多重继承会让我们的代码更加复杂。

二.多态

• 多态是⾯向对象的三⼤特性之⼀。
• 通俗的来讲，就是具有多种形态。即一个对象以不同的形态来进行呈现。

#多态
class Doctor():
    def name(self):
        return '医生'

class Nurse():

    def name(self):
        return '护士'
        
class Teacher():
    def name(self):
        return '教师'
        
a = Doctor()
b = Nurse()
c = Teacher()

def Person(obj):
    print('我是一名%s'%obj.name())
Person(a)
Person(b)
Person(c)

• 我们通过不同的参数（对象）对Person函数对进行调用，输出不同的结果，其实就是体现出了多态性。

我们再次回顾⾯向对象三⼤特性：

• 封装 确保对象中数据的安全
• 继承 保证了对象的扩展性
• 多态 保证了程序的灵活性

三.（类、实例）属性和方法

1.属性

• 类属性：直接在类中定义的属性是类属性
• 类属性可以通过类或类的实例访问到。但是类属性只能通过类对象来修改，⽆法通过实例对象修改
• 实例属性：通过实例对象添加的属性属于实例属性
• 实例属性只能通过实例对象来访问和修改，类对象⽆法访问修改

举例如下：

#属性
class Person():
    name = '李云龙' #类属性

a = Person()
print(a.name)
print(Person.name)  #从输出结果我们可以得出，类的属性可以通过类和实例来进行访问
#通过实例对象进行类属性的修改不会影响类属性原本的输出
a.name = "赵刚"
print(a.name)
print(Person.name)

class Person():
    name = '李云龙' #类属性

a = Person()
print(a.name)
print(Person.name)  #从输出结果我们可以得出，类的属性可以通过类和实例来进行访问
#通过在类对象中进行类属性的修改会影响类和实例属性的输出
Person.name = "秀琴"
print(a.name)
print(Person.name)

#实例属性  通过实例独享添加的属性是实例属性
class Person():
    name = '李云龙' #类属性
    def __init__(self):
        self.age = '18'   # 实例属性

a = Person()
#通过实例对象访问
print(a.age)
#通过类对象访问
print(Person.age)  # AttributeError: type object 'Person' has no attribute '_age'
#由此我们得出，实例属性只能通过实例对象来访问，类对象无法进行访问和修改

2.方法

(1).实例方法

• 在类中定义，以self为第⼀个参数的⽅法都是实例⽅法
• 实例⽅法可以通过类实例和类去调⽤
• 当通过实例进行调⽤时，会⾃动将当前调⽤对象作为self传⼊
• 当通过类进行调⽤时，不会⾃动传递self，我们必须⼿动传递self

#方法
#实例方法   在类中定义 以self为第一个参数的方法为实例方法
class Person():
    def Speak(self):
        print("Hello ！")
a = Person()
a.Speak()
# Person.Speak() # TypeError: Speak() missing 1 required positional argument: 'self'
Person.Speak(a)  #传递了self

(2).类方法（@classmethod）

#类方法
class Person():
#在类的内部使用    @classmethod 来修饰的方法属于类方法
#类方法的第一个参数是cls,也会⾃动被传递。cls就是当前的类对象
    @classmethod
    def Name(cls):
        print('李云龙')
a =Person()
a.Name()   #实例调用
Person.Name()  #类调用

• 类⽅法 在类的内容以@classmethod 来修饰的⽅法属于类⽅法
• 类⽅法第⼀个参数是cls 也会⾃动被传递。cls就是当前的类对象
• 类⽅法和实例⽅法的区别，实例⽅法的第⼀个参数是self，类⽅法的第⼀个参数是cls
• 类⽅法可以通过类去调⽤，也可以通过实例调⽤
  

(3).静态⽅法（@staticmethod）

• 在类中⽤@staticmethod来修饰的⽅法属于静态⽅法。
• 静态⽅法不需要指定任何的默认参数，静态⽅法可以通过类和实例调⽤。
• 静态⽅法（一般不常用）⼀般都是些⼯具⽅法，和当前类⽆关。它只是⼀个保存到当前类中的函数。

#静态方法
#在类中，用 @staticmethod 进行修饰的方法，我们称之为静态方法
#不需制定任何默认参数  静态方法可以被类对象和实例对象调用
#静态方法与本身无关，其实就是一个功能函数
class Person():
    @staticmethod
    def speak():
        print("你给我站住！")
a = Person()
a.speak()
Person.speak()

本文地址：https://blog.csdn.net/weixin_45095678/article/details/107425662