Python 面向对象编程基础：编织水果类的魔法

已于 2023-12-11 23:59:13 修改
阅读量1k 收藏 16
点赞数 16
分类专栏： python学习之旅 文章标签： python 开发语言 编程 面向对象
于 2023-12-11 23:54:07 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41780234/article/details/134938524
版权

目录

写在开头

在Python的编程世界中，面向对象编程（Object-Oriented Programming，OOP）被认为是一种强大而灵活的范式。本文将深入介绍Python中面向对象编程的基础知识，并以水果类为例，展开探讨“编织类的魔法”。我们将围绕着类和对象的幻术、封装、继承、多态的基本法则，以及如何创建自己的魔法类展开讨论。

1、类和对象的幻术

在Python中，类（Class）和对象（Object）是面向对象编程的核心概念。类是一种用户自定义的数据类型，用于描述具有相同属性和方法的对象集合。而对象则是类的实例，是具体的数据实体。

1.1 类的定义

在Python中，使用class关键字定义一个类。类包含属性（成员变量）和方法（成员函数），通过类可以创建多个相似的对象。以下是一个简单的类的定义示例：

class Fruit:
    def __init__(self, name, size):
        self.name = name
        self.size = size

    def display_info(self):
        print(f"{self.name} {self.size}")

在上述代码中，Fruit是一个类，具有name和size两个属性以及display_info方法。

1.2 对象的创建

中等大小
通过类可以创建对象，即类的实例。对象是类的具体实体，具有类定义的属性和方法。以下是创建Fruit类的对象的示例：

# 创建Car类的两个对象
banana = Fruit("banana", "medium")
apple = Fruit("apple", "medium")

# 调用对象的方法
banana.display_info()  # 输出：banana medium
apple.display_info()  # 输出：apple medium

在这个例子中，banana 和apple 都是Fruit类的对象，它们拥有相同的属性和方法，但具体的属性值可以不同。

1.3 类和对象的关系

类和对象之间的关系可以理解为蓝图和实例的关系。类是一种模板，定义了对象应该具有的属性和方法，而对象是根据类创建的具体实体，拥有类定义的特征和行为。

1.3.1 访问对象属性和方法

通过对象可以访问类定义的属性和方法。属性可以用点运算符.进行访问，方法可以通过调用来执行。示例代码如下：

# 访问对象属性和方法
print(banana.size)       # 输出：medium
print(apple.name)       # 输出：apple
apple.display_info()     # 输出：apple medium

在这里，我们通过点运算符分别访问了对象的属性和调用了对象的方法。

1.3.2 对象的独立性

每个对象都是独立的实体，拥有自己的属性值。修改一个对象的属性不会影响其他对象。示例代码：

# 修改对象属性
apple.size= "little"
apple.display_info()     # 输出：apple little
banana.display_info()     # 输出：banana medium

通过上述代码，我们修改了apple的size属性，但banana的属性保持不变。

1.4 完整例子

在Python中，类是对对象的抽象，对象是类的实例。我们将以水果类为例，展示类和对象的基本概念：

class Fruit:
    def __init__(self, name):
        self.name = name

    def taste(self):
        pass

class Banana(Fruit):
    def taste(self):
        return f"The {self.name} tastes sweet and creamy."

class Apple(Fruit):
    def taste(self):
        return f"The {self.name} tastes crisp and juicy."

class Plum(Fruit):
    def taste(self):
        return f"The {self.name} tastes sweet and tart."

# 创建水果对象
banana_instance = Banana("Banana")
apple_instance = Apple("Apple")
plum_instance = Plum("Plum")

# 调用水果的方法
print(banana_instance.taste())  # 输出：The Banana tastes sweet and creamy.
print(apple_instance.taste())   # 输出：The Apple tastes crisp and juicy.
print(plum_instance.taste())    # 输出：The Plum tastes sweet and tart.

这段代码展示了如何创建水果类及其子类，并通过对象调用方法展现了多态的特性。每个水果子类都有自己特定的味道，展现了OOP中类和对象的幻术。

2. 封装、继承、多态的基本法则

在Python中，封装、继承、和多态是面向对象编程的三大基本法则。这些法则为代码提供了结构化、灵活和可扩展的特性。

2.1 封装

