python基础13----面向对象02

最新推荐文章于 2023-05-29 20:32:57 发布

†徐先森®

最新推荐文章于 2023-05-29 20:32:57 发布

阅读量191

点赞数

分类专栏： python基础

本文链接：https://blog.csdn.net/qq_36622490/article/details/87707430

版权

python基础专栏收录该内容

17 篇文章 1 订阅

订阅专栏

【本章节涵盖重点内容：一个类里怎么访问另一个类的属性，继承的作用和语法，多继承时父类有同名方法的处理方案，重写的作用和语法，重写后调用父类方法的三种方案，私有属性和私有方法的定义方式和用途，子类能否使用父类的私有属性，多态的好处和实现方式】

一，继承介绍以及单继承

1. 现实中的继承

在现实生活中，继承一般指的是子女继承父辈的财产

2. 程序中的继承

在程序中，继承描述的是多个类之间的所属关系。
如果一个类A里面的属性和方法可以复用，则可以通过继承的方式，传递到类B里。
那么类A就是基类，也叫做父类；类B就是派生类，也叫做子类。

# 父类
class A(object):
    def __init__(self):
        self.num = 10

    def print_num(self):
        print(self.num + 10)
# 子类
class B(A):
    pass


b = B()
print(b.num) 
b.print_num()

二，单继承：子类只继承一个父类

故事情节：煎饼果子老师傅在煎饼果子界摸爬滚打几十年，拥有一身精湛的煎饼果子技术，并总结了一套"古法煎饼果子配方"。

可是老师傅年迈已久，在嗝屁之前希望把自己的配方传承下去，于是老师傅把配方传给他的徒弟大猫...

# 定义一个Master类
class Master(object):
    def __init__(self):
        # 属性
        self.kongfu = "古法煎饼果子配方" 

    # 实例方法
    def make_cake(self):
        print("按照 <%s> 制作了一份煎饼果子..." % self.kongfu)


# 定义Prentice类，继承了 Master，则Prentice是子类，Master是父类。
class Prentice(Master): 
    # 子类可以继承父类所有的属性和方法，哪怕子类没有自己的属性和方法，也可以使用父类的属性和方法。
    pass                


damao = Prentice()  # 创建子类实例对象
print(damao.kongfu) # 子类对象可以直接使用父类的属性
damao.make_cake()   # 子类对象可以直接使用父类的方法

说明：

虽然子类没有定义__init__方法初始化属性，也没有定义实例方法，但是父类有。所以只要创建子类的对象，就默认执行了那个继承过来的__init__方法

总结：

子类在继承的时候，在定义类时，小括号()中为父类的名字
父类的属性、方法，会被继承给子类

剧情发展：

大猫掌握了师傅的配方，可以制作古法煎饼果子。但是大猫是个爱学习的好孩子，他希望学到更多的煎饼果子的做法，于是通过百度搜索，找到了一家煎饼果子培训学校。（多继承）

三，多层继承

class Master(object):
    def __init__(self):
        self.kongfu = "古法煎饼果子配方"  

    def make_cake(self):
        print("[古法] 按照 <%s> 制作了一份煎饼果子..." % self.kongfu)


class Prentice(Master):
    def __init__(self):
        self.kongfu = "猫氏煎饼果子配方"
        self.money = 10000  # 亿美金

    def make_cake(self):
        self.__init__() # 执行本类的__init__方法，做属性初始化 self.kongfu = "猫氏...."
        print("[猫氏] 按照 <%s> 制作了一份煎饼果子..." % self.kongfu)


    # 调用父类方法格式：父类类名.父类方法(self)
    def make_old_cake(self):
        Master.__init__(self) # 调用了父类Master的__init__方法 self.kongfu = "古法...."
        Master.make_cake(self) # 调用了父类Master的实例方法


class PrenticePrentice(Prentice): # 多层继承
    pass


pp = PrenticePrentice()
pp.make_cake() # 调用父类的实例方法
pp.make_old_cake()

print(pp.money)

剧情发展：

大猫觉得配方传承下去没问题，但是钱是辛辛苦苦挣得血汗钱，不想传给徒弟。（私有权限）

四，多继承：子类继承多个父类

class Master(object):
    def __init__(self):
        self.kongfu = "古法煎饼果子配方"  # 实例变量，属性

    def make_cake(self):                    # 实例方法，方法
        print("[古法] 按照 <%s> 制作了一份煎饼果子..." % self.kongfu)

    def dayandai(self):
        print("师傅的大烟袋..")

