2.2 python基础知识复习——python面向对象的原理和代码详解

面向对象编程是程序设计的一种范式，旨在通过封装、继承和多态等机制来组织和管理代码。Python 是一种支持面向对象编程的语言。下面是面向对象编程的基本原理以及代码示例。

面向对象编程的基本原理

1. 类和对象：

   • 类（Class）：是一种自定义的数据类型，用于描述具有相同特征和行为的对象的集合。它定义了对象的属性（数据）和方法（操作）。
   • 对象（Object）：是类的实例。对象是实际存在的，通过类创建的。

2. 封装（Encapsulation）：

   • 将数据和操作数据的方法封装在一个类中。封装有助于隐藏对象的内部实现细节，并只暴露必要的接口。

3. 继承（Inheritance）：

   • 允许新创建的类（子类）继承现有类（父类）的属性和方法。继承有助于代码的重用。

4. 多态（Polymorphism）：

   • 不同的类可以实现相同的方法名，但具体的实现可以不同。这使得程序可以以相同的方式处理不同的对象。

5. 抽象（Abstraction）：

   • 抽象是将复杂的实现隐藏在简单的接口背后，只暴露必要的信息。Python 中的抽象可以通过定义抽象基类（ABC）来实现。

class Animal:
    # 类的构造函数
    def __init__(self, name, age):
        self.name = name
        self.age = age
    # 类的方法
    def speak(self):
        raise NotImplementedError("Subclasses must implement this method")
    def description(self):
        return f"{self.name} is {self.age} years old"

class Dog(Animal):
    # 子类构造函数
    def __init__(self, name, age, breed):
        super().__init__(name, age)  # 调用父类构造函数
        self.breed = breed

    # 子类实现父类的方法
    def speak(self):
        return "我是狗"

class Cat(Animal):
    # 子类构造函数
    def __init__(self, name, age, color):
        super().__init__(name, age)  # 调用父类构造函数
        self.color = color

    # 子类实现父类的方法
    def speak(self):
        return "我是猫"

# 创建对象
dog = Dog("狗子1号", 5)
cat = Cat("Whiskers", 3)

# 调用方法
print(dog.description())  # 输出: Buddy is 5 years old
print(dog.speak())        # 输出: 我是狗
print(cat.description())  # 输出: Whiskers is 3 years old
print(cat.speak())        # 输出: 我是猫

__init__ 方法在 Python 中是一个特殊的实例方法，被称为构造函数。它在创建类的实例时自动调用，用于初始化对象的属性。这个方法的主要作用是确保对象在创建时被正确地初始化。

※ __init__ 方法的作用

1. 初始化属性：

   • __init__ 方法通常用于设置对象的初始状态，即为对象的属性赋初值。例如，初始化对象的名称、年龄、颜色等属性。

2. 自动调用：

   • 当创建一个类的实例时，Python 会自动调用 __init__ 方法，无需显式调用它。

class Person:
    def __init__(self, name, age):
        self.name = name  # 初始化 name 属性
        self.age = age    # 初始化 age 属性
# 创建一个 Person 类的实例
person = Person("Alice", 30)
print(person.name)  # 输出: Alice
print(person.age)   # 输出: 30

一些常用的面试八股（自己这几天面试有用到）：

**1.**单下划线和双下划线区别

|------------|-------------------------------------------------------------------------|----------------------------------------------------------------------|
| 特性 | 单下划线 _ | 双下划线 __ |
| 用途 | 用于表示"保护"成员（protected），主要是编码约定 | 用于实现名称修饰（name mangling），增强封装性 |
| 访问级别 | 不强制访问限制，只是约定，不阻止外部访问 | 实现了名称修饰，使得外部代码更难以访问 |
| 访问方式 | 主要通过约定，外部代码或子类可以访问 | 通过名称修饰机制访问，通常不推荐直接访问 |
| 名称修饰 | 无名称修饰 | 会将变量名改为 _ClassName__variable |
| 在类中的使用 | 用于表示该成员是内部使用的，外部应避免访问 | 用于防止子类或外部代码意外访问或覆盖这些成员 |
| 示例代码 | python class MyClass: def init(self): self._protected = "Protected" | python class MyClass: def init(self): self.__private = "Private" |

2._new_和_init_的区别

|----------|-------------------------------------------------------------------------------------------------------------------------------------------|-------------------------------------------------------------------------------------------------------|
| 特性 | new | init |
| 角色 | 创建新的对象实例 | 初始化新创建的对象实例 |
| 调用时机 | 在对象创建之前被调用 | 在 new 成功创建对象后被调用 |
| 方法类型 | 静态方法 | 实例方法 |
| 返回值 | 返回一个新的对象实例 | 没有返回值（返回 None） |
| 主要用途 | 控制实例的创建过程，创建不可变类型的实例或实现单例模式 | 设置实例的初始状态，初始化对象的属性 |
| 常见实现 | super().new(cls) | 设置对象的属性，如 self.value = value |
| 示例代码 | python class MyClass: def new(cls, *args, **kwargs): print("Creating instance...") instance = super().new(cls) return instance | python class MyClass: def init(self, value): print("Initializing instance...") self.value = value |

3. 浅拷贝与深拷贝的区别

浅拷贝 (Shallow Copy)

• 概念：

  • 浅拷贝创建一个新的对象，并将原始对象的最外层内容复制到新对象中。对于嵌套的对象（如列表中的列表），浅拷贝只复制它们的引用，而不是它们本身。

• 实现方式：

  • 可以使用 copy 模块的 copy() 函数来实现浅拷贝。

深拷贝 (Deep Copy)

• 概念：

  • 深拷贝创建一个新的对象，并递归地复制原始对象的所有内容，包括所有嵌套的对象。这样，新对象完全独立于原始对象，任何对新对象的修改不会影响原始对象。

• 实现方式：

  • 可以使用 copy 模块的 deepcopy() 函数来实现深拷贝。

|----------------|---------------------------------|-------------------------------|
| 特性 | 浅拷贝 (Shallow Copy) | 深拷贝 (Deep Copy) |
| 复制对象 | 只复制对象的最外层结构，内部的嵌套对象仍然指向原始对象 | 递归地复制整个对象及其所有嵌套对象，完全独立于原始对象 |
| copy方法**** | 使用 copy.copy() 实现 | 使用 copy.deepcopy() 实现 |
| 处理嵌套对象 | 嵌套对象的引用仍然指向原始对象，即修改嵌套对象会影响原始对象 | 嵌套对象也会被复制，修改嵌套对象不会影响原始对象 |
| 性能 | 通常比深拷贝更快，因为只复制了一层对象 | 通常比浅拷贝更慢，因为需要递归复制所有嵌套对象 |
| 适用场景 | 对象不包含复杂嵌套结构，或者不需要对嵌套对象进行独立操作时适用 | 对象包含复杂嵌套结构，或者需要对嵌套对象进行独立操作时适用 |

#浅拷贝
import copy
original_list = [1, [2, 3], 4]
shallow_copied_list = copy.copy(original_list)

# 修改嵌套列表中的元素
shallow_copied_list[1][0] = 99

print(original_list)  # 输出: [1, [99, 3], 4]
print(shallow_copied_list)  # 输出: [1, [99, 3], 4]


#深拷贝
import copy
original_list = [1, [2, 3], 4]
deep_copied_list = copy.deepcopy(original_list)

# 修改嵌套列表中的元素
deep_copied_list[1][0] = 99

print(original_list)  # 输出: [1, [2, 3], 4]
print(deep_copied_list)  # 输出: [1, [99, 3], 4]

#