面向对象的 Python 编程，你需要知道这些！

​​​​摘要：Python 没有像 java 中的“private”这样的访问说明符。除了强封装外，它支持大多数与“面向对象”编程语言相关的术语。因此它不是完全面向对象的。

本文分享自华为云社区《从零开始学python| 面向对象编程 Python：你需要知道的一切》，原文作者：Yuchuan 。

面向对象的编程作为一门学科在开发人员中得到了普遍的追随。Python，一种受欢迎的编程语言，也遵循面向对象的编程范式。它处理为 OOP 概念奠定基础的 Python 类和对象的声明。这篇关于“面向对象的 Python 编程”的文章将带您了解如何声明 Python 类、从它们实例化对象以及 OOP 的四种方法。  

什么是面向对象编程？（Python 中的 OOP 概念）

​

面向对象编程是一种使用“对象”的思想来表示数据和方法的计算机编程方式。它也是一种用于创建整洁且可重用的代码而不是冗余代码的方法。程序分为独立的对象或几个小程序。每个单独的对象都代表应用程序的不同部分，它们具有自己的逻辑和数据以在它们内部进行通信。

现在，为了更清楚地了解为什么我们使用 oops 而不是 pop，我在下面列出了不同之处。

面向对象和面向过程编程的区别

​这就是差异的全部，继续前进，让我们了解 Python OOPs Conceots。

什么是 Python OOP 概念？

Python 中的主要 OOP（面向对象编程）概念包括类、对象、方法、继承、多态、数据抽象和封装。

这就是差异的全部，让我们继续了解类和对象。

什么是类和对象？

类是对象的集合，或者您可以说它是定义公共属性和行为的对象的蓝图。现在问题来了，你是怎么做到的？ 

嗯，它以一种使代码可重用性变得容易的方式对数据进行逻辑分组。我可以给你一个现实生活中的例子——把一个办公室把“员工”想象成一个类，以及与它相关的所有属性，比如“emp_name”、“emp_age”、“emp_salary”、“emp_id”作为 Python 中的对象。让我们从编码的角度来看看如何实例化一个类和一个对象。

类是在“类”关键字下定义的。

例子：

class class1(): // class 1 is the name of the class

​注意： Python 不区分大小写。

对象：

对象是类的实例。它是一个具有状态和行为的实体。简而言之，它是一个可以访问数据的类的实例。

语法：  obj= class1()

这里 obj 是 class1 的“对象”。

在 python 中创建对象和类：

例子：

class employee():    def __init__(self,name,age,id,salary):   //creating a function        self.name = name // self is an instance of a class        self.age = age        self.salary = salary        self.id = id emp1 = employee("harshit",22,1000,1234) //creating objectsemp2 = employee("arjun",23,2000,2234)print(emp1.__dict__)//Prints dictionary

​说明： 'emp1' 和 'emp2' 是针对类 'employee' 实例化的对象。这里，单词 (__dict__) 是一个“字典”，它根据给定的参数（姓名、年龄、薪水）打印对象 'emp1' 的所有值。(__init__) 就像一个构造函数，无论何时创建对象都会调用它。

我希望现在你们将来在处理“类”和“对象”时不会遇到任何问题。

有了这个，让我带你了解一下面向对象的编程方法：

面向对象的编程方法：

面向对象的编程方法涉及以下概念。

• Inheritance

• Polymorphism

• Encapsulation

• Abstraction

让我们详细了解继承的第一个概念。

继承：

曾经听亲戚说过这样的对话“你长得像你的父亲/母亲”，这背后的原因被称为'继承'。从编程方面来说，一般是指“不加任何修改地将父类的特性继承或转移到子类”。新类称为派生/子 类，从中派生的类称为父 类/基类。

​让我们详细了解每个子主题。

单一继承：

单级继承使派生类能够从单个父类继承特征。

例子：

​

class employee1()://This is a parent classdef __init__(self, name, age, salary):  self.name = nameself.age = ageself.salary = salary class childemployee(employee1)://This is a child classdef __init__(self, name, age, salary,id):self.name = nameself.age = ageself.salary = salaryself.id = idemp1 = employee1('harshit',22,1000) print(emp1.age)

​输出：22

解释：

• 我正在使用父类并创建一个构造函数 (__init__)，类本身正在使用参数（'name'、'age' 和 'salary'）初始化属性。

• 创建了一个子类“childemployee”，它继承了父类的属性，最后根据参数实例化了对象“emp1”和“emp2”。

