Python面向对象的三大特征 - - 封装、继承、多态

*_花非人陌_*

已于 2023-03-07 23:50:19 修改

阅读量1.8k

点赞数 1

分类专栏： python 文章标签： java 开发语言 python pycharm

于 2023-03-07 19:32:57 首次发布

本文链接：https://blog.csdn.net/qq_41619571/article/details/129377012

版权

python 专栏收录该内容

9 篇文章 0 订阅

订阅专栏

2. dir() 查看对象属性（方法本质也是属性）

一、三大特征介绍

1、封装（隐藏）

隐藏对象的属性和实现细节，只对外提供必要的方法。相当于将“细节封装起来”，只对外暴露“相关调用方法”。
通过“私有属性、私有方法”的方式，实现“封装”。Python追求简洁的语法，没有严格的语法级别的“访问控制符”，更多的是依靠程序员自觉实现

2、继承

继承可以让子类具有父类的特性，提高了代码的重用性。
从设计上是一种增量进化，原有父类设计不变的情况下，可以增加新的功能，或者改进已有的算法

3、多态

多态是一种允许不同对象对相同消息作出响应的机制。在多态中，不同的对象可以具有相同的方法名称，但是它们的行为可能会有所不同。这样就可以通过一个通用的方法调用来处理多个不同的对象。多态可以提高代码的灵活性和可扩展性。

二、继承

1、子类扩展父类

1.语法格式

Python支持多重继承，一个子类可以继承多个父类。继承的语法格式如下：

class 子类类名(父类1[，父类2，...])：
    类体

如果在类定义中没有指定父类，则默认父类是 object 类。也就是说， object 是所有类的父类，里面定义了一些所有类共有的默认实现，比如： __new__()

2.构造函数

①. 子类不重写__init__，实例化子类时，会自动调用父类定义的 __init__。

class Person:
    def __init__(self,name,age):
        print("Person的构造方法")
        self.name = name
        self.age = age

    def say_age(self):
        print(self.name,"的年龄是：",self.age)


class Stedent(Person):
    pass



s1 = Stedent("张三",15)
print(dir(s1))
s1.say_age()


'''
Person的构造方法
[... 'age', 'name', 'say_age']
张三 的年龄是： 15
None

#查看Stedent类对象的所有属性、方法，已经包含了Person类'''

②. 子类重写了__init__时，实例化子类，就不会调用父类已经定义的__init__。

class Person:
    def __init__(self,name,age):
        print("Person的构造方法")
        self.name = name
        self.age = age

    def say_age(self):
        print(self.name,"的年龄是：",self.age)


class Stedent(Person):
    def __init__(self,name,age,score):
        self.name = name
        self.age = age
        self.score = score    #定义自己的方法


s1 = Stedent("张三",15)
print(dir(s1))
s1.say_age()
print(s1.score)

'''
*************运行报错***********
TypeError: __init__() missing 1 required positional argument: 'score'
此时因为没有继承父类“Person”的构造方法，所以报错，需要添加score参数

'''

#修改s1处代码
s1 = Stedent("张三",15，100)

'''
[... 'age', 'name', 'say_age', 'score']
张三 的年龄是： 15
100
'''

③. 如果重写了 __init__ 时，要使用父类的构造方法，可以使用 super 关键字，也可以使用如下格式调用：父类名.__init__(self, 参数列表)

class Person:
    def __init__(self,name,age):
        print("Person的构造方法")
        self.name = name
        self.age = age

    def say_age(self):
        print(self.name,"的年龄是：",self.age)


class Stedent(Person):

    def __init__(self,name,age,score):
        Person.__init__(self,name,age)
        print("Student的构造方法1")
        self.score = score



s1 = Stedent("张三",15,100)
s1.say_age()
print(s1.score)

'''
Person的构造方法
Student的构造方法1
张三 的年龄是： 15
100

'''

class Person:
    def __init__(self,name,age):
        print("Person的构造方法")
        self.name = name
        self.age = age

    def say_age(self):
        print(self.name,"的年龄是：",self.age)


