Python面向对象编程全面指南：从基础到进阶，一篇文章搞定所有核心概念！

1. 面向对象与面向过程对比
核心区别
表格复制维度面向过程 (POP)面向对象 (OOP)编程思想以"过程"为中心，关注如何执行以"对象"为中心，关注数据与行为的封装核心单元函数/过程类与对象数据处理数据与函数分离，通过参数传递数据与方法封装在对象内部，通过接口访问代码复用通过函数调用实现通过继承、多态等机制实现适用场景简单任务、线性流程、性能敏感场景复杂系统、需求变化频繁、需要高度模块化的项目典型代表C语言、结构化编程Java、Python、C++等现代编程语言
代码示例对比
面向过程实现python# 计算圆的面积和周长

面向对象实现pythonclass Circle:
   

class Circle:
    def __init__(self, radius):
        self.radius = radius
    
    def calculate_area(self):
        return 3.14159 * self.radius ** 2
    
    def calculate_perimeter(self):
        return 2 * 3.14159 * self.radius

circle = Circle(5)
area = circle.calculate_area()
perimeter = circle.calculate_perimeter()
 

2. 类与实例
核心概念

类 (Class) : 是创建对象的蓝图或模板，定义了对象的属性和方法
实例 (Instance) : 是类的具体实现，是类的具体化产物
对象 (Object) : 实例的同义词，在Python中一切皆对象
代码示例python# 定义类

class Person:
    species = "Homo sapiens"  # 类属性

    def __init__(self, name, age):
        self.name = name  # 实例属性
        self.age = age

    def introduce(self):  # 实例方法
        return f"我叫{self.name}，今年{self.age}岁"

# 创建实例
person1 = Person("张三", 25)
person2 = Person("李四", 30)

# 访问属性和方法
print(person1.name)  # 输出: 张三
print(person2.introduce())  # 输出: 我叫李四，今年30岁
print(Person.species)  # 输出: Homo sapiens
 

3. 魔法函数汇总
Python中的魔法函数（Magic Methods）是双下划线包裹的特殊方法，用于实现类的特殊行为。
分类汇总

class L:
    ### 构造与析构
    def __init__(self, value=None):
        self.value = value
        self.container = []
    
    def __del__(self):
        print("对象被销毁")

    ### 字符串表示
    def __str__(self):
        return f"(value={self.value})"

    ### 算术运算
    def __add__(self, other):
        return self.value + other
    
    def __sub__(self, other):
        return self.value - other
    
    def __mul__(self, other):
        return self.value * other
    
    def __truediv__(self, other):
        return self.value / other
    
    def __mod__(self, other):
        return self.value % other

    ### 比较运算
    def __eq__(self, other):
        return self.value == other
    
    def __ne__(self, other):
        return self.value != other
    
    def __lt__(self, other):
        return self.value < other
    
    def __le__(self, other):
        return self.value <= other
    
    def __gt__(self, other):
        return self.value > other
    
    def __ge__(self, other):
        return self.value >= other

    def __len__(self):
        return len(self.container)
    
    def __getitem__(self, key):
        return self.container[key]
    
    def __setitem__(self, key, value):
        self.container[key] = value
    
    def __delitem__(self, key):
        del self.container[key]
    
    def __iter__(self):
        return iter(self.container)
    
    def __next__(self):
        return next(self.container)

    ### 上下文管理
    def __enter__(self):
        print("进入上下文")
        return self
    
    def __exit__(self, exc_type, exc_val, exc_tb):
        print("退出上下文")

    ### 属性访问
    def __getattr__(self, name):
        return f"属性 {name} 不存在"
    
    def __getattribute__(self, name):
        return object.__getattribute__(self, name)
    
    def __setattr__(self, name, value):
        object.__setattr__(self, name, value)
    
    def __delattr__(self, name):
        object.__delattr__(self, name)
 

实例演示：

class Vector:
    def __init__(self, x, y):
        self.x = x
        self.y = y
    
    def __add__(self, other):
        return Vector(self.x + other.x, self.y + other.y)
    
    def __str__(self):
        return f"Vector({self.x}, {self.y})"

