python3面向对象编程 – Python3教程

上一章Python教程请查看：python3自定义异常

在本文中，你将通过示例了解Python中的面向对象编程(OOP)及其基本概念。

Python中的OOP面向对象编程介绍

Python是一种多范式编程语言，也就是说，它支持不同的编程方法。

解决编程问题的流行方法之一是创建对象，这就是所谓的面向对象编程(OOP)。

一个对象有两个特征：

• 属性
• 行为

举个例子：

Parrot是一个对象：

• 姓名、年龄、颜色都是属性
• 唱歌、跳舞都是行为

Python中的OOP概念侧重于创建可重用代码，这个概念也被称为DRY(不要重复自己)。

在Python中，OOP的概念遵循一些基本原则:

类class

类是对象的蓝图。

我们可以把类想象成一只带着标签的鹦鹉，它包含了名字、颜色、大小等所有细节，根据这些描述，我们可以研究鹦鹉，在这里，parrot是一个对象。

parrot类的例子可以是:

class Parrot:
    pass

在这里，我们使用class关键字来定义一个空类Parrot，我们从类中构造实例，实例是由特定类创建的特定对象。

对象object

对象(实例)是类的实例化，在定义类时，只定义对象的描述，因此，不分配内存或存储。

parrot类对象的例子可以是：

obj = Parrot()

在这里，obj是Parrot类的对象。

假设我们有关于parrot的详细信息，现在，我们将展示如何构建parrot的类和对象。

例1：在Python中创建类和对象

class Parrot:

    # 类属性
    species = "bird"

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

# 实例化Parrot类
bb = Parrot("BBB", 10)
ww = Parrot("WWW", 15)

# 访问类属性
print("BBB is a {}".format(bb.__class__.species))
print("WWW is also a {}".format(ww.__class__.species))

# 访问属性
print("{} is {} years old".format( bb.name, blu.age))
print("{} is {} years old".format( ww.name, woo.age))

在上面的程序中，我们创建了一个名为Parrot的类，然后，我们定义属性，属性是对象的特征。

然后，我们创建Parrot类的实例，这里，bb和ww是对新对象的引用(值)。

然后，我们使用_class_.species访问class属性，类的所有实例的类属性都是相同的。类似地，我们使用blu.name和blu.age访问实例属性。但是，对于类的每个实例，实例属性都是不同的。

方法

方法是在类的主体中定义的函数，它们用于定义对象的行为。

例2：在Python中创建方法

class Parrot:
    
    # 属性
    def __init__(self, name, age):
        self.name = name
        self.age = age
    
    # 方法
    def sing(self, song):
        return "{} sings {}".format(self.name, song)

    def dance(self):
        return "{} is now dancing".format(self.name)

# 对象
blu = Parrot("Blu", 10)

# 调用方法
print(blu.sing("'Happy'"))
print(blu.dance())

在上面的程序中，我们定义了两个方法sing()和dance()，这些被称为实例方法，因为它们是在实例对象上调用的。

继承

继承是一种创建新类的方法，用于在不修改现有类的细节的情况下使用它，形成的类是一个派生类(或子类)，类似地，现有类是基类(或父类)。

例3：Python中使用继承

# 父类
class Bird:
    
    def __init__(self):
        print("Bird is ready")

    def whoisThis(self):
        print("Bird")

    def swim(self):
        print("Swim faster")

# 子类
class Penguin(Bird):

    def __init__(self):
        # call super() function
        super().__init__()
        print("Penguin is ready")

    def whoisThis(self):
        print("Penguin")

    def run(self):
        print("Run faster")

peggy = Penguin()
peggy.whoisThis()
peggy.swim()
peggy.run()

在上面的程序中，我们创建了两个类：Bird(父类)和Penguin(子类)。子类继承父类的函数，我们可以从swim()方法中看到这一点，同样，子类修改了父类的行为。我们可以从whoisThis()方法中看到这一点，此外，通过创建一个新的run()方法，我们扩展了父类的功能。

此外，我们在使用_init__()方法之前使用了super()函数，这是因为我们希望将_init__()方法的内容从父类拉到子类中。

封装

在Python中使用OOP，我们可以限制对方法和变量的访问，这就防止了数据被称为封装的直接修改。在Python中，我们使用下划线作为前缀来表示私有属性也就是单“_”或双“__”。

例4：Python中的数据封装

class Computer:

    def __init__(self):
        self.__maxprice = 900

    def sell(self):
        print("Selling Price: {}".format(self.__maxprice))

    def setMaxPrice(self, price):
        self.__maxprice = price

c = Computer()
c.sell()

c.__maxprice = 1000
c.sell()

# 使用 setter 函数
c.setMaxPrice(1000)
c.sell()

在上面的程序中，我们定义了一个类计算机，我们使用_init__()方法来存储计算机的最高销售价格。我们试图修改价格，但是，我们不能更改它，因为Python将_maxprice作为私有属性对待。要更改值，我们使用setter函数也就是setMaxPrice()以price为参数。

多态性

多态性是(在OOP中)为多个表单(数据类型)使用公共接口的能力。

假设，我们需要给一个形状上色，有多个形状选项(矩形、正方形、圆形)，然而，我们可以用同样的方法来着色任何形状，这个概念称为多态性。

例5：在Python中使用多态性

class Parrot:

    def fly(self):
        print("Parrot can fly")
    
    def swim(self):
        print("Parrot can't swim")

class Penguin:

    def fly(self):
        print("Penguin can't fly")
    
    def swim(self):
        print("Penguin can swim")

# 通用接口
def flying_test(bird):
    bird.fly()


blu = Parrot()
peggy = Penguin()


flying_test(blu)
flying_test(peggy)

在上面的程序中，我们定义了Parrot和Penguin两个类，它们都有通用的方法fly()方法。然而，它们的功能是不同的，为了允许多态性，我们创建了通用接口i。函数的作用是：获取任何对象。然后，我们在flying_test()函数中传递对象blu和peggy，它会有效地运行。

注意事项：

• 编程变得简单而高效。
• 该类是可共享的，因此可以重用代码。
• 程序的生产率提高了
• 通过数据抽象，数据是安全的。