【Python篇】Python 类和对象:详细讲解(下篇)

简介: 【Python篇】Python 类和对象:详细讲解(下篇)

Python 类和对象:详细讲解(下篇)

15. 接口和协议(Interfaces and Protocols)

15.1 什么是接口?

接口是一个类必须遵循的规则或约定,它定义了类应该具备哪些方法,但不提供具体的实现。在 Python 中,接口常用在规定某些类必须实现特定的方法。通过接口,不同的类可以被相同的代码调用,只要它们实现了接口的要求。

15.2 协议的基本概念

协议是 Python 中的一种接口定义方式,常用于规定一个类应该具备哪些方法。协议是“非正式”的接口,它不要求显式地继承任何东西,只需要类实现了协议中的方法。

例子:定义飞行协议
from typing import Protocol

# 定义一个飞行协议,规定类必须有 fly 方法
class Flyer(Protocol):
    def fly(self) -> None:
        pass

# 定义一个 Bird 类,它实现了 fly 方法
class Bird:
    def fly(self) -> None:  # 注意 -> None 表示这个方法不返回任何值
        print("Bird is flying")

# 定义一个 Airplane 类,它也实现了 fly 方法
class Airplane:
    def fly(self) -> None:
        print("Airplane is flying")

# 定义一个函数,这个函数接受任何有 fly 方法的对象
def make_fly(flyer: Flyer):
    flyer.fly()

# 创建 Bird 和 Airplane 的实例,并传递给 make_fly 函数
bird = Bird()
plane = Airplane()

make_fly(bird)    # 输出: Bird is flying
make_fly(plane)   # 输出: Airplane is flying
详细解释
  1. Flyer(Protocol): Flyer 是一个协议类,它定义了所有实现此协议的类必须具备的 fly 方法。
  2. fly(self) -> None: -> None 的意思是这个方法不返回任何值。None 是 Python 的一种特殊类型,表示什么都没有。
  3. make_fly(flyer: Flyer): 这个函数接受任何实现 Flyer 协议的对象作为参数。无论是 Bird 还是 Airplane,只要它们实现了 fly 方法,就可以传给这个函数。
输出示例
Bird is flying
Airplane is flying

这个示例展示了 BirdAirplane 类如何实现同样的 fly 方法,使得它们都可以被 make_fly 函数调用


16. 装饰器模式(Decorator Pattern)

16.1 什么是装饰器?

装饰器是 Python 中的一个强大特性,允许你在不修改原始函数的情况下,为函数添加额外的功能。装饰器本质上是一个函数,它接收另一个函数作为参数,并返回一个新的函数。

例子:简单的函数装饰器
# 定义一个简单的装饰器函数
def simple_decorator(func):
    def wrapper():
        print("Something is happening before the function is called.")
        func()  # 调用原始函数
        print("Something is happening after the function is called.")
    return wrapper

# 使用装饰器
@simple_decorator  # @符号表示我们使用simple_decorator来装饰say_hello函数
def say_hello():
    print("Hello!")

# 调用被装饰的函数
say_hello()
详细解释
  1. @simple_decorator: 这个语法糖(简便写法)表示将 say_hello 函数传递给 simple_decorator 装饰器,相当于 say_hello = simple_decorator(say_hello)
  2. wrapper(): 装饰器内部定义的 wrapper 函数包裹了原始的 say_hello 函数,在调用 say_hello 时,会先执行 wrapper 内的代码。
  3. func(): func 是原始的 say_hello 函数,通过调用它,我们在 wrapper 中执行了原始函数的功能。
输出示例
Something is happening before the function is called.
Hello!
Something is happening after the function is called.

16.2 为什么 @ 符号放在函数定义上面?

  • @符号的作用: 它是用来简化装饰器应用的。如果没有 @ 符号,你需要手动将函数传给装饰器。使用 @ 符号时,装饰器会在函数定义之后立即应用,不需要手动传递。
代码对比
# 使用 @ 语法糖
@simple_decorator
def say_hello():
    print("Hello!")

