面向对象编程（OOP）是一种以对象为核心的编程范式。Python全面支持OOP，主要包含以下核心概念：

一、类与对象

1.类(Class)

类是创建对象的模板或蓝图，它定义了对象的属性和方法。

class Dog:# 类属性（所有实例共享）species = "Canis familiaris"# 初始化方法（构造对象）def __init__(self, name, age):# 实例属性（每个对象独立）self.name = nameself.age = age# 实例方法def bark(self):return f"{self.name} says Woof!"

2.对象（Object）

对象是类的实例，具有类定义的属性和方法。

my_dog = Dog("Buddy", 3)
print(my_dog.bark())  # 输出: Buddy says Woof!

二、三大核心特性

1.封装（Encapsulation）

        封装是将数据（属性）和操作数据的方法（行为）绑定在一起，并隐藏内部实现细节，只对外提供必要的接口。Python通过私有属性和私有方法实现封装。

class BankAccount:def __init__(self, balance=0):self.__balance = balance  # 私有属性def deposit(self, amount):if amount > 0:self.__balance += amountreturn Truereturn Falsedef withdraw(self, amount):if 0 < amount <= self.__balance:self.__balance -= amountreturn Truereturn Falsedef get_balance(self):  # 提供获取余额的方法return self.__balanceaccount = BankAccount(100)
account.deposit(50)
print(account.get_balance())  # 输出: 150
# print(account.__balance)  # 报错，无法直接访问私有属性

2.继承（Inheritance）

继承允许一个类（子类）继承另一个类（父类）的属性和方法，实现代码的重用和扩展。

class Animal:def __init__(self, name):self.name = namedef speak(self):raise NotImplementedError("Subclass must implement abstract method")class Dog(Animal):def speak(self):return f"{self.name} says woof!"class Cat(Animal):def speak(self):return f"{self.name} says meow!"dog = Dog("Buddy")
cat = Cat("Whiskers")
print(dog.speak())  # 输出: Buddy says woof!
print(cat.speak())  # 输出: Whiskers says meow!

3.多态（Polymorphism）

        多态是指同一个方法调用在不同对象上产生不同的行为。在Python中，多态通过继承和方法重写实现。

# 继续使用上面的Animal、Dog和Cat类def animal_sound(animal):print(animal.speak())animals = [Dog("Buddy"), Cat("Whiskers")]
for animal in animals:animal_sound(animal)  # 分别输出: Buddy says woof! 和 Whiskers says meow!

三、类成员详解

        类成员是面向对象编程的核心概念，Python中的类成员主要分为三类：属性、方法和特殊成员。下面详细解析各类成员的特性和用法：

1.属性（Attributes）

 (1).类属性

类属性是属于类的，所有对象共享该属性。

class Circle:# 类属性pi = 3.14159def __init__(self, radius):self.radius = radiusdef area(self):return Circle.pi * self.radius ** 2circle1 = Circle(5)
circle2 = Circle(10)print(circle1.area())  # 输出: 78.53975
print(circle2.area())  # 输出: 314.159

(2).实例属性

实例属性是属于对象的，每个对象可以有不同的属性值。

class Dog:def __init__(self, name, breed):# 实例属性self.name = nameself.breed = breeddog1 = Dog("Buddy", "Golden Retriever")
dog2 = Dog("Max", "German Shepherd")print(dog1.name)  # 输出: Buddy
print(dog2.breed) # 输出: German Shepherd

 综合案例：

class User:# 类属性（所有用户共享）platform = "WebApp"def __init__(self, name):# 实例属性（每个用户独立）self.name = name# 保护属性（约定私有）self._session_id = id(self)# 私有属性（强私有）self.__password = "default"# 访问示例
u = User("Alice")
print(u.platform)        # 类属性 → "WebApp"
print(u.name)            # 实例属性 → "Alice"
print(u._session_id)     # 保护属性 → 123456
print(u.__password)      # 报错！AttributeError
print(u._User__password) # 私有属性 → "default"（不推荐）

2.方法（Methods）

(1). 实例方法

实例方法是属于对象的方法，第一个参数通常是 self，用于引用对象本身。

