对象（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!

运行效果:

解释说明

1. class Person: 表示定义了一个名为Person的类。

2. def say_hello(self): 定义了一个名为say_hello的方法，方法名后的括号中的self表示这个方法属于Person类的实例，即针对该类的对象进行操作。

3. print("Hello, I am a person!") 在say_hello方法内部，用于打印输出文本"Hello, I am a person!"。

4. person = Person() 创建一个名为person的实例，使用Person类来初始化它。这里实际上调用了Person类的构造函数，将创建的实例赋给变量person。

5. 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

解释说明：

1. class Calculator: 表示定义了一个名为Calculator的类。

2. def add(self, a, b): 定义了一个名为add的方法，方法名后的括号中的self表示这个方法属于Calculator类的实例，即针对该类的对象进行操作。方法还有两个参数a和b，用于接收需要进行相加的两个数。

3. return a + b 在add方法内部，通过将a和b相加的结果作为返回值。

4. def subtract(self, a, b): 定义了一个名为subtract的方法，方法名后的括号中的self表示这个方法属于Calculator类的实例，即针对该类的对象进行操作。方法还有两个参数a和b，用于接收需要进行相减的两个数。

5. return a - b 在subtract方法内部，通过将a和b相减的结果作为返回值。

6. calculator = Calculator() 创建一个名为calculator的实例，使用Calculator类来初始化它。

7. result = calculator.add(2, 3) 调用calculator对象的add方法，并传入参数2和3。将返回的结果赋给变量result。

8. print(result) 打印输出变量result的值。输出：5，因为2 + 3 的结果是5。

9. result = calculator.subtract(5, 2) 调用calculator对象的subtract方法，并传入参数5和2。将返回的结果赋给变量result。

10. 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。

解释说明：

1. class Circle: 表示定义了一个名为Circle的类。

2. def __init__(self, radius): 定义了一个特殊方法__init__，用于初始化对象的属性。方法名前后的双下划线表示这是一个特殊方法。它有两个参数self和radius，其中self表示当前对象的实例，radius是用于指定圆的半径。

3. self.radius = radius 通过将传入的radius参数赋值给实例的属性radius，将radius的值存储在实例变量中，以便后续使用。

4. def calculate_area(self): 定义了一个名为calculate_area的方法，方法名后的括号中的self表示这个方法属于Circle类的实例，即针对该类的对象进行操作。

5. return 3.14 * self.radius ** 2 在calculate_area方法内部，计算并返回圆的面积。使用数学公式（π × 半径的平方）计算圆的面积。

6. circle1 = Circle(5) 创建一个名为circle1的实例，使用Circle类来初始化它。传入参数5作为radius属性的值，表示创建一个半径为5的圆。

7. area1 = circle1.calculate_area() 调用circle1对象的calculate_area方法，计算圆的面积。将返回的结果赋给变量area1。

8. print(area1) 打印输出变量area1的值。输出：78.5，因为半径为5的圆的面积是78.5。

9. circle2 = Circle(3) 创建一个名为circle2的实例，使用Circle类来初始化它。传入参数3作为radius属性的值，表示创建一个半径为3的圆。

10. area2 = circle2.calculate_area() 调用circle2对象的calculate_area方法，计算圆的面积。将返回的结果赋给变量area2。

11. 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 若城.

运行效果:

>解释说明：

1. class Person: 表示定义了一个名为Person的类。

2. def __init__(self, name): 定义了一个特殊方法__init__，用于初始化对象的属性。方法名前后的双下划线表示这是一个特殊方法。它有两个参数self和name，其中self表示当前对象的实例，name是用于指定对象的名称。

3. self.name = name 通过将传入的name参数赋值给实例的属性name，将name的值存储在实例变量中，以便后续使用。

4. def say_hello(self): 定义了一个名为say_hello的方法，方法名后的括号中的self表示这个方法属于Person类的实例，即针对该类的对象进行操作。