# 不使用 @ 语法糖,等同于上面的代码
def say_hello():
    print("Hello!")
say_hello = simple_decorator(say_hello)

17. 上下文管理器(Context Managers)

17.1 什么是上下文管理器?

上下文管理器用于在一段代码运行前后自动管理资源,比如文件、网络连接等。上下文管理器确保资源在使用后被正确释放,避免资源泄漏问题。

示例:使用上下文管理器管理文件
# 使用上下文管理器打开文件
with open('example.txt', 'w') as file:
    file.write('Hello, World!')

# 这个文件会在 with 语句块结束时自动关闭

17.2 自定义上下文管理器

你可以通过定义 __enter____exit__ 方法来自定义上下文管理器。这两个方法分别在上下文管理器的进入和退出时执行。

示例:自定义上下文管理器
class MyContextManager:
    def __enter__(self):
        print("Entering the context")
        return self
    
    def __exit__(self, exc_type, exc_val, exc_tb):
        print("Exiting the context")
        if exc_type:
            print(f"Exception type: {exc_type}")
            print(f"Exception value: {exc_val}")
            print(f"Traceback: {exc_tb}")
        return True  # 处理异常后,继续执行

# 使用自定义上下文管理器
with MyContextManager():
    print("Inside the context")
    raise ValueError("Oops!")  # 故意引发一个异常


详细解释
  1. enter: 当你进入 with 语句时,__enter__ 方法会被自动调用。你可以在这里做一些初始化操作。
  2. exit: 当 with 语句结束时,__exit__ 方法会被调用。这个方法接受三个参数:exc_type(异常类型)、exc_val(异常值)、exc_tb(异常的追踪信息)。这些参数用于处理在 with 语句块内发生的任何异常。
  3. return True: 如果 __exit__ 返回 True,异常将被抑制,不会向外抛出。如果返回 False 或者不返回,异常将会被继续抛出。
输出示例
Entering the context
Inside the context
Exiting the context
Exception type: <class 'ValueError'>
Exception value: Oops!
Traceback: <traceback object at 0x...>


18. 元类(Metaclasses)

18.1 什么是元类?

元类是用来创建类的“类”。普通类是用来创建对象的,而元类是用来创建类的。元类通常用于自动修改类的定义或行为。

示例:简单的元类
class MyMeta(type):
    def __new__(cls, name, bases, dct):
        print(f"Creating class {name}")
        return super().__new__(cls, name, bases, dct)

class MyClass(metaclass=MyMeta):
    pass

# 创建 MyClass 的实例
obj = MyClass()
详细解释
  1. type: type 是 Python 内置的元类,用于创建所有的类。MyMeta 继承自 type,我们通过 __new__ 方法来控制类的创建。
  2. new(cls, name, bases, dct): __new__ 是一个特殊的方法,它在 __init__ 之前被调用,用于创建类。cls 是元类本身,name 是类的名称,bases 是类的基类(父类),dct 是类的属性和方法的字典。
  1. metaclass=MyMeta: 当你定义 MyClass 时,Python 会使用 MyMeta 元类来创建 MyClass 类。
输出示例
Creating class MyClass

当你定义 MyClass 时,会输出 Creating class MyClass,表示元类 MyMeta 正在创建 MyClass


19. 面向对象设计原则(SOLID Principles)

19.1 SOLID 原则简介

SOLID 是面向对象设计的五大原则,用来编写可维护、可扩展的代码。我们一条一条来看。

19.1.1 单一职责原则(SRP)

单一职责原则(Single Responsibility Principle)要求一个类应该只负责一件事。这样可以让类更简单、更易维护。

示例:单一职责原则
class ReportGenerator:
    def generate(self):
        print("Generating report")

class ReportSaver:
    def save(self):
        print("Saving report")
  • ReportGenerator 负责生成报告。
  • ReportSaver 负责保存报告。每个类都有明确的职责,不会混在一起。
19.1.2 开放/封闭原则(OCP)

开放/封闭原则(Open/Closed Principle)要求软件实体(类、模块、函数等)应该对扩展开放,对修改封闭。

