【Python基础编程】多态、静态方法与类对象的核心概念

易辰君

已于 2024-10-14 22:36:46 修改

阅读量1.1k

点赞数 42

分类专栏： python核心编程文章标签： python 开发语言

于 2024-09-09 16:06:26 首次发布

本文链接：https://blog.csdn.net/2401_86688088/article/details/141864988

版权

python核心编程专栏收录该内容

14 篇文章 1 订阅

订阅专栏

前言

上篇文章主要介绍了python面向对象继承、重写和super等，接下来继续了解多态，静态方法以及类相关的知识点。

一、多态

多态是面向对象编程的一个核心概念，它指的是不同对象能够以相同的方式响应相同的方法调用。多态允许我们用统一的接口来处理不同类型的对象，从而提高代码的灵活性和可扩展性。

（一）多态的示例

多态意味着“多种形态”，它使得不同的对象可以用相同的方法名来处理不同的操作。关键点是不同的对象可以有不同的实现，但可以用相同的方法名来调用它们。

通过继承实现多态

假设有一个基类 Animal 和两个子类 Dog 和 Cat，它们都重写了 speak 方法：

class Animal:
    def speak(self):
        raise NotImplementedError("子类必须重写该方法")

class Dog(Animal):
    def speak(self):
        return "旺旺"

class Cat(Animal):
    def speak(self):
        return "喵喵"

# 函数接收 Animal 类型的对象并调用 speak 方法
def make_animal_speak(animal):
    print(animal.speak())

dog = Dog()
cat = Cat()

make_animal_speak(dog)  # 输出：旺旺
make_animal_speak(cat)  # 输出：喵喵

该示例中，Dog 和 Cat 类都实现了 speak 方法。虽然 make_animal_speak 函数只知道它接受的是一个 Animal 类型的对象，但它可以正确地调用 speak 方法并得到不同的结果，这就是多态的体现。

通过鸭子类型实现多态

Python 是一种动态类型语言，不强制要求对象遵循某种接口。只要一个对象实现了某个方法，我们就可以用这个方法来操作对象，这种特性被称为“鸭子类型”。

示例：

class Bird:
    def speak(self):
        return "啾啾"

def make_animal_speak(animal):
    print(animal.speak())

bird = Bird()
make_animal_speak(bird)  # 输出：啾啾

在这个示例中，Bird 类虽然不继承自 Animal，但它也实现了 speak 方法，因此可以被 make_animal_speak 函数接受和调用。这种灵活性是鸭子类型的特性。

（二）多态的优势

代码重用: 多态使得可以编写更通用的代码，从而减少重复代码。例如，make_animal_speak 函数可以处理任何实现了 speak 方法的对象，无论它们是什么类。
灵活性: 可以在不改变函数或方法的情况下，添加新的类和对象，只要这些类实现了相同的方法。
扩展性: 容易扩展系统。例如，添加新的动物类只需实现 speak 方法，而无需更改现有的处理代码。

（三）总结

多态是 Python 中的一个重要特性，它允许不同的对象使用相同的接口进行操作。通过继承和鸭子类型，Python 提供了灵活的方式来实现多态，从而提高代码的复用性和可扩展性。理解和使用多态可以帮助你编写更干净、可维护的代码，并且在处理复杂系统时能够更好地适应变化。

二、静态方法

静态方法是类中的一种方法，它不依赖于类的实例，也不依赖于类的状态。静态方法可以在不创建类实例的情况下调用。静态方法在 python 中通过 @staticmethod 装饰器来定义。

（一）定义

静态方法在类中定义时使用 @staticmethod 装饰器，它与类的状态无关，不会自动接收类实例或类本身作为参数。

示例：

class MyClass:
    @staticmethod
    def my_static_method(param1, param2):
        return f"参数的值是{param1}和{param2}"

# 调用静态方法
result = MyClass.my_static_method(1, 2)
print(result)  # 输出：参数的值是1和2

在这个示例中，my_static_method 是一个静态方法，它可以通过类名 MyClass 直接调用，而不需要创建类的实例。

（二）特点

