Python面向对象编程：封装和继承

Python是一种面向对象的编程语言，封装和继承是面向对象编程的两个重要概念。通过封装，我们可以将类的数据和操作封装在一起，实现数据的隐私与安全；通过继承，我们可以基于已有的类创建新的类，避免重复代码，简化程序设计。本文就介绍一下Python面向对象编程的封装和继承的相关知识。

1. 封装

封装是面向对象编程的一个重要思想，它指的是将数据和方法封装到类内部，以控制其访问的可见性和安全性，避免外部直接对类的内部数据和方法进行修改和操作。在Python中，可以通过以下方式实现封装：

1.1. 属性封装

在Python中，我们可以通过__双下划线将类的属性变成私有的，外部无法直接访问。如果要访问这些私有属性，可以通过类提供的公有方法来进行访问，从而保证数据的隐私和安全性。例如，下面的代码演示了如何通过属性封装实现对卡车的速度和载重的限制：

class Truck:
    def __init__(self, speed, load):
        self.__speed = speed
        self.__load = load

    def get_speed(self):
        return self.__speed

    def set_speed(self, speed):
        if speed < 0:
            self.__speed = 0
        elif speed > 120:
            self.__speed = 120
        else:
            self.__speed = speed

    def get_load(self):
        return self.__load

    def set_load(self, load):
        if load < 0:
            self.__load = 0
        elif load > 100:
            self.__load = 100
        else:
            self.__load = load

t = Truck(80, 50)
print(t.get_speed())    # 输出80
t.set_speed(150)
print(t.get_speed())    # 输出120
print(t.get_load())     # 输出50
t.set_load(-50)
print(t.get_load())     # 输出0

1.2. 方法封装

在Python中，我们也可以通过方法的封装来实现数据和方法的保护。例如，我们可以将某些方法设置为私有方法，在外部无法被直接调用，从而实现数据的保护。下面的代码演示了如何通过方法封装实现对银行账户的余额和密码的保护：

class Account:
    def __init__(self, balance, password):
        self.balance = balance
        self.__password = password

    def deposit(self, amount):
        self.balance += amount

    def withdraw(self, amount, password):
        if password == self.__password:
            self.balance -= amount

    def __check_password(self, password):
        return password == self.__password

a = Account(1000, '123456')
a.deposit(500)
a.withdraw(300, '123456')
print(a.balance)    # 输出1200
a.withdraw(500, '666666')
print(a.balance)    # 输出1200，密码错误无法取款

2. 继承

继承是面向对象编程的另一个重要概念，它指的是创建一个新类，这个新类继承了原有的一个或多个类的特征和功能，并可以基于这些特征和功能添加新的属性和方法。通过继承，我们可以避免重复编写代码，实现代码的重用和简化程序设计。在Python中，可以通过以下方式实现继承：

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def say_hello(self):
        print('Hello, my name is', self.name)

class Student(Person):
    def __init__(self, name, age, grade):
        super().__init__(name, age)
        self.grade = grade

    def say_hello(self):
        super().say_hello()
        print('I am a student in', self.grade)

p = Person('Tom', 20)
p.say_hello()      # 输出Hello, my name is Tom

s = Student('Jerry', 18, 'Grade 3')
s.say_hello()      # 输出Hello, my name is Jerry，I am a student in Grade 3

上面的代码定义了一个Person类和一个Student类，Student类继承了Person类的属性和方法，并增加了一个名为grade的属性和一个重写了父类方法的say_hello()方法。在通过super()函数继承父类的构造方法和方法时，调用父类方法时需要使用super()函数。

在Python中，还可以通过多重继承实现一个子类继承多个父类的特征和功能。例如：

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

    def say_hello(self):
        print('Hello, my name is', self.name)

class Fly:
    def fly(self):
        print('I am flying')

class Bird(Animal, Fly):
    def __init__(self, name):
        Animal.__init__(self, name)

b = Bird('Eagle')
b.say_hello()      # 输出Hello, my name is Eagle
b.fly()            # 输出I am flying

上面的代码定义了一个Animal类和一个Fly类，Bird类继承了这两个类，并增加了一个重写了父类方法的say_hello()方法。在通过多重继承继承父类时，可以在定义类时在类名后用逗号隔开多个父类。

综上所述，封装和继承是Python面向对象编程中的两个重要概念。通过封装保证数据的隐私和安全性，通过继承实现代码的重用和简化程序设计。在程序设计时，应该充分利用封装和继承的优势，使代码更加模块化和易于扩展。