Python面向对象编程基础知识和示例代码

文章目录

  • 对象(Object)
        • 示例代码一
  • 类的成员方法(Method)
        • 示例代码二
  • 类和对象(Class and Object):
        • 示例代码三
  • 构造方法(Constructor):
        • 示例代码四
  • 魔术方法(Magic Methods):
        • 示例代码五
  • 封装(Encapsulation):
        • 示例代码六
  • 继承(Inheritance):
        • 示例代码七
  • 类型注解(Type Annotations):
        • 示例代码八
  • 多态(Polymorphism):
        • 示例代码九
  • 完结

对象(Object)

Python面向对象编程基础知识和示例代码_第1张图片

对象是类的实例化,也可以理解为类定义的一个具体实体。对象具有自己的状态(属性)和行为(方法)。通过使用类名后面加上括号的方式来创建对象。在 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!

运行效果:
Python面向对象编程基础知识和示例代码_第2张图片

解释说明

  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)

Python面向对象编程基础知识和示例代码_第3张图片

类的成员方法是定义在类内部的函数,用于执行特定的任务。它们通常在对象实例上调用,并且可以访问类的属性。在成员方法内部,通过 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):

Python面向对象编程基础知识和示例代码_第4张图片

类是一种蓝图或模板,它定义了对象的属性和方法。对象是类的实例,它具有类定义的特性。通过类,我们可以创建多个对象,每个对象都有独立的属性值。

示例代码三

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面向对象编程基础知识和示例代码_第5张图片

构造方法是一种特殊的方法,它在创建对象时自动调用。它用于初始化对象的属性。在 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 若城.

运行效果:

Python面向对象编程基础知识和示例代码_第6张图片>解释说明:

  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):

Python面向对象编程基础知识和示例代码_第7张图片

魔术方法是以双下划线开头和结尾的特殊方法,用于在特定情况下自动调用。例如,__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类有两个属性:xy,分别表示点的横坐标和纵坐标。

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

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

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

  5. 通过print(point)打印输出实例point的字符串表示,即输出:“Point(2, 3)”。因为根据__str__方法的定义,打印输出的结果是"Point(2, 3)"。

封装(Encapsulation):

Python面向对象编程基础知识和示例代码_第8张图片

封装是面向对象编程中的一个重要特性,它将数据和操作封装在类中,并通过公共接口提供对数据的访问。在 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方法用于向账户中存款,它有两个参数:selfamount(表示要存入的金额)。在方法内部,将amount加到实例的_balance属性上,以增加账户余额。

  4. withdraw方法用于从账户中取款,它有两个参数:selfamount(表示要取出的金额)。在方法内部,首先检查账户的余额是否足够支付取款金额。如果足够,则从实例的_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):

Python面向对象编程基础知识和示例代码_第9张图片

继承是一种机制,允许一个类继承另一个类的属性和方法。被继承的类称为父类或基类,继承的类称为子类或派生类。子类可以重写父类的方法或添加新的方法。

示例代码七

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. DogCat类都继承自Animal类,通过使用圆括号将父类的名称放在类名后面来实现继承。这样,DogCat类就具有了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面向对象编程基础知识和示例代码_第10张图片

类型注解是 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的函数,它接受两个参数ab,并且指定它们的类型为整数(int)。函数的返回值类型也被指定为整数(int)。

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

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

  4. 通过调用print(result)打印输出result的值,即3。这是因为1 + 2的结果为3

多态(Polymorphism):

Python面向对象编程基础知识和示例代码_第11张图片

多态是面向对象编程的重要概念,它允许不同的对象对相同的消息作出不同的响应。通过多态,我们可以实现代码的灵活性和可扩展性。在 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)。

完结

Python面向对象编程基础知识和示例代码_第12张图片

你可能感兴趣的:(python案例分析归纳,python,类,对象,类型注解和多态,构造方法,成员方法,魔术方法)