目录

1. 面向对象编程概念（OOP）

1.1 什么是类和对象？

1.2 类的定义

1.3 类和对象的关系

1.4 小李的理解

2. 抽象

2.1 抽象的概念

2.2 抽象类和方法

2.3 小李的理解

3. 类和实例

3.1 类的定义和实例化

3.2 类的属性和方法

3.3 小李的理解

4. 封装/接口

4.1 封装的概念

4.2 接口的概念

4.3 小李的理解

5. 继承

5.1 继承的概念

5.2 方法重写

5.3 小李的理解

6. 多态

6.1 多态的概念

6.2 实现多态

6.3 小李的理解

7. 自省/反射

7.1 自省的概念

7.2 使用自省进行动态操作

7.3 小李的理解

8. 静态方法和类方法

8.1 静态方法

8.2 类方法

总结

---

 

专栏：python学习笔记 

上一卷：Python模块化与包管理

1. 面向对象编程概念（OOP）

面向对象编程（OOP） 是一种编程范式，通过将程序组织成对象的集合来实现。对象不仅包含数据，还包含操作这些数据的方法。OOP的核心概念包括类、对象、属性和方法。

1.1 什么是类和对象？

• 类（Class） 是一个模板或蓝图，用来创建对象。类定义了对象的属性和行为。
• 对象（Object） 是类的实例。创建对象就是根据类创建一个具体的实例。

例子：

class Dog:# 类的初始化方法def __init__(self, name, age):self.name = name  # 属性self.age = age    # 属性# 方法def bark(self):return f"{self.name} says Woof!"# 创建对象
my_dog = Dog("Rex", 5)
print(my_dog.bark())

1.2 类的定义

在Python中，类通过 class 关键字定义。类中的函数称为方法，变量称为属性。类的方法通常以 self 作为第一个参数，表示实例本身。

例子：

class Cat:def __init__(self, name):self.name = namedef meow(self):return f"{self.name} says Meow!"# 创建对象
my_cat = Cat("Whiskers")
print(my_cat.meow())

1.3 类和对象的关系

类是对象的模板，定义了对象的结构和行为。而对象是类的实例，每个对象都有独立的属性和方法。

class Person:def __init__(self, name, age):self.name = nameself.age = agedef greet(self):return f"Hello, my name is {self.name} and I am {self.age} years old."# 创建多个对象
person1 = Person("Alice", 30)
person2 = Person("Bob", 25)print(person1.greet())
print(person2.greet())

1.4 小李的理解

类就像是制作饼干的模具，它定义了饼干的形状和尺寸。而对象就像是用模具做出的具体饼干，每块饼干可以有不同的口味（属性），但它们的形状和尺寸（结构和行为）都是相同的。

2. 抽象

抽象 是指对现实世界的复杂问题进行简化，通过抓住主要特征而忽略细节。在编程中，抽象帮助我们创建更加简洁和易维护的代码。

2.1 抽象的概念

抽象就是提取对象的主要特征，而忽略不重要的细节。通过抽象，我们可以专注于对象的核心功能，而不被次要特征所干扰。

例子：

class Animal:def __init__(self, name):self.name = namedef make_sound(self):pass  # 抽象方法，不具体实现class Dog(Animal):def make_sound(self):return "Woof!"class Cat(Animal):def make_sound(self):return "Meow!"# 创建对象
dog = Dog("Rex")
cat = Cat("Whiskers")print(dog.make_sound())
print(cat.make_sound())

2.2 抽象类和方法

在Python中，我们可以通过定义抽象类和抽象方法来实现抽象。抽象类不能被实例化，只能被继承。抽象方法在抽象类中定义，但在子类中实现。

例子：

from abc import ABC, abstractmethodclass Vehicle(ABC):@abstractmethoddef start_engine(self):passclass Car(Vehicle):def start_engine(self):return "Car engine started"class Motorcycle(Vehicle):def start_engine(self):return "Motorcycle engine started"# 创建对象
car = Car()
motorcycle = Motorcycle()print(car.start_engine())
print(motorcycle.start_engine())

2.3 小李的理解

