python零基础入门 （8）-- 面向对象

前言

Python是一种简单易学、功能强大的编程语言，它支持面向对象编程（Object-Oriented Programming，简称OOP）。面向对象编程是一种编程范式，它将程序中的数据和操作数据的方法封装在一起，形成一个对象。通过使用面向对象编程，我们可以更好地组织和管理代码，提高代码的可重用性和可维护性。本教程将介绍Python面向对象编程的基本概念和使用方法，帮助读者快速入门。

1. 面向对象编程基础

1.1 类和对象

在面向对象编程中，类是对象的模板，用于定义对象的属性和方法。对象是类的实例，通过实例化类来创建对象。下面是一个简单的示例：

# 定义一个类
class Car:
    # 类的属性
    color = "red"
    brand = "Toyota"
    
    # 类的方法
    def start(self):
        print("The car is starting.")
    
    def stop(self):
        print("The car is stopping.")

# 实例化类，创建对象
my_car = Car()

# 访问对象的属性
print(my_car.color)  # 输出：red
print(my_car.brand)  # 输出：Toyota

# 调用对象的方法
my_car.start()  # 输出：The car is starting.
my_car.stop()  # 输出：The car is stopping.

1.2 属性和方法

类中的属性是用于存储数据的变量，方法是用于操作数据的函数。属性和方法都可以在类的内部和外部进行访问。下面是一个示例：

class Dog:
    # 类的属性
    breed = "Labrador"
    
    # 类的方法
    def bark(self):
        print("The dog is barking.")
    
    def eat(self, food):
        print(f"The dog is eating {food}.")
​
# 创建对象
my_dog = Dog()
​
# 访问对象的属性
print(my_dog.breed)  # 输出：Labrador
​
# 调用对象的方法
my_dog.bark()  # 输出：The dog is barking.
my_dog.eat("bone")  # 输出：The dog is eating bone.

1.3 封装、继承和多态

封装是将数据和操作数据的方法封装在一起，形成一个对象。继承是一种通过创建新类来继承现有类的属性和方法的机制。多态是指同一种方法可以在不同的类中具有不同的实现方式。下面是一个示例：

# 封装
class Circle:
    def __init__(self, radius):
        self.radius = radius
    
    def get_area(self):
        return 3.14 * self.radius * self.radius
​
my_circle = Circle(5)
print(my_circle.get_area())  # 输出：78.5
​
# 继承
class Animal:
    def __init__(self, name):
        self.name = name
    
    def speak(self):
        pass
​
class Cat(Animal):
    def speak(self):
        print("Meow!")
​
class Dog(Animal):
    def speak(self):
        print("Woof!")
​
my_cat = Cat("Tom")
my_dog = Dog("Buddy")
my_cat.speak()  # 输出：Meow!
my_dog.speak()  # 输出：Woof!
​
# 多态
def make_speak(animal):
    animal.speak()
​
make_speak(my_cat)  # 输出：Meow!
make_speak(my_dog)  # 输出：Woof!

以上示例展示了面向对象编程基础中的类和对象、属性和方法、封装、继承和多态的概念，并给出了相应的代码示例。通过学习和理解这些基础概念，可以更好地应用面向对象编程思想解决实际问题。

2. 定义和使用类

2.1 类的定义和实例化

类的定义是通过class关键字来实现的，实例化类则是通过类名加括号来创建对象。下面是一个示例：

# 定义一个Person类
class Person:
    pass

# 实例化Person类，创建对象
person = Person()

2.2 属性和方法的定义

类中的属性是用于存储数据的变量，方法是用于操作数据的函数。属性和方法可以在类的内部使用self关键字来定义，self代表类的实例。下面是一个示例：

# 定义一个Person类
class Person:
    # 定义属性
    name = "John"
    
    # 定义方法
    def say_hello(self):
        print(f"Hello, my name is {self.name}.")
​
# 实例化Person类，创建对象
person = Person()
​
# 访问对象的属性
print(person.name)  # 输出：John
​
# 调用对象的方法
person.say_hello()  # 输出：Hello, my name is John.

2.3 构造方法和析构方法

构造方法是在实例化类时自动调用的方法，用于初始化对象的属性。析构方法在对象被销毁时自动调用，用于清理对象。构造方法使用__init__方法来定义，析构方法使用__del__方法来定义。下面是一个示例：