5. print(f"Hello, my name is {self.name}.") 在say_hello方法内部，使用f-string格式化字符串打印输出文本。其中，{self.name}将会被实例的属性name的值所替代，输出类似于"Hello, my name is 若城."的文本。

6. person = Person("若城") 创建一个名为person的实例，使用Person类来初始化它。传入参数"若城"作为name属性的值，用于指定person对象的名称。

7. 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)"。

1. 代码定义了一个名为Point的类，它表示一个点的坐标。Point类有两个属性：x和y，分别表示点的横坐标和纵坐标。

2. __init__方法是一个特殊方法，用于在创建对象时进行初始化操作。它有三个参数：self（表示当前对象实例）、x和y。在__init__方法内部，将传入的x参数赋值给实例的x属性，将传入的y参数赋值给实例的y属性。

3. __str__方法也是一个特殊方法，用于返回对象的字符串表示。在本例中，__str__方法被重写，它返回形如"Point(x, y)"的字符串，其中x和y是实例的属性值。

4. 代码创建了一个名为point的实例，使用Point类来初始化它，并传入参数2和3作为x和y的值。这样就创建了一个横坐标为2、纵坐标为3的点。

5. 通过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。

解释说明

1. 代码定义了一个名为BankAccount的类，它表示一个银行账户。BankAccount类有一个属性_balance，表示账户的余额。注意，属性名前面的下划线 _ 表示这是一个私有属性。

2. __init__方法是一个特殊方法，用于在创建对象时进行初始化操作。它有两个参数：self（表示当前对象实例）和balance（表示账户的初始余额）。在__init__方法内部，将传入的balance参数赋值给实例的_balance属性。

3. deposit方法用于向账户中存款，它有两个参数：self和amount（表示要存入的金额）。在方法内部，将amount加到实例的_balance属性上，以增加账户余额。

4. withdraw方法用于从账户中取款，它有两个参数：self和amount（表示要取出的金额）。在方法内部，首先检查账户的余额是否足够支付取款金额。如果足够，则从实例的_balance属性中减去amount，以更新账户余额。否则，打印输出"Insufficient funds."表示余额不足。

5. get_balance方法用于获取账户的余额，它只有一个参数：self。在方法内部，直接返回实例的_balance属性的值。

6. 代码创建了一个名为account的实例，使用BankAccount类来初始化它，并传入参数1000作为初始余额。这样就创建了一个初始余额为1000的银行账户。

7. 通过调用account.withdraw(500)方法从账户中取出500。此时账户的余额为500。

8. 通过调用print(account.get_balance())打印输出调用account.get_balance()方法的返回值，即账户的余额。输出为500，因为初始余额为1000，取出了500。

9. 再次调用account.deposit(100)方法，向账户中存入100。此时账户的余额为600。

10. 通过调用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方法。

解释说明

1. 代码定义了一个名为Animal的类，它表示一个动物。Animal类有一个方法sound，用于输出动物发出的声音。

2. Dog和Cat类都继承自Animal类，通过使用圆括号将父类的名称放在类名后面来实现继承。这样，Dog和Cat类就具有了Animal类中定义的属性和方法。

3. Dog类中重写了从父类Animal继承而来的sound方法，输出的是"Dog 汪汪."，表示狗发出的声音是“汪汪”。

4. Cat类中也重写了从父类Animal继承而来的sound方法，输出的是"Cat 喵喵."，表示猫发出的声音是“喵喵”。

5. 代码创建了一个名为dog的对象实例，使用Dog类来初始化它。然后，通过调用dog.sound()方法，输出为"Dog 汪汪."，即狗发出了“汪汪”的声音。

6. 再次创建了一个名为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。

解释说明

1. 代码定义了一个名为add_numbers的函数，它接受两个参数a和b，并且指定它们的类型为整数（int）。函数的返回值类型也被指定为整数（int）。

2. 在函数体内，通过return语句返回了a和b的和，即a + b。

3. 通过调用add_numbers(1, 2)函数，并传入参数1和2。函数将计算1 + 2的结果，并将结果返回。返回的值被赋给result变量。

4. 通过调用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）。

完结