class School(object):
    def __init__(self):
        self.kongfu = "现代煎饼果子配方"

    def make_cake(self):
        print("[现代] 按照 <%s> 制作了一份煎饼果子..." % self.kongfu)

    def xiaoyandai(self):
        print("学校的小烟袋..")


# class Prentice(School, Master):  # 多继承，继承了多个父类（School在前）
#     pass


class Prentice(Master, School):  # 多继承，继承了多个父类（Master在前）
    pass

damao = Prentice()
print(damao.kongfu) # 执行Master的属性
damao.make_cake() # 执行Master的实例方法

# 子类的魔法属性__mro__决定了属性和方法的查找顺序
print(Prentice.__mro__)

damao.dayandai() # 不重名不受影响
damao.xiaoyandai()

School.make_cake(damao)  # 重名，可以强制指定执行某一个父类的方法。需要我们自己为 self 传值。

说明：

多继承可以继承多个父类，也继承了所有父类的属性和方法
注意：如果多个父类中有同名的属性和方法，则默认使用第一个父类的属性和方法（根据类的魔法属性__mro__的顺序来查找）
多个父类中，不重名的属性和方法，不会有任何影响。

剧情发展：

大猫掌握了师傅的配方和学校的配方，通过研究，大猫在两个配方的基础上，创建了一种全新的煎饼果子配方，称之为 "猫氏煎饼果子配方"。（子类重写父类同名属性和方法）

五，私有权限

私有权限：在属性名和方法名前面加上两个下划线 __

类的私有属性和私有方法，都不能在类之外访问，但是可以在本类内部访问；

类的私有属性和私有方法，都不会被子类继承，子类也无法访问；
私有属性和私有方法往往用来处理类的内部事情，不能在类外部访问，起到安全作用。

class Prentice(object):
    def __init__(self):
        self.kongfu = "猫氏煎饼果子配方"
        # 私有属性，可以在类内部通过self调用，但不能通过对象访问
        self.__money = 10000  

    # 私有方法，可以在类内部通过self调用，但不能通过对象访问
    def __print_info(self):
        print(self.kongfu)
        print(self.__money)

    def make_cake(self):
        self.__init__()
        print("[猫氏] 按照 <%s> 制作了一份煎饼果子..." % self.kongfu)

class PrenticePrentice(Prentice):
    pass


damao = Prentice()
# 类的外面不能访问私有权限的属性和方法
# print(damao.__money)
# damao.__print_info()


pp = PrenticePrentice()
# 子类可以直接使用父类的公有属性和方法
pp.make_cake()
# 子类不能继承父类私有权限的属性和方法
print(pp.__money) 
pp.__print_info()

总结

Python如果在属性和方法名前面加了2个下划线'__'，则表明该属性和方法是私有权限，否则为公有权限。
私有属性、方法只能在定义的类内部使用。

六，修改私有属性的值

如果需要修改一个对象的属性值，通常有2种方法
1. 对象名.属性名 = 数据 ----> 直接修改
2. 对象名.方法名() ----> 间接修改
私有属性不能直接访问，所以无法通过第一种方式修改，一般的通过第二种方式修改私有属性的值：定义一个可以调用的公有方法，在这个公有方法内访问修改。

class Prentice(object):
    def __init__(self):
        self.kongfu = "猫氏煎饼果子配方"
        # 私有属性，可以在类内部通过self调用，但不能通过对象访问
        self.__money = 10000  

    # 现代软件开发中，通常会定义get_xxx()方法和set_xxx()方法来获取和修改私有属性值。

    # 返回私有属性的值
    def get_money(self):
        return self.__money

    # 接收参数，修改私有属性的值
    def set_money(self, num):
        self.__money = num


damao = Prentice()
# 对象不能访问私有权限的属性和方法
# print(damao.__money)
# damao.__print_info()

# 可以通过访问公有方法set_money()来修改私有属性的值
damao.set_money(100)

# 可以通过访问公有方法get_money()来获取私有属性的值
print(damao.get_money())

七，子类重写父类的同名属性和方法

class Master(object):
    def __init__(self):
        self.kongfu = "古法煎饼果子配方" 

    def make_cake(self): 
        print("[古法] 按照 <%s> 制作了一份煎饼果子..." % self.kongfu)


class Prentice(Master):
    def __init__(self):
        self.kongfu = "猫氏煎饼果子配方"

    def make_cake(self):
        print("[猫氏] 按照 <%s> 制作了一份煎饼果子..." % self.kongfu)


