Python精选200Tips：61-70

AnFany

已于 2024-09-11 14:43:23 修改

阅读量1.2k

点赞数 28

分类专栏： Python200+Tips 文章标签： python 策略模式开发语言

于 2024-09-05 15:23:35 首次发布

本文链接：https://blog.csdn.net/qq_32882309/article/details/141920876

版权

Everything is an object, but not all companions are everything.

061 面向对象编程
062 类的基本结构
063 类的封装
064 类的继承
065 多态
066 类的组合
067 类的聚合
068 抽象类
069 类方法和静态方法
070 属性装饰器

对象问题总是要面对的，无论是生活中还是学习Python时

运行系统：macOS Sonoma 14.6.1
Python编译器：PyCharm 2024.1.4 (Community Edition)
Python版本：3.12

往期链接：

1-5	6-10	11-20	21-30	31-40

41-50	51-60:函数

061 面向对象编程

面向对象编程（OOP）是一种编程范式，具有许多优点，特别是在大型软件开发和复杂系统设计中。以下是 OOP 的一些主要好处：

代码重用

继承：通过继承机制，可以创建新类以复用已有类的属性和方法，减少代码重复。
模块化：可以将功能划分为多个类和模块，方便管理和重用。

封装性

数据保护：通过封装，可以限制对对象内部状态的直接访问，从而保护数据的完整性。
简化接口：用户只需了解如何使用公共方法，而不必关心内部实现细节。

易于维护

局部修改：可以独立修改某个类的实现，而不影响其他类，降低维护成本。
清晰结构：面向对象的结构使得代码更易读，便于理解和维护。

抽象
OOP 允许开发者创建抽象数据类型，隐藏复杂性，使得用户只需关注重要的功能，而不必了解复杂的实现细节。
多态
多态性允许不同类的对象以相同的方式进行操作，增强了代码的灵活性。例如，使用相同的方法名称可以实现不同的行为。
适应性
OOP 使得系统能够更加灵活地应对变化。通过扩展类和添加新功能，可以轻松适应需求的变化。
模拟现实世界
OOP 允许开发者使用类和对象来模拟现实世界中的事物，使得设计和理解变得更加直观。

面向对象编程 (OOP) 的编码原则帮助开发者编写可维护、可扩展和可重用的代码。以下是一些重要的编码原则：

单一职责原则 (Single Responsibility Principle, SRP)
一个类应该只有一个职责或原因引起变化。可以增强可维护性，清晰的类结构使得理解和修改代码变得更加简单。
开放/封闭原则 (Open/Closed Principle, OCP)
软件实体（类、模块、函数等）应该对扩展开放，对修改封闭。允许通过扩展现有功能来添加新特性，减少对现有代码的改动。
里氏替换原则 (Liskov Substitution Principle, LSP)
子类对象应该能够替代父类对象，且不影响程序的正确性。确保继承关系的合理性，防止意外的行为变化。
接口隔离原则 (Interface Segregation Principle, ISP)
不应强迫客户端依赖于它们不使用的接口。接口应尽量小而专用。避免不必要的依赖，增强系统的灵活性。
依赖倒转原则 (Dependency Inversion Principle, DIP)
高层模块不应依赖低层模块，二者都应依赖抽象；抽象不应依赖细节，细节应依赖抽象。增强模块间的解耦性，提高系统的灵活性和可重用性。
组合优于继承 (Composition Over Inheritance)
尽量使用对象组合而不是类继承来实现功能。提高代码的灵活性，减少复杂性，避免继承层次导致的问题。
代码重用原则
尽量避免重复代码，通过类的继承或组合、模块化等方式重用代码。降低维护成本，提高代码的可读性和可维护性。
明确性原则
代码应该清晰明了，易于理解。命名应具有描述性，避免模糊不清的缩写和命名。提高代码的可读性，降低理解和维护的难度。
避免过度设计
在设计系统时，避免过度复杂化和不必要的抽象。保持代码简单，便于理解和维护，减少开发时间。

062 类的基本结构

Python 中的类是面向对象编程（Object Oriented Programming，OOP）的核心概念之一。类是创建对象的蓝图，允许你将数据和功能封装在一起。

使用 class 关键字来定义一个类。类通常包含属性（变量）和方法（函数）。

# 类的基本结构
class ClassName:
    def __init__(self, parameters): # init的前后均是两个下划线。
        self.attribute = parameters  # 实例属性

    def method(self):
        # 方法体
        pass

代码解释：

构造函数 __init__：
（1）用于初始化对象的属性。
（2）self 代表当前对象的实例。
属性：
类的变量，可以是实例属性（特定于某个对象）或类属性（所有对象共享）。
方法：
（1）类中的函数，定义了类的行为。
（2）可以访问和修改对象的属性。

示例：前男友类

# 示例1：定义一个前男友类。前男友有名字和年龄两个通用的属性，定义了2个哄(PIAN)人的方法。
class ExBoyFriend:
    def __init__(self, name, age):
        self.name = name  # 属性
        self.age = age    # 属性

    def coax_one(self):      # 方法
        return "say cheesy love lines"

    def coax_two(self):      # 方法
        return "make a promise"

# 创建对象/实例
exboyfriend1 = ExBoyFriend("N8", 24) # N8对应name，24对应age
print(exboyfriend1.name)  # 输出: N8
print(exboyfriend1.age)   # 输出: 24
print(exboyfriend1.coax_one())  # 输出: say cheesy love lines

