Python进阶————面向对象高级

于 2024-09-01 21:38:28 发布
阅读量662 收藏 5
点赞数 20
分类专栏： Python进阶知识 文章标签： python 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Lyg970112/article/details/141701143
版权

面向对象高级

前言

  • 接下来我们学习Python中的继承、封装、多态以及其他特性

一、继承

  • 面向对象中的继承： 指的是多个类之间的所属关系，即子类默认继承父类的属性和方法。

1.1. 单继承

语法

class 类名(父类名):
	代码
	...

一个摊煎饼的老师傅[master]，在煎饼果子界摸爬滚打多年，研发了一套精湛的摊煎饼技术， 师父要把这套技术传授给他的唯一的最得意的徒弟[apprentice]。[初始化、无参]

# 1.定义师傅类
class Master(object):
    # 1.1 属性
    def __init__(self):
        self.kofu = '[传统方法]'

    # 1.2 方法
    def make_cake(self):
        print(f'使用{self.kofu}摊煎饼')


# 2.定义徒弟类  继承自Master
class Tudi(Master):
    pass

# 3.实例化
xiaoming = Tudi()         
print(xiaoming.kofu)	  # [传统方法]
xiaoming.make_cake()	  # 使用[传统方法]摊煎饼

1.2. 多继承

  • 多继承就是：一个类同时继承了多个父类。

语法

class 类名(父类名1,父类名2,...):  # 多个父类
	代码
	...

小明是个爱学习的好孩子，想学习更多的摊煎饼果子技术，于是，在百度搜索到小吃学校[school]，学习摊煎饼果子技术。

# 1.定义师傅类
class Master(object):
    # 1.1 属性
    def __init__(self):
        self.kofu = '[传统方法]'

    # 1.2 方法
    def make_cake(self):
        print(f'使用{self.kofu}摊煎饼')


# 2.定义学校类
class School(object):
    # 1.1 属性
    def __init__(self):
        self.kofu = '[学院派方法煎饼]'

    # 1.2 方法
    def make_cake(self):
        print(f'使用{self.kofu}摊煎饼')


# 3.定义徒弟类
class Tudi(School, Master):
    pass


# 3.实例化
xiaoming = Tudi()
print(xiaoming.kofu)    # [学院派方法煎饼]
xiaoming.make_cake()    # 使用[学院派方法煎饼]摊煎饼

注意：当一个类有多个父类时，默认使用第一个父类的同名属性和方法。

1.3. 方法重写

  • 重写也叫作覆盖，就是当子类属性或方法与父类的属性或方法名字相同的时候，从父类继承下来的成员可以重新定义！

xiaoming 掌握了老师傅的技术后，自己潜心钻研出一套自己的独门配方的全新摊煎饼果子技术。

# 1.定义师傅类
class Master(object):
    # 1.1 属性
    def __init__(self):
        self.kofu = '[传统方法]'

    # 1.2 方法
    def make_cake(self):
        print(f'使用{self.kofu}摊煎饼')


# 2.定义学校类
class School(object):
    # 1.1 属性
    def __init__(self):
        self.kofu = '[学院派方法]'

    # 1.2 方法
    def make_cake(self):
        print(f'使用{self.kofu}摊煎饼')


# 3.定义徒弟类
class Tudi(School,Master):
    # 1.1 属性
    def __init__(self):
        self.kofu = '[xiaoming独创技术]'
    # 1.2 方法
    def make_cake(self):
        print(f'使用{self.kofu}摊煎饼')


# 3.实例化
xiaoming = Tudi()
print(xiaoming.kofu)   # [xiaoming独创技术]
xiaoming.make_cake()   # 使用[xiaoming独创技术]摊煎饼

当父类中跟子类中有同名方法的时候，子类可以重写父类方法，子类对象调用该方法的时候，优先使用自己的，用完再用父类的

1.4. 子类调用父类方法

  • 子类中仍想要保留父类的行为，则需要在子类中调用父类方法可以使用的以下两个方法：

1.4.1 父类名.父类方法名()

