共计 7375 个字符,预计需要花费 19 分钟才能阅读完成。
摘要: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 objects
emp2 = 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 class
def __init__(self, name, age, salary):
self.name = name
self.age = age
self.salary = salary
class childemployee(employee1)://This is a child class
def __init__(self, name, age, salary,id):
self.name = name
self.age = age
self.salary = salary
self.id = id
emp1 = employee1('harshit',22,1000)
print(emp1.age)
输入:22
解释:
- 我正在应用父类并创立一个构造函数 (__init__),类自身正在应用参数(’name’、’age’ 和 ‘salary’)初始化属性。
- 创立了一个子类“childemployee”,它继承了父类的属性,最初依据参数实例化了对象“emp1”和“emp2”。
- 最初,我曾经打印了 emp1 的年龄。嗯,你能够做很多事件,比方打印整本字典或姓名或薪水。
多级继承:
多级继承使派生类可能从间接父类继承属性,而间接父类又从其父类继承属性。
例子:
class employee()://Super class
def __init__(self,name,age,salary):
self.name = name
self.age = age
self.salary = salary
class childemployee1(employee)://First child class
def __init__(self,name,age,salary):
self.name = name
self.age = age
self.salary = salary
class childemployee2(childemployee1)://Second child class
def __init__(self, name, age, salary):
self.name = name
self.age = age
self.salary = salary
emp1 = 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 Inheritance
self.name = name
self.age = age
self.salary = salary
class childemployee1(employee):
def __init__(self,name,age,salary):
self.name = name
self.age = age
self.salary = salary
class childemployee2(employee):
def __init__(self, name, age, salary):
self.name = name
self.age = age
self.salary = salary
emp1 = 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 = id
emp1 = 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 Overloading
obj.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 = id
def 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 = childemployee1
c.earn(employee)
d = childemployee2
d.earn(employee)
输入:没钱,有钱
阐明:在下面的例子中,我创立了两个类 ‘childemployee1’ 和 ‘childemployee2’,它们派生自同一个基类 ’employee’。这是一个没有收到钱而另一个失去的问题。当初真正的问题是这是怎么产生的?好吧,如果您仔细观察,我在这里创立了一个空函数并应用了 Pass(当您不想执行任何命令或代码时应用的语句)。当初,在两个派生类下,我应用了雷同的空函数,并将打印语句用作 ‘no money’ 和 ‘has money’。最初,创立了两个对象并调用了函数。
持续探讨下一个面向对象的 Python 编程办法,我将探讨封装。
封装:
在原始模式中,封装基本上意味着将数据绑定到单个类中。与 Java 不同,Python 没有任何公有关键字。不应间接拜访类,而应以下划线为前缀。
让我向您展现一个示例以便更好地了解。
例子:
class employee(object):
def __init__(self):
self.name = 1234
self._age = 1234
self.__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 = 1000000
def earn(self):
print("earning is:{}".format(self.__maxearn))
def setmaxearn(self,earn)://setter method used for accesing private class
self.__maxearn = earn
emp1 = employee()
emp1.earn()
emp1.__maxearn = 10000
emp1.earn()
emp1.setmaxearn(10000)
emp1.earn()
输入:
收益为:1000000,收益为:1000000,收益为:10000
阐明:应用 setter 办法提供对公有类办法的间接拜访。这里我定义了一个员工类,并应用了一个(__maxearn),它是这里用来存储员工最大支出的 setter 办法,以及一个以价格为参数的 setter 函数 setmaxearn()。
这是一个显著的封装示例,咱们限度对公有类办法的拜访,而后应用 setter 办法授予拜访权限。
接下来在面向对象编程中,python 方法论探讨了一个称为形象的要害概念。
形象:
假如您应用网上银行或任何其余流程从 bookmyshow 预订了一张电影票。您不晓得如何生成 pin 或如何实现验证的过程。这在编程方面被称为“形象”,它基本上意味着您只显示特定流程的实现细节,而对用户暗藏细节。它用于通过对适宜问题的类进行建模来简化简单问题。
抽象类不能被实例化,这仅仅意味着你不能为这种类型的类创建对象。它只能用于继承性能。
例子:
from abc import ABC,abstractmethod
class employee(ABC):
def emp_id(self,id,name,age,salary): //Abstraction
pass
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 中的类、对象和面向对象的概念相干的所有概念。确保您尽可能多地练习并复原您的教训。
点击关注,第一工夫理解华为云陈腐技术~