Python 基础面向对象编程魔法方法和运算符重载高级特性

最新推荐文章于 2024-08-14 12:00:04 发布

Back to the original

最新推荐文章于 2024-08-14 12:00:04 发布

阅读量51

点赞数 1

分类专栏： python django 开发文章标签： python 开发语言

本文链接：https://blog.csdn.net/qq_45150540/article/details/134257875

版权

python django 开发专栏收录该内容

3 篇文章 0 订阅

订阅专栏

Python面向对象编程

通过使用类、对象、继承、多态、封装、属性和方法以及魔法方法和运算符重载，可以创建可重用、可扩展和维护性高的代码结构。

1.类和对象

类（Class）：类是创建对象的模板，定义了对象的属性和方法。类本身是一种类型，可以创建多个对象。
对象（Object）：对象是类的实例。每个对象都继承了类的属性和方法。
以下是Python代码示例，演示了类和对象的概念：

#-------------------------------------------------------类（Class）
# 定义一个Person类
class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age
    
    def say_hello(self):
        print(f"Hello, my name is {self.name} and I am {self.age} years old.")

#-------------------------------------------------------对象（Object）
# 创建一个Person对象
p1 = Person("Alice", 25)

# 调用对象的say_hello方法
p1.say_hello()

# 创建一个新的Person对象
p2 = Person("Bob", 30)

# 调用对象的say_hello方法
p2.say_hello()

输出结果：

Hello, my name is Alice and I am 25 years old.
Hello, my name is Bob and I am 30 years old.

2.继承和多态

继承（Inheritance）：继承是面向对象编程中的一个重要概念。它允许一个类继承另一个类的属性和方法。通过继承，可以创建更特定的子类，同时保留父类的功能。
多态（Polymorphism）：多态是指一个接口或者父类引用可以指向多种实际类型，且可以根据实际类型来调用被重载的方法。多态的存在大大提高了程序的复用性和可维护性。

#-------------------------------------------------------继承（Inheritance）
class Student(Person):  # 继承自Person类
    def study(self):
        print("I am studying.")

class Worker(Person):  # 继承自Person类
    def work(self):
        print("I am working.")


#-------------------------------------------------------多态（Polymorphism）
# 创建一个Person对象
p1 = Person("Alice", 25)
p1.say_hello()  # 输出：Hello, my name is Alice and I am 25 years old.

# 创建一个Student对象，继承自Person类
s1 = Student("Bob", 20)
s1.say_hello()  # 输出：Hello, my name is Bob and I am 20 years old.
s1.study()  # 输出：I am studying.

# 创建一个Worker对象，继承自Person类
w1 = Worker("Charlie", 30)
w1.say_hello()  # 输出：Hello, my name is Charlie and I am 30 years old.
w1.work()  # 输出：I am working.

Student 和 Worker 类继承了 Person 类，同时添加了各自特有的方法。这就是继承的作用。然后我们创建了 Student 和 Worker 的实例，并调用了它们的方法。这就是多态的作用，即一个基类的引用可以指向多种实际类型的对象。

3.封装（属性和方法）

封装（Encapsulation）是指隐藏对象的属性和实现细节，只暴露必要的接口。通过封装，可以保护对象的状态，同时控制对它的访问。

类方法和实例方法

类方法（Class Method）：类方法是与类关联的方法，可以通过类名直接调用。它需要使用装饰器@classmethod来定义。
实例方法（Instance Method）：实例方法是与对象实例关联的方法，只能通过对象实例调用。它需要使用装饰器@staticmethod来定义。
你已经正确地定义了一个Person类，并实现了一个实例方法say_hello。在这个基础上，我们可以很容易地加入封装和对类方法、实例方法的实现。

首先，让我们通过添加私有属性（以双下划线开头）来实现封装。私有属性只能在类的内部访问，这可以保护对象的状态。接着，我们将创建一个类方法和一个实例方法。

下面是一个例子：

    
    # 类方法
    @classmethod
    def get_name(cls):
        return cls.__name  # 可以访问name属性

    # 实例方法
    def get_age(self):
        return self.__age  # 可以访问age属性

    def say_hello(self):
        print(f"Hello, my name is {self.__name} and I am {self.__age} years old.")  在代码中加入封装（Encapsulation）是指隐藏对象的属性和实现细节，只暴露必要的接口。通过封装，可以保护对象的状态，同时控制对它的访问。

5.魔法方法和运算符重载

魔法方法（Magic Methods）：魔法方法是一些特殊的方法，以双下划线开头和结尾，如__init__()、__str__()等。它们提供了一种方式让开发者在特定情况下自定义对象的行为。比如在__init__()方法中，可以定义对象的初始化操作；在__str__()方法中，可以定义对象的字符串表示形式。
运算符重载（Operator Overloading）：运算符重载是指定义类中特定运算符的行为。通过定义相应的方法，可以改变运算符的行为。例如，可以通过定义__add__()方法来自定义两个对象之间的加法运算。

