面向对象编程(Object-Oriented Programming, OOP) 是一种编程范式，它使用基于对象的方式来组织代码。Python 的面向对象编程可以使用 Class 来实现。Class 是 Python 中面向对象编程的核心，它可以实现面向对象编程中的封装、继承和多态等特性。
一、创建 Class
要定义一个 Class，可以使用 class 关键字。
class Person:
def __init__(self, name, age):
self.name = name
self.age = age
以上代码定义了一个名为 Person 的 Class，该 Class 有两个属性：name 和 age。__init__ 方法是 Class 的构造函数，当创建 Class 对象时会自动调用该方法，self 参数代表对象本身。可以通过如下代码创建一个 Person 对象：
person = Person("Jack", 30)
print(person.name) # 输出 Jack
print(person.age) # 输出 30
该代码会创建一个名为 person 的对象，同时输出 person 对象的 name 和 age 属性。
二、继承与多态
继承是指新的 Class 可以基于现有 Class 创建。Python 支持单继承和多重继承。
在继承时，新的 Class 被称为子类（Subclass），已有 Class 被称为父类（Superclass）。子类会自动继承父类的属性和方法，并且可以重写、添加或删除这些属性和方法。
class Student(Person):
def __init__(self, name, age, grade):
super().__init__(name, age)
self.grade = grade
def study(self):
print(self.name, "is studying in grade", self.grade)
student = Student("Tom", 18, 12)
print(student.name) # 输出 Tom
print(student.age) # 输出 18
print(student.grade) # 输出 12
student.study() # 输出 Tom is studying in grade 12
以上代码定义了一个名为 Student 的子类，该子类继承了 Person 父类的 name 和 age 属性，并添加了一个 grade 属性和 study 方法。可以通过如下代码创建一个 Student 对象：
该代码会创建一个名为 student 的对象，输出 student 对象的 name、age 和 grade 属性，同时调用 student 对象的 study 方法。
多态是指在继承关系中，子类可以使用父类定义的方法，但是可以自己定义该方法的实现，也可以使用父类已定义的方法实现。这样，在不同的情况下，子类可以使用自己的方法实现，父类方法的实现也可以被使用。
三、封装
封装是指把代码和数据包装在一起，以便于隐藏内部实现细节。Python 中，可以使用公开、私有和受保护的访问修饰符来实现封装。
公开访问修饰符用于定义公共属性和方法，可以通过 Class 的对象来访问它们。
class Car:
def __init__(self, color):
self.color = color
def start(self):
print("The car is starting...")
car = Car("red")
print(car.color) # 输出 red
car.start() # 输出 The car is starting...
以上代码定义了一个名为 Car 的 Class，该 Class 有一个公共属性 color 和一个公共方法 start。可以通过如下代码创建一个 Car 对象：
该代码会创建一个名为 car 的对象，输出 car 对象的 color 属性，并调用 car 对象的 start 方法。
私有访问修饰符用于定义私有属性和方法，可以在 Class 内部访问它们，但是无法在 Class 的外部访问它们。
class BankAccount:
def __init__(self, balance):
self.__balance = balance
def deposit(self, amount):
self.__balance += amount
def withdraw(self, amount):
if amount <= self.__balance:
self.__balance -= amount
else:
print("Not enough balance")
account = BankAccount(1000)
account.deposit(500)
account.withdraw(2000) # 不足 2000 的余额，将输出 Not enough balance
以上代码定义了一个名为 BankAccount 的 Class，该 Class 有一个私有属性 balance，以及两个公共方法 deposit 和 withdraw。私有属性 balance 可以通过双下划线加变量名的方式定义。
可以通过如下代码创建一个 BankAccount 对象，并分别调用它的 deposit 和 withdraw 方法。由于 balance 属性是私有的，无法在 Class 的外部直接访问该属性。
受保护访问修饰符用于定义受保护的属性和方法，可以在 Class 及其子类中访问它们，但是无法在 Class 的外部访问它们。
class Animal:
def __init__(self, name, species):
self._name = name
self._species = species
def _eat(self):
print(self._name, "is eating...")
class Dog(Animal):
def __init__(self, name, breed):
super().__init__(name, "Dog")
self._breed = breed
def bark(self):
print(self._name, "is barking...")
dog = Dog("Charlie", "Golden Retriever")
dog.bark() # 输出 Charlie is barking...
dog._eat() # 输出 Charlie is eating...
以上代码定义了一个名为 Animal 的 Class 和一个名为 Dog 的子类。Animal Class 有两个受保护的属性 _name 和 _species，以及一个受保护的方法 _eat。Dog Class 继承了 Animal Class，并添加了一个受保护的属性 _breed 和一个公共方法 bark。在子类中可以通过 self._name 访问父类的受保护属性 _name，输出 dog 对象的 name 属性，同时调用 dog 对象的 bark 和 _eat 方法。