使用该方法的时候父类名.父类方法名(self) 括号中必须要有self

很多顾客都希望能吃到徒弟做出的有自己独立品牌的煎饼果子，也有学校配方技术的煎饼果子味道。

# 1.定义师傅类
class Master(object):
    # 1.1 属性
    def __init__(self):
        self.kofu = '[传统方法]'

    # 1.2 方法
    def make_cake(self):
        print(f'使用{self.kofu}摊煎饼')


# 2.定义学校类
class School(object):
    # 1.1 属性
    def __init__(self):
        self.kofu = '[学院派方法]'

    # 1.2 方法
    def make_cake(self):
        print(f'使用{self.kofu}摊煎饼')


# 3.定义徒弟类
class Tudi(School,Master):
    # 1.1 属性
    def __init__(self):
        self.kofu = '[独创技术]'
    # 1.2 方法
    def make_cake(self):
        print(f'使用{self.kofu}摊煎饼')

    # 1.3 使用老师傅的技术
    def master_make_cake(self):
        Master.__init__(self)
        Master.make_cake(self)

    # 1.4 使用学校技术
    def school_make_cake(self):
        School.__init__(self)
        School.make_cake(self)


# 3.实例化
xiaoming = Tudi()
print(xiaoming.kofu)         # [独创技术]
xiaoming.make_cake()	     # 使用[独创技术]摊煎饼
xiaoming.master_make_cake()  # 使用[传统方法]摊煎饼
xiaoming.school_make_cake()	 # 使用[学院派方法]摊煎饼

1.4.2 super().父类方法名()

使用该方法的时候，super后边必须加括号，且 父类方法名括号中啥也不能有

很多顾客都希望能吃到徒弟做出的有自己独立品牌的煎饼果子，也有学校配方技术的煎饼果子味道。

# 1.定义师傅类
class Master(object):
    # 1.1 属性
    def __init__(self):
        self.kofu = '[传统方法]'

    # 1.2 方法
    def make_cake(self):
        print(f'使用{self.kofu}摊煎饼')


# 2.定义学校类
class School(object):
    # 1.1 属性
    def __init__(self):
        self.kofu = '[学院派方法]'

    # 1.2 方法
    def make_cake(self):
        print(f'使用{self.kofu}摊煎饼')


# 3.定义徒弟类
class Tudi(School,Master):
    # 1.1 属性
    def __init__(self):
        self.kofu = '[独创技术]'
    # 1.2 方法
    def make_cake(self):
        print(f'使用{self.kofu}摊煎饼')

    # 1.3 使用老师傅的技术
    def master_make_cake(self):
    	# 必须重新初始化父类的属性
        Master.__init__(self)
        super().make_cake()

    # 1.4 使用学校技术
    def school_make_cake(self):
        # 必须重新初始化父类的属性
        School.__init__(self)
        super().make_cake()


# 3.实例化
xiaoming = Tudi()
print(xiaoming.kofu)         # [独创技术]
xiaoming.make_cake()	     # 使用[独创技术]摊煎饼
xiaoming.master_make_cake()  # 使用[传统方法]摊煎饼
xiaoming.school_make_cake()	 # 使用[学院派方法]摊煎饼

1.5. 多层继承

"""
多层继承介绍:
    概述:
        实际开发中, 类与类之间是可以多层继承的, 例如: 类A继承类B, 类B继承类C, 这就是: 多层继承.
    例如:
        A => 继承B => 继承C => 继承object
"""

N年后，小明老了，想要把“有自己的独立品牌，也有学院配方技术的煎饼果子味道”的所有技术传授给自己的徒弟。

# 1. 创建1个师傅类, 充当父类.
class Master(object):
    # 1.1 定义父类的 属性.
    def __init__(self):
        self.kongfu = '[古法煎饼果子配方]'

    # 1.2 定义父类的 行为, 表示: 摊煎饼.
    def make_cake(self):
        print(f'使用 {self.kongfu} 制作煎饼果子')