魔法方法：

自定义对象的行为。以双下划线开头和结尾的，例如 __init__()、__str__()、__len__() 等等。这些方法提供了一种方式让开发者在调用对象或对对象进行特定操作时，可以定义自己的行为。

__init__() 是一个类的构造器，当创建类的新实例时，会自动调用这个方法。我们可以在这个方法中定义对象的初始化操作。

class MyClass:
    def __init__(self, value):
        self.value = value
        print("Object is being initialized")

obj = MyClass(10)  # 输出："Object is being initialized"

__str__() 是一个可以定义对象的字符串表示的方法。如果我们创建一个类，并希望当我们尝试将其打印出来时，能显示一些自定义信息，就可以在这个方法中定义。

class MyClass:
    def __init__(self, value):
        self.value = value

    def __str__(self):
        return f"MyClass instance with value: {self.value}"

obj = MyClass(10)
print(obj)  # 输出："MyClass instance with value: 10"

其他的魔法方法还包括 __repr__()、__len__()、__getitem__() 等等，通过使用它们，可以定义对象在各种情况下的行为。

运算符重载：

运算符重载使得我们可以在类中定义特定运算符的行为。例如，我们可以在一个类中定义 __add__() 方法来自定义两个对象之间的加法运算。

class MyClass:
    def __init__(self, value):
        self.value = value

    def __add__(self, other):
        return MyClass(self.value + other.value)  # 假设其他也是一个 MyClass 实例

obj1 = MyClass(10)
obj2 = MyClass(20)
obj3 = obj1 + obj2  # 假设这里的加法是我们自定义的加法行为
print(obj3.value)  # 输出：30，因为我们自定义了加法行为使得 obj1 的值加上 obj2 的值得到一个新的 MyClass 实例 obj3，其值为30。

6.Python高级特性

1. 生成器

生成器是Python中的一个高级特性，它允许你创建一个可以生成值的迭代器，而不是一次性计算所有值。这样可以在需要时才生成值，从而节省内存空间。

生成器示例代码：

def simple_generator():
    yield 1
    yield 2
    yield 3

# 创建一个生成器对象
gen = simple_generator()

# 使用next()函数获取生成器的下一个值
print(next(gen))  # 输出：1
print(next(gen))  # 输出：2
print(next(gen))  # 输出：3

# 使用for循环迭代生成器
for value in gen:
    print(value)  # 输出：1 2 3

定义了一个名为simple_generator的生成器函数，它使用yield语句返回一系列值。然后我们创建了一个生成器对象，并使用next()函数获取每个值。当我们尝试获取更多的值时，会抛出StopIteration异常，表示生成器已经没有更多的值可以生成。
使用for循环来迭代gen这个生成器对象，它会依次输出每个值，直到抛出StopIteration异常表示没有更多的值可以生成。

Python中的迭代器（Iterator）和协程（Coroutine）是两个重要的概念，它们都是Python语言的高级特性。

2. 迭代器（Iterator）

迭代器是一种设计模式，它允许你通过调用next()方法来逐个访问聚合对象中的每个元素。在Python中，你可以通过实现__iter__()和__next__()方法来创建一个迭代器类。

下面是一个简单的迭代器示例代码：

class MyIterator:
    def __init__(self, start, end):
        self.current = start
        self.end = end

    def __iter__(self):
        return self

    def __next__(self):
        if self.current >= self.end:
            raise StopIteration
        result = self.current
        self.current += 1
        return result

迭代器类接受起始和结束参数，并在每次调用next()方法时返回下一个值。当没有更多的值时，它会抛出StopIteration异常。
也可以使用for循环来使用这个迭代器：

my_iterator = MyIterator(0, 3)
for value in my_iterator:
    print(value)  # 输出：0 1 2

3. 协程（Coroutine）

协程是一种轻量级的线程，它可以在执行过程中挂起，并在以后的某个时间点继续执行。协程是通过使用async和await关键字来实现的。

协程示例代码：

async def my_coroutine():
    print('Start')
    await asyncio.sleep(1)  # 挂起1秒钟
    print('End')

这个协程函数在开始时会打印"Start"，然后挂起1秒钟，最后打印"End"。我们可以使用asyncio库来运行这个协程：

import asyncio

my_coroutine = my_coroutine()
asyncio.run(my_coroutine)  # 输出：Start 1秒钟后输出：End

使用了asyncio库中的run()函数来运行my_coroutine协程。这个函数会创建事件循环并运行协程，直到协程完成。

4.装饰器

