Python编程基础与实践:Python面向对象编程入门

原创已于 2025-08-04 10:21:02 修改 · 334 阅读

3 ·

CC 4.0 BY-SA版权

文章标签：

#python #开发语言 #编程语言

于 2025-08-04 09:37:00 首次发布

面向对象编程基础：从概念到实践

学习目标

通过本课程，学员将掌握Python中面向对象编程的基本概念，包括类和对象的定义、构造函数的使用、封装、继承和多态等核心概念。通过实践，学员将能够独立设计和实现简单的面向对象程序。

学习内容

1 面向对象编程基础

1.1 类和对象

在面向对象编程中，类（Class）是创建对象（Object）的模板。类定义了对象的属性和方法，而对象则是类的实例。通过类，可以创建多个具有相同属性和方法的对象，每个对象可以拥有不同的属性值。

1.1.1 类的定义

在Python中，使用class关键字来定义一个类。类的定义通常包括类名、属性和方法。类名通常首字母大写，以区别于其他变量名。

class Dog:
    # 类属性
    species = "Canis familiaris"

    # 初始化方法
    def __init__(self, name, age):
        self.name = name  # 实例属性
        self.age = age    # 实例属性

    # 实例方法
    def description(self):
        return f"{self.name} is {self.age} years old."

    # 另一个实例方法
    def speak(self, sound):
        return f"{self.name} says {sound}"

在这个例子中，Dog类定义了两个实例属性name和age，以及两个实例方法description和speak。species是一个类属性，所有Dog对象共享这个属性。

1.1.2 对象的创建

创建对象时，需要调用类的构造函数（__init__方法）。构造函数用于初始化对象的属性。

# 创建Dog对象
my_dog = Dog("Buddy", 3)

# 访问对象的属性
print(my_dog.name)  # 输出: Buddy
print(my_dog.age)   # 输出: 3

# 调用对象的方法
print(my_dog.description())  # 输出: Buddy is 3 years old.
print(my_dog.speak("Woof Woof"))  # 输出: Buddy says Woof Woof

1.2 封装

封装是面向对象编程的一个重要特性，它允许将数据和操作数据的方法绑定在一起，隐藏对象的内部实现细节，只暴露必要的接口给外部使用。封装可以提高代码的安全性和可维护性。
在Python中，可以通过在属性名前加两个下划线__来定义私有属性。私有属性不能直接从类的外部访问，但可以通过公共方法来访问和修改。

class BankAccount:
    def __init__(self, owner, balance=0):
        self.owner = owner
        self.__balance = balance  # 私有属性

    def deposit(self, amount):
        if amount > 0:
            self.__balance += amount
            print(f"Deposited {amount}. New balance: {self.__balance}")
        else:
            print("Deposit amount must be positive.")

    def withdraw(self, amount):
        if 0 < amount <= self.__balance:
            self.__balance -= amount
            print(f"Withdrew {amount}. New balance: {self.__balance}")
        else:
            print("Invalid withdrawal amount.")

    def get_balance(self):
        return self.__balance

# 创建BankAccount对象
account = BankAccount("Alice", 1000)

# 尝试直接访问私有属性（会失败）

# 通过公共方法访问和修改私有属性
account.deposit(500)  # 输出: Deposited 500. New balance: 1500
account.withdraw(200)  # 输出: Withdrew 200. New balance: 1300
print(account.get_balance())  # 输出: 1300

1.3 继承与多态

继承是面向对象编程中的另一个重要特性，它允许创建一个新类，继承现有类的属性和方法。新类称为子类，现有类称为父类或基类。多态是指子类可以覆盖或扩展父类的方法，以实现不同的行为。

1.3.1 继承

在Python中，可以通过在类定义时指定父类来实现继承。子类可以重用父类的属性和方法，也可以添加新的属性和方法。

class Animal:
    def __init__(self, name):
        self.name = name

    def speak(self):
        raise NotImplementedError("Subclass must implement abstract method")

class Dog(Animal):
    def speak(self):
        return f"{self.name} says Woof!"

class Cat(Animal):
    def speak(self):
        return f"{self.name} says Meow!"

# 创建Animal的子类对象
dog = Dog("Buddy")
cat = Cat("Whiskers")

# 调用子类的方法
print(dog.speak())  # 输出: Buddy says Woof!
print(cat.speak())  # 输出: Whiskers says Meow!

在这个例子中，Animal类定义了一个抽象方法speak，子类Dog和Cat分别实现了这个方法。通过继承，子类可以重用父类的属性和方法，同时也可以扩展新的功能。

1.3.2 多态

多态允许使用统一的接口来调用不同子类的方法，即使这些方法在不同的子类中实现方式不同。

def animal_speak(animal):
    print(animal.speak())

# 传递不同类型的对象
animal_speak(dog)  # 输出: Buddy says Woof!
animal_speak(cat)  # 输出: Whiskers says Meow!