1. 首页
  2. 技术文章

34、面向对象的Python编程

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

面向对象编程

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

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

一个对象具有两个特征:

  • 属性
  • 行为

让我们举个例子:

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

  • 名称,年龄,颜色作为属性
  • 唱歌,跳舞作为行为

Python中的OOP概念专注于创建可重用的代码。此概念也称为DRY(不要重复自己)。

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


类是对象的蓝图。

我们可以将类看作是带有标签的鹦鹉的素描。它包含有关名称,颜色,大小等的所有详细信息。基于这些描述,我们可以研究鹦鹉。在这里,鹦鹉是一个对象。

鹦鹉类的示例可以是:

class Parrot:
    pass

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


对象

对象(实例)是类的实例。定义类时,仅定义对象的描述。因此,没有分配内存或存储。

鹦鹉类对象的示例可以是:

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类。这里,blu 和 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中,我们使用下划线作为前缀(即single_或double)来表示私有属性__

示例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。我们试图修改价格。但是,我们无法更改它,因为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")

# 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 和 Penguin。他们每个人都有一个共同的fly()方法。但是,它们的功能是不同的。

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


要记住的要点:

  • 面向对象的程序设计使程序易于理解且高效。
  • 由于该类是可共享的,因此可以重用该代码。
  • 数据通过数据抽象是安全的。
  • 多态允许相同的接口用于不同的对象,因此程序员可以编写高效的代码。
版权声明:本文内容由互联网用户贡献,该文观点仅代表作者本人。本站不拥有所有权,不承担相关法律责任。如发现有侵权/违规的内容, 联系QQ1841324605,本站将立刻清除。

发表评论

您的电子邮箱地址不会被公开。 必填项已用*标注

联系我们

服务热线:130-0886-1890

QR code