在 Python 中，我们可以通过关键字 class 来定义一个类。在定义类之后，通过实例化这个类来创建一个对象。每个类中必须包含一个构造函数__init__()，它用来初始化对象。下面是一个简单的例子：
class Person:
def __init__(self, name): # 构造函数，初始化实例变量name
self.name = name
def say_hello(self): # 实例方法，打印问候语及name属性值
print("Hello, my name is", self.name)
person = Person("Tom") # 创建Person类的实例对象，传入参数"Tom"
person.say_hello() # 调用实例方法，输出问候语及name属性值
在这个例子中，我们定义了一个名为 Person 的类，并且定义了一个构造函数 __init__()，它接受一个参数 name。在构造函数中初始化了一个名为 name 的实例变量，并将其设置为传入的参数 name。还定义了一个名为 say_hello() 的方法，它用来打印一个问候语。在这个方法中，我们使用了 self.name 来引用实例变量 name。最后，我们创建了一个名为 person 的对象，并调用了它的 say_hello() 方法。
在 Python 中，我们可以通过类继承的方式来创建一个新的子类。子类可以继承父类的方法和属性，并且还可以添加自己的方法和属性。下面是一个简单的例子：
# 定义一个Animal类
class Animal:
def run(self):
print('动物在奔跑')
# 定义一个Dog类，继承自Animal类
class Dog(Animal):
def bark(self):
print('汪汪汪！')
# 定义一个Cat类，继承自Animal类
class Cat(Animal):
def catch(self):
print('抓老鼠！')
dog = Dog()
dog.run() # 输出 "动物在奔跑"
dog.bark() # 输出 "汪汪汪！"
cat = Cat()
cat.run() # 输出 "动物在奔跑"
cat.catch() # 输出 "抓老鼠！"
在这个例子中，我们定义了一个Animal类，其中有一个方法run。然后我们通过继承这个类，分别定义了一个Dog类和Cat类，并在这两个类中添加了自己的方法。现在，我们创建一个Dog实例和Cat实例，并调用它们各自的方法。
多态是面向对象编程中另一个重要的概念，它允许我们在不同的对象上调用相同的方法，这样就可以增加代码的灵活性。下面是一个多态例子：
# 定义一个Animal类
class Animal:
def run(self):
print('动物在奔跑')
# 定义一个Dog类，继承自Animal类
class Dog(Animal):
def talk(self):
print('汪汪汪！')
# 定义一个Cat类，继承自Animal类
class Cat(Animal):
def talk(self):
print('喵喵喵！')
# 定义一个函数，接受一个Animal实例作为参数
def animal_talk(animal):
animal.talk()
dog = Dog()
cat = Cat()
animal_talk(dog) # 输出 "汪汪汪！"
animal_talk(cat) # 输出 "喵喵喵！"
在上面的代码中，我们定义了一个函数animal_talk，它接受一个Animal实例作为参数，并且调用这个实例的talk方法。然后我们分别创建了一个Dog实例和Cat实例，并将它们作为参数传递给animal_talk函数。由于Dog和Cat都继承自Animal类，并且它们都有自己的talk方法，因此它们可以被当做参数传递给animal_talk函数，并且正确地输出对应的语句。
封装是面向对象编程中的又一个重要的概念，它允许我们把数据和方法作为一个整体封装起来，只对外暴露必要的方法和属性，这样可以保证数据的安全性，同时也减少了代码的耦合性。下面是一个简单的封装例子：
# 定义一个Person类
class Person:
def __init__(self, name, age):
self.name = name
self.age = age
self.__gender = 'male' # 私有属性
def say_hello(self):
print("Hello, my name is %s, I'm %s years old." % (self.name, self.age))
def get_gender(self):
return self.__gender
def set_gender(self, gender):
if gender in ['male', 'female']:
self.__gender = gender
else:
print('错误！性别只能是"male"或"female"')
p = Person('Tom', 18)
p.say_hello() # 输出 "Hello, my name is Tom, I'm 18 years old."
print(p.get_gender()) # 输出 "male"
p.set_gender('female')
print(p.get_gender()) # 输出 "female"
p.set_gender('其他') # 输出 "错误！性别只能是"male"或"female""
在上面的代码中，我们定义了一个Person类，其中有一个私有属性__gender，还有两个公有方法get_gender和set_gender，用来获取和设置__gender属性。由于__gender是私有属性，外部无法直接访问，因此需要通过类提供的公有方法来访问和修改属性值。
在 Python 中，我们可以使用类方法和静态方法来创建只属于类本身的方法。类方法是一种与类相关的方法。类方法可以访问类变量，并且它们可以在没有创建实例的情况下调用。静态方法是一种独立于类的方法。静态方法通常用于执行一些与类无关的任务，例如打印一个消息。下面是一个简单的例子：
以下是增加注释后的代码：
class MyClass:
class_variable = 10 # 类变量，属于类而非实例对象
@classmethod
def class_method(cls): # 类方法，第一个参数cls表示类本身，可以通过它来访问类变量和调用类方法
print(f"Class variable: {cls.class_variable}")
@staticmethod
def static_method(): # 静态方法，不需要访问实例或类的状态，因此不需要传入self或cls参数
print("This is a static method")
MyClass.class_method() # 调用类方法，输出类变量的值
MyClass.static_method() # 调用静态方法，输出提示信息
在这个例子中，我们定义了一个名为 MyClass 的类。它包括一个类变量 class_variable 和两个方法 class_method() 和 static_method()。 class_method() 方法是一个类方法，因为它使用了 @classmethod 装饰器。它可以访问类变量，并在没有创建实例的情况下调用。在本例中，我们打印了类变量的值。static_method() 方法是一个静态方法，因为它使用了 @staticmethod 装饰器。它是一个独立于类的方法，并可以在没有创建实例的情况下调用。最后，我们调用了这两个方法，并打印它们的输出结果。
在前面的例子中，我们已经使用过构造函数 __init__ 来初始化对象，构造函数的主要作用是在对象创建时初始化对象的成员变量，从而保证对象的正确初始化。构造函数的语法如下：
def __init__(self, arg1, arg2, ...):
'''Constructor docstring'''
self.var1 = value1
self.var2 = value2
...
构造函数的名称必须为 __init__，它的第一参数必须是 self，后续的参数是可选的。下面是一个使用构造函数初始化成员变量的例子：
class Circle:
'''Circle class'''
def __init__(self, radius):
'''constructor'''
self.radius = radius
可以看到，__init__ 方法接收一个参数 radius，并将其赋值给实例变量 self.radius。这样，在创建 Circle 类的对象时，就可以通过传递 radius 参数来初始化该对象的 radius 属性。
与构造函数相对应的是析构函数，它在对象被销毁时调用，用于清理对象占用的资源。析构函数的语法如下：
def __del__(self):
'''Destructor docstring'''
# release resources
析构函数的名称必须为 __del__，它的第一个参数也必须是 self。下面是一个使用析构函数释放资源的例子：
class MyClass:
'''MyClass'''
def __init__(self):
'''Constructor'''
self.resource = create_resource()
def __del__(self):
'''Destructor'''
release_resource(self.resource)
在上述代码中，MyClass 类的构造函数 __init__ 创建了一个资源，并将其保存在 self.resource 中。当对象被销毁时，析构函数 __del__ 将调用 release_resource() 函数来释放该资源。需要注意的是，Python 中的垃圾回收机制会自动回收对象占用的资源，因此析构函数并不是必需的，仅当需要手动完成清理工作时才需要定义析构函数。
