python基础到进阶（二）--面向对象编程

最新推荐文章于 2024-06-13 23:55:30 发布

七罪_暴食

最新推荐文章于 2024-06-13 23:55:30 发布

阅读量807

点赞数 26

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

本文链接：https://blog.csdn.net/qq_40155994/article/details/137540760

版权

python 专栏收录该内容

6 篇文章 0 订阅

订阅专栏

面向对象编程（Object-Oriented Programming，OOP）是一种编程范式，通过将数据和操作封装在对象中，以模拟现实世界中的对象和其相互作用。Python 是一种支持面向对象编程的高级编程语言，下面是关于 Python 面向对象编程的讲解：

类和对象：

类（Class）： 类是一种用户自定义的数据类型，用于描述具有相似属性和方法的对象的集合。类可以看作是创建对象的模板，定义了对象共同的属性和行为。
对象（Object）： 对象是类的实例，它是具体的数据实体，具有类所定义的属性和方法。

封装：

封装（Encapsulation）： 封装是一种将数据和操作封装在类中的概念。通过封装，类将数据和操作绑定在一起，用户只能通过类的公共方法来访问数据，从而隐藏了对象的内部实现细节。

继承：

继承（Inheritance）： 继承是一种在已有类的基础上创建新类的机制。子类（派生类）可以继承父类（基类）的属性和方法，并且可以添加新的属性和方法，以及修改或覆盖父类的方法。

多态：

多态（Polymorphism）： 多态是指同一个方法调用在不同的对象上可以产生不同的行为。在 Python 中，多态性表现为不同对象对相同方法的调用可能会产生不同的结果，这取决于对象自身的类型和实现方式。

类的定义：

在 Python 中，使用 class 关键字定义类。类的定义包括类名、类的属性和方法等。

class MyClass:
    # 属性
    class_variable = "This is a class variable"

    # 构造方法
    def __init__(self, value):
        self.instance_variable = value

    # 方法
    def instance_method(self):
        return "This is an instance method"

    @classmethod
    def class_method(cls):
        return "This is a class method"

    @staticmethod
    def static_method():
        return "This is a static method"

类的实例化：

使用类名加括号即可创建对象的实例。

obj = MyClass(10)

访问属性和调用方法：

通过点号（.）运算符访问对象的属性和调用对象的方法。

print(obj.instance_variable)   # 输出对象的属性
print(obj.instance_method())   # 调用对象的方法

封装

封装（Encapsulation）是面向对象编程中的一个重要概念，它指的是将数据和方法封装在类中，并通过访问控制来限制对数据的直接访问，从而实现了数据的安全性和代码的可维护性。下面详细讲解Python中的封装：

封装的目的：

数据隐藏： 封装可以将对象的数据隐藏起来，只允许通过类的方法来访问和修改数据，防止直接对数据进行非法操作。
实现接口： 封装通过暴露类的公共方法作为对象的接口，隐藏了内部实现细节，使得类的使用者只需要关注如何使用接口而不必了解具体实现。
提高可维护性： 封装将数据和方法组织在一起，使得代码更加模块化和易于维护，降低了代码的耦合度。

封装的实现方式：

访问控制： 在Python中，通过属性和方法的访问控制来实现封装。
- 公共属性和方法： 使用 self 关键字定义的属性和方法默认是公共的，可以被类的外部访问。
- 私有属性和方法： 在属性或方法的名字前加上双下划线 __ 可以将其定义为私有的，外部无法直接访问。

class MyClass:
    def __init__(self, value):
        self.__private_var = value  # 私有属性

    def public_method(self):
        return self.__private_var * 2

obj = MyClass(10)
print(obj.public_method())  # 输出：20
print(obj.__private_var)    # 错误：AttributeError，私有属性无法直接访问

属性装饰器： 使用属性装饰器 @property、@property.setter 和 @property.deleter 可以定义属性的访问器、修改器和删除器，进一步控制属性的访问和修改。

class MyClass:
    def __init__(self):
        self.__private_var = 0  # 私有属性

    @property
    def private_var(self):
        return self.__private_var

    @private_var.setter
    def private_var(self, value):
        if value >= 0:
            self.__private_var = value

obj = MyClass()
print(obj.private_var)      # 输出：0
obj.private_var = 20        # 设置私有属性值
print(obj.private_var)      # 输出：20
obj.private_var = -10       # 错误：属性设置失败，不能小于0

私有方法： 与私有属性类似，可以将方法定义为私有的，外部无法直接调用。

class MyClass:
    def __private_method(self):
        return "This is a private method"

    def public_method(self):
        result = self.__private_method()  # 内部调用私有方法
        return result