示例:开放/封闭原则
class Shape:
    def area(self):
        pass

class Circle(Shape):
    def __init__(self, radius):
        self.radius = radius

    def area(self):
        return 3.14 * (self.radius ** 2)

class Rectangle(Shape):
    def __init__(self, length, width):
        self.length = length
        self.width = width

    def area(self):
        return self.length * self.width


  • 通过继承 Shape 类,我们可以创建新的形状类,而不需要修改现有代码。
19.1.3 里氏替换原则(LSP)

里氏替换原则(Liskov Substitution Principle)要求子类对象必须能够替换基类对象,而不会影响程序的正确性。

示例:里氏替换原则
class Bird:
    def fly(self):
        print("Bird is flying")

class Penguin(Bird):
    def fly(self):
        raise NotImplementedError("Penguins cannot fly")

# 这种设计违反了里氏替换原则,因为企鹅不能飞,但它继承了能飞的鸟类
  • Penguin 不能替代 Bird,因为企鹅不会飞,这违反了里氏替换原则。
19.1.4 接口隔离原则(ISP)

接口隔离原则(Interface Segregation Principle)要求类不应该被强迫实现它不需要的接口或方法。

示例:接口隔离原则
class Workable:
    def work(self):
        pass

class Eatable:
    def eat(self):
        pass

class Worker(Workable, Eatable):
    def work(self):
        print("Working")

    def eat(self):
        print("Eating")

class Robot(Workable):
    def work(self):
        print("Working")

# Robot 只实现了它需要的接口,而不是所有接口


  • Robot 只实现了 Workable 接口,而不需要实现 Eatable 接口。
19.1.5 依赖倒置原则(DIP)

依赖倒置原则(Dependency Inversion Principle)要求高层模块不应该依赖于低层模块,而应该依赖于抽象(接口)。

示例:依赖倒置原则
class Keyboard:
    def type(self):
        return "Typing"

class Monitor:
    def display(self):
        return "Displaying"

class Computer:
    def __init__(self, keyboard: Keyboard, monitor: Monitor):
        self.keyboard = keyboard
        self.monitor = monitor

    def operate(self):
        print(self.keyboard.type())
        print(self.monitor.display())
  • Computer 依赖于 KeyboardMonitor 抽象,而不是它们的具体实现,这使得更换这些组件变得容易。

以上就是关于【Python篇】Python 类和对象:详细讲解(下篇)的内容啦,各位大佬有什么问题欢迎在评论区指正,您的支持是我创作的最大动力!❤️