封装是一种将数据和方法包装在类的内部，对外部隐藏实现细节的机制。通过封装，我们可以控制对类的访问和修改，这种优点主要集中在以下几个方面：

  • 隐藏实现细节

    • 封装允许将类的实现细节隐藏起来，只暴露必要的接口。这样可以减少外部对类内部结构的依赖，提高代码的模块化和可维护性。

  • 防止直接访问

    • 通过将属性设置为私有，可以防止直接访问和修改类内部的数据，确保数据的安全性和一致性。

  • 提供公共接口

    • 封装提供了一个清晰的公共接口，外部用户只需要关心如何使用接口，而不需要了解类的内部实现细节。这降低了使用者与实现者之间的耦合度。

使用私有属性

在Python中，可以通过使用双下划线 __ 前缀将属性设置为私有，即只能在类的内部访问。

class Fruit:
    def __init__(self, name):
        self.__name = name  # 私有属性

    def get_name(self):
        return self.__name

# 创建Fruit对象
apple = Fruit("Apple")

# 试图直接访问私有属性将引发错误
# print(apple.__name)  # 错误：'Fruit' object has no attribute '__name'

# 通过公有方法获取私有属性值
print(apple.get_name())  # 输出：Apple

在上述代码中，__name 是私有属性，通过 公有方法get_name 方法提供了对其安全访问的接口。

2.2 类的继承

2.2.1 什么是类的继承

在Python中，类的继承是一种重要的面向对象编程（OOP）概念。它允许一个类（称为子类）继承另一个类（称为父类或基类）的属性和方法。子类可以使用父类的特性，也可以在需要时进行修改或扩展。

2.2.2 基本的类继承语法

下面是一个简单的示例，展示了如何创建父类和子类：

class Fruit:
    def __init__(self, name):
        self.name = name

    def describe(self):
        return f"I am a {self.name}"

class Apple(Fruit):
    def __init__(self, name, color):
        super().__init__(name)
        self.color = color

    def describe(self):
        return f"I am an {self.color} apple named {self.name}"

在这个例子中，Fruit 是父类，Apple 是子类。子类 Apple 继承了父类 Fruit 的属性和方法，并且可以通过 super() 调用父类的构造函数。

2.2.3 方法的重写（Override）

子类可以重写父类的方法，以适应自身的特定需求。在上述例子中，Apple 重写了 describe 方法。

2.2.4 多重继承

Python支持多重继承，一个类可以继承多个父类的特性。例如：

class ColorfulFruit:
    def __init__(self, color):
        self.color = color

class ColoredApple(Apple, ColorfulFruit):
    def __init__(self, name, color):
        Apple.__init__(self, name, color)
        ColorfulFruit.__init__(self, color)

    def describe(self):
        return f"I am a {self.color} apple named {self.name}"

在这个例子中，ColoredApple 继承了 Apple 和 ColorfulFruit 两个类，同时拥有它们的属性和方法。

2.2.5 抽象类和接口

抽象类和接口是类继承中的概念，它们提供了一种约束子类必须实现某些方法的机制。在 Python 中，可以通过 ABC 模块来定义抽象基类。

from abc import ABC, abstractmethod

class Shape(ABC):
    @abstractmethod
    def area(self):
        pass

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

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

在这个例子中，Shape 是一个抽象基类，要求子类必须实现 area 方法。

2.2.6 类的继承与实例化

通过类的继承，可以创建多个相关的类，每个类可以有自己的属性和方法。然后，通过实例化来创建类的对象，并使用这些对象调用相应的方法。

apple = Apple("Fuji", "red")
print(apple.describe())

colored_apple = ColoredApple("Gala", "green")
print(colored_apple.describe())

这段代码展示了如何实例化 Apple 和 ColoredApple 类，并调用它们的 describe 方法。

2.3 多态

在Python中，多态是面向对象编程的一个重要概念，它允许不同类的对象对相同的方法做出不同的响应。多态性使得代码更加灵活，能够适应不同类型的对象，提高了代码的可扩展性和可维护性。

2.3.1 多态的基本理念

多态是指不同的对象可以通过相同的接口进行访问，但实际的操作可能会因对象的类型而产生不同的行为。这种灵活性使得代码更具可扩展性和可维护性。

2.3.2 多态的实现方式

在Python中，多态主要通过方法的重写（override）来实现。当调用一个对象的方法时，解释器会在运行时确定调用哪个方法，而不是在编译时确定。这使得相同的方法名可以在不同的类中实现不同的行为。

2.3.3 多态的应用场景

让我们通过一个水果的例子来演示多态的应用。考虑有两种水果类：Apple 和 Orange，它们都具有一个 taste 方法，但实现不同的行为。

class Apple:
    def taste(self):
        return "Sweet and Crispy"

class Orange:
    def taste(self):
        return "Citrusy and Tangy"

现在，我们可以创建一个通用的函数 describe_taste，该函数接受任何水果类的对象并调用其 taste 方法：