• 最后，我已经打印了 emp1 的年龄。嗯，你可以做很多事情，比如打印整本字典或姓名或薪水。

多级继承：

多级继承使派生类能够从直接父类继承属性，而直接父类又从其父类继承属性。

例子：

class employee()://Super classdef __init__(self,name,age,salary):  self.name = nameself.age = ageself.salary = salaryclass childemployee1(employee)://First child classdef __init__(self,name,age,salary):self.name = nameself.age = ageself.salary = salary class childemployee2(childemployee1)://Second child classdef __init__(self, name, age, salary):self.name = nameself.age = ageself.salary = salaryemp1 = employee('harshit',22,1000)emp2 = childemployee1('arjun',23,2000) print(emp1.age)print(emp2.age)

​输出：22,23

解释：

• 上面写的代码中已经说明得很清楚了，这里我把超类定义为 employee，子类定义为 childemployee1。现在，childemployee1 充当 childemployee2 的父级。

• 我已经实例化了两个对象“emp1”和“emp2”，其中我从超类“employee”和“name”、“age、salary”和“id”中为 emp1 传递参数“name”、“age”、“salary” ” 来自父类“childemployee1”

层次继承：

分层级继承使多个派生类能够从父类继承属性。

例子：

class employee():def __init__(self, name, age, salary):     //Hierarchical Inheritanceself.name = nameself.age = ageself.salary = salary class childemployee1(employee):def __init__(self,name,age,salary):self.name = nameself.age = ageself.salary = salary class childemployee2(employee):def __init__(self, name, age, salary):self.name = nameself.age = ageself.salary = salaryemp1 = employee('harshit',22,1000)emp2 = employee('arjun',23,2000) print(emp1.age)print(emp2.age)

​输出：22,23

解释：

• 在上面的例子中，你可以清楚地看到有两个子类“childemployee1”和“childemployee2”。他们从一个共同的父类“员工”继承功能。

• 对象 'emp1' 和 'emp2' 根据参数 'name'、'age'、'salary' 进行实例化。

多重继承：

多级继承使一个派生类可以从多个基类继承属性。

例子：

class employee1()://Parent class    def __init__(self, name, age, salary):          self.name = name        self.age = age        self.salary = salary class employee2()://Parent class    def __init__(self,name,age,salary,id):     self.name = name     self.age = age     self.salary = salary     self.id = id class childemployee(employee1,employee2):    def __init__(self, name, age, salary,id):     self.name = name     self.age = age     self.salary = salary     self.id = idemp1 = employee1('harshit',22,1000)emp2 = employee2('arjun',23,2000,1234) print(emp1.age)print(emp2.id)

​输出：22,1234

解释： 在上面的例子中，我取了两个父类“employee1”和“employee2”。还有一个子类“childemployee”，它通过针对父类的参数实例化对象“emp1”和“emp2”来继承父类。

这完全是关于继承，在面向对象编程 Python 中继续前进，让我们深入研究“多态”。

多态：

你们一定都使用过 GPS 导航路线，根据交通情况，您在同一目的地遇到多少条不同的路线，这不是很神奇吗，从编程的角度来看，这被称为“多态性”。这是一种这样的 OOP 方法，其中一项任务可以以多种不同的方式执行。简单来说，它是一个对象的属性，它允许它采取多种形式。

​多态有两种类型：

• 编译时多态

• 运行时多态性

编译时多态：

编译时多态性也称为静态多态性，它在程序编译时得到解决。一个常见的例子是“方法重载”。让我向您展示一个相同的快速示例。

例子：

class employee1():def name(self):print("Harshit is his name")    def salary(self):print("3000 is his salary") def age(self):print("22 is his age") class employee2():def name(self):print("Rahul is his name") def salary(self):print("4000 is his salary") def age(self):print("23 is his age") def func(obj)://Method Overloadingobj.name()obj.salary()obj.age() obj_emp1 = employee1()obj_emp2 = employee2() func(obj_emp1)func(obj_emp2)

​输出：

Harshit 是他的名字 3000 是他的薪水 22 是他的年龄 Rahul 是他的名字 4000 是他的薪水 23 是他的年龄

解释：

• 在上面的程序中，我创建了两个类 'employee1' 和 'employee2' 并为 'name'、'salary' 和 'age' 创建了函数，并打印了相同的值而不从用户那里获取它。

• 现在，欢迎来到主要部分，我创建了一个以“obj”为参数的函数，并调用了所有三个函数，即“name”、“age”和“salary”。

