技术共享

探索【Python面向对象】编程：新时代的高级编程范式详解

2024-07-12

한어Русский языкEnglishFrançaisIndonesianSanskrit日本語DeutschPortuguêsΕλληνικάespañolItalianoSuomalainenLatina

目录

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） 是类的实例。创建对象就是根据类创建一个具体的实例。

例子：

  1. class Dog:
  2.     # 类的初始化方法
  3.     def __init__(self, name, age):
  4.         self.name = name  # 属性
  5.         self.age = age    # 属性
  6.  
  7.     # 方法
  8.     def bark(self):
  9.         return f"{self.name} says Woof!"
  10.  
  11. # 创建对象
  12. my_dog = Dog("Rex", 5)
  13. print(my_dog.bark())

1.2 类的定义

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

例子：

  1. class Cat:
  2.     def __init__(self, name):
  3.         self.name = name
  4.  
  5.     def meow(self):
  6.         return f"{self.name} says Meow!"
  7.  
  8. # 创建对象
  9. my_cat = Cat("Whiskers")
  10. print(my_cat.meow())

1.3 类和对象的关系

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

  1. class Person:
  2.     def __init__(self, name, age):
  3.         self.name = name
  4.         self.age = age
  5.  
  6.     def greet(self):
  7.         return f"Hello, my name is {self.name} and I am {self.age} years old."
  8.  
  9. # 创建多个对象
  10. person1 = Person("Alice", 30)
  11. person2 = Person("Bob", 25)
  12.  
  13. print(person1.greet())
  14. print(person2.greet())

1.4 小李的理解

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

2. 抽象

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

2.1 抽象的概念

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

例子：

  1. class Animal:
  2.     def __init__(self, name):
  3.         self.name = name
  4.  
  5.     def make_sound(self):
  6.         pass  # 抽象方法，不具体实现
  7.  
  8. class Dog(Animal):
  9.     def make_sound(self):
  10.         return "Woof!"
  11.  
  12. class Cat(Animal):
  13.     def make_sound(self):
  14.         return "Meow!"
  15.  
  16. # 创建对象
  17. dog = Dog("Rex")
  18. cat = Cat("Whiskers")
  19.  
  20. print(dog.make_sound())
  21. print(cat.make_sound())

2.2 抽象类和方法

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

例子：

  1. from abc import ABC, abstractmethod
  2.  
  3. class Vehicle(ABC):
  4.     @abstractmethod
  5.     def start_engine(self):
  6.         pass
  7.  
  8. class Car(Vehicle):
  9.     def start_engine(self):
  10.         return "Car engine started"
  11.  
  12. class Motorcycle(Vehicle):
  13.     def start_engine(self):
  14.         return "Motorcycle engine started"
  15.  
  16. # 创建对象
  17. car = Car()
  18. motorcycle = Motorcycle()
  19.  
  20. print(car.start_engine())
  21. print(motorcycle.start_engine())

2.3 小李的理解

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

3. 类和实例

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

3.1 类的定义和实例化

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

例子：

  1. class Student:
  2.     def __init__(self, name, grade):
  3.         self.name = name
  4.         self.grade = grade
  5.  
  6.     def introduce(self):
  7.         return f"Hi, I am {self.name} and I am in grade {self.grade}."
  8.  
  9. # 创建实例
  10. student1 = Student("Alice", 10)
  11. student2 = Student("Bob", 12)
  12.  
  13. print(student1.introduce())
  14. print(student2.introduce())

3.2 类的属性和方法

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

例子：

  1. class Book:
  2.     def __init__(self, title, author):
  3.         self.title = title
  4.         self.author = author
  5.  
  6.     def get_info(self):
  7.         return f"'{self.title}' by {self.author}"
  8.  
  9. # 创建实例
  10. book = Book("1984", "George Orwell")
  11. print(book.get_info())

3.3 小李的理解

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

4. 封装/接口

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

4.1 封装的概念

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

例子：

  1. class Account:
  2.     def __init__(self, owner, balance=0):
  3.         self.owner = owner
  4.         self.__balance = balance  # 私有属性
  5.  
  6.     def deposit(self, amount):
  7.         if amount > 0:
  8.             self.__balance += amount
  9.         else:
  10.             raise ValueError("Deposit amount must be positive")
  11.  
  12.     def withdraw(self, amount):
  13.         if 0 < amount <= self.__balance:
  14.             self.__balance -= amount
  15.         else:
  16.             raise ValueError("Insufficient funds or invalid amount")
  17.  
  18.     def get_balance(self):
  19.         return self.__balance
  20.  
  21. # 创建实例
  22. account = Account("John")
  23. account.deposit(100)
  24. print(account.get_balance())

4.2 接口的概念

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