v1 = Vector(1, 2)
v2 = Vector(3, 4)
v3 = v1 + v2
print(v3)  # 输出: Vector(4, 6)
 

4. 封装
核心概念
封装是面向对象编程的三大特性之一，指的是将对象的状态信息隐藏在对象内部，不允许外部程序直接访问对象内部信息，而是通过该类所提供的方法来实现对内部信息的操作和访问。
5. 继承
核心概念
继承是面向对象编程的三大特性之一，允许一个类（子类/派生类）继承另一个类（父类/基类）的属性和方法，从而实现代码复用。
类型

单继承：一个子类只能继承一个父类
多继承：一个子类可以继承多个父类（Python支持）

class Parent:
    def method(self):
        print("Parent method")

class Child(Parent):
    pass
 

代码示例python# 父类

class Animal:
    def __init__(self, name):
        self.name = name
    
    def eat(self):
        print(f"{self.name} 正在吃东西")

class Dog(Animal):
    def bark(self):
        print(f"{self.name} 正在汪汪叫")

class Cat(Animal):
    def meow(self):
        print(f"{self.name} 正在喵喵叫")

# 创建Dog实例并调用方法
dog = Dog("旺财")
dog.eat()  # 调用继承自Animal的方法
dog.bark() # 调用Dog特有方法

# 创建Cat实例并调用方法
cat = Cat("咪咪")
cat.eat()  # 调用继承自Animal的方法
cat.meow() # 调用Cat特有方法
 

6. 多态
核心概念
多态是面向对象编程的三大特性之一，指的是同一个方法调用可以根据对象的不同而表现出不同的行为。
实现方式

编译时多态：方法重载（Python不支持）
运行时多态：方法重写（Python支持）代码示例pythonclass Animal:

class Animal:
    def __init__(self, name):
        self.name = name
    
    def eat(self):
        print(f"{self.name} 正在吃东西")

class Dog(Animal):
    def bark(self):
        print(f"{self.name} 正在汪汪叫")

class Cat(Animal):
    def meow(self):
        print(f"{self.name} 正在喵喵叫")

# 创建Dog实例并调用方法
dog = Dog("旺财")
dog.eat()  # 调用继承自Animal的方法
dog.bark() # 调用Dog特有方法

# 创建Cat实例并调用方法
cat = Cat("咪咪")
cat.eat()  # 调用继承自Animal的方法
cat.meow() # 调用Cat特有方法
 

7. 多继承
核心概念

一个类可以有一父类（Java，c++）

        也可以有多个类

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def walk(self):
        print("run")

    def __str__(self):
        return f"{self.name}{self.age}"

class Flyer:
    def __init__(self, speed):
        self.speed = speed

    def fly(self):
        print("fly")

    def __str__(self):
        return f"{self.speed}"

class Superman(Person, Flyer):
    def __init__(self, name, age, speed):
        Person.__init__(self, name, age)
        Flyer.__init__(self, speed)

    def __str__(self):
        return f"{self.name}{self.age}{self.speed}"

sp = Superman("超人", 25, 120)
print(sp)
 

8. 抽象类
核心概念
抽象类是一种不能被实例化的类，要求子类必须实现特定的方法。
 

代码示例python

class Circle(Shape):
    def __init__(self, radius):
        self.radius = radius
    
    def area(self):
        return 3.14159 * self.radius ** 2
    
    def perimeter(self):
        return 2 * 3.14159 * self.radius
 

实例化与输出

circle = Circle(5)
print(circle.area())      # 输出: 78.53975
print(circle.perimeter()) # 输出: 31.4159
 

9. 枚举类
核心概念
枚举类（Enum）是一种特殊的类，用于定义一组具名的常量，提高代码可读性和可维护性。
代码示例

from enum import Enum

class GameState(Enum):
    READY = "准备阶段"
    PLAYING = "游戏中"
    ENDED = "游戏结束"

current_state = GameState.READY