• 后来，针对这两个类实例化了对象 emp_1 和 emp_2 并简单地调用了函数。这种类型称为方法重载，它允许一个类具有多个同名的方法。

运行时多态：

运行时多态性也称为动态多态性，它在运行时解析。运行时多态性的一个常见示例是“方法覆盖”。让我通过一个示例向您展示以便更好地理解。

例子：

class employee():   def __init__(self,name,age,id,salary):         self.name = name       self.age = age       self.salary = salary       self.id = iddef earn(self):        pass class childemployee1(employee):    def earn(self)://Run-time polymorphism      print("no money") class childemployee2(employee):    def earn(self):       print("has money") c = childemployee1c.earn(employee)d = childemployee2d.earn(employee)

​输出：没钱，有钱

说明：在上面的例子中，我创建了两个类 'childemployee1' 和 'childemployee2'，它们派生自同一个基类 'employee'。这是一个没有收到钱而另一个得到的问题。现在真正的问题是这是怎么发生的？好吧，如果您仔细观察，我在这里创建了一个空函数并使用了 Pass（当您不想执行任何命令或代码时使用的语句）。现在，在两个派生类下，我使用了相同的空函数，并将打印语句用作 'no money' 和 'has money' 。最后，创建了两个对象并调用了函数。

继续讨论下一个面向对象的 Python 编程方法，我将讨论封装。

封装：

在原始形式中，封装基本上意味着将数据绑定到单个类中。与 Java 不同，Python 没有任何私有关键字。不应直接访问类，而应以下划线为前缀。

让我向您展示一个示例以便更好地理解。

例子：

class employee(object):def __init__(self):   self.name = 1234self._age = 1234self.__salary = 1234 object1 = employee()print(object1.name)print(object1._age)print(object1.__salary)

​输出：

1234 回溯（最近一次通话）：1234 文件“C:/Users/Harshit_Kant/PycharmProjects/test1/venv/encapsu.py”，第 10 行，在打印（object1.__salary）中 AttributeError: 'employee'object has no attribute ' __薪水'

说明：你会得到这个问题，下划线和错误是什么？好吧，python 类将私有变量视为不能直接访问的 (__salary)。

因此，我在下一个示例中使用了 setter 方法，该方法提供对它们的间接访问。

例子：

class employee():def __init__(self):self.__maxearn = 1000000def earn(self):print("earning is:{}".format(self.__maxearn)) def setmaxearn(self,earn)://setter method used for accesing private classself.__maxearn = earn emp1 = employee()emp1.earn() emp1.__maxearn = 10000emp1.earn() emp1.setmaxearn(10000)emp1.earn()

​输出：

收益为：1000000，收益为：1000000，收益为：10000

说明： 使用 setter 方法提供对私有类方法的间接访问。这里我定义了一个员工类，并使用了一个(__maxearn)，它是这里用来存储员工最大收入的 setter 方法，以及一个以价格为参数的 setter 函数 setmaxearn()。

这是一个明显的封装示例，我们限制对私有类方法的访问，然后使用 setter 方法授予访问权限。

接下来在面向对象编程中，python 方法论讨论了一个称为抽象的关键概念。

抽象：

假设您使用网上银行或任何其他流程从 bookmyshow 预订了一张电影票。您不知道如何生成 pin 或如何完成验证的过程。这在编程方面被称为“抽象”，它基本上意味着您只显示特定流程的实现细节，而对用户隐藏细节。它用于通过对适合问题的类进行建模来简化复杂问题。

抽象类不能被实例化，这仅仅意味着你不能为这种类型的类创建对象。它只能用于继承功能。

例子：

from abc import ABC,abstractmethodclass employee(ABC):def emp_id(self,id,name,age,salary):    //Abstractionpass class childemployee1(employee):def emp_id(self,id):print("emp_id is 12345") emp1 = childemployee1()emp1.emp_id(id)

​输出：emp_id 是 12345

说明： 正如你在上面的例子中看到的，我们导入了一个抽象方法，程序的其余部分有一个父类和一个派生类。为“childemployee”基类实例化了一个对象，并且正在使用抽象的功能。

Python 是 100% 面向对象的吗？

Python 没有像 java 中的“private”这样的访问说明符。除了强封装外，它支持大多数与“面向对象”编程语言相关的术语。因此它不是完全面向对象的。

这使我们结束了关于“面向对象的 Python 编程”的文章。我希望您已经了解了与 Python 中的类、对象和面向对象的概念相关的所有概念。确保您尽可能多地练习并恢复您的经验。

点击关注，第一时间了解华为云新鲜技术~