def describe_taste(fruit):
    print(f"The taste of the fruit is {fruit.taste()}")

使用多态，我们可以创建不同类型的水果对象：

apple = Apple()
orange = Orange()
banana = Banana()

# 使用多态
fruits = [apple, orange, banana]

for fruit in fruits:
    describe_taste(fruit)

这个例子中，我们无需修改 describe_taste 函数，就能够适应这个新的水果类，Apple、Orange和Banana都是Fruit的子类，它们重写了Fruit类的taste方法。这种优势在大型项目中尤为重要，因为它减少了对已有代码的修改，提高了代码的可维护性和可扩展性。

2.3.4 多态性的优势

通过多态，我们可以使用相同的代码遍历不同类型的水果，无需关心具体类型。这种优势在大型项目中尤为重要，因为它减少了对已有代码的修改，提高了代码的可维护性和可扩展性。

2.3.5 与抽象基类相关的知识

在Python中，我们还可以使用抽象基类（Abstract Base Classes，ABC）来实现多态。ABC定义了一组抽象方法，子类必须实现这些方法。这确保了子类在不同的上下文中能够正确地使用多态，展示了多态如何提高代码的灵活性。

from abc import ABC, abstractmethod

class Fruit(ABC):
    @abstractmethod
    def taste(self):
        pass

class Apple(Fruit):
    def taste(self):
        return "Sweet and Crispy"

class Orange(Fruit):
    def taste(self):
        return "Citrusy and Tangy"

在这里，Fruit 类定义了一个抽象方法 taste，并且 Apple 和 Orange 类都继承了 Fruit 类并实现了 taste 方法。这样，我们可以确保所有水果类都具有相同的接口，从而实现了多态。

3. 类的访问控制

在Python中，类的访问控制是通过成员属性和方法的命名规则以及修饰符来实现的。了解类的访问控制有助于保护类的内部实现细节，同时提供对外部的合适接口。

3.1 属性和方法的命名规则

在Python中，通过在属性和方法的名称前添加一个或多个下划线来指定它们的访问级别。以下是常见的命名规则：

  • 一个下划线（例如 _variable）表示属性或方法是受保护的，应当被视为内部实现的一部分，但仍然可以被访问。
  • 两个下划线（例如 __variable）表示属性或方法是私有的，只能在类的内部访问，而不能被外部直接访问。
  • 两个下划线开头和结尾（例如 __variable__）通常表示特殊方法，由Python解释器使用，不建议自行定义类似命名规则的属性或方法。

3.2 通过方法进行属性访问

在Python中，可以通过属性的getter和setter方法来控制对属性的访问。这种方式使得我们可以在属性被访问或修改之前进行额外的逻辑操作。

让我们通过水果的例子来演示类的访问控制。

class Fruit:
    def __init__(self, name):
        self._name = name  # 受保护的属性

    @property
    def name(self):
        return self._name

    @name.setter
    def name(self, new_name):
        if isinstance(new_name, str):
            self._name = new_name
        else:
            print("Invalid name format")

# 使用属性访问控制
apple = Fruit("Apple")
print(apple.name)  # 访问受保护的属性

apple.name = "Green Apple"  # 使用setter方法修改属性
print(apple.name)

在这个例子中，_name 被定义为受保护的属性，通过 @property 装饰器和对应的setter方法，我们实现了对 name 属性的访问控制。属性 name 可以被外部访问，但是通过setter方法可以进行额外的逻辑判断。

3.3 类的继承和访问控制

继承是面向对象编程中常用的机制之一。子类可以继承父类的属性和方法，同时可以通过访问控制来限制对继承成员的访问。

class CitrusFruit(Fruit):
    def __init__(self, name, sourness):
        super().__init__(name)
        self._sourness = sourness  # 受保护的属性

    @property
    def sourness(self):
        return self._sourness

    @sourness.setter
    def sourness(self, value):
        if 0 <= value <= 10:
            self._sourness = value
        else:
            print("Sourness value should be between 0 and 10")

# 使用继承和访问控制
orange = CitrusFruit("Orange", 8)
print(orange.name)      # 继承父类的属性
print(orange.sourness)  # 访问子类新增的属性

orange.sourness = 11    # 使用setter方法进行逻辑判断

在这个例子中，CitrusFruit 类继承自 Fruit 类，同时新增了一个受保护的属性 sourness。通过访问控制，我们限制了对 sourness 属性的访问，确保其值在合法范围内。

3.4 类的装饰器和访问控制