# 定义一个Person类
class Person:
    # 构造方法
    def __init__(self, name):
        self.name = name
        print(f"Person {self.name} is created.")
    
    # 析构方法
    def __del__(self):
        print(f"Person {self.name} is destroyed.")
​
# 实例化Person类，创建对象
person = Person("John")
​
# 输出：Person John is created.
​
# 销毁对象
del person
​
# 输出：Person John is destroyed.

2.4 类的继承和派生

类的继承是一种通过创建新类来继承现有类的属性和方法的机制。派生类是从基类继承而来的类。通过继承，派生类可以获得基类的属性和方法，并可以添加自己的属性和方法。下面是一个示例：

# 定义一个基类Animal
class Animal:
    def __init__(self, name):
        self.name = name
    
    def speak(self):
        print("Animal is speaking.")
​
# 定义一个派生类Dog，继承自Animal
class Dog(Animal):
    def bark(self):
        print("Dog is barking.")
​
# 实例化Dog类，创建对象
dog = Dog("Buddy")
​
# 访问继承自基类的属性和方法
print(dog.name)  # 输出：Buddy
dog.speak()  # 输出：Animal is speaking.
​
# 调用派生类自己的方法
dog.bark()  # 输出：Dog is barking.

2.5 方法的重写和重载

方法的重写是指在派生类中重新定义基类中已有的方法。重写后，派生类的对象在调用该方法时将执行派生类中的实现。方法的重载是指在同一个类中定义多个同名但参数个数或参数类型不同的方法。下面是一个示例：

# 定义一个基类Shape
class Shape:
    def area(self):
        print("This is the area method in Shape.")
​
# 定义一个派生类Circle，重写基类的area方法
class Circle(Shape):
    def area(self):
        print("This is the area method in Circle.")
​
# 定义一个派生类Rectangle，重载基类的area方法
class Rectangle(Shape):
    def area(self, length, width):
        print(f"This is the area method in Rectangle. The area is {length * width}.")
​
# 实例化Circle类和Rectangle类，创建对象
circle = Circle()
rectangle = Rectangle()
​
# 调用重写后的方法
circle.area()  # 输出：This is the area method in Circle.
​
# 调用重载后的方法
rectangle.area(5, 3)  # 输出：This is the area method in Rectangle. The area is 15.

以上示例展示了定义和使用类中的类的定义和实例化、属性和方法的定义、构造方法和析构方法、类的继承和派生、方法的重写和重载的概念，并给出了相应的代码示例。通过学习和理解这些概念，可以更好地应用面向对象编程思想解决实际问题。

3. 类的特殊方法

3.1 __init__()方法

__init__()方法是一个特殊的方法，用于在实例化类时进行对象的初始化操作。它在对象创建后自动调用，并且可以接收参数来初始化对象的属性。下面是一个示例：

# 定义一个Person类
class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age
​
# 实例化Person类，创建对象
person = Person("John", 25)
​
# 访问对象的属性
print(person.name)  # 输出：John
print(person.age)  # 输出：25

3.2 __str__()方法

__str__()方法是一个特殊的方法，用于返回对象的字符串表示。当我们使用print()函数打印对象时，实际上是调用了对象的__str__()方法。下面是一个示例：

# 定义一个Person类
class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age
    
    def __str__(self):
        return f"Person: {self.name}, {self.age} years old."
​
# 实例化Person类，创建对象
person = Person("John", 25)
​
# 打印对象
print(person)  # 输出：Person: John, 25 years old.

3.3 __len__()方法

__len__()方法是一个特殊的方法，用于返回对象的长度。它通常在自定义的容器类中使用，例如列表、字符串等。下面是一个示例：​

# 定义一个MyList类
class MyList:
    def __init__(self, items):
        self.items = items
    
    def __len__(self):
        return len(self.items)
​
# 实例化MyList类，创建对象
my_list = MyList([1, 2, 3, 4, 5])
​
# 访问对象的长度
print(len(my_list))  # 输出：5

3.4 __getitem__()和__setitem__()方法

__getitem__()方法是一个特殊的方法，用于获取对象的索引值对应的元素。__setitem__()方法是一个特殊的方法，用于设置对象的索引值对应的元素。它们通常在自定义的容器类中使用，例如列表、字典等。下面是一个示例：

