面向对象编程

Python 是一种多范式编程语言。它支持不同的编程方法。
解决编程问题的流行方法之一是创建对象。这称为面向对象编程 (OOP)。
一个对象有两个特征：

• 属性
• 行为

让我们举个例子：
鹦鹉是一个对象，因为它具有以下属性：

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

Python 中的 OOP 概念侧重于创建可重用的代码。这个概念也被称为 DRY（不要重复自己）。
在 Python 中，OOP 的概念遵循一些基本原则：

班级

类是对象的蓝图。
我们可以将班级视为带有标签的鹦鹉草图。它包含有关名称、颜色、大小等的所有详细信息。根据这些描述，我们可以研究鹦鹉。在这里，鹦鹉是一个对象。
鹦鹉类的例子可以是：
鹦鹉类： 经过
这里，我们使用class关键字来定义一个空类鹦鹉. 从类中，我们构造实例。实例是从特定类创建的特定对象。

目的

对象（实例）是类的实例化。定义类时，只定义对象的描述。因此，没有分配内存或存储。
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))
输出
布鲁是一只鸟 呜也是鸟 布鲁 10 岁了 Woo 15 岁
在上面的程序中，我们创建了一个名为的类 鹦鹉. 然后，我们定义属性。属性是对象的特征。
这些属性init在类的方法中定义。创建对象后，首先运行的是初始化方法。
然后，我们创建实例 鹦鹉班级。这里，蓝光 和 呜 是对我们新对象的引用（值）。
我们可以使用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())
输出
布鲁唱“快乐” 布鲁现在在跳舞
在上面的程序中，我们定义了两个方法，即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()
输出
鸟准备好了 企鹅准备好了 企鹅 游得更快 跑得更快
在上面的程序中，我们创建了两个类，即 鸟 （父类）和 企鹅（子类）。子类继承父类的功能。我们可以从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()
输出
售价：900 售价：900 售价：1000
在上面的程序中，我们定义了一个 计算机 班级。
我们使用init()方法来存储 的最高售价Computer。我们试图修改价格。然而，我们不能改变它，因为 Python 对待__最大价格 作为私有属性。
如图所示，要更改值，我们必须使用 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)
输出
鹦鹉会飞 企鹅不会飞
在上面的程序中，我们定义了两个类 鹦鹉 和 企鹅. 他们每个人都有一个共同的fly()方法。但是，它们的功能是不同的。
为了使用多态，我们创建了一个通用接口即flying_test()函数，它接受任何对象并调用该对象的fly()方法。因此，当我们通过蓝光 和 佩吉flying_test()函数中的对象，它有效地运行。

要记住的要点：

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