对象（Object）
对象是类的实例化，也可以理解为类定义的一个具体实体。对象具有自己的状态（属性）和行为（方法）。通过使用类名后面加上括号的方式来创建对象。在 Python 中，使用关键字 class 来定义类。
示例代码一
class Person: # 定义一个名为Person的类。 def say_hello(self): # 定义一个方法（函数）叫做say_hello，它有一个参数self。self代表当前对象的实例。 print("Hello, I am a person!") # 打印输出文本"Hello, I am a person!" person = Person() # 创建一个名为person的实例，使用Person类来初始化它。 person.say_hello() # 调用person对象的say_hello方法，输出：Hello, I am a person!
运行效果:
解释说明
class Person:表示定义了一个名为Person的类。def say_hello(self):定义了一个名为say_hello的方法，方法名后的括号中的self表示这个方法属于Person类的实例，即针对该类的对象进行操作。print("Hello, I am a person!")在say_hello方法内部，用于打印输出文本"Hello, I am a person!"。person = Person()创建一个名为person的实例，使用Person类来初始化它。这里实际上调用了Person类的构造函数，将创建的实例赋给变量person。person.say_hello()调用person对象的say_hello方法。这里通过对象实例person来调用类中的方法，因为say_hello方法没有传入其他参数，所以调用时不需要传入参数。
类的成员方法（Method）
类的成员方法是定义在类内部的函数，用于执行特定的任务。它们通常在对象实例上调用，并且可以访问类的属性。在成员方法内部，通过 self 关键字引用对象本身。
示例代码二
class Calculator: # 定义一个名为Calculator的类。 def add(self, a, b): # 定义一个名为add的方法，它有三个参数self、a、b。 return a + b # 返回a和b的和。 def subtract(self, a, b): # 定义一个名为subtract的方法，它有三个参数self、a、b。 return a - b # 返回a和b的差。 calculator = Calculator() # 创建一个名为calculator的实例，使用Calculator类来初始化它。 result = calculator.add(2, 3) # 调用calculator对象的add方法，并传入参数2和3。将返回值赋给变量result。 print(result) # 打印输出变量result的值。输出：5 result = calculator.subtract(5, 2) # 调用calculator对象的subtract方法，并传入参数5和2。将返回值赋给变量result。 print(result) # 打印输出变量result的值。输出：3
解释说明：
class Calculator:表示定义了一个名为Calculator的类。def add(self, a, b):定义了一个名为add的方法，方法名后的括号中的self表示这个方法属于Calculator类的实例，即针对该类的对象进行操作。方法还有两个参数a和b，用于接收需要进行相加的两个数。return a + b在add方法内部，通过将a和b相加的结果作为返回值。def subtract(self, a, b):定义了一个名为subtract的方法，方法名后的括号中的self表示这个方法属于Calculator类的实例，即针对该类的对象进行操作。方法还有两个参数a和b，用于接收需要进行相减的两个数。return a - b在subtract方法内部，通过将a和b相减的结果作为返回值。calculator = Calculator()创建一个名为calculator的实例，使用Calculator类来初始化它。result = calculator.add(2, 3)调用calculator对象的add方法，并传入参数2和3。将返回的结果赋给变量result。print(result)打印输出变量result的值。输出：5，因为2 + 3 的结果是5。result = calculator.subtract(5, 2)调用calculator对象的subtract方法，并传入参数5和2。将返回的结果赋给变量result。print(result)打印输出变量result的值。输出：3，因为5 - 2 的结果是3。
类和对象（Class and Object）：
类是一种蓝图或模板，它定义了对象的属性和方法。对象是类的实例，它具有类定义的特性。通过类，我们可以创建多个对象，每个对象都有独立的属性值。
示例代码三
class Circle: # 定义了一个名为Circle的类。 def __init__(self, radius): # 定义了一个特殊方法__init__，用于初始化对象的属性。方法有两个参数self和radius。 self.radius = radius # 将传入的radius参数赋值给实例的属性radius。 def calculate_area(self): # 定义了一个名为calculate_area的方法，它有一个参数self。 return 3.14 * self.radius ** 2 # 返回圆的面积，计算公式为3.14乘以半径的平方。 circle1 = Circle(5) # 创建一个名为circle1的实例，使用Circle类来初始化它，并传入参数5作为radius的值。 area1 = circle1.calculate_area() # 调用circle1对象的calculate_area方法，计算圆的面积。将返回值赋给变量area1。 print(area1) # 打印输出变量area1的值。输出：78.5，因为半径为5的圆的面积是78.5。 circle2 = Circle(3) # 创建一个名为circle2的实例，使用Circle类来初始化它，并传入参数3作为radius的值。 area2 = circle2.calculate_area() # 调用circle2对象的calculate_area方法，计算圆的面积。将返回值赋给变量area2。 print(area2) # 打印输出变量area2的值。输出：28.26，因为半径为3的圆的面积是28.26。
解释说明：
class Circle:表示定义了一个名为Circle的类。def __init__(self, radius):定义了一个特殊方法__init__，用于初始化对象的属性。方法名前后的双下划线表示这是一个特殊方法。它有两个参数self和radius，其中self表示当前对象的实例，radius是用于指定圆的半径。self.radius = radius通过将传入的radius参数赋值给实例的属性radius，将radius的值存储在实例变量中，以便后续使用。def calculate_area(self):定义了一个名为calculate_area的方法，方法名后的括号中的self表示这个方法属于Circle类的实例，即针对该类的对象进行操作。return 3.14 * self.radius ** 2在calculate_area方法内部，计算并返回圆的面积。使用数学公式（π × 半径的平方）计算圆的面积。circle1 = Circle(5)创建一个名为circle1的实例，使用Circle类来初始化它。传入参数5作为radius属性的值，表示创建一个半径为5的圆。area1 = circle1.calculate_area()调用circle1对象的calculate_area方法，计算圆的面积。将返回的结果赋给变量area1。print(area1)打印输出变量area1的值。输出：78.5，因为半径为5的圆的面积是78.5。circle2 = Circle(3)创建一个名为circle2的实例，使用Circle类来初始化它。传入参数3作为radius属性的值，表示创建一个半径为3的圆。area2 = circle2.calculate_area()调用circle2对象的calculate_area方法，计算圆的面积。将返回的结果赋给变量area2。print(area2)打印输出变量area2的值。输出：28.26，因为半径为3的圆的面积是28.26。
构造方法（Constructor）：
构造方法是一种特殊的方法，它在创建对象时自动调用。它用于初始化对象的属性。在 Python 中，构造方法的名称是 __init__()。通过构造方法，我们可以为对象传递初始值。
示例代码四
class Person: # 定义一个名为Person的类。 def __init__(self, name): # 定义一个特殊方法__init__用于初始化对象的属性，它有两个参数self和name。 self.name = name # 将传入的name参数赋值给实例的属性name。 def say_hello(self): # 定义一个名为say_hello的方法，它有一个参数self。self代表当前对象的实例。 print(f"Hello, my name is {self.name}.") # 使用f-string格式化字符串，打印输出"Hello, my name is {self.name}." person = Person("若城") # 创建一个名为person的实例，使用Person类来初始化它，并传入参数"若城"作为name的值。 person.say_hello() # 调用person对象的say_hello方法，输出：Hello, my name is 若城.
运行效果:
>解释说明：
class Person:表示定义了一个名为Person的类。def __init__(self, name):定义了一个特殊方法__init__，用于初始化对象的属性。方法名前后的双下划线表示这是一个特殊方法。它有两个参数self和name，其中self表示当前对象的实例，name是用于指定对象的名称。self.name = name通过将传入的name参数赋值给实例的属性name，将name的值存储在实例变量中，以便后续使用。def say_hello(self):定义了一个名为say_hello的方法，方法名后的括号中的self表示这个方法属于Person类的实例，即针对该类的对象进行操作。print(f"Hello, my name is {self.name}.")在say_hello方法内部，使用f-string格式化字符串打印输出文本。其中，{self.name}将会被实例的属性name的值所替代，输出类似于"Hello, my name is 若城."的文本。person = Person("若城")创建一个名为person的实例，使用Person类来初始化它。传入参数"若城"作为name属性的值，用于指定person对象的名称。person.say_hello()调用person对象的say_hello方法。通过对象实例person来调用类中的方法，因为say_hello方法没有传入其他参数，所以调用时不需要传入额外参数。
魔术方法（Magic Methods）：
魔术方法是以双下划线开头和结尾的特殊方法，用于在特定情况下自动调用。例如，__init__() 是一个构造方法，__str__() 用于返回对象的字符串表示。通过覆盖这些魔术方法，我们可以自定义类的行为。
示例代码五
class Point: # 定义了一个名为Point的类。 def __init__(self, x, y): # 定义了一个特殊方法__init__，用于初始化对象的属性。方法有三个参数self、x和y。 self.x = x # 将传入的x参数赋值给实例的属性x。 self.y = y # 将传入的y参数赋值给实例的属性y。 def __str__(self): # 定义了一个特殊方法__str__，用于返回对象的字符串表示。 return f"Point({self.x}, {self.y})" # 返回形如"Point(x, y)"的字符串，其中x和y是实例的属性值。 point = Point(2, 3) # 创建一个名为point的实例，使用Point类来初始化它，并传入参数2和3作为x和y的值。 print(point) # 打印输出实例point的字符串表示。输出：Point(2, 3)，因为根据__str__方法的定义，打印输出的结果是"Point(2, 3)"。
- 代码定义了一个名为
Point的类，它表示一个点的坐标。Point类有两个属性：x和y，分别表示点的横坐标和纵坐标。 __init__方法是一个特殊方法，用于在创建对象时进行初始化操作。它有三个参数：self（表示当前对象实例）、x和y。在__init__方法内部，将传入的x参数赋值给实例的x属性，将传入的y参数赋值给实例的y属性。__str__方法也是一个特殊方法，用于返回对象的字符串表示。在本例中，__str__方法被重写，它返回形如"Point(x, y)"的字符串，其中x和y是实例的属性值。- 代码创建了一个名为
point的实例，使用Point类来初始化它，并传入参数2和3作为x和y的值。这样就创建了一个横坐标为2、纵坐标为3的点。 - 通过
print(point)打印输出实例point的字符串表示，即输出：“Point(2, 3)”。因为根据__str__方法的定义，打印输出的结果是"Point(2, 3)"。
封装（Encapsulation）：
封装是面向对象编程中的一个重要特性，它将数据和操作封装在类中，并通过公共接口提供对数据的访问。在 Python 中，我们使用属性和方法来实现封装。
示例代码六
class BankAccount: # 定义了一个名为BankAccount的类。 def __init__(self, balance): # 定义了一个特殊方法__init__，用于初始化对象的属性。方法有两个参数self和balance。 self._balance = balance # 将传入的balance参数赋值给实例的属性_balance。 def deposit(self, amount): # 定义了一个名为deposit的方法，它有两个参数self和amount。 self._balance += amount # 将amount加到实例的属性_balance上。 def withdraw(self, amount): # 定义了一个名为withdraw的方法，它有两个参数self和amount。 if self._balance >= amount: # 检查实例的属性_balance是否大于等于amount。 self._balance -= amount # 如果满足条件，将amount从实例的属性_balance中减去。 else: print("Insufficient funds.") # 如果不满足条件，打印输出"Insufficient funds."。 def get_balance(self): # 定义了一个名为get_balance的方法，它有一个参数self。 return self._balance # 返回实例的属性_balance的值。 account = BankAccount(1000) # 创建一个名为account的实例，使用BankAccount类来初始化它，并传入参数1000作为balance的值。 account.withdraw(500) # 调用account对象的withdraw方法，从账户中取出500。 print(account.get_balance()) # 打印输出调用account对象的get_balance方法的返回值。输出：500，因为初始余额为1000，取出了500。 account.deposit(100) # 调用account对象的deposit方法，向账户中存入100。 print(account.get_balance()) # 打印输出调用account对象的get_balance方法的返回值。输出：600，因为账户余额为500，存入了100。
解释说明
- 代码定义了一个名为
BankAccount的类，它表示一个银行账户。BankAccount类有一个属性_balance，表示账户的余额。注意，属性名前面的下划线_表示这是一个私有属性。 __init__方法是一个特殊方法，用于在创建对象时进行初始化操作。它有两个参数：self（表示当前对象实例）和balance（表示账户的初始余额）。在__init__方法内部，将传入的balance参数赋值给实例的_balance属性。deposit方法用于向账户中存款，它有两个参数：self和amount（表示要存入的金额）。在方法内部，将amount加到实例的_balance属性上，以增加账户余额。withdraw方法用于从账户中取款，它有两个参数：self和amount（表示要取出的金额）。在方法内部，首先检查账户的余额是否足够支付取款金额。如果足够，则从实例的_balance属性中减去amount，以更新账户余额。否则，打印输出"Insufficient funds."表示余额不足。get_balance方法用于获取账户的余额，它只有一个参数：self。在方法内部，直接返回实例的_balance属性的值。- 代码创建了一个名为
account的实例，使用BankAccount类来初始化它，并传入参数1000作为初始余额。这样就创建了一个初始余额为1000的银行账户。 - 通过调用
account.withdraw(500)方法从账户中取出500。此时账户的余额为500。 - 通过调用
print(account.get_balance())打印输出调用account.get_balance()方法的返回值，即账户的余额。输出为500，因为初始余额为1000，取出了500。 - 再次调用
account.deposit(100)方法，向账户中存入100。此时账户的余额为600。 - 通过调用
print(account.get_balance())打印输出调用account.get_balance()方法的返回值，即账户的余额。输出为600，因为账户余额为500，存入了100。
继承（Inheritance）：
继承是一种机制，允许一个类继承另一个类的属性和方法。被继承的类称为父类或基类，继承的类称为子类或派生类。子类可以重写父类的方法或添加新的方法。
示例代码七
class Animal: # 定义了一个名为Animal的类。 def sound(self): # 定义了一个名为sound的方法，它有一个参数self。 print("Animal makes a sound.") # 打印输出"Animal makes a sound."。 class Dog(Animal): # 定义了一个名为Dog的类，它继承自Animal类。 def sound(self): # 定义了一个名为sound的方法，它有一个参数self。 print("Dog 汪汪.") # 打印输出"Dog 汪汪."。 class Cat(Animal): # 定义了一个名为Cat的类，它继承自Animal类。 def sound(self): # 定义了一个名为sound的方法，它有一个参数self。 print("Cat 喵喵.") # 打印输出"Cat 喵喵."。 dog = Dog() # 创建一个名为dog的对象实例，使用Dog类来初始化它。 dog.sound() # 调用对象实例dog的sound方法，输出：Dog barks.，因为Dog类重写了从父类Animal继承而来的sound方法。 cat = Cat() # 创建一个名为cat的对象实例，使用Cat类来初始化它。 cat.sound() # 调用对象实例cat的sound方法，输出：Cat meows.，因为Cat类重写了从父类Animal继承而来的sound方法。
解释说明
- 代码定义了一个名为
Animal的类，它表示一个动物。Animal类有一个方法sound，用于输出动物发出的声音。 Dog和Cat类都继承自Animal类，通过使用圆括号将父类的名称放在类名后面来实现继承。这样，Dog和Cat类就具有了Animal类中定义的属性和方法。Dog类中重写了从父类Animal继承而来的sound方法，输出的是"Dog 汪汪."，表示狗发出的声音是“汪汪”。Cat类中也重写了从父类Animal继承而来的sound方法，输出的是"Cat 喵喵."，表示猫发出的声音是“喵喵”。- 代码创建了一个名为
dog的对象实例，使用Dog类来初始化它。然后，通过调用dog.sound()方法，输出为"Dog 汪汪."，即狗发出了“汪汪”的声音。 - 再次创建了一个名为
cat的对象实例，使用Cat类来初始化它。然后，通过调用cat.sound()方法，输出为"Cat 喵喵."，即猫发出了“喵喵”的声音。
类型注解（Type Annotations）：
类型注解是 Python 3.5 引入的一项功能，可以在函数声明和变量声明中指定类型信息。类型注解并不会改变 Python 的动态特性，但可以提供类型检查和文档生成等好处。
示例代码八
def add_numbers(a: int, b: int) -> int: # 定义了一个名为add_numbers的函数，接受两个参数a和b，并指定它们的类型为int，返回值类型为int。 return a + b # 返回a和b的和。 result = add_numbers(1, 2) # 调用add_numbers函数，并传入参数1和2。将函数的返回值赋给result变量。 print(result) # 打印输出result的值。输出：3，因为1加2等于3。
解释说明
- 代码定义了一个名为
add_numbers的函数，它接受两个参数a和b，并且指定它们的类型为整数（int）。函数的返回值类型也被指定为整数（int）。 - 在函数体内，通过
return语句返回了a和b的和，即a + b。 - 通过调用
add_numbers(1, 2)函数，并传入参数1和2。函数将计算1 + 2的结果，并将结果返回。返回的值被赋给result变量。 - 通过调用
print(result)打印输出result的值，即3。这是因为1 + 2的结果为3。
多态（Polymorphism）：
多态是面向对象编程的重要概念，它允许不同的对象对相同的消息作出不同的响应。通过多态，我们可以实现代码的灵活性和可扩展性。在 Python 中，多态是通过继承和方法重写来实现的。
示例代码九
# 定义一个名为Shape的基类 class Shape: def calculate_area(self): pass # 定义一个名为Rectangle的子类，继承自Shape类 class Rectangle(Shape): def __init__(self, width, height): self.width = width self.height = height # 重写calculate_area方法，计算矩形的面积 def calculate_area(self): return self.width * self.height # 定义一个名为Circle的子类，继承自Shape类 class Circle(Shape): def __init__(self, radius): self.radius = radius # 重写calculate_area方法，计算圆形的面积 def calculate_area(self): return 3.14 * self.radius ** 2 # 创建一个包含矩形和圆形对象的列表 shapes = [Rectangle(4, 5), Circle(3)] # 遍历形状列表并计算每个形状的面积 for shape in shapes: # 调用各个形状对象的calculate_area方法计算面积 area = shape.calculate_area() # 打印输出每个形状对象的面积 print(area)
解释说明
class Shape: def calculate_area(self): pass
定义了一个名为Shape的类。该类表示形状，它有一个calculate_area方法，但是方法体内什么也没有。这个方法在子类中会被重写。
class Rectangle(Shape): def __init__(self, width, height): self.width = width self.height = height def calculate_area(self): return self.width * self.height
定义了一个名为Rectangle的类，它继承自Shape类。Rectangle类有一个构造方法__init__，用于初始化矩形对象的宽度和高度。然后，它重写了继承自Shape类的calculate_area方法，以计算矩形的面积并返回。
class Circle(Shape): def __init__(self, radius): self.radius = radius def calculate_area(self): return 3.14 * self.radius ** 2
定义了一个名为Circle的类，它继承自Shape类。Circle类有一个构造方法__init__，用于初始化圆形对象的半径。然后，它重写了继承自Shape类的calculate_area方法，以计算圆形的面积并返回。
shapes = [Rectangle(4, 5), Circle(3)]
创建一个名为shapes的列表，包含了一个矩形对象和一个圆形对象。矩形的宽度为4，高度为5。圆形的半径为3。
for shape in shapes: area = shape.calculate_area() print(area)
使用for循环遍历shapes列表中的每个元素，并将当前元素赋值给变量shape。
在循环体内，调用shape对象的calculate_area()方法来计算形状的面积，并将结果赋给变量area。
然后，通过print(area)打印输出每个形状的面积。这将依次输出矩形的面积（20）和圆形的面积（28.26）。
完结