class Stedent(Person):

    def __init__(self,name,age,score):
        super(Stedent,self).__init__(name,age)
        print("Student的构造方法1")
        self.score = score



s1 = Stedent("张三",15,100)
s1.say_age()
print(s1.score)

#结果和父类名方式一样

2、类成员的继承和重写

1. 成员继承

子类继承了父类除构造方法之外的所有成员（私有属性、私有方法也被继承）

Python中私有属性“_“下划线和 “__“双下划线的区别”

class Person:
    def __init__(self,name,age):
        print("Person的构造方法")
        self.name = name
        self.__age = age
        '''
        将age属性私有
        '''

    def say_age(self):
        print(self.name,"的年龄是：",self.__age)


class Stedent(Person):

    def __init__(self,name,age,score):
        super(Stedent,self).__init__(name,age)
        print("Student的构造方法1")
        self.score = score

    def say_score(self):
        print("我的分数",self.score)


s1 = Stedent("张三",15,100)
s1.say_age()
s1.say_score()
print(dir(s1))


'''
Person的构造方法
Student的构造方法1
张三 的年龄是： 15
我的分数 100
['_Person__age',...]
'''

2. 方法重写

子类可以重新定义父类中的方法，这样就会覆盖父类的方法，也称为“重写”

class Person:

    def __init__(self,name,age):
        self.name = name
        self.age = age

    def say_age(self):
        print(self.name,"的年龄是：",self.age)

    def say_name(self):
        print("我是",self.name)


class Student(Person):

    def __init__(self,name,age,score):
        Person.__init__(self,name,age)
        self.score = score

    def say_score(self):    #自己定义的方法
        print(self.name,"的分数是：",self.score)

    def say_name(self):     #重写父类的方法
        print("你好，我是",self.name)



s1 = Student("张三",15,85)
s1.say_score()
s1.say_name()
s1.say_age()


'''
张三 的分数是： 85
你好，我是 张三        #已经重写了父类的方法
张三 的年龄是： 15
'''

3、查看类的继承层次结构

通过类的方法 mro() 或者类的属性 __mro__ 可以输出这个类的继承层次结构。

class A:pass
class B(A):pass
class C(B):pass

print(C.mro())
#或者 print(C.__mro__)

'''
[<class '__main__.C'>, <class '__main__.B'>, <class '__main__.A'>, <class 'object'>]
'''
#依次C - B - A -object

4、object根类

1.描述

object 类是所有类的父类，因此所有的类都有 object 类的属性和方法。

2. dir() 查看对象属性（方法本质也是属性）

class Person:

    def __init__(self,name,age):
        self.name = name
        self.age = age

    def say_age(self):
        print(self.name,"的年龄是：",self.age)


obj = object()
print(dir(obj))
s2 = Person("花非人陌",18)
print(dir(s2))

运行结果

['__class__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', 
'__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', 
'__lt__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', 
'__sizeof__', '__str__', '__subclasshook__']

['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', 
'__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', 
'__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', 
'__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 
'age', 'name', 'say_age']

从上面可以发现这样几个特点

class Person:

    def __init__(self,name,age):
        self.name = name
        self.age = age

    def say_age(self):
        print(self.name,"的年龄是：",self.age)


s2 = Person("花非人陌",18)
print(type(s2.age))
print(type(s2.name))
print(type(s2.say_age))


'''
运行结果
<class 'int'>
<class 'str'>
<class 'method'>
'''

①. Person 对象增加了六个属性：

__dict__ __module__ __weakref__ age name say_age

②. object 的所有属性， Person 类作为 object 的子类，显然包含了所有的属性

③. 我们打印 age 、 name 、 say_age ，发现 say_age 虽然是方法，实际上也是属性。只不过，这个属性的类型是 method 而已。

3. 重写 str() 方法

①. object 有一个 __str__() 方法，用于返回一个对于“对象的描述”。内置函数 str(对象) , 调用的就是__str__()