允许你在不改变原有函数或方法的情况下，对其功能进行增强或修改。装饰器本质上是一个接受函数对象作为参数的可调用对象，并返回一个新的函数对象。它可以让我们在函数执行前后添加额外的逻辑，或者对函数进行更复杂的修改。

Python装饰器示例：

def my_decorator(func):
    def wrapper():
        print("Before the function is called.")
        func()
        print("After the function is called.")
    return wrapper

@my_decorator
def say_hello():
    print("Hello!")

say_hello()

输出结果为：

Before the function is called.
Hello!
After the function is called.

定义了一个名为my_decorator的装饰器函数，它接受一个函数对象作为参数，并返回一个新的函数对象wrapper。wrapper函数在执行被装饰的函数之前和之后打印一些额外的信息。然后我们使用@my_decorator语法糖将say_hello函数装饰起来。最后调用say_hello函数时，实际上执行的是wrapper函数。

Python装饰器可以用于各种场景，比如日志记录、性能测试、事务处理等。通过使用装饰器，我们可以很方便地对函数或方法进行增强，而不需要修改其原始代码。

5. 上下文管理器

在Python中，上下文管理器（Context Manager）是利用上下文管理器协议来实现的一种高级特性。它主要用于对资源的访问和清理，以确保在程序执行过程中，资源能够被正确地管理和释放。

上下文管理器的实现主要涉及到两个方法：__enter__()和__exit__()。当使用with语句进入上下文时，__enter__()方法会被调用，而在离开上下文时，__exit__()方法会被调用。这两个方法都接受一个参数，即上下文管理器对象本身（通常使用self表示）。

下面是一个简单的上下文管理器示例：

class MyContext:
    def __enter__(self):
        print("Entering the context")
        return self

    def __exit__(self, exc_type, exc_val, exc_tb):
        print("Exiting the context")

with MyContext() as x:
    print("Inside the context")

输出结果为：

Entering the context
Inside the context
Exiting the context

定义了一个名为MyContext的上下文管理器类。在进入上下文时，__enter__()方法会打印"Entering the context"并返回上下文管理器对象本身。在进入上下文后，我们可以使用as关键字将返回的值赋给一个变量（本例中为x），这个变量可以在上下文中使用。当离开上下文时，__exit__()方法会打印"Exiting the context"。

使用上下文管理器的主要优势在于它能够自动管理资源，无论在程序执行过程中是否发生异常，资源都会被正确地释放。这有助于避免因资源泄漏而导致的问题。

6.描述符

定义一个描述符（Descriptor）和一个使用该描述符的类（MyClass）。描述符被用来拦截对属性（attr）的访问，并在访问时打印消息。然而，这段代码存在一些问题：

代码：

class Descriptor:  
    def __get__(self, instance, owner):  
        print("Getting value")  
        return instance._value  
  
    def __set__(self, instance, value):  
        print("Setting value")  
        instance._value = value  
     def __delete__(self, instance):  
        print("Deleting value")

class MyClass:  
    def __init__(self, value):  
        self._value = value  
        self.attr = Descriptor()()  # 创建 Descriptor 的实例

访问 attr 属性时，会触发 Descriptor 的方法：

my_instance = MyClass(5)
print(my_instance.attr)  # "Getting value" and prints: 5 Descriptor 的 __get__ 方法
my_instance.attr = 10  # "Setting value"  触发 Descriptor 的 __set__ 方法
print(my_instance.attr)  # "Getting value" and prints: 10
del my_instance.attr  # "Deleting value"  Descriptor 的 __delete__ 方法

定义了一个名为Descriptor的描述符类，它具有__get__()和__set__()和 delete()方法。这些方法分别在读取和设置属性时被调用，并输出一些消息。然后，我们定义了一个名为MyClass的类，它具有一个名为_value的属性，并使用Descriptor类来创建一个名为attr的属性。当我们访问attr属性时，会调用Descriptor.get()方法，并输出"Getting value"消息。当我们设置attr属性时，会调用Descriptor.set()方法，并输出"Setting value"消息。

7.动态类型和鸭子类型

动态类型（Dynamic Typing）:

在 Python 中，不需要预先声明变量的类型。变量的类型会根据赋给它的值自动推断。这就是动态类型的特性。

# 动态类型示例
x = 5  # x 是一个整数
y = "Hello"  # y 是一个字符串
z = 3.14  # z 是一个浮点数

鸭子类型（Duck Typing）:

鸭子类型强调的是对象的行为，而不是它的类型。在 Python 中，可以通过定义方法来模拟其他对象的行为，而无需关心它们的实际类型。

# 鸭子类型示例
class Duck:
    def quack(self):
        print("Quack!")

class Person:
    def quack(self):
        print("Hello!")

def quack(duck):
    duck.quack()

person = Person()
duck = Duck()
quack(person)  # 输出 "Hello!"
quack(duck)    # 输出 "Quack!"