Python面向对象编程基础知识和示例代码
文章目录
- 对象（Object）
-
-
-
- 示例代码一
-
-
- 类的成员方法（Method）
-
-
-
- 示例代码二
-
-
- 类和对象（Class and Object）：
-
-
-
- 示例代码三
-
-
- 构造方法（Constructor）：
-
-
-
- 示例代码四
-
-
- 魔术方法（Magic Methods）：
-
-
-
- 示例代码五
-
-
- 封装（Encapsulation）：
-
-
-
- 示例代码六
-
-
- 继承（Inheritance）：
-
-
-
- 示例代码七
-
-
- 类型注解（Type Annotations）：
-
-
-
- 示例代码八
-
-
- 多态（Polymorphism）：
-
-
-
- 示例代码九
-
-
- 完结
对象（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）。
完结