②. __str__() 经常用于 print() 方法，帮助查看对象的信息。__str__() 可以重写

class Person:

    def __init__(self,name,age):
        self.name = name
        self.__age = age

    def __str__(self):
        '''将对象转化成一个字符串描述，一般用于print方法'''
        print("重写__str__方法")
        return "名字是：{0},年龄是{1}".format(self.name,self.__age)
p = Person("花非人陌",18)
print(p)
s = str(p)
print(s)

'''
重写__str__方法            #重写了对象
名字是：花非人陌,年龄是18  #打印了返回值
重写__str__方法            #重写了对象并将返回值给了s
名字是：花非人陌,年龄是18
'''

5、多重继承

Python支持多重继承，一个子类可以有多个“直接父类”。这样，就具备了“多个父类”的特点。但是由于，这样会被“类的整体层次”搞的异常复杂，尽量避免使用。

class A:
    def aa(self):
        print("aa")
class B:
    def bb(self):
        print("bb")
class C(B,A):
    def cc(self):
        print("cc")
c = C()
c.cc()
c.bb()
c.aa()
print(C.mro())

'''
输出结果：
cc
bb
aa
[<class '__main__.C'>, <class '__main__.B'>, <class '__main__.A'>, <class 'object'>]
'''

类结构为：

6、MRO方法解析顺序

Python支持多继承，如果父类中有相同名字的方法，在子类没有指定父类名时，解释器将“从左向右”按顺序搜索。
MRO（Method Resolution Order）：方法解析顺序。我们可以通过 mro() 方法获得“类的层次结构”，方法解析顺序也是按照这个“类的层次结构”寻找的。

class A:
    def aa(self):
        print("aa")
    def say(self):
        print("say AAA!")

class B:
    def bb(self):
        print("bb")
    def say(self):
        print("say BBB!")

class C(B,A):        #B和A代表先后顺序，B优先于A
    def cc(self):
        print("cc")

c = C()
print(C.mro())    #打印层次结构
c.say()           #解释器寻找的方法是从左到右

'''
执行结果：
[<class '__main__.C'>, <class '__main__.B'>, <class '__main__.A'>, <class 'object'>]
say BBB!
'''

7、super()获得父类定义

super() 是一个内置函数，用于获取当前类的父类（或超类）的定义。它可以用来调用父类的方法、属性或构造函数。

在子类中，如果想要获得父类的方法时，我们可以通过 super() 来做。super() 代表父类的定义，不是父类对象。

调用父类的构造方法： super(子类名称,self).__init__(参数列表)

例子：在构造函数和方法中使用 super() 函数来调用父类的方法或构造函数

class A:
    def __init__(self):
        print("A的构造方法")

    def say(self):
        print("A: ", self)
        print("say AAA")

class B(A):
    def __init__(self):
        #A.__init__(self) 调用父类的say方法
        super(B, self).__init__()  # 调用父类的构造方法
        print("B的构造方法")

    def say(self):
        # A.say(self) 调用父类的say方法
        super().say()  # 通过super()调用父类的方法
        print("say BBB")
b = B()
b.say()

'''
A的构造方法
B的构造方法
A:  <__main__.B object at 0x0000000001514748>
say AAA
say BBB
'''

三、多态

1、多态描述

多态（polymorphism）是指同一个方法调用由于对象不同可能会产生不同的行为。

2、多态注意事项

①. 多态是方法的多态，属性没有多态

②. 多态的存在有2个必要的条件：继承、方法重写

class Animal:
    def shout(self):
        print("动物发出的声音")

class Dog(Animal):
    def shout(self):
        print("小狗汪汪叫")

class Cat(Animal):
    def shout(self):
        print("小猫喵喵叫")

def animalShout(a):
    a.shout() #传入的对象不同，shout方法对应的实际行为也不同。

animalShout(Dog())
animalShout(Cat())

'''
执行结果：
小狗汪汪叫
小猫喵喵叫
'''