# 定义一个MyList类
class MyList:
    def __init__(self, items):
        self.items = items
    
    def __getitem__(self, index):
        return self.items[index]
    
    def __setitem__(self, index, value):
        self.items[index] = value
​
# 实例化MyList类，创建对象
my_list = MyList([1, 2, 3, 4, 5])
​
# 获取对象的元素
print(my_list[2])  # 输出：3
​
# 设置对象的元素
my_list[2] = 10
print(my_list[2])  # 输出：10

以上示例展示了类的特殊方法中的__init__()方法、__str__()方法、__len__()方法、__getitem__()和__setitem__()方法的概念，并给出了相应的代码示例。这些特殊方法可以让我们在自定义类时更灵活地操作对象的属性和行为。

4. 面向对象设计原则

4.1 单一职责原则

单一职责原则（Single Responsibility Principle，SRP）指的是一个类应该只有一个引起它变化的原因。换句话说，一个类应该只负责一项职责。如果一个类承担了多个职责，那么当其中一个职责发生变化时，可能会影响到其他职责。下面是一个示例：

# 不符合单一职责原则的示例
class FileManager:
    def read_file(self, file_path):
        # 读取文件的操作
    
    def write_file(self, file_path, content):
        # 写入文件的操作
    
    def delete_file(self, file_path):
        # 删除文件的操作

上述示例中的FileManager类承担了读取文件、写入文件和删除文件的职责，违反了单一职责原则。应该将这些职责拆分成独立的类，例如一个FileReader类负责读取文件，一个FileWriter类负责写入文件，一个FileDeleter类负责删除文件。

4.2 开放封闭原则

开放封闭原则（Open-Closed Principle，OCP）指的是一个类应该对扩展开放，对修改封闭。换句话说，一个类的行为应该可以扩展，而不需要修改原有的代码。下面是一个示例：

# 符合开放封闭原则的示例
class Shape:
    def area(self):
        raise NotImplementedError("Subclasses must implement this method.")
​
class Circle(Shape):
    def __init__(self, radius):
        self.radius = radius
    
    def area(self):
        return 3.14 * self.radius ** 2
​
class Rectangle(Shape):
    def __init__(self, length, width):
        self.length = length
        self.width = width
    
    def area(self):
        return self.length * self.width

上述示例中的Shape类定义了一个抽象的area()方法，但没有具体的实现。Circle类和Rectangle类继承自Shape类，并分别实现了自己的area()方法。这样，如果需要新增一个形状，只需要创建一个新的类并继承自Shape类，并实现自己的area()方法，而不需要修改原有的代码。

4.3 里氏替换原则

里氏替换原则（Liskov Substitution Principle，LSP）指的是子类对象可以替换父类对象，而程序的行为不会发生变化。换句话说，子类应该能够替换掉父类并且不影响程序的正确性。下面是一个示例：

# 符合里氏替换原则的示例
class Bird:
    def fly(self):
        print("The bird is flying.")
​
class Ostrich(Bird):
    def fly(self):
        raise NotImplementedError("Ostriches cannot fly.")

上述示例中的Bird类定义了一个fly()方法，而Ostrich类继承自Bird类并重写了fly()方法。尽管鸵鸟不能飞行，但它仍然可以替换掉鸟类对象，因为它继承了Bird类的所有方法，并且程序的行为不会发生变化。

4.4 接口隔离原则

接口隔离原则（Interface Segregation Principle，ISP）指的是客户端不应该依赖它不需要的接口。换句话说，一个类不应该强迫它的客户端依赖于它们不使用的方法。下面是一个示例：

# 符合接口隔离原则的示例
class Printer:
    def print(self, document):
        raise NotImplementedError("Subclasses must implement this method.")
​
class Scanner:
    def scan(self, document):
        raise NotImplementedError("Subclasses must implement this method.")
​
class Photocopier(Printer, Scanner):
    def print(self, document):
        # 打印文档的操作
    
    def scan(self, document):
        # 扫描文档的操作

上述示例中的Printer类和Scanner类分别定义了打印和扫描的方法，而Photocopier类同时继承了Printer类和Scanner类，并实现了这两个方法。这样，如果只需要打印功能，就可以使用Printer类；如果只需要扫描功能，就可以使用Scanner类；如果需要同时打印和扫描功能，就可以使用Photocopier类。

