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]

#