# 2. 创建1个师傅类, 充当父类.
class School(object):
    # 2.1 定义父类的 属性.
    def __init__(self):
        self.kongfu = '[学院派煎饼果子配方]'

    # 2.2 定义父类的 行为, 表示: 摊煎饼.
    def make_cake(self):
        print(f'使用 {self.kongfu} 制作煎饼果子')

# 3. 定义徒弟类, 继承自师傅类.
class Prentice(School, Master):
    # 3.1 定义本类(子类)的 属性.
    def __init__(self):
        self.kongfu = '[独创煎饼果子配方]'

    # 3.2 定义本类(子类)的 行为, 表示: 摊煎饼.
    def make_cake(self):        # 子类出现和父类重名且一模一样的函数, 称之为: 方法重写.
        print(f'使用 {self.kongfu} 制作煎饼果子')

    # 3.3 定义函数 make_master_cake(), 表示: 古法摊煎饼果子配方.
    def make_master_cake(self):
        # 前提(细节): 需要重新初始化一下父类的 属性.
        Master.__init__(self)
        # 调用Master#make_cake()
        Master.make_cake(self)

    # 3.4 定义函数 make_school_cake(), 表示: 黑马AI摊煎饼果子配方.
    def make_school_cake(self):
        # 前提(细节): 需要重新初始化一下父类的 属性.
        School.__init__(self)
        # 调用School#make_cake()
        School.make_cake(self)

# 4. 定义徒孙类, 继承: 徒弟类.
class TuSun(Prentice):      # 继承关系:  TuSun => Prentice => School, Master => object
    pass

# 在main函数中测试
if __name__ == '__main__':
    # 4. 创建 徒孙类 的对象
    ts = TuSun()

    # 5. 调用父类的成员.
    print(f'属性: {ts.kongfu}')  # 属性: [独创煎饼果子配方]
    ts.make_cake()               # 使用 [独创煎饼果子配方] 制作煎饼果子
    ts.make_master_cake()        # 使用 [古法煎饼果子配方] 制作煎饼果子
    ts.make_school_cake()        # 使用 [学院派煎饼果子配方] 制作煎饼果子

二、封装

  • 在软件编程中，将属性和方法书写到类的里面的操作即为封装，封装可以为属性和方法添加私有权限。

2.1. 私有属性

  • 在Python中，可以为属性设置私有权限，即设置某个属性不继承给子类。

  • 设置私有权限的方式：在属性名前面加上两个下划线 __，

格式

"""
self.__属性名

当设置了属性为私有属性后，那么我们只能在本类中通过self. 的方法来访问该属性

如果在类外想要访问私有属性的话，必须通过公共方法才行
"""

代码如下（示例）：

class Prentice(object):
    # 1.1 属性
    def __init__(self):
        self.kongfu = '[独创的煎饼果子配方]'
        # 私有的属性.
        self.__money = 500000         # 这个才是私有化的写法.

    # 1.2 对外提供公共的访问方式, 可以实现: 获取私有的变量, 以及给变量设置值.
    # 获取值.
    def get_money(self):
        return self.__money

    # 设置值
    def set_money(self, money):
        # 可以在这里对 money属性做判断, 但是没必要. 因为Python属于后端代码, 这里的钱肯定是前端传过来的, 而传过来的数据已经经过了前端的校验.
        # 换言之, 这里如果校验就属于 二次校验了.  实际开发中, 重要字段会做二次校验, 否者可以不做校验.
        # if money > 0:
        #     self.__money = money
        # else:
        #     self.__money = 0
        self.__money = money



# 2. 定义徒孙类, 继承自徒弟类.
class TuSun(Prentice):
    pass

# 在main函数中测试调用
if __name__ == '__main__':
    # 3. 创建徒孙类对象.
    ts = TuSun()
    # 4. 尝试访问父类的成员.
    # 父类的公共的 属性
    print(f'父类的属性: {ts.kongfu}') # 父类的属性: [独创的煎饼果子配方]

    print(f'父类的私有属性, 通过 公共的方式访问: {ts.get_money()}')  # 父类的私有属性, 通过 公共的方式访问: 500000
    
    # 通过父类的公共方式, 修改 父类的私有属性.
    ts.set_money(10)
    print(f'父类的私有属性, 通过 公共的方式访问: {ts.get_money()}')  # 父类的私有属性, 通过 公共的方式访问: 10