# 创建另一个对象/实例
exboyfriend2 = ExBoyFriend("N26", 38) # N26对应name，38对应age
print(exboyfriend2.name)  # 输出: N26
print(exboyfriend2.age)   # 输出: 38
print(exboyfriend2.coax_two())  # 输出: make a promise

2 示例：开过的车

class Car:
    def __init__(self, make, model, year):
        self.make_car = make
        self.model_car = model
        self.year_car = year

    def display_info(self):
        return f"{
     self.year_car} {
     self.make_car} {
     self.model_car}"

# 创建对象
my_car = Car("VW", "Passat", 2021)
print(my_car.display_info())  # 输出: 2021 VW Passat

063 类的封装

类的封装是面向对象编程（OOP）的核心概念之一，它是指将数据（属性）和操作数据的方法（函数）结合在一起，形成一个独立的单位（类）。封装的主要目的是保护对象的内部状态，限制外部对对象内部数据的直接访问，从而提高代码的安全性和维护性。封装的关键点：

数据隐藏
通过将属性设置为私有（private），可以限制对对象内部状态的直接访问，从而保护数据的完整性。
访问修饰符
公有（public）：属性和方法可以被外部访问。
私有（private）：属性和方法只能在类内部访问，外部无法直接访问。
受保护（protected）：属性和方法可以被类本身和其子类访问，但外部无法直接访问。
getter 和 setter 方法
使用公共方法（getter 和 setter）来访问和修改私有属性，从而可以在访问时添加验证逻辑，确保数据的一致性和有效性。
接口
通过定义清晰的公共接口，用户可以与对象进行交互，而无需了解其内部实现。这有助于简化使用并提高可维护性。
增强安全性
封装可以防止外部代码对对象状态的意外修改，从而提高程序的稳定性和安全性。

示例

class Person:
    def __init__(self, name, age, gender):
        self.__name = name  # 私有属性, 前面两个下划线
        self.__age = age    # 私有属性
        self.gender = gender  # 公有属性

    # Getter for name
    def get_name(self):
        return self.__name

    # Setter for name
    def set_name(self, name):
        self.__name = name

    # Getter for age
    def get_age(self):
        return self.__age

    # Setter for age with validation
    def set_age(self, age):
        if age >= 0:
            self.__age = age
        else:
            print("Age must be a non-negative integer.")

# 示例使用
person1 = Person("Alice", 30, "Female")

# 使用 Getter 方法
print(person1.get_name())  # 输出: Alice
print(person1.get_age())   # 输出: 30
print(person1.gender)       # 输出: Female

# 使用 Setter 方法，修改私有属性
person1.set_name("Bob")
person1.set_age(35)
print(person1.get_name())  # 输出: Bob
print(person1.get_age())   # 输出: 35

# 尝试设置一个无效的年龄
person1.set_age(-5)        # 输出: Age must be a non-negative integer.

# 可直接修改公有属性
person1.gender = "Male"
print(person1.gender)       # 输出: Male

# 直接访问私有属性，是不可以的
print(person1.__name)       # 输出: AttributeError: 'Person' object has no attribute '__name'

示例：银行账户管理系统

class BankAccount:
    def __init__(self, owner, balance=0):
        self.__owner = owner          # 私有属性，账户持有人
        self.__balance = balance      # 私有属性，账户余额

    # Getter for owner
    def get_owner(self):
        return self.__owner

    # Getter for balance
    def get_balance(self):
        return self.__balance

    # 存款方法
    def deposit(self, amount):
        if amount > 0:
            self.__balance += amount
            return f"Deposited {
     amount}. New balance is {
     self.__balance}."
        return "Deposit amount must be positive."

    # 取款方法
    def withdraw(self, amount):
        if 0 < amount <= self.__balance:
            self.__balance -= amount
            return f"Withdrew {
     amount}. New balance is {
     self.__balance}."
        return "Insufficient funds or invalid amount."

# 示例使用
account = BankAccount("Alice", 1000)

# 查看账户持有人和余额
print(account.get_owner())      # 输出: Alice
print(account.get_balance())    # 输出: 1000

# 存款
print(account.deposit(500))      # 输出: Deposited 500. New balance is 1500.

# 取款
print(account.withdraw(200))     # 输出: Withdrew 200. New balance is 1300.

# 尝试取款超过余额
print(account.withdraw(2000))    # 输出: Insufficient funds or invalid amount.

064 类的继承

类的继承是面向对象编程（OOP）的一种机制，它允许一个类（子类）继承另一个类（父类）的属性和方法。通过继承，可以实现代码的重用和扩展。以下是关于类的继承的详细介绍和示例。

基本概念
（1）父类（基类）：被继承的类。
（2）子类（派生类）：继承父类的类，可以添加新的属性和方法或重写父类的方法。
继承的好处
（1）代码重用：通过继承，可以重用父类的代码，减少重复。
（2）扩展性：子类可以在父类的基础上扩展新功能。
（3）多态性：通过继承，可以实现多态性，允许不同子类以相同的方式调用父类的方法。

基本结构

 # 父类
class ParentClass: 
    def __init__(self, value):
        self.value = value

    def display(self):
        return f"Value: {
     self.value}"

# 子类
class ChildClass(ParentClass): # 括号中是父类的名字，父类可以是自定义的类，也可以是python中的类，例如异常类Exception
    def __init__(self, value, extra_value):
        super().__init__(value)  # 调用父类的构造函数
        self.extra_value = extra_value

    def display_extra(self):
        return f"Extra Value: {
     self.extra_value}"

# 示例使用
parent_instance = ParentClass(10)
print(parent_instance.display())