Python中的装饰器提供了一种灵活的方式来修改或扩展类的行为。通过使用装饰器，我们可以对类的方法进行额外的控制或添加功能。

def uppercase_decorator(func):
    def wrapper(self):
        result = func(self)
        return result.upper()
    return wrapper

class FruityMessage:
    def __init__(self, message):
        self._message = message

    @property
    def message(self):
        return self._message

    @message.setter
    def message(self, new_message):
        self._message = new_message

    @uppercase_decorator
    def get_uppercase_message(self):
        return self._message

# 使用装饰器进行访问控制
fruit_message = FruityMessage("Hello, I'm a fruit!")
print(fruit_message.get_uppercase_message())  # 使用装饰器修改方法行为

在这个例子中，我们定义了一个装饰器 uppercase_decorator，它将一个方法的返回值转换为大写。通过在 get_uppercase_message 方法上应用这个装饰器，我们实现了对方法行为的额外控制。

3.5 静态方法和类方法

在类中，静态方法和类方法提供了两种不同的方法类型，它们分别通过 @staticmethod 和 @classmethod 装饰器进行定义。这两种方法不依赖于实例，可以通过类名直接调用。

class FruitUtil:
    @staticmethod
    def is_sweet(taste):
        return "Sweet" in taste

    @classmethod
    def from_dict(cls, fruit_dict):
        name = fruit_dict.get("name", "Unknown Fruit")
        return cls(name)

# 使用静态方法和类方法
print(FruitUtil.is_sweet("Sweet and Juicy"))  # 静态方法
orange_dict = {"name": "Orange"}
orange = FruitUtil.from_dict(orange_dict)  # 类方法
print(orange.name)

在这个例子中，is_sweet 是一个静态方法，它不依赖于类的实例；而 from_dict 是一个类方法，它可以使用类的构造函数创建新的实例。这些方法可以在不创建类实例的情况下被调用，提供了一种与实例无关的功能。

3.7 属性和方法的继承与覆盖

在面向对象编程中，继承是一种重要的机制，允许子类继承父类的属性和方法。同时，子类也可以选择性地覆盖或扩展父类的方法。

class ExoticFruit(Fruit):
    def __init__(self, name, sweetness, country_of_origin):
        super().__init__(name)
        self._sweetness = sweetness
        self._country_of_origin = country_of_origin

    @property
    def sweetness(self):
        return self._sweetness

    @sweetness.setter
    def sweetness(self, value):
        if 0 <= value <= 10:
            self._sweetness = value
        else:
            print("Sweetness value should be between 0 and 10")

    def describe(self):
        return f"{self.name} is from {self._country_of_origin} and has sweetness level {self.sweetness}"

# 使用属性和方法的继承与覆盖
mango = ExoticFruit("Mango", 9, "India")
print(mango.describe())  # 调用子类的方法
print(mango.name)        # 继承父类的属性

在这个例子中，ExoticFruit 类继承自 Fruit 类，同时新增了属性 sweetness 和 country_of_origin，并覆盖了父类的 describe 方法。通过这种方式，子类可以在不改变父类行为的前提下，添加自己的特有属性和方法，实现更具体的功能。

4.类的方法

4.1 实例方法

实例方法是最常用的方法类型，它操作对象的实例，并通过 self 参数访问对象的属性和其他方法。

class Fruit:
    def __init__(self, name, color):
        self.name = name
        self.color = color

    def describe(self):
        return f"A {self.color} {self.name}"

apple = Fruit("Apple", "red")
print(apple.describe())  # 输出: A red Apple

4.2 类方法

类方法是在类级别上操作的方法，使用 @classmethod 装饰器定义，并使用 cls 参数代表类本身。

class Fruit:
    total_fruits = 0

    def __init__(self, name, color):
        self.name = name
        self.color = color
        Fruit.total_fruits += 1

    @classmethod
    def get_total_fruits(cls):
        return cls.total_fruits

apple = Fruit("Apple", "red")
banana = Fruit("Banana", "yellow")

print(Fruit.get_total_fruits())  # 输出: 2

4.3 静态方法

静态方法是在类中定义的独立于实例和类的方法，使用 @staticmethod 装饰器定义，不需要额外的参数。

class Fruit:
    @staticmethod
    def is_valid_color(color):
        valid_colors = ["red", "yellow", "green"]
        return color.lower() in valid_colors

print(Fruit.is_valid_color("red"))    # 输出: True
print(Fruit.is_valid_color("purple")) # 输出: False

4.4 属性方法

属性方法允许使用点运算符访问方法，就像访问属性一样。使用 @property 装饰器定义。