目录
相关文章
|
9天前
|
安全 大数据 程序员
Python operator模块的methodcaller:一行代码搞定对象方法调用的黑科技
`operator.methodcaller`是Python中处理对象方法调用的高效工具,替代冗长Lambda,提升代码可读性与性能。适用于数据过滤、排序、转换等场景,支持参数传递与链式调用,是函数式编程的隐藏利器。
47 4
|
1月前
|
安全 JavaScript Java
Python中None与NoneType的真相:从单例对象到类型系统的深度解析
本文通过10个真实场景,深入解析Python中表示“空值”的None与NoneType。从单例模式、函数返回值,到类型注解、性能优化,全面揭示None在语言设计与实际编程中的核心作用,帮助开发者正确高效地处理“无值”状态,写出更健壮、清晰的Python代码。
163 3
|
1月前
|
Python
解决Python中AttributeError:'image'对象缺少属性'read_file'的问题策略。
通过上述策略综合考虑,您将能够定位问题并确定如何解决它。记住,Python社区很庞大,也很乐于帮助解决问题,因此不要害怕在求助时提供尽可能多的上下文和您已经尝试过的解决方案。
73 0
|
5月前
|
Python
解决Python报错:DataFrame对象没有concat属性的多种方法(解决方案汇总)
总的来说,解决“DataFrame对象没有concat属性”的错误的关键是理解concat函数应该如何正确使用,以及Pandas库提供了哪些其他的数据连接方法。希望这些方法能帮助你解决问题。记住,编程就像是解谜游戏,每一个错误都是一个谜题,解决它们需要耐心和细心。
277 15
|
5月前
|
安全 测试技术 开发者
Python中的“空”:对象的判断与比较
在Python开发中,判断对象是否为“空”是常见操作,但其中暗藏诸多细节与误区。本文系统梳理了Python中“空”的判定逻辑,涵盖None类型、空容器、零值及自定义对象的“假值”状态,并对比不同判定方法的适用场景与性能。通过解析常见误区(如混用`==`和`is`、误判合法值等)及进阶技巧(类型安全检查、自定义对象逻辑、抽象基类兼容性等),帮助开发者准确区分各类“空”值,避免逻辑错误,同时优化代码性能与健壮性。掌握这些内容,能让开发者更深刻理解Python的对象模型与业务语义交集,从而选择最适合的判定策略。
199 5
|
5月前
|
人工智能 Python
[oeasy]python083_类_对象_成员方法_method_函数_function_isinstance
本文介绍了Python中类、对象、成员方法及函数的概念。通过超市商品分类的例子,形象地解释了“类型”的概念,如整型(int)和字符串(str)是两种不同的数据类型。整型对象支持数字求和,字符串对象支持拼接。使用`isinstance`函数可以判断对象是否属于特定类型,例如判断变量是否为整型。此外,还探讨了面向对象编程(OOP)与面向过程编程的区别,并简要介绍了`type`和`help`函数的用法。最后总结指出,不同类型的对象有不同的运算和方法,如字符串有`find`和`index`方法,而整型没有。更多内容可参考文末提供的蓝桥、GitHub和Gitee链接。
123 11
|
8月前
|
测试技术 Python
【03】做一个精美的打飞机小游戏,规划游戏项目目录-分门别类所有的资源-库-类-逻辑-打包为可玩的exe-练习python打包为可执行exe-优雅草卓伊凡-持续更新-分享源代码和游戏包供游玩-1.0.2版本
【03】做一个精美的打飞机小游戏,规划游戏项目目录-分门别类所有的资源-库-类-逻辑-打包为可玩的exe-练习python打包为可执行exe-优雅草卓伊凡-持续更新-分享源代码和游戏包供游玩-1.0.2版本
352 31
【03】做一个精美的打飞机小游戏,规划游戏项目目录-分门别类所有的资源-库-类-逻辑-打包为可玩的exe-练习python打包为可执行exe-优雅草卓伊凡-持续更新-分享源代码和游戏包供游玩-1.0.2版本
|
6月前
|
存储 C语言 Python
[oeasy]python077_int类型怎么用_整数运算_integer_进制转化_int类
本文主要讲解了Python中`int`类型的应用与特性。首先回顾了`int`词根的溯源,探讨了整型变量的概念及命名规则(如匈牙利命名法)。接着分析了整型变量在内存中的存储位置和地址,并通过`type()`和`id()`函数验证其类型和地址。还介绍了整型变量的运算功能,以及如何通过`int()`函数将字符串转化为整数,支持不同进制间的转换(如二进制转十进制)。此外,文章提及了关键字`del`的使用场景,对比了Python与C语言中`int`的区别,并总结了整型与字符串类型的差异,为后续深入学习奠定基础。
112 1
|
9月前
|
存储 数据处理 Python
Python如何显示对象的某个属性的所有值
本文介绍了如何在Python中使用`getattr`和`hasattr`函数来访问和检查对象的属性。通过这些工具,可以轻松遍历对象列表并提取特定属性的所有值,适用于数据处理和分析任务。示例包括获取对象列表中所有书籍的作者和检查动物对象的名称属性。
195 2
|
9月前
|
缓存 监控 算法
Python内存管理:掌握对象的生命周期与垃圾回收机制####
本文深入探讨了Python中的内存管理机制,特别是对象的生命周期和垃圾回收过程。通过理解引用计数、标记-清除及分代收集等核心概念,帮助开发者优化程序性能,避免内存泄漏。 ####
208 3

推荐镜像

更多