# 如果子类和父类的方法名和属性名相同，则默认使用子类的
# 叫 子类重写父类的同名方法和属性
damao = Prentice()
print(damao.kongfu) # 子类和父类有同名属性，则默认使用子类的
damao.make_cake() # 子类和父类有同名方法，则默认使用子类的

# 子类的魔法属性__mro__决定了属性和方法的查找顺序
print(Prentice.__mro__)

剧情发展：

大猫的新配方大受欢迎，但是有些顾客希望也能吃到古法配方的煎饼果子...（子类调用父类的同名属性和方法）

八，子类调用父类同名属性和方法

class Master(object):
    def __init__(self):
        self.kongfu = "古法煎饼果子配方"  # 实例变量，属性

    def make_cake(self):  # 实例方法，方法
        print("[古法] 按照 <%s> 制作了一份煎饼果子..." % self.kongfu)


class Prentice(Master):  # 多继承，继承了多个父类
    def __init__(self):
        self.kongfu = "猫氏煎饼果子配方"

    def make_cake(self):
        self.__init__() # 执行本类的__init__方法，做属性初始化 self.kongfu = "猫氏...."
        print("[猫氏] 按照 <%s> 制作了一份煎饼果子..." % self.kongfu)


    # 调用父类方法格式：父类类名.父类方法(self)
    def make_old_cake(self):
        # 可以通过执行Master类的__init__方法，来修改self的属性值
        Master.__init__(self) # 调用了父类Master的__init__方法 self.kongfu = "古法...."
        Master.make_cake(self) # 调用父类Master的实例方法


# 实例化对象，自动执行子类的__init__方法
damao = Prentice()

damao.make_cake() # 调用子类的方法（默认重写了父类的同名方法）

print("--" * 10)
damao.make_old_cake() # 进入实例方法去调用父类Master的方法

执行结果：

[猫氏] 按照 <猫氏煎饼果子配方> 制作了一份煎饼果子...
--------------------
[古法] 按照 <古法煎饼果子配方> 制作了一份煎饼果子...

核心点：

无论何时何地，self都表示是子类的对象。在调用父类方法时，通过传递self参数，来控制方法和属性的访问修改。

剧情发展：

大猫的煎饼果子店非常红火，终于有一天，他成了世界首富！！

但是他也老了，所以他希望把师傅的配方以及自己的配方继续传承下去...（多层继承）

九，super()的使用

问题：

class Master(object):
    def __init__(self):
        self.kongfu = "古法煎饼果子配方"  # 实例变量，属性

    def make_cake(self):  # 实例方法，方法
        print("[古法] 按照 <%s> 制作了一份煎饼果子..." % self.kongfu)


class Prentice(Master):
    def __init__(self):
        self.kongfu = "猫氏煎饼果子配方"

    def make_cake(self):
        self.__init__()  # 执行本类的__init__方法，做属性初始化 self.kongfu = "猫氏...."
        print("[猫氏] 按照 <%s> 制作了一份煎饼果子..." % self.kongfu)

    def make_old_cake(self):
        # 方式1. 指定执行父类的方法
        # Master.__init__(self)
        # Master.make_cake(self)

        # 方法2. super() 带参数版本
        # super(Prentice, self).__init__() # 执行父类的 __init__方法 
        # super(Prentice, self).make_cake()

        # 方法3. super()的简化版，只支持新式类
        super().__init__()  # 执行父类的 __init__方法 
        super().make_cake()  # 执行父类的 实例方法


damao = Prentice()
damao.make_cake()
damao.make_old_cake()

知识点：

强制使用父类名调用方法，如果父类类名修改了，那么子类也要涉及多次修改。但是比较适合多继承使用。
使用super() 可以自动查找父类。调用顺序遵循 __mro__ 类属性的顺序。比较适合单继承使用。

†徐先森®

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
python基础13----面向对象02

【本章节涵盖重点内容：一个类里怎么访问另一个类的属性，继承的作用和语法，多继承时父类有同名方法的处理方案，重写的作用和语法，重写后调用父类方法的三种方案，私有属性和私有方法的定义方式和用途，子类能否使用父类的私有属性，多态的好处和实现方式】一，继承介绍以及单继承1. 现实中的继承在现实生活中，继承一般指的是子女继承父辈的财产2. 程序中的继承在程序中，继承描述的是多个类之间...
复制链接

扫一扫