class Fruit:
    def __init__(self, name, color):
        self._name = name
        self._color = color

    @property
    def name(self):
        return self._name

    @property
    def color(self):
        return self._color

    @property
    def description(self):
        return f"A {self.color} {self.name}"

apple = Fruit("Apple", "red")
print(apple.name)        # 输出: Apple
print(apple.color)       # 输出: red
print(apple.description)  # 输出: A red Apple

4.5 设置器和删除器方法

属性的设置器方法使用 @<property_name>.setter 装饰器定义，删除器方法使用 @<property_name>.deleter 装饰器定义。

class Fruit:
    def __init__(self, name, color):
        self._name = name
        self._color = color

    @property
    def name(self):
        return self._name

    @name.setter
    def name(self, new_name):
        self._name = new_name

    @name.deleter
    def name(self):
        del self._name

apple = Fruit("Apple", "red")
print(apple.name)  # 输出: Apple

apple.name = "Green Apple"
print(apple.name)  # 输出: Green Apple

del apple.name
# print(apple.name)  # 抛出 AttributeError，属性已被删除

4.6 魔法方法

魔法方法是Python中用双下划线 __ 包围的方法，用于实现对象的特殊行为。以下是一些常用的魔法方法：

4.6.1 __init__ 初始化方法

__init__ 方法在对象创建时调用，用于初始化对象的属性。

class Fruit:
    def __init__(self, name, color):
        self.name = name
        self.color = color

apple = Fruit("Apple", "red")
print(apple.name, apple.color)  # 输出: Apple red

4.6.2 __str__ 字符串表示方法

__str__ 方法定义了对象的字符串表示形式，通过 str(obj) 或 print(obj) 调用。

class Fruit:
    def __init__(self, name, color):
        self.name = name
        self.color = color

    def __str__(self):
        return f"{self.color} {self.name}"

apple = Fruit("Apple", "red")
print(apple)  # 输出: red Apple

4.6.3 __repr__ 表示方法

__repr__ 方法定义了对象的官方字符串表示形式，通过 repr(obj) 调用。

class Fruit:
    def __init__(self, name, color):
        self.name = name
        self.color = color

    def __repr__(self):
        return f"Fruit('{self.name}', '{self.color}')"

apple = Fruit("Apple", "red")
print(repr(apple))  # 输出: Fruit('Apple', 'red')

4.6.4 __add__ 加法方法

__add__ 方法定义了对象的加法行为，通过 obj1 + obj2 调用。

class Fruit:
    def __init__(self, name, color):
        self.name = name
        self.color = color

    def __add__(self, other):
        return Fruit(f"{self.name} {other.name}", f"{self.color}-{other.color}")

apple = Fruit("Apple", "red")
banana = Fruit("Banana", "yellow")

fruit_salad = apple + banana
print(fruit_salad.name, fruit_salad.color)  # 输出: Apple Banana red-yellow

4.6.5 __len__ 长度方法

__len__ 方法定义了对象的长度，通过 len(obj) 调用。

class FruitBasket:
    def __init__(self):
        self.fruits = []

    def add_fruit(self, fruit):
        self.fruits.append(fruit)

    def __len__(self):
        return len(self.fruits)

basket = FruitBasket()
basket.add_fruit(Fruit("Apple", "red"))
basket.add_fruit(Fruit("Banana", "yellow"))

print(len(basket))  # 输出: 2

4.7 定制类

4.7.1 __getattr__ 和 __setattr__

__getattr__ 方法在试图访问一个不存在的属性时被调用，而 __setattr__ 方法在给属性赋值时被调用。

class Fruit:
    def __init__(self, name, color):
        self.name = name
        self.color = color

    def __getattr__(self, attr):
        return f"{attr} not found"

    def __setattr__(self, attr, value):
        if attr == "color":
            value = value.upper()
        super().__setattr__(attr, value)

apple = Fruit("Apple", "red")
print(apple.size)   # 输出: size not found
print(apple.color)  # 输出: RED

4.7.2 __del__ 删除方法

__del__ 方法定义了对象被删除时的行为，通过 del obj 调用。

class Fruit:
    def __init__(self, name, color):
        self.name = name
        self.color = color

    def __del__(self):
        print(f"{self.name} deleted")

apple = Fruit("Apple", "red")
del apple  # 输出: Apple deleted

4.7.3 __call__ 调用方法

__call__ 方法允许将对象当作函数调用，通过 obj() 调用。

class Counter:
    def __init__(self):
        self.count = 0

    def __call__(self):
        self.count += 1
        return self.count