2.2. 私有方法

  • 在Python中，可以为方法设置私有权限，即设置某个方法不继承给子类。
  • 设置私有权限的方式：在方法名前面加上两个下划线 __

格式

"""
def __方法名(self):
     ...

当设置了属性为私有属性后，那么我们只能在本类中通过self. 的方法来访问该属性

如果在类外想要访问私有属性的话，必须通过公共方法才行
"""

小明把煎饼果子技术传承给徒弟的同时，不想把自己的独创配方制作过程继承给徒弟，这时就要为制作独创配方这个方法设置私有权限。

# 1. 定义徒弟类, 有自己的属性 和 行为.
class Prentice(object):
    # 1.1 属性
    def __init__(self):
        self.kongfu = '[独创的煎饼果子配方]'
        # 私有的属性.
        # self.__money__ = 500000     # 这个不是私有, 就是变量名叫: __money__
        self.__money = 500000         # 这个才是私有化的写法.

    # 1.2 对外提供公共的访问方式, 可以实现: 获取私有的变量, 以及给变量设置值.
    # 获取值.
    def get_money(self):
        return self.__money

    # 设置值
    def set_money(self, money):
        self.__money = money

    # 1.3 行为
    def __make_cake(self):
        print(f'采用 {self.kongfu} 制作煎饼果子!')
        # 验证: 私有成员, 在本类中是可以直接访问的.
        print(f'私房钱为: {self.__money}')

    # 针对于父类的私有方法, 提供公共的访问方式(在其内部调用 私有化的方法即可)
    def my_make(self):
        # 调用私有化方法 __make_cake()
        self.__make_cake()

# 2. 定义徒孙类, 继承自徒弟类.
class TuSun(Prentice):

    pass

# 在main函数中测试调用
if __name__ == '__main__':
    # 3. 创建徒孙类对象.
    ts = TuSun()

    # 4. 尝试访问父类的成员.
    # 4.1 父类的 私有的 属性.
    print(f'父类的私有属性, 通过 公共的方式访问: {ts.get_money()}')
    # 通过父类的公共方式, 修改 父类的私有属性.
    ts.set_money(10)
    print(f'父类的私有属性, 通过 公共的方式访问: {ts.get_money()}')
    print('-' * 21)

    # 4.2 父类的 私有的 方法(行为).
    # ts.__make_cake()        # AttributeError, 父类私有成员(方法), 子类无法直接访问.
    # ts.make_cake()
    ts.my_make()

三、多态

3.1. 多态的条件

"""
1、有继承 （定义父类、定义子类，子类继承父类)
2、函数重写 （子类重写父类的函数）
3、父类引用指向子类对象 （子类对象传给父类对象调用者）
"""

3.2. 多态的定义

  • 多态，指的是：多种状态。比如：同样一个函数在不同的场景下有不同的状态。

代码演示如下

class Animal(object):
    def speak(self):
        print("animal 嗯嗯 ")
        pass


class Dog(Animal):
    def speak(self):
        print('汪汪汪')


class Cat(Animal):
    def speak(self):
        print('喵喵喵')


# def make_noise(animal):
def make_noise(animal:Animal):
    animal.speak()

if __name__ == '__main__':
    mydog = Dog()
    mycat = Cat()
    animal =  Animal()

    make_noise(mydog)     # 汪汪汪
    # make_noise(mycat)   # 喵喵喵
    # make_noise(animal)   # animal 嗯嗯
    pass

四、面向对象的其他特性

4.1. 对象属性

"""
对于属性，调用时有两种方式，如下：
	1、 self.对象属性名  # 类内部
	
	2、 对象名.对象属性名   # 类外部
"""

4.2. 类属性

