Python 面向对象编程

在本教程中，您将借助示例了解 Python 中的面向对象编程 (OOP) 及其基本概念。

视频：Python 中的面向对象编程

面向对象编程

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

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

一个对象有两个特征：

属性
行为

举个例子吧：

鹦鹉是一个对象，因为它具有以下属性：

姓名、年龄、颜色作为属性
唱歌、跳舞是一种行为

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

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

类

类是对象的蓝图。

我们可以将班级视为带有标签的鹦鹉的草图。它包含有关名称，颜色，大小等的所有详细信息。根据这些描述，我们可以研究鹦鹉。在这里，鹦鹉是一个对象。

鹦鹉类的例子可以是：

class Parrot:
    pass

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

对象

对象（实例）是类的实例化。定义类时，只定义对象的描述。因此，没有分配内存或存储空间。

鹦鹉类对象的例子可以是：

obj = Parrot()

这里，obj 是类 Parrot 的对象 .

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

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

class Parrot:

    # class attribute
    species = "bird"

    # instance attribute
    def __init__(self, name, age):
        self.name = name
        self.age = age

# instantiate the Parrot class
blu = Parrot("Blu", 10)
woo = Parrot("Woo", 15)

# access the class attributes
print("Blu is a {}".format(blu.__class__.species))
print("Woo is also a {}".format(woo.__class__.species))

# access the instance attributes
print("{} is {} years old".format( blu.name, blu.age))
print("{} is {} years old".format( woo.name, woo.age))

输出

Blu is a bird
Woo is also a bird
Blu is 10 years old
Woo is 15 years old

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

这些属性在 __init__ 中定义类的方法。它是创建对象后首先运行的初始化方法。

然后，我们创建 Parrot 的实例班级。在这里，蓝光 和 woo 是对我们新对象的引用（值）。

我们可以使用 __class__.species 访问类属性 .类的所有实例的类属性都是相同的。同样，我们使用 blu.name 访问实例属性和 blu.age .但是，类的每个实例的实例属性都是不同的。

要了解有关类和对象的更多信息，请转到 Python 类和对象

方法

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

示例 2：在 Python 中创建方法

class Parrot:
    
    # instance attributes
    def __init__(self, name, age):
        self.name = name
        self.age = age
    
    # instance method
    def sing(self, song):
        return "{} sings {}".format(self.name, song)

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

# instantiate the object
blu = Parrot("Blu", 10)

# call our instance methods
print(blu.sing("'Happy'"))
print(blu.dance())

输出

Blu sings 'Happy'
Blu is now dancing

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

继承

继承是一种创建新类以使用现有类的详细信息而不修改它的方法。新形成的类是派生类（或子类）。同样，现有类是基类（或父类）。

示例 3：在 Python 中使用继承

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

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

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

# child class
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 is ready
Penguin is ready
Penguin
Swim faster
Run faster

在上面的程序中，我们创建了两个类，即 Bird （父类）和 Penguin （儿童班）。子类继承父类的功能。我们可以从 swim() 中看到这一点方法。

同样，子类修改了父类的行为。我们可以从 whoisThis() 中看到这一点方法。此外，我们通过创建一个新的 run() 来扩展父类的功能方法。

此外，我们使用 super() __init__() 内的函数方法。这允许我们运行 __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()

# change the price
c.__maxprice = 1000
c.sell()

# using setter function
c.setMaxPrice(1000)
c.sell()

输出

Selling Price: 900
Selling Price: 900
Selling Price: 1000

在上面的程序中，我们定义了一个 Computer 类。

我们使用 __init__() Computer最高售价的存储方法 .这里，注意代码

c.__maxprice = 1000

在这里，我们尝试修改 __maxprice 的值课外。但是，由于 __maxprice 是一个私有变量，这个修改在输出中是看不到的。

如图所示，要更改值，我们必须使用 setter 函数，即 setMaxPrice() 以价格为参数。

多态

多态性是一种（在 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")

# common interface
def flying_test(bird):
    bird.fly()

#instantiate objects
blu = Parrot()
peggy = Penguin()

# passing the object
flying_test(blu)
flying_test(peggy)

输出

Parrot can fly
Penguin can't fly

在上面的程序中，我们定义了两个类 Parrot 和 企鹅 .他们每个人都有一个共同的fly() 方法。但是，它们的功能是不同的。

为了使用多态性，我们创建了一个通用接口，即 flying_test() 接受任何对象并调用对象的 fly() 的函数方法。因此，当我们通过 blu 和 佩吉 flying_test() 中的对象功能，运行有效。

要记住的关键点：

面向对象编程使程序易于理解且高效。
由于类是可共享的，因此代码可以重复使用。
通过数据抽象确保数据安全可靠。
多态允许不同对象使用相同的接口，因此程序员可以编写高效的代码。

Python 自定义异常 Python 对象和类

Python