counter = Counter()
print(counter())  # 输出: 1
print(counter())  # 输出: 2
4.7.4 __getitem__ 和 __setitem__

__getitem__ 和 __setitem__ 方法用于定义对象的索引操作，通过 obj[index] 和 obj[index] = value 调用。

class FruitBasket:
    def __init__(self):
        self.fruits = []

    def __getitem__(self, index):
        return self.fruits[index]

    def __setitem__(self, index, value):
        self.fruits[index] = value

basket = FruitBasket()
basket.fruits = [Fruit("Apple", "red"), Fruit("Banana", "yellow")]

print(basket[0].name)  # 输出: Apple
basket[1] = Fruit("Orange", "orange")
print(basket[1].color)  # 输出: orange
4.7.5 __iter__ 和 __next__ 迭代方法

__iter__ 和 __next__ 方法用于定义对象的迭代行为，通过 iter(obj) 和 next(obj) 调用。

class FruitBasket:
    def __init__(self):
        self.fruits = []

    def add_fruit(self, fruit):
        self.fruits.append(fruit)

    def __iter__(self):
        self.index = 0
        return self

    def __next__(self):
        if self.index < len(self.fruits):
            fruit = self.fruits[self.index]
            self.index += 1
            return fruit
        else:
            raise StopIteration

basket = FruitBasket()
basket.add_fruit(Fruit("Apple", "red"))
basket.add_fruit(Fruit("Banana", "yellow"))

for fruit in basket:
    print(fruit.name)  # 输出: Apple Banana

4.8 类的装饰器

4.8.1 @classmethod 装饰器

@classmethod 装饰器用于定义类方法，类方法操作类级别的属性或行为。

class Fruit:
    total_fruits = 0

    def __init__(self, name, color):
        self.name = name
        self.color = color
        Fruit.total_fruits += 1

    @classmethod
    def get_total_fruits(cls):
        return cls.total_fruits

apple = Fruit("Apple", "red")
banana = Fruit("Banana", "yellow")

print(Fruit.get_total_fruits())  # 输出: 2

4.8.2 @staticmethod 装饰器

@staticmethod 装饰器用于定义静态方法，静态方法与类和实例无关。

class MathOperation:
    @staticmethod
    def add(x, y):
        return x + y

    @staticmethod
    def multiply(x, y):
        return x * y

result1 = MathOperation.add(3, 5)        # 静态方法调用
result2 = MathOperation.multiply(2, 4)   # 静态方法调用

print(result1, result2)  # 输出: 8 8

4.8.3 @property 装饰器

@property 装饰器用于定义属性方法，使得方法可以像属性一样访问。

class Fruit:
    def __init__(self, name, color):
        self._name = name
        self._color = color

    @property
    def name(self):
        return self._name

    @property
    def color(self):
        return self._color

    @property
    def description(self):
        return f"A {self.color} {self.name}"

apple = Fruit("Apple", "red")
print(apple.name)        # 输出: Apple
print(apple.color)       # 输出: red
print(apple.description)  # 输出: A red Apple

4.8.4 @classmethod 与 @staticmethod 区别

@classmethod 用于操作类级别的属性和行为，而 @staticmethod 与类和实例无关，可以看作是独立的函数。

class MyClass:
    class_var = "Class Variable"

    @classmethod
    def class_method(cls):
        return cls.class_var

    @staticmethod
    def static_method():
        return "Static Method"

print(MyClass.class_method())   # 输出: Class Variable
print(MyClass.static_method())  # 输出: Static Method

4.8.5 @property、@setter 和 @deleter

通过 @property、@<property_name>.setter 和 @<property_name>.deleter 装饰器，可以定义属性的访问、设置和删除方法。

class Fruit:
    def __init__(self, name, color):
        self._name = name
        self._color = color

    @property
    def name(self):
        return self._name

    @name.setter
    def name(self, new_name):
        self._name = new_name

    @name.deleter
    def name(self):
        del self._name

apple = Fruit("Apple", "red")
print(apple.name)  # 输出: Apple

apple.name = "Green Apple"
print(apple.name)  # 输出: Green Apple

del apple.name
# print(apple.name)  # 抛出 AttributeError，属性已被删除

4.9 元类

元类是类的类，用于控制类的创建和行为。元类通常是 type 的子类，可以通过定义 __metaclass__ 属性或在 class 定义时使用 metaclass 参数来指定。

class MyMeta(type):
    def __new__(cls, name, bases, dct):
        # 修改类的行为或属性
        dct['added_method'] = lambda self: print(f"Hello from {name}")
        return super().__new__(cls, name, bases, dct)

