云社区 博客 博客详情

从零开始学python | 面向对象编程 Python:你需要知道的一切

Yuchuan 发表于 2021-06-01 09:11:45 2021-06-01
0
0

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

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

本文将详细介绍以下几个方面:

让我们开始吧。

什么是面向对象编程?(Python 中的 OOP 概念)

Python - 顶级编程语言 - Edureka

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

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

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

    Object-Oriented Programming (OOP)

    Procedural-Oriented Programming (Pop)

    描述

    It is a bottom-up approach

    It is a top-down approach

    这是一种自上而下的方法

    Program is divided into objects

    Program is divided into functions

    程序分为功能

    Makes use of Access modifiers

    ‘public’, private’, protected’

    Doesn’t use Access modifiers

    不使用 访问修饰符

    It is more secure

    It is less secure

    它不太安全

    Object can move freely within member functions

    Data can move freely from function to function within programs

    数据可以在程序内从一个函数自由移动到另一个函数

    It supports inheritance

    It does not support inheritance

    不支持继承

    这就是差异的全部,继续前进,让我们了解 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

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

      继承:

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

      TypesOfInheritance - Python 类 - Edureka

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

      单一继承:

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

      例子:

      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 方法,其中一项任务可以以多种不同的方式执行。简单来说,它是一个对象的属性,它允许它采取多种形式

      多态示例-面向对象编程python-Edureka

      多态有两种类型:

      • 编译时多态
      • 运行时多态性

      编译时多态:

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

      例子:

      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 中的类、对象和面向对象的概念相关的所有概念。确保您尽可能多地练习并恢复您的经验。

      登录后可下载附件,请登录或者注册

      【版权声明】本文为华为云社区用户原创内容,转载时必须标注文章的来源(华为云社区),文章链接,文章作者等基本信息,否则作者和本社区有权追究责任。如果您发现本社区中有涉嫌抄袭的内容,欢迎发送邮件至:huaweicloud.bbs@huawei.com进行举报,并提供相关证据,一经查实,本社区将立刻删除涉嫌侵权内容。
      评论文章 //点赞 收藏 0
      点赞
      分享文章到微博
      分享文章到朋友圈

      上一篇:【Linux C编程】第十二章 信号1

      下一篇:从零开始学Python| 合集分类目录索引二

      评论 (0)


      登录后可评论,请 登录注册

      评论