obj = MyClass()
print(obj.public_method())  # 输出：This is a private method
print(obj.__private_method())  # 错误：AttributeError，私有方法无法直接调用

继承

继承的基本概念：

父类（基类）和子类（派生类）： 在继承关系中，父类是被继承的类，子类是基于父类定义的新类。
继承的语法： 在 Python 中，使用子类的定义中的括号里指定父类名来实现继承。

class ParentClass:
    # 父类的属性和方法

class ChildClass(ParentClass):
    # 子类的属性和方法

继承的特性：

代码重用： 继承允许子类重用父类的属性和方法，避免了代码的重复编写。
拓展功能： 子类可以在继承父类的基础上，添加新的属性和方法，以实现更多的功能。
覆盖方法： 子类可以重写（覆盖）父类的方法，以适应自身的需求。

示例：

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

    def speak(self):
        return "Animal speaks"

class Dog(Animal):  # Dog 类继承自 Animal 类
    def speak(self):  # 覆盖父类的 speak 方法
        return "Dog barks"

class Cat(Animal):  # Cat 类继承自 Animal 类
    def speak(self):  # 覆盖父类的 speak 方法
        return "Cat meows"

# 使用示例
dog = Dog("Buddy")
cat = Cat("Whiskers")

print(dog.name)       # 输出：Buddy
print(dog.speak())    # 输出：Dog barks
print(cat.name)       # 输出：Whiskers
print(cat.speak())    # 输出：Cat meows

方法重载：

在 Python 中，方法重载并不是一个强制性的概念，因为 Python 支持动态类型和多态性。在实践中，如果子类需要不同于父类的方法实现，可以直接覆盖父类的方法。

方法重载的实现方式：

参数的默认值： 在方法定义时，通过给参数设置默认值，可以实现方法的重载。

class MyClass:
    def my_method(self, x=0, y=0):
        return x + y

obj = MyClass()
print(obj.my_method())      # 输出：0，使用默认参数
print(obj.my_method(1))     # 输出：1，只传递了一个参数
print(obj.my_method(1, 2))  # 输出：3，传递了两个参数

可变参数： 使用可变参数（*args 或 **kwargs）也可以实现方法的重载，因为可变参数可以接受不定数量的参数。

class MyClass:
    def my_method(self, *args):
        return sum(args)

obj = MyClass()
print(obj.my_method())          # 输出：0，没有传递参数
print(obj.my_method(1))         # 输出：1，传递了一个参数
print(obj.my_method(1, 2, 3))   # 输出：6，传递了多个参数

关键字参数： 使用关键字参数也可以实现方法的重载，因为关键字参数允许传递任意数量的参数，并且可以指定参数名。

class MyClass:
    def my_method(self, **kwargs):
        if 'x' in kwargs and 'y' in kwargs:
            return kwargs['x'] + kwargs['y']
        else:
            return 0

obj = MyClass()
print(obj.my_method())          # 输出：0，没有传递参数
print(obj.my_method(x=1))       # 输出：1，只传递了一个参数
print(obj.my_method(x=1, y=2))  # 输出：3，传递了两个参数

方法重载的优势：

灵活性： 方法重载使得方法可以根据不同的参数调用不同的实现，从而增强了方法的灵活性。
简洁性： 使用方法重载可以避免在类中定义多个同名方法，使得代码更加简洁易懂。
可读性： 方法重载使得代码的调用方式更加统一和直观，提高了代码的可读性和可维护性。

super() 函数：

super() 函数用于调用父类的方法，可以在子类中调用父类的构造函数或其他方法。

class ChildClass(ParentClass):
    def __init__(self, value):
        super().__init__(value)  # 调用父类的构造函数

通过继承，Python 提供了一种有效的方式来组织和扩展代码，使得代码更加模块化、可维护和可扩展。

多态

多态的基本概念：

多态性： 多态性指的是同一类的不同对象对同一消息做出不同的响应。
动态类型： 在 Python 中，对象的类型是在运行时确定的，因此可以根据对象的实际类型来调用相应的方法。
动态绑定： 方法调用是动态绑定的，即在运行时确定调用哪个方法，而不是在编译时确定。

示例：

class Animal:
    def speak(self):
        raise NotImplementedError("Subclass must implement abstract method")

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

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

# 多态性的体现
def animal_speak(animal):
    return animal.speak()

# 使用示例
dog = Dog()
cat = Cat()

print(animal_speak(dog))  # 输出：Dog barks
print(animal_speak(cat))  # 输出：Cat meows