class MyClass(metaclass=MyMeta):
    def existing_method(self):
        print("Existing method")

obj = MyClass()
obj.existing_method()  # 输出: Existing method
obj.added_method()     # 输出: Hello from MyClass

在这个例子中，MyMeta 是一个元类，它通过在 MyClass 的创建阶段修改类的字典来添加了一个新方法。

5、创建自己的魔法类

在Python中，我们可以通过元类来创建自定义的类，实现更高级的自定义行为。以下是一个简单的例子：

class MyMeta(type):
    def __new__(cls, name, bases, attrs):
        attrs['custom_attribute'] = 42
        return super().__new__(cls, name, bases, attrs)

# 使用自定义元类创建类
class MyClass(metaclass=MyMeta):
    pass

# 创建类的实例
my_instance = MyClass()

# 访问自定义属性
print(my_instance.custom_attribute)  # 输出：42

通过元类，我们可以在类创建时动态地修改类的属性和方法，为类的行为定制更高级的魔法。

写在最后

本文深入介绍了Python面向对象编程的基础知识，结合水果类的例子，展示了类和对象的幻术、封装、继承、多态的基本法则。通过具体的水果类操作代码，读者可以更好地理解和应用这些概念，编织出自己的魔法世界。在实际项目中，善用这些OOP的基本法则，可以使代码更具可维护性、扩展性和复用性，提高开发效率。