"""
所谓类属性，指的就是类所拥有的属性，它被共享于整个类中(即都可以直接调用)，格式如下：
		1、 类名.类属性名    # 推荐使用

		2、 对象名.类属性名

"""

4.3. 类方法

  • 类方法，指的是类所拥有的方法，并需要使用[装饰器]@classmethod来标识其为类方法

同时一定要注意的是对于类方法的第一个参数必须是类对象，通常以cls作为第一个参数名，格式如下：

@classmethod
def 类方法名(cls):
    ...


# 调用时，格式如下：

	1、 类名.类方法名()    # 推荐使用

	2、 对象名.类方法名()

类方法一般和类属性配合使用，尤其是使用私有类属性时。

4.4. 静态方法

静态方法需要通过装饰器@staticmethod来来标识其为静态方法，且静态方法不需要多定义参数，格式如下：

@staticmethod
def 静态方法名():
    ...

# 调用时，格式如下：
	1、 类名.静态方法名    # 推荐使用

	2、 对象名.静态方法名

功能不变的时候使用静态方法

总结

  • 以上就是面向对象的封装、继承、多态的定义与代码演示。
记得多吃点
关注
  • 20
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Python3入门与进阶——““面向对象，”闭包”。（也没有很难）
01-20
Python一切都是“对象”，包括“函数”。在很多其它语言中，函数只是一段可执行代码，但Python的“函数”是可以实例化的。 因此可以做到： a=def 也可以：把函数作为对象传递到另一个函数里作为参数，也可以把一个...
Python从基础到进阶——模块&面向对象编程」（2）面向对象编程
01-06
面向对象的设计思想是抽象出 Class，根据Class 创建 Instance。（类是抽象的模板，而实例是根据类创建出来的一个个具体的“对象”） 面向对象的抽象程度又比函数要高，因为一个Class 既包含数据，又包含操作数据的...
Python入门——类，面向对象的编程
12-21
【Python入门——类，面向对象的编程】 面向对象编程（Object-Oriented Programming，OOP）是一种编程范式，它将程序设计中的实体抽象为对象，通过对象来封装数据和行为，实现代码的复用和模块化。在Python中，类是...
Python从基础到进阶——「模块&面向对象编程」（1）模块和类
01-20
Python编程语言中，模块（Module）和面向对象编程（Object-Oriented Programming, OOP）是两个核心概念，尤其对于大型项目来说，它们是代码组织和重用的关键。本篇文章将深入探讨这两个主题。 首先，模块是Python...
Python进阶必备——HiKari为了拿捏Python整理的技术笔记
10-05
理解这一机制有助于设计良好的面向对象程序，控制属性的可见性和继承行为。 第二章“并发机制”深入探讨了Python在多线程、多进程以及异步I/O方面的处理： 1. **多线程与GIL（全局解释器锁）**：Python的多线程在...
python12 中，No module named‘distutils‘错误
热门推荐
qq_43557600的博客
08-27 1万+
python12 “ No module named'distutils' ”,​ 安装 pip install setuptools ，解决 ​
centos7 安装 superset4.0.2 教程
m0_37759590的博客
08-27 1万+
centos7 安装 superset4.0.2 教程
python从入门到精通：数据可视化-图形开发
2401_83283514的博客
08-29 1064
• Json是一种轻量级的数据交互格式，可以按照Json指定的格式去组织和封装数据• Json本质上是一种带有特殊格式的字符串主要功能：json就是一种在各个编程语言中流通的数据格式，负责不同编程语言中的数据传递和交互，类似于：• 国际通用语言-英语• 中国不同名族的通用语言-中文（普通话）• 各种编程语言存储数据的容器不尽相同，在python中有字典dict这样的数据类型，而其它语言可能没有对应的字典。为了让不同的语言都能够相互通用的互相传递数据，Json就是一种非常良好的数据中转格式。
CSS解析:定位和层叠上下文
最新发布
晓风残月淡的博客
08-31 1137
许多开发人员对定位的理解很粗略，如果不完全了解定位，就很容易给自己挖坑。有时候可能会把错误的元素放在其他元素前面，要解决这个问题却没有那么简单。一般的布局方法是用各种操作来控制文档流的行为。定位则不同：它将元素彻底从文档流中移走。它允许你将元素放在屏幕的任意位置。还可以将一个元素放在另一个元素的前面或后面，彼此重叠。
【python】关于判断空值None、判断len()=0，和 if not 的区别
Meggie35的博客
08-28 5841
python的“空”与“无”之辩，关于None，和空数值。在程序中，判断里面没有值和判断东西是不是为空，也是不一样的东西，我们可以往下看看具体的区别。
使用 DrissionPage 和 2Captcha 处理 Turnstile 验证并获取 Faucet 签名
qq_41631913的博客
08-30 496
本教程介绍了两种获取 Cloudflare Turnstile 验证值并使用 faucet 签名 API 的方法。第一种方法通过 DrissionPage 模拟浏览器操作，手动获取验证码值。第二种方法则通过 2Captcha 服务，自动化解决验证码问题。
yolo7 自定义数据训练
hzh839900的专栏
08-27 631
数据定义文件train.txt val.txt。预定义标签 格式name label。数据集定义文件errimg.yaml。图片文件和标签文件放在一起。数据打标labelimg。
无法验证 Anaconda 仓库证书
qq_38332453的博客
08-28 174
无法验证 Anaconda 仓库的证书
【Python-办公自动化】批量修改EXCEL指定内容
2202_76035290的博客
08-29 2821
欢迎来到"花花 Show Python"，一名热爱编程和分享知识的技术博主。在这里，我将与您一同探索Python的奥秘，分享编程技巧、项目实践和学习心得。无论您是编程新手还是资深开发者，都能在这里找到有价值的信息和灵感。我热衷于将复杂的技术概念以简单易懂的方式呈现给大家，让每个人都能享受到编程的乐趣。我相信，通过不断的学习和实践，我们都能够成为更好的开发者。如果您喜欢我的内容，别忘了点击关注哦！这样您就可以第一时间获取我的更新和分享。您的支持是我不断前进的动力。
人工智能开发实战机器学习算法解析
sinat_30844883的博客
08-29 3270
机器学习算法是人工智能领域的重要组成部分，它们通过从数据中学习并自动改进，而无需进行显式的编程。机器学习算法可以分为多种类型，包括监督学习、无监督学习、半监督学习、迁移学习和强化学习。每种类型都有其特定的应用场景和优势。
Python 高级特效 - 生成器 ( Generator)
weixin_48591974的博客
08-31 385
生成器是一种一边循环一边计算的机制,通过列表生成式，可以直接创建一个列表，但是受到内存的限制，列表容量是有限的，当列表元素很 大的时候，会很浪费内存空间。所以可以通过生成器 Generator 生成，它的作用相比列表，内存占用少，节约资源
【2024】Datawhale AI夏令营-从零上手Mobile Agent-Task1笔记
Mocode的博客
08-28 860
Task1主要任务是跑通Mobile-Agent Demo。
Python | Leetcode Python题解之第384题打乱数组
Mopes__的博客
08-30 311
Python | Leetcode Python题解之第384题打乱数组
宝塔面板网站SSL证书到期如何手动和自动续签Let’s Encrypt
weixin_45734165的博客
08-27 1322
宝塔面板提供2种免费的SSL证书：宝塔SSL，Let’s Encrypt。前面第1，2步骤主要是手动续签，比较稳定可靠，唯一的缺点是需要进入后台进行操作，并且有时候可能忘记续签。实际上宝塔面板还提供了很多计划任务的脚本，可以自动续签Let’s Encrypt证书。不管是给网站部署SSL还是给网站SSL续签，利用宝塔后台来进行网站SSL证书的管理还是比较方便高效的。2.手动续签：网站设置后台点击【SSL】》【Let’s Encrypt】》【续签】1.手动续签：登录宝塔面板后台，点击【网站】》【设置】
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值