什么是面向对象编程（OOP）？
面向对象编程（Object-Oriented Programming，简称OOP）是一种常用的编程范式，它以对象为核心，将数据和操作封装在一起，通过定义类和创建实例来实现代码的组织和重用。
在面向对象编程中，我们通过抽象出具有相似特征的数据和功能，定义类（Class），并使用这些类创建实例（Instance）。每个对象都具有特定的属性（Attributes）和方法（Methods），这些共同的特征和行为被封装在类中，使得代码变得模块化、可维护和可扩展。
Python是一种支持面向对象编程的动态语言，它提供了易于理解和使用的语法，使得面向对象编程在Python中变得简单而强大。
类与实例的定义
在Python中，可以使用class关键字定义一个类，并使用该类创建实例。下面是一个简单的示例：
class Person:
def __init__(self, name, age):
self.name = name
self.age = age
def say_hello(self):
print(f"Hello, my name is {self.name} and I am {self.age} years old.")
# 创建实例
person1 = Person("Alice", 25)
person2 = Person("Bob", 30)
# 调用实例方法
person1.say_hello() # 输出：Hello, my name is Alice and I am 25 years old.
person2.say_hello() # 输出：Hello, my name is Bob and I am 30 years old.
在上面的示例中，我们定义了一个名为Person的类。类包含了一个特殊的方法__init__，它被称为构造方法（Constructor），在创建实例时自动调用。构造方法接受name和age两个参数，并将其赋值给实例属性self.name和self.age。
类中的方法使用def关键字进行定义，第一个参数通常被命名为self，表示对当前实例的引用。在示例中，我们定义了一个名为say_hello的方法，用于打印实例的姓名和年龄。
通过调用类来创建实例，我们可以使用实例访问类的属性和方法。在示例中，我们分别创建了person1和person2两个Person类的实例，然后使用实例的say_hello方法打印出相应的信息。
类的属性和方法
类不仅可以包含实例属性和方法，还可以拥有类属性和类方法。类属性是类级别的属性，它们被所有实例共享；而类方法则是与类相关联的方法，可以通过类本身调用。
下面是一个展示类属性和类方法的示例：
class Circle:
pi = 3.14159
def __init__(self, radius):
self.radius = radius
def get_area(self):
return self.pi * self.radius ** 2
@classmethod
def update_pi(cls, new_pi):
cls.pi = new_pi
# 创建实例
circle1 = Circle(5)
circle2 = Circle(10)
# 访问类属性
print(circle1.pi) # 输出：3.14159
print(circle2.pi) # 输出：3.14159
# 调用实例方法
print(circle1.get_area()) # 输出：78.53975
print(circle2.get_area()) # 输出：314.159
# 调用类方法
Circle.update_pi(3.14)
# 访问修改后的类属性
print(circle1.pi) # 输出：3.14
print(circle2.pi) # 输出：3.14
在上述示例中，我们定义了一个名为Circle的类。类属性pi表示圆的π值，在所有实例间共享。构造方法接收一个radius参数，并将其赋值给实例属性self.radius。
类中定义了一个名为get_area的实例方法，用于计算圆的面积。该方法通过访问实例属性和类属性来完成计算。
类方法使用@classmethod装饰器进行标记，以表示它与类相关联。在示例中，我们定义了一个名为update_pi的类方法，用于更新类属性pi的值。
通过创建实例并调用相应的属性和方法，我们可以操作类属性和实例属性，并使用类方法来更新类属性的值。
继承与多态
面向对象编程的一个重要概念是继承（Inheritance），它允许一个类通过继承另一个类的属性和方法，并可以进行拓展和修改。
下面是一个展示继承与多态的示例：
class Animal:
def __init__(self, name):
self.name = name
def speak(self):
raise NotImplementedError("Subclass must implement abstract method")
class Dog(Animal):
def speak(self):
return "Woof!"
class Cat(Animal):
def speak(self):
return "Meow!"
# 创建实例
dog = Dog("Buddy")
cat = Cat("Kitty")
# 调用实例方法
print(dog.speak()) # 输出：Woof!
print(cat.speak()) # 输出：Meow!
在上述示例中，我们定义了一个名为Animal的基类，并声明了一个抽象方法speak。抽象方法是一种特殊的方法，它只有方法签名而没有具体的实现。在Python中，可以通过抛出NotImplementedError来指示子类必须实现该方法。
然后，我们创建了Dog和Cat两个子类，它们分别继承了Animal的属性和方法。这两个子类实现了自己的speak方法，从而改变了父类的行为。
通过创建相应的子类实例，我们可以调用speak方法，它们的行为与父类不同，体现了多态性。这意味着我们可以通过一个统一的接口（speak方法），调用不同子类的实际实现。
封装与访问控制
面向对象编程通过封装（Encapsulation）来隐藏数据和实现细节，避免对外部代码的直接访问和修改。在Python中，可以使用访问控制限定符来实现封装。
下面是一个演示访问控制的示例：
class Person:
def __init__(self, name, age):
self._name = name # 使用单个下划线表示属性为受保护的属性
self.__age = age # 使用双下划线表示属性为私有属性
def get_name(self):
return self._name
def set_name(self, name):
self._name = name
def __get_age(self):
return self.__age
def __set_age(self, age):
self.__age = age
# 创建实例
person = Person("Alice", 25)
# 访问受保护的属性
print(person._name) # 输出：Alice
# 调用受保护的方法
person.set_name("Bob")
print(person.get_name()) # 输出：Bob
# 访问私有属性（会抛出错误）
#print(person.__age)
#print(person._Person__age)
# 调用私有方法（会抛出错误）
#print(person.__get_age())
#print(person._Person__get_age())
在上述示例中，我们定义了一个名为Person的类。该类有一个受保护的属性_name和一个私有属性__age。受保护的属性可以通过单个下划线进行访问，而私有属性则无法直接访问。
我们还定义了get_name和set_name两个公共方法来访问和修改_name属性。这样，外部代码无法直接访问_name属性，只能通过公共方法进行操作，从而实现了对属性的访问控制。
在类中定义的私有方法get_age和set_age也遵循了相同的访问控制规则。它们是无法直接调用的，只能在类的内部使用。
需要注意的是，Python的访问控制并不是严格的限制，只是一种约定。因此，可以通过某些方式绕过这些访问控制机制，但通常不建议这样做，以保持良好的编程实践和代码可读性。
总结
本文介绍了Python中面向对象编程的基本概念。我们了解了类与实例的定义，学习了类属性和实例属性、类方法和实例方法的用法。
