面向对象编程是程序设计的一种范式,旨在通过封装、继承和多态等机制来组织和管理代码。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]
#