不访问实例属性或方法: 静态方法不能访问实例属性或类属性，因为它不与任何特定的实例或类关联。
适用于工具函数: 静态方法通常用于实现不依赖于类状态的功能，比如辅助函数或工具函数。
可以通过实例调用: 虽然静态方法可以通过实例调用，但这并不是推荐的做法，因为静态方法与实例的状态无关。

（三）总结

静态方法在 Python 中是一个方便的工具，用于定义那些不依赖于实例或类状态的方法。它们通过 @staticmethod 装饰器来定义，适用于各种工具函数和与类或实例状态无关的功能。静态方法可以通过类名直接调用，也可以通过实例调用，但通常推荐通过类名进行调用以保持代码的清晰性。

三、类属性

类属性是直接定义在类中的变量，而不是定义在类的实例方法中。类属性对于类的所有实例都是共享的，这意味着如果你修改了类属性的值，所有实例都会看到这个修改。

（一）定义

类属性是在类的定义体中，通常直接在类的顶部定义的变量。与实例属性不同，它们不依赖于某个特定的实例。

示例：

class MyClass:
    class_attribute = "我是一个类属性"

# 访问类属性
print(MyClass.class_attribute)  # 输出：我是一个类属性

# 创建实例
obj1 = MyClass()
obj2 = MyClass()

# 通过实例访问类属性
print(obj1.class_attribute)  # 输出：我是一个类属性
print(obj2.class_attribute)  # 输出：我是一个类属性

在这个示例中，class_attribute 是一个类属性，它可以通过类本身MyClass.class_attribute或通过类的实例obj1.class_attribute、obj2.class_attribute来访问。

（二）类属性和实例属性的区别

类属性: 由类本身共享，对于所有实例都是相同的。如果修改了类属性，所有实例都能看到这个变化。
实例属性: 由每个实例独有，实例属性的值只影响特定实例。

示例：

class MyClass:
    class_attribute = "我是类属性"

    def __init__(self, value):
        self.instance_attribute = value  # 实例属性

# 创建实例
obj1 = MyClass("我是实例属性1")
obj2 = MyClass("我是实例属性2")

# 访问类属性
print(obj1.class_attribute)  # 输出：我是类属性
print(obj2.class_attribute)  # 输出：我是类属性

# 访问实例属性
print(obj1.instance_attribute)  # 输出：我是实例属性1
print(obj2.instance_attribute)  # 输出：我是实例属性2

# 修改类属性
MyClass.class_attribute = "修改类属性"

# 所有实例都会看到修改后的类属性
print(obj1.class_attribute)  # 输出：修改类属性
print(obj2.class_attribute)  # 输出：修改类属性

（三）使用场景

类属性适用于以下场景：

共享状态: 当你希望所有实例共享某个属性的值时，可以使用类属性。
常量定义: 类属性常被用于定义类级别的常量或默认值。
计数器: 类属性可以用于跟踪类的所有实例的某种共享状态，例如计数器，用于记录创建了多少个实例。

（四）总结

类属性是 Python 中非常有用的工具，可以用于定义在所有实例之间共享的变量。它们与实例属性不同，不依赖于特定的实例，并且通常用于定义类级别的常量、共享状态或作为计数器。理解类属性与实例属性的区别有助于更好地设计和组织你的 Python 类。

四、类方法

类方法是一种特殊的方法，它与类本身相关联，而不是与类的实例关联。类方法使用 @classmethod 装饰器来定义，并且其第一个参数通常被命名为 cls，以表示它是类本身，而不是类的实例。

（一）类方法的特点

关联类：类方法可以访问类的属性和其他类方法，但无法直接访问实例属性。
共享数据：类方法可以用于在类级别共享数据，适合于那些需要在类和所有实例之间共享的变量。
多态性：类方法可以在子类中被继承和重写，使得它们适用于不同的子类。

（二）定义类方法

要定义一个类方法，你需要使用 @classmethod 装饰器，然后将第一个参数设置为 cls。