抽象就像是把一幅复杂的画简化为几何图形。比如，一只具体的猫有很多特征（毛色、大小、年龄等），但我们只关注它会喵喵叫的特点，这就是对猫进行的抽象。

3. 类和实例

类和实例 是OOP的基础。类是模板，实例是具体对象。实例通过类创建，具有类定义的属性和方法。

3.1 类的定义和实例化

定义类并创建实例是OOP的基本操作。类定义了属性和方法，而实例则是类的具体对象。

例子：

class Student:def __init__(self, name, grade):self.name = nameself.grade = gradedef introduce(self):return f"Hi, I am {self.name} and I am in grade {self.grade}."# 创建实例
student1 = Student("Alice", 10)
student2 = Student("Bob", 12)print(student1.introduce())
print(student2.introduce())

3.2 类的属性和方法

类的属性是对象的状态，方法是对象的行为。类的属性通过 __init__ 方法初始化，方法在类中定义。

例子：

class Book:def __init__(self, title, author):self.title = titleself.author = authordef get_info(self):return f"'{self.title}' by {self.author}"# 创建实例
book = Book("1984", "George Orwell")
print(book.get_info())

3.3 小李的理解

类和实例就像是房子的图纸和实际的房子。图纸（类）定义了房子的结构和功能，而实际的房子（实例）则是根据图纸建造的具体对象。

4. 封装/接口

封装 是将对象的状态（属性）和行为（方法）隐藏在类内部，通过接口（方法）与外界交互。封装提高了代码的安全性和可维护性。

4.1 封装的概念

封装是OOP的核心概念之一，它通过隐藏对象的内部状态，只暴露必要的接口，来保护对象的数据。这样，外部代码不能直接访问或修改对象的内部状态，只能通过对象提供的方法来操作数据。

例子：

class Account:def __init__(self, owner, balance=0):self.owner = ownerself.__balance = balance  # 私有属性def deposit(self, amount):if amount > 0:self.__balance += amountelse:raise ValueError("Deposit amount must be positive")def withdraw(self, amount):if 0 < amount <= self.__balance:self.__balance -= amountelse:raise ValueError("Insufficient funds or invalid amount")def get_balance(self):return self.__balance# 创建实例
account = Account("John")
account.deposit(100)
print(account.get_balance())

4.2 接口的概念

接口是对象与外部交互的唯一方式。通过接口，外部代码可以调用对象的方法，而不能直接访问对象的内部状态。

例子：

class Car:def __init__(self, model):self.model = modelself.__engine_started = Falsedef start_engine(self):if not self.__engine_started:self.__engine_started = Truereturn "Engine started"else:return "Engine is already running"def stop_engine(self):if self.__engine_started:self.__engine_started = Falsereturn "Engine stopped"else:return "Engine is not running"# 创建实例
car = Car("Toyota")
print(car.start_engine())
print(car.stop_engine())

4.3 小李的理解

封装就像是手机的外壳。手机内部的电路和元件（对象的状态）被封装在外壳里面，用户只能通过按键和屏幕（接口）与手机交互，而无法直接接触内部的元件。

5. 继承

继承 是OOP的另一个核心概念，它允许我们基于一个现有的类创建一个新的类，新类继承了现有类的所有属性和方法。

5.1 继承的概念

继承是指一个类（子类）从另一个类（父类）获取属性和方法。通过继承，子类可以复用父类的代码，同时可以添加新的属性和方法，或重写父类的方法。

例子：

class Animal:def __init__(self, name):self.name = namedef speak(self):passclass Dog(Animal):def speak(self):return "Woof!"class Cat(Animal):def speak(self):return "Meow!"# 创建实例
dog = Dog("Rex")
cat = Cat("Whiskers")print(dog.speak())
print(cat.speak())

5.2 方法重写

子类可以重写父类的方法，即在子类中定义与父类同名的方法，从而实现不同的功能。

例子：

class Shape:def area(self):return 0class Rectangle(Shape):def __init__(self, width, height):self.width = widthself.height = heightdef area(self):return self.width * self.heightclass Circle(Shape):def __init__(self, radius):self.radius = radiusdef area(self):return 3.14 * (self.radius ** 2)# 创建实例
rectangle = Rectangle(3, 4)
circle = Circle(5)print(rectangle.area())
print(circle.area())