class Rectangle:def __init__(self, length, width):self.length = lengthself.width = width# 实例方法def area(self):return self.length * self.widthrect = Rectangle(5, 10)
print(rect.area())  # 输出: 50

(2).类方法

        类方法是属于类的方法，使用 @classmethod 装饰器定义，第一个参数通常是 cls，用于引用类本身。

class Pizza:def __init__(self, radius, ingredients):self.radius = radiusself.ingredients = ingredients@classmethoddef margherita(cls):return cls(12, ["tomato sauce", "mozzarella", "basil"])@classmethoddef pepperoni(cls):return cls(14, ["tomato sauce", "mozzarella", "pepperoni"])pizza1 = Pizza.margherita()
pizza2 = Pizza.pepperoni()print(pizza1.ingredients)  # 输出: ['tomato sauce', 'mozzarella', 'basil']
print(pizza2.radius)       # 输出: 14

(3).静态方法

静态方法是属于类的方法，使用 @staticmethod 装饰器定义，不需要 self 或 cls 参数。

class Math:@staticmethoddef add(a, b):return a + bresult = Math.add(3, 5)
print(result)  # 输出: 8

综合案例: 

class Calculator:# 类属性PI = 3.14159# 实例方法def add(self, a, b):return a + b# 类方法@classmethoddef circle_area(cls, radius):return cls.PI * radius ** 2# 静态方法@staticmethoddef is_even(num):return num % 2 == 0# 调用示例
calc = Calculator()
calc.add(2, 3)             # 实例方法 → 5
Calculator.circle_area(2)   # 类方法 → 12.56636
Calculator.is_even(7)       # 静态方法 → False

3.特殊成员（魔术方法）

        魔术方法（Magic Methods）是 Python 面向对象编程的核心特性，它们以双下划线开头和结尾（如 __init__），用于定义类的特殊行为。这些方法会在特定操作发生时自动调用，让自定义类拥有类似内置类型的行为。

1. 对象生命周期方法

class Lifecycle:def __new__(cls, *args, **kwargs):print("创建对象（内存分配）")return super().__new__(cls)def __init__(self, name):print(f"初始化对象: {name}")self.name = namedef __del__(self):print(f"销毁对象: {self.name}")obj = Lifecycle("Test")  # 输出: 创建对象 → 初始化对象: Test
del obj                 # 输出: 销毁对象: Test

2. 字符串表示方法

class Person:def __init__(self, name, age):self.name = nameself.age = age# 用户友好展示def __str__(self):return f"{self.name} ({self.age}岁)"# 开发者调试/重建对象def __repr__(self):return f"Person('{self.name}', {self.age})"# 格式化输出def __format__(self, format_spec):if format_spec == 'short':return self.name[0].upper()return str(self)p = Person("张三", 30)
print(str(p))    # 张三 (30岁)
print(repr(p))   # Person('张三', 30)
print(f"{p:short}")  # 张

 其他不在一一展示

class Vector2D:def __init__(self, x, y):self.x = xself.y = y# 字符串表示（用户友好）def __str__(self):return f"({self.x}, {self.y})"# 运算符重载（向量加法）def __add__(self, other):return Vector2D(self.x + other.x, self.y + other.y)# 长度定义（模长）def __len__(self):return int((self.x**2 + self.y**2)**0.5)v1 = Vector2D(3, 4)
v2 = Vector2D(1, 2)
print(v1)          # 触发__str__ → (3, 4)
print(v1 + v2)     # 触发__add__ → (4, 6)
print(len(v1))     # 触发__len__ → 5

四、高级特性

1.属性访问控制

@property装饰器实现属性保护

class Temperature:def __init__(self, celsius):self._celsius = celsius  # 保护属性@propertydef celsius(self):  # Getterreturn self._celsius@celsius.setterdef celsius(self, value):if value < -273.15:raise ValueError("Too cold")self._celsius = value

2.抽象基类（ABC）

定义接口规范

from abc import ABC, abstractmethodclass Animal(ABC):@abstractmethoddef speak(self):passclass Cat(Animal):def speak(self):  # 必须实现抽象方法return "Meow"