面向对象编程是程序设计的一种范式，旨在通过封装、继承和多态等机制来组织和管理代码。Python 是一种支持面向对象编程的语言。下面是面向对象编程的基本原理以及代码示例。
面向对象编程的基本原理
类和对象：
- 类（Class）：是一种自定义的数据类型，用于描述具有相同特征和行为的对象的集合。它定义了对象的属性（数据）和方法（操作）。
- 对象（Object）：是类的实例。对象是实际存在的，通过类创建的。
封装（Encapsulation）：
- 将数据和操作数据的方法封装在一个类中。封装有助于隐藏对象的内部实现细节，并只暴露必要的接口。
继承（Inheritance）：
- 允许新创建的类（子类）继承现有类（父类）的属性和方法。继承有助于代码的重用。
多态（Polymorphism）：
- 不同的类可以实现相同的方法名，但具体的实现可以不同。这使得程序可以以相同的方式处理不同的对象。
抽象（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__ 方法的作用
初始化属性：
__init__方法通常用于设置对象的初始状态，即为对象的属性赋初值。例如，初始化对象的名称、年龄、颜色等属性。
自动调用：
- 当创建一个类的实例时，Python 会自动调用
__init__方法，无需显式调用它。
- 当创建一个类的实例时，Python 会自动调用
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]
#