例子：

  1. class Car:
  2.     def __init__(self, model):
  3.         self.model = model
  4.         self.__engine_started = False
  5.  
  6.     def start_engine(self):
  7.         if not self.__engine_started:
  8.             self.__engine_started = True
  9.             return "Engine started"
  10.         else:
  11.             return "Engine is already running"
  12.  
  13.     def stop_engine(self):
  14.         if self.__engine_started:
  15.             self.__engine_started = False
  16.             return "Engine stopped"
  17.         else:
  18.             return "Engine is not running"
  19.  
  20. # 创建实例
  21. car = Car("Toyota")
  22. print(car.start_engine())
  23. print(car.stop_engine())

4.3 小李的理解

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

5. 继承

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

5.1 继承的概念

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

例子：

  1. class Animal:
  2.     def __init__(self, name):
  3.         self.name = name
  4.  
  5.     def speak(self):
  6.         pass
  7.  
  8. class Dog(Animal):
  9.     def speak(self):
  10.         return "Woof!"
  11.  
  12. class Cat(Animal):
  13.     def speak(self):
  14.         return "Meow!"
  15.  
  16. # 创建实例
  17. dog = Dog("Rex")
  18. cat = Cat("Whiskers")
  19.  
  20. print(dog.speak())
  21. print(cat.speak())

5.2 方法重写

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

例子：

  1. class Shape:
  2.     def area(self):
  3.         return 0
  4.  
  5. class Rectangle(Shape):
  6.     def __init__(self, width, height):
  7.         self.width = width
  8.         self.height = height
  9.  
  10.     def area(self):
  11.         return self.width * self.height
  12.  
  13. class Circle(Shape):
  14.     def __init__(self, radius):
  15.         self.radius = radius
  16.  
  17.     def area(self):
  18.         return 3.14 * (self.radius ** 2)
  19.  
  20. # 创建实例
  21. rectangle = Rectangle(3, 4)
  22. circle = Circle(5)
  23.  
  24. print(rectangle.area())
  25. print(circle.area())

5.3 小李的理解

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

6. 多态

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

6.1 多态的概念

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

例子：

  1. class Animal:
  2.     def speak(self):
  3.         pass
  4.  
  5. class Dog(Animal):
  6.     def speak(self):
  7.         return "Woof!"
  8.  
  9. class Cat(Animal):
  10.     def speak(self):
  11.         return "Meow!"
  12.  
  13. def animal_sound(animal):
  14.     print(animal.speak())
  15.  
  16. # 创建实例
  17. dog = Dog()
  18. cat = Cat()
  19.  
  20. animal_sound(dog)
  21. animal_sound(cat)

 

6.2 实现多态

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

例子：

  1. class Shape:
  2.     def draw(self):
  3.         pass
  4.  
  5. class Rectangle(Shape):
  6.     def draw(self):
  7.         return "Drawing a rectangle"
  8.  
  9. class Circle(Shape):
  10.     def draw(self):
  11.         return "Drawing a circle"
  12.  
  13. def draw_shape(shape):
  14.     print(shape.draw())
  15.  
  16. # 创建实例
  17. rectangle = Rectangle()
  18. circle = Circle()
  19.  
  20. draw_shape(rectangle)
  21. draw_shape(circle)

 

6.3 小李的理解

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

7. 自省/反射

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

7.1 自省的概念

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

例子：

  1. class Person:
  2.     def __init__(self, name, age):
  3.         self.name = name
  4.         self.age = age
  5.  
  6. person = Person("Alice", 30)
  7.  
  8. # 使用内置函数进行自省
  9. print(type(person))
  10. print(hasattr(person, "name"))
  11. print(getattr(person, "name"))
  12. setattr(person, "name", "Bob")
  13. print(person.name)
  14. delattr(person, "name")

7.2 使用自省进行动态操作

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

例子：

  1. class Car:
  2.     def __init__(self, model):
  3.         self.model = model
  4.         self.speed = 0
  5.  
  6.     def accelerate(self):
  7.         self.speed += 5
  8.         return self.speed
  9.  
  10. car = Car("Toyota")
  11.  
  12. # 动态操作对象
  13. if hasattr(car, "accelerate"):
  14.     method = getattr(car, "accelerate")
  15.     print(method())
  16.     print(method())
  17.  
  18. # 动态设置属性
  19. setattr(car, "color", "red")
  20. print(car.color)

7.3 小李的理解

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

8. 静态方法和类方法

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

8.1 静态方法

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

例子：

  1. class Math:
  2.     @staticmethod
  3.     def add(a, b):
  4.         return a + b
  5.  
  6. print(Math.add(5, 3))

 

8.2 类方法

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

例子：

  1. class Math:
  2.     factor = 2
  3.  
  4.     @classmethod
  5.     def multiply(cls, value):
  6.         return cls.factor * value
  7.  
  8. print(Math.multiply(5))

总结

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

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

个人简介

潜心研究技术三十余年，精通java、linux、javascript、php、css、等等各种语言，在开源领域有诸多贡献，建立开发者文档站，将一些技术开发中的问题分享出来，以供大家查阅

我的联系方式

邮箱