4.5 依赖倒置原则

依赖倒置原则（Dependency Inversion Principle，DIP）指的是高层模块不应该依赖于低层模块，而是应该依赖于抽象。换句话说，模块之间的依赖关系应该通过抽象来建立，而不是具体的实现。下面是一个示例：

# 符合依赖倒置原则的示例
class Database:
    def get_data(self):
        raise NotImplementedError("Subclasses must implement this method.")
​
class MySQLDatabase(Database):
    def get_data(self):
        # 从MySQL数据库获取数据的操作
​
class OracleDatabase(Database):
    def get_data(self):
        # 从Oracle数据库获取数据的操作
​
class DataProcessor:
    def __init__(self, database):
        self.database = database
    
    def process_data(self):
        data = self.database.get_data()
        # 处理数据的操作

上述示例中的DataProcessor类依赖于抽象的Database类，而不是具体的实现类。这样，可以通过传入不同的数据库对象来实现不同的数据处理操作，而不需要修改DataProcessor类的代码。

以上示例展示了面向对象设计原则中的单一职责原则、开放封闭原则、里氏替换原则、接口隔离原则和依赖倒置原则，并给出了相应的代码示例。这些原则是指导面向对象设计和编程的重要原则，可以提高代码的可维护性和可扩展性。

5. 实例：设计一个简单的银行账户管理系统

5.1 分析需求

我们需要设计一个简单的银行账户管理系统，其中包括账户类和银行类。账户类应该具有账户号码、账户余额和账户持有人的属性，以及存款、取款和查询余额的方法。银行类应该能够创建账户、关闭账户和查询账户信息。

5.2 定义类和属性

根据需求分析，我们可以定义两个类：Account（账户）类和Bank（银行）类。Account类应该具有账户号码、账户余额和账户持有人的属性。Bank类应该具有一个账户列表的属性。

class Account:
    def __init__(self, account_number, balance, account_holder):
        self.account_number = account_number
        self.balance = balance
        self.account_holder = account_holder
​
class Bank:
    def __init__(self):
        self.accounts = []

5.3 实现方法

根据需求分析，我们可以在Account类中实现存款、取款和查询余额的方法，以及在Bank类中实现创建账户、关闭账户和查询账户信息的方法。

class Account:
    def __init__(self, account_number, balance, account_holder):
        self.account_number = account_number
        self.balance = balance
        self.account_holder = account_holder
    
    def deposit(self, amount):
        self.balance += amount
    
    def withdraw(self, amount):
        if self.balance >= amount:
            self.balance -= amount
        else:
            print("Insufficient balance.")
    
    def get_balance(self):
        return self.balance
​
class Bank:
    def __init__(self):
        self.accounts = []
    
    def create_account(self, account_number, balance, account_holder):
        account = Account(account_number, balance, account_holder)
        self.accounts.append(account)
    
    def close_account(self, account_number):
        for account in self.accounts:
            if account.account_number == account_number:
                self.accounts.remove(account)
                break
    
    def get_account_info(self, account_number):
        for account in self.accounts:
            if account.account_number == account_number:
                return account
        return None

5.4 测试程序

我们可以编写一些测试代码来验证银行账户管理系统的功能。

 # 创建一个银行对象
bank = Bank()
​
# 创建账户并存入银行
bank.create_account("001", 1000, "John")
bank.create_account("002", 2000, "Alice")
​
# 查询账户信息
account = bank.get_account_info("001")
print(account.account_number)  # 输出：001
print(account.balance)  # 输出：1000
print(account.account_holder)  # 输出：John
​
# 存款
account.deposit(500)
print(account.balance)  # 输出：1500
​
# 取款
account.withdraw(800)
print(account.balance)  # 输出：700
​
# 关闭账户
bank.close_account("002")
​
# 查询已关闭的账户
account = bank.get_account_info("002")
print(account)  # 输出：None

结语

通过本教程的学习，读者将了解到Python面向对象编程的基本概念和使用方法，掌握类的定义和使用、属性和方法的定义、类的继承和派生、方法的重写和重载等知识点。同时，读者还将学会如何利用面向对象编程的思想和原则进行程序设计，提高代码的可维护性和可扩展性。希望本教程能够帮助读者快速入门Python面向对象编程，并在实际开发中发挥作用。