[Python]一、Python基础编程（3）

news2024/9/22 5:34:02

F:\BaiduNetdiskDownload\2023人工智能开发学习路线图\1、人工智能开发入门\1、零基础Python编程

1. 面向对象-其他

1.1 面向对象三大特征

封装

        将属性和⽅法书写到类的⾥⾯的操作即为封装

        封装可以为属性和⽅法添加私有权限

继承

        ⼦类默认继承⽗类的所有属性和⽅法

        ⼦类可以重写⽗类属性和⽅法

多态

        传⼊不同的对象，产⽣不同的结果

面向对象编程（OOP）的三大特征是封装、继承和多态。以下是对这三大特征的详细说明：

1. 封装（Encapsulation）

定义：
封装是将数据和操作数据的方法结合在一起，形成一个独立的对象。通过封装，内部实现细节可以隐藏，外部只能通过公开的方法访问和修改对象的状态。

优点：

数据保护：可以防止外部直接访问和修改对象的内部状态。

接口简化：通过提供公共方法，简化了与对象的交互。

维护性：更改内部实现时，不会影响外部代码，只需确保公开的方法保持不变。

示例：

python

复制
class BankAccount:
    def __init__(self, balance=0):
        self.__balance = balance  # 私有属性

    def deposit(self, amount):
        if amount > 0:
            self.__balance += amount

    def withdraw(self, amount):
        if 0 < amount <= self.__balance:
            self.__balance -= amount

    def get_balance(self):
        return self.__balance  # 公开方法访问私有属性

account = BankAccount()
account.deposit(100)
print(account.get_balance())  # 输出: 100
2. 继承（Inheritance）

定义：
继承是指一个类（子类）可以继承另一个类（父类）的属性和方法。通过继承，可以实现代码的重用和扩展。

优点：

代码重用：避免重复编写相同的代码。

扩展性：可以在子类中扩展或修改父类的功能。

层次结构：形成清晰的类层次结构，便于管理和维护。

示例：

python

复制
class Animal:
    def speak(self):
        return "Animal sound"

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

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

dog = Dog()
cat = Cat()
print(dog.speak())  # 输出: Bark
print(cat.speak())  # 输出: Meow
3. 多态（Polymorphism）

定义：
多态是指不同类的对象可以通过相同的接口（方法）进行操作。具体执行的操作取决于对象的实际类型，而不是引用的类型。

优点：

灵活性：可以用相同的方式处理不同类型的对象。

可扩展性：可以很容易地添加新类型而不影响现有代码。

示例：

python

复制
def animal_sound(animal):
    print(animal.speak())

animal_sound(Dog())  # 输出: Bark
animal_sound(Cat())  # 输出: Meow
总结

封装：保护对象的内部状态，通过公共方法进行交互。

继承：允许子类继承和扩展父类的功能，促进代码重用。

多态：通过相同的接口处理不同类型的对象，提高代码的灵活性和可扩展性。

这三大特征共同构成了面向对象编程的基础，使得软件设计更加模块化、可维护和易于扩展。

1.2 多态

多态指的是⼀类事物有多种形态，（⼀个抽象类有多个⼦类，因⽽多态的概念依赖于继承）。

        定义：多态是⼀种使⽤对象的⽅式，⼦类重写⽗类⽅法，调⽤不同⼦类对象的相同⽗类⽅法，可以产⽣不同的执⾏结果

        好处：调⽤灵活，有了多态，更容易编写出通⽤的代码，做出通⽤的编程，以适应需求的不断变化！

        实现步骤：

                定义⽗类，并提供公共⽅法

                定义⼦类，并重写⽗类⽅法

                传递⼦类对象给调⽤者，可以看到不同⼦类执⾏效果不同

举例说明Python中多态的定义，好处和实现步骤

多态是面向对象编程中的一个重要特性，它允许不同类的对象通过相同的接口进行操作。下面是关于多态在 Python 中的定义、好处和实现步骤的详细说明。

多态的定义

在 Python 中，多态指的是不同类的实例可以使用相同的方法名，但实现的方式可以不同。通过这种方式，程序可以更灵活地处理不同类型的对象。

多态的好处

灵活性：

可以使用相同的接口处理不同类型的对象，增强了代码的灵活性。

可扩展性：

新的类可以很容易地被添加到系统中，而不需要更改现有代码。

提高可读性：

代码更具可读性，因为它使用统一的接口来处理不同的对象。

实现步骤

定义一个父类：

创建一个父类，定义一个方法（接口），这个方法会在子类中被重写。

定义子类：

创建一个或多个子类，重写父类的方法以实现不同的行为。

使用多态：

创建子类的实例，并通过父类的引用调用重写的方法。

示例

以下是一个具体的示例，展示了如何在 Python 中实现多态。

1. 定义一个父类

python

复制
class Animal:
    def speak(self):
        raise NotImplementedError("子类必须实现这个方法")
2. 定义子类

python

复制
class Dog(Animal):
    def speak(self):
        return "Bark"

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

class Cow(Animal):
    def speak(self):
        return "Moo"
3. 使用多态

python

复制
def animal_sound(animal):
    print(animal.speak())

# 创建对象
dog = Dog()
cat = Cat()
cow = Cow()

# 使用多态
animal_sound(dog)  # 输出: Bark
animal_sound(cat)  # 输出: Meow
animal_sound(cow)  # 输出: Moo
总结

多态的定义：不同类的对象可以通过相同的方法名进行操作，具体执行的行为取决于对象的实际类型。

好处：提供灵活性、可扩展性和提高代码可读性。

实现步骤：

定义一个父类并声明方法。

创建子类并重写父类的方法。

使用父类的引用调用子类的方法。

通过这种方式，多态使得代码更加灵活且易于扩展，适应不同的需求。

如何在实际项目中应用多态？

多态在实际项目中的应用非常广泛，特别是在设计灵活和可扩展的系统时。以下是一些常见的多态应用场景，以及相关示例。

1. 图形绘制应用

在图形绘制应用中，可以使用多态来处理不同类型的形状（如圆形、矩形等），而不需要知道具体的形状类型。

示例

python

复制
class Shape:
    def draw(self):
        raise NotImplementedError("子类必须实现这个方法")

class Circle(Shape):
    def draw(self):
        return "Drawing a Circle"

class Rectangle(Shape):
    def draw(self):
        return "Drawing a Rectangle"

class Triang