while True:
    print(f"\n当前状态: {current_state.value}")
    print("1. 开始游戏  2. 结束游戏  3. 重新开始")
    
    try:
        choice = int(input("请选择操作: "))
        
        if choice == 1 and current_state == GameState.READY:
            current_state = GameState.PLAYING
            print("→ 游戏开始！")
            
        elif choice == 2 and current_state == GameState.PLAYING:
            current_state = GameState.ENDED
            print("→ 游戏已结束")
            
        elif choice == 3 and current_state == GameState.ENDED:
            current_state = GameState.READY
            print("→ 重置游戏状态")
            
        else:
            print("× 无效操作或状态不匹配")
            
    except ValueError:
        print("× 请输入有效数字")
 

10. 数据的访问级别

class Person:
    def __init__(self, name, age, sex):
        self.name = name      # 公有变量
        self.__age = age      # 私有变量（双下划线开头）
        self._sex = sex       # 受保护变量（单下划线开头）
    
    def __str__(self):
        return self._sex

class SuperPerson(Person):
    def __str__(self):
        return self._sex

# 测试代码
sp = SuperPerson("li", 22, "nv")
print(sp)  # 输出: nv
 

11. 4个Attr函数
Python提供了4个内置函数用于属性访问：

**getattr(obj, name[, default]) **: 获取对象属性
**setattr(obj, name, value) **: 设置对象属性
**hasattr(obj, name) **: 检查对象是否有该属性
**delattr(obj, name) **: 删除对象属性

代码示例python

class Person:
    max_v = 100

    def __init__(self,name):
        self.name=name
    def __str__(self):
        return self.name

    def get_name(self):
        print(self.name)
    @classmethod
    def get_info(cls):
        print("lalal")

    @staticmethod
    def super_p(a,b):
        return a if a > b else b

p = Person("li")
print(hasattr(p,"name"),hasattr(Person,"name"))
print(hasattr(p,"get_name"),hasattr(Person,"get_name"))
print(hasattr(p,"get_info"),hasattr(Person,"get_info"))
print(hasattr(p,"max_v"),hasattr(Person,"max_v"))


setattr(Person,"sex","男")
print(hasattr(Person,"sex"))
delattr(Person,"max_v")
print(hasattr(Person,"max_v"))

setattr(Person,"c",lambda x:x**2)
print(hasattr(Person, "c"))
r = getattr(Person,"c")
r(2)
 

12. 类成员

代码示例python

实例属性是每个实例独有的数据，通过self.属性名定义或访问。类属性直接定义在类内部，所有实例共享，通过类名.属性名访问或修改。实例可以读取类属性，但修改时会创建同名实例属性而非修改类属性本身。

实例方法属于实例，第一个参数为self，用于操作实例数据。类方法属于类，需用@classmethod装饰器，第一个参数为cls，常用于获取类级信息（如类名、父类）。实例可调用类方法，但cls始终指向类本身。

静态方法通过@staticmethod装饰器定义，属于类但无强制参数（如self或cls），常用于工具函数封装。实例和类均可调用。

class Person:
    """
    alallala
    """
    max_v = 1000

    def __init__(self,name):
        self.name = name

    def get_name(self):
        print(self.name)

    def __str__(self):
        return self.name

    @classmethod
    def get_class_info(cls):
        return {
            "name":Person.__name__,
            "doc":Person.__doc__,
            "base":Person.__bases__

        }
    @staticmethod
    def say_hi():
        print("lallalalallalla")

p = Person("lll")
# print(p.get_name())
print(p.__doc__)
print(p.max_v)
p.max_v = 1200
print(p.max_v,Person.max_v)

print(Person.get_class_info())
print(p.get_class_info())
Person.say_hi()
p.say_hi()

13. 动态添加类成员

类属性：直接添加
类方法直接添加，添加的方法需要有装饰器和cls参数
静态方法：直接添加添加的方法需要有装饰器，对参数没要求

import types

class Person:
    def __init__(self,name):
        self.name=name

    def __str__(self):
        return f"{self.name}{self.age}"

    def get_name(self):
        return  self.name

#
p = Person("li")
p2 = Person("ll")

print(p.name,p.get_name())
print(p2.name,p2.get_name())

p.get_age = types.MethodType(lambda self:self.age,p)


Person.Max_v = 100
print(Person.Max_v,p.Max_v,p2.Max_v)