class MyClass:
    class_variable = "这是一个类变量"

    def __init__(self, value):
        self.instance_variable = value

    @classmethod
    def class_method(cls):
        return f"这是类方法，类变量是: {cls.class_variable}"

# 调用类方法
print(MyClass.class_method())

（三）使用场景

工厂方法：类方法常用于工厂模式中，用于创建类的不同实例。例如，根据不同的输入参数创建不同类型的实例。
访问或修改类变量：如果你需要在多个实例之间共享数据，可以使用类方法来访问或修改类变量。
子类行为控制：类方法可以被子类重写，从而改变其行为。

示例：

class Circle:
    pi = 3.14

    def __init__(self, radius):
        self.radius = radius

    @classmethod
    def from_diameter(cls, diameter):
        radius = diameter / 2
        return cls(radius)

# 使用类方法创建一个Circle实例
circle = Circle.from_diameter(10)
print(f"Radius: {circle.radius}")  # 输出：Radius: 5.0

该示例中，from_diameter 是一个类方法，它通过给定的直径来创建 Circle 类的实例。

（四）总结

类方法提供了一种通过类本身而非实例来操作和访问类的功能的方式。它们非常适合那些不依赖于实例状态的方法，尤其是在需要共享数据或行为的情况下。

五、类对象

类对象指的是通过定义一个类所创建的对象。类对象不仅包含类的属性和方法，还可以用于实例化类，从而创建类的实例。理解类对象的概念对于掌握面向对象编程非常重要。

当你定义一个类时，Python会自动创建一个类对象。这个类对象可以用来访问类的属性、方法以及创建类的实例。换句话说，类本身也是一个对象，它属于 type 类。

（一）创建类对象

定义一个类就会创建一个类对象。示例如下：

class MyClass:
    class_variable = "这是一个类变量"

    def class_method(self):
        return "这是一个类方法"

# MyClass 就是一个类对象

在上面的代码中，MyClass 是一个类对象。你可以通过它来访问类属性和方法，或者创建实例：

# 访问类属性
print(MyClass.class_variable)  # 输出：这是一个类变量

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

# 调用实例方法
print(my_instance.class_method())  # 输出：这是一个类方法

（二）类对象的特性

类的定义：类对象是通过 class 语句定义的，它包含了类的所有属性和方法。
属性访问：可以通过类对象直接访问类属性，但不能直接访问实例属性。实例属性只能通过实例对象来访问。
方法调用：类对象可以用于调用类方法和静态方法（使用 @classmethod 或 @staticmethod 装饰），但通常实例方法是通过实例对象调用的。

（三）类对象的使用

类对象在Python中有广泛的应用，主要包括实例化类，访问类级别的属性、调用类方法和静态方法和动态修改类属性和方法，详细如下：

（1）实例化类：通过类对象来创建类的实例。

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

# 创建实例
my_dog = Dog("Buddy")

（2）访问类级别的属性：类对象可以用来访问类级别的属性（类变量）。

class Car:
    wheels = 4

# 通过类对象访问类变量
print(Car.wheels)  # 输出：4

（3）调用类方法和静态方法：可以通过类对象来调用类方法和静态方法。

class Math:
    @staticmethod
    def add(a, b):
        return a + b

# 调用静态方法
print(Math.add(3, 4))  # 输出：7

（4）动态修改类属性和方法：类对象可以用于在运行时动态修改类的属性和方法。

class Person:
    name = "杰克"

# 动态修改类属性
Person.name = "李四"
print(Person.name)  # 输出：李四

（四）类对象和实例对象的区别

类对象：代表类本身，可以用来创建实例、访问类级别的属性和方法。
实例对象：是类的具体实现，包含类对象的属性和方法，还可以有自己的实例属性。

示例：

class Rectangle:
    default_color = "blue"  # 类变量

    def __init__(self, width, height):
        self.width = width  # 实例变量
        self.height = height  # 实例变量

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

# 通过类对象访问类变量
print(Rectangle.default_color)  # 输出：blue

# 创建类的实例
rect = Rectangle(10, 5)

# 通过实例对象访问实例变量
print(rect.area())  # 输出：50