5.3 小李的理解

继承就像是父母给孩子的遗产。父母（父类）把他们的财产（属性和方法）传给孩子（子类），孩子不仅可以使用这些财产，还可以通过自己的努力（添加新属性和方法）变得更加富有。

6. 多态

多态 是指同一个方法在不同的对象上具有不同的表现形式。多态允许我们通过同一个接口调用不同对象的方法，从而实现不同的功能。

6.1 多态的概念

多态是OOP的重要特性之一，它通过父类引用指向子类对象，使得同一方法可以有不同的实现。多态提高了代码的灵活性和可扩展性。

例子：

class Animal:def speak(self):passclass Dog(Animal):def speak(self):return "Woof!"class Cat(Animal):def speak(self):return "Meow!"def animal_sound(animal):print(animal.speak())# 创建实例
dog = Dog()
cat = Cat()animal_sound(dog)
animal_sound(cat)

 

6.2 实现多态

在Python中，多态通常通过方法重写和父类引用来实现。通过父类引用指向子类对象，可以调用子类的方法。

例子：

class Shape:def draw(self):passclass Rectangle(Shape):def draw(self):return "Drawing a rectangle"class Circle(Shape):def draw(self):return "Drawing a circle"def draw_shape(shape):print(shape.draw())# 创建实例
rectangle = Rectangle()
circle = Circle()draw_shape(rectangle)
draw_shape(circle)

 

6.3 小李的理解

多态就像是万能遥控器。无论是控制电视、空调还是音响，只要这些设备有相应的接口（方法），遥控器（父类引用）就能通过相同的按键（方法调用）实现不同的功能。

7. 自省/反射

自省 是指对象在运行时能够知道自己的信息。Python提供了一些内置函数用于自省，如 type()、id()、hasattr() 等。

7.1 自省的概念

自省是指对象能够在运行时获取自身的信息，如属性、方法等。自省使得Python程序具有高度的动态性和灵活性。

例子：

class Person:def __init__(self, name, age):self.name = nameself.age = ageperson = Person("Alice", 30)# 使用内置函数进行自省
print(type(person))
print(hasattr(person, "name"))
print(getattr(person, "name"))
setattr(person, "name", "Bob")
print(person.name)
delattr(person, "name")

7.2 使用自省进行动态操作

通过自省，我们可以在运行时动态地操作对象的属性和方法，使得程序更加灵活和动态。

例子：

class Car:def __init__(self, model):self.model = modelself.speed = 0def accelerate(self):self.speed += 5return self.speedcar = Car("Toyota")# 动态操作对象
if hasattr(car, "accelerate"):method = getattr(car, "accelerate")print(method())print(method())# 动态设置属性
setattr(car, "color", "red")
print(car.color)

7.3 小李的理解

自省就像是人在照镜子。通过镜子（自省机制），人可以看到自己的样子（对象的属性和方法），并根据需要进行调整（动态操作对象）。

8. 静态方法和类方法

静态方法 和 类方法 是与类相关联的方法，而不是与实例相关联的方法。静态方法使用 @staticmethod 装饰器，类方法使用 @classmethod 装饰器。

8.1 静态方法

静态方法是类的一个方法，但它不与任何类实例绑定。静态方法不能访问类的实例，也不能修改类的状态。它们通常用于执行一些与类无关的操作，但逻辑上属于类的功能。

例子：

class Math:@staticmethoddef add(a, b):return a + bprint(Math.add(5, 3))

 

8.2 类方法

类方法是绑定到类而不是实例的方法。类方法的第一个参数是类本身，通常命名为 cls。类方法可以访问类的属性和其他类方法。

例子：

class Math:factor = 2@classmethoddef multiply(cls, value):return cls.factor * valueprint(Math.multiply(5))

总结

Python的面向对象编程的各个方面，包括面向对象编程的基本概念、抽象、类和实例、封装、继承、多态、自省以及静态方法和类方法。

希望这篇详细的博客能帮助你深入理解Python的面向对象编程，并在实际项目中应用这些知识。如果你有任何问题或需要进一步的帮助，请随时与我联系！