theskylife
关注
专栏目录
Python 面向对象编程：类的创建与初始化、实例属性与方法、类属性与方法
12-21
面向对象编程是Python编程的重要组成部分，它通过模拟现实世界的实体来组织代码，使得代码更加模块化和可重用。在Python中，面向对象主要涉及类（Class）的创建、实例化（Instantiation）、属性（Attributes）和方法...
水果类
Python_ID的博客
07-25 6201
# 定义一个水果类，然后通过水果类，创建苹果对象、橘子对象、西瓜对象并分别添加属性:颜色和价格: class Fruits: """水果类""" def __init__(self, color, price): # 颜色属性 self.__color = color # 价格属性 self.__price = price def get_color(self): return self.__co
python基础语法04
Binbinhb的博客
09-12 1053
一、面向对象 1、类 类是一系列事件的统称，同类事物必定具有相同的特征。 （1）特征 状态（品种，重量等）/变量（成员变量） （2）类的定义 定义格式一： class 类名: pass 定义格式二： class 类名: 成员 class Cat: pass （3）创建对象 格式： 变量名 = 类名() cat1 = Cat() 2、类成员...
[Python] 入门（10）：Python 基础 -- 面向对象编程
花解语
06-03 392
往期回顾： [Python] 入门（1）：安装 Python 及必要组件 [Python] 入门（2）：Python 基础 – 变量 [Python] 入门（3）：Python 基础 – 内建函数 [Python] 入门（4）：Python 基础 – 列表和词典的方法 [Python] 入门（5）：Python 基础 – 字符串的方法 [Python] 入门（6）：Python 基础 – Pyt...
Python基础语法 面向对象程序设计（二）
ShengXIABai的博客
04-04 1499
面向对象程序设计（二） 一、属性（@property） 1.类属性和实例属性：返回所存储的值 2.通过@property（装饰器）将一个方法转换为属性：一种特殊的属性，访问时将计算它的值。另外，该属性也可以添加安全保护机制 在Python中，通过@property（装饰器）将一个方法转换为属性，从而实现用于计算的属性。 该方法转换为属性后，可以直接通过方法名来访问方法，而不再需要添加一对小括号（），这样可以使代码更简洁 注意：通过@property转换后的属性不能重新赋值 语法格式：
python面向对象编程二
lhaniey的博客
10-27 723
三、属性和方法 •类由成员变量（对应于对象的属性）和成员函数（对应于对象的方法）组成。属性是对数据的封装，方法则表示对象具有的行为。 •Python的构造函数、析构函数、私有属性或方法都是通过名称约定区分的。 此外，Python还提供了一些有用的内置方法，简化了类的实现 1、类的成员属性 •Python的类的成员一般分为私有属性和公有属性，像C++有定义属性的关键字（public、pri...
python基础：面向对象的编程 类 示例
01-20
文章目录示例1：创建和使用类示例2：创建和使用类示例3：继承示例1示例4：继承示例2示例5：继承，将实例用作属性 示例1：创建和使用类 创建一个名为Restaurant 的类，其方法__ init __()设置两个属性：restaurant_...
Python面向对象编程基础实例分析
09-18
Python面向对象编程是一种流行的编程范式，其基础在于类（Class）和对象（Object）的概念。Python中的类是对现实世界中事物的抽象和模拟，它能够定义出具有属性（Attributes）和方法（Methods）的数据结构。对象则是...
Python面向对象编程基础解析（一）
09-21
### Python面向对象编程基础解析 #### 一、面向对象编程简介 面向对象编程（Object-Oriented Programming，简称 OOP）是一种重要的编程范式，在现代软件工程中占据着举足轻重的地位。OOP 的核心思想是将现实世界中...
bayes实现水果分类（python，包含数据集）
09-25
使用bayes算法实现水果分类，附件中包含数据集 #根据测试数据进行提取数据特征， 分类，求方差，均值，然后对每类进行特征值提取
python_test_05
weixin_44786482的博客
03-29 843
要求： （1）创建狗类：Dog() （2）Dog类具有： 实例属性：name(名字)、type(类型)、color(颜色)、love_food(喜欢吃的食物) eat_num(吃食物的次数) 实例方法：使用__init__方法进行初始化 str 输出：xxx是xx颜色xx类型的小狗，喜欢吃xxx eat() 说明：吃一次食物，eat_num加1 class Dog(): def _...
python 分类_简单机器学习入门教程：用Python解决简单的水果分类问题
weixin_39856269的博客
11-23 1494
在这篇机器学习入门教程中，我们将使用Python中最流行的机器学习工具scikit- learn,在Python中实现几种机器学习算法。使用简单的数据集来训练分类器区分不同类型的水果。这篇文章的目的是识别出最适合当前问题的机器学习算法。因此，我们要比较不同的算法，选择性能最好的算法。让我们开始吧!数据水果数据集由爱丁堡大学的Iain Murray博士创建。他买了几十个不同种类的橘子、柠檬和苹果，并...
用Python解决简单的水果分类问题(二)
uvwxyzhao的博客
07-06 4294
接着上一篇:用Python解决简单的水果分类问题(一)https://blog.csdn.net/uvwxyzhao/article/details/80924139继续:绘制KNN分类器的决策边界:这里封装一个方法:这里分别调参,看下效果:效果如下:训练集k=5的训练集k=1的训练集k=10的测试集k=5的最后看acc:效果如图:至此,这个水果分类的机器学习就搞定了......
用Python解决简单的水果分类问题(一)
热门推荐
uvwxyzhao的博客
07-05 1万+
译文地址:http://www.atyun.com/14092.html源码地址:https://github.com/susanli2016/Machine-Learning-with-Python/blob/master/Solving%20A%20Simple%20Classification%20Problem%20with%20Python.ipynb数据集:https://github...
水果（数据结构与算法）（python）
MengJing_的博客
12-29 1470
现在有水果，雪梨，苹果，红苹果、青苹果等几个类，水果有美容等功能，雪梨有除了美容的功能还有止咳的功能，苹果除了美容的功能，还有被当成礼品赠送的功能。红苹果的颜色是红色的，青苹果的颜色是青色的，并且青苹果虽然有苹果的功能，但是青苹果一般不用于当礼品。请根据上面的描述与自然界之间的具体关系，做以下事情。 （1）描述上述类之间的继承关系。 （2）通过Python代码模拟出上面的事物与案例...
阿里天池“水果店小系统”的python实现
qq_48637067的博客
11-01 1801
最近在阿里天池上面学习人工智能的课程，发现这个“水果店小系统”挺有趣的，实现难度也不大，就编写了代码，实现了它，顺便复习了一下python的基础语法。 class Fruit: #定义一个水果类，并封装 def __init__(self, fname, price, count, remark): #定义一个结构体 self.fname = fname self.price = price self.count = count
python面向对象之水果超市
weixin_48064384的博客
05-24 2945
目录项目要求分析问题，把概念模型转化为E-R图运行结果查询全部水果查询指定名称水果增加水果修改水果的数量删除水果按照价格排序添加水果的种类显示商品的品牌退出系统python源代码mysql源代码 项目要求 编写一个程序，实现以下功能： 水果超市 1.查询全部水果 2.查询指定名称的水果 3.增加水果 4.修改水果的数量 5.删除水果 6.按照价格排序 7.添加水果的种类 8.显示商品的品牌 0.退出系统 分析问题，把概念模型转化为E-R图 运行结果 查询全部水果 查询指定名称水果 增加水果 修改
简单题101. 对称二叉树 （python）20240922
最新发布
Sep21m_wyy的博客
09-22 384
【代码】简单题101. 对称二叉树 （python）20240922。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

theskylife

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值