关于面向对象编程:一文讲全了Python-类和对象内容

摘要：这是一个对于 Python 类和对象的全部内容。

本文分享自华为云社区《从零开始学 python | Python 类和对象—面向对象编程》，原文作者：Yuchuan。

Python 在沉闷开发人员方面将超过其余语言之后,Python 开发人员的需要只会增长。Python 遵循面向对象的编程范式。它解决申明 python 类，从它们创建对象并与用户交互。在面向对象的语言中，程序被分成独立的对象，或者你能够说成几个小程序。每个对象代表应用程序的不同局部，它们能够互相通信。

在这个 python 类博客中，您将按以下程序理解类和对象的各个方面：

What is a Python Class?
Methods and Attributes in a class
What are Objects?
OOPs Concepts:
Inheritance
Polymorphism
Abstraction

python 中的类是创立特定对象的蓝图。它使您能够以特定形式构建软件。问题来了，怎么办？类容许咱们以一种易于重用的形式对咱们的数据和函数进行逻辑分组，并在须要时进行构建。思考下图。

在第一张图片 (A) 中，它代表了一个能够被视为 Class 的房子的蓝图。应用雷同的蓝图，咱们能够创立多个屋宇，这些能够视为 Objects。应用类，您能够为您的程序增加一致性，以便以更简洁、更无效的形式应用它们。属性是通过点表示法拜访的数据成员（类变量和实例变量）和办法。

类变量 是一个类的所有不同对象 / 实例共享的变量。
实例变量 是每个实例惟一的变量。它是在办法外部定义的，并且只属于类的以后实例。
办法也称为函数，它们在类中定义并形容对象的行为。

当初，让咱们继续前进，看看它在 PyCharm 中是如何工作的。要开始，首先看一下 python 类的语法。

语法：

class Class_name:
statement-1
.
.
statement-N

在这里，“class”语句创立了一个新的类定义。类的名称紧跟在 python 中的关键字“class”之后，后跟一个冒号。要在 python 中创立一个类，请思考以下示例：

class employee:
 pass
 #no attributes and methods
 emp_1=employee()
 emp_2=employee()
 #instance variable can be created manually
 emp_1.first='aayushi'
 emp_1.last='Johari'
 emp_1.email='aayushi@edureka.co'
 emp_1.pay=10000
 
emp_2.first='test'
 emp_2.last='abc'
 emp_2.email='test@company.com'
 emp_2.pay=10000
 print(emp_1.email)
 print(emp_2.email)

输入–

aayushi@edureka.co
test@company.com

当初，如果咱们不想手动设置这些变量怎么办。你会看到很多代码，而且很容易出错。所以为了让它主动，咱们能够应用“init”办法。为此，让咱们理解一下 Python 类中的办法和属性到底是什么。

如果没有一些性能，当初创立一个类是不残缺的。因而，能够通过设置各种属性来定义性能，这些属性充当与这些属性相干的数据和性能的容器。python 中的函数也称为办法。谈到 init 办法，它是一个非凡的函数，每当实例化该类的新对象时都会调用它。您能够将其视为 initialize 办法，或者如果您来自任何其余面向对象的编程背景，例如 C++、Java 等，则能够将其视为构造函数。当初当咱们在类中设置办法时，它们会主动接管实例。让咱们持续应用 python 类并应用此办法承受名字、姓氏和薪水。

class employee:
    def __init__(self, first, last, sal):
        self.fname=first
        self.lname=last
        self.sal=sal
        self.email=first + '.' + last + '@company.com'
 
emp_1=employee('aayushi','johari',350000)
emp_2=employee('test','test',100000)
print(emp_1.email)
print(emp_2.email)

当初在咱们的“init”办法中，咱们设置了这些实例变量（self、first、last、sal）。Self 是实例，这意味着每当咱们写 self.fname=first 时，它与 emp_1.first=’aayushi’ 雷同。而后咱们创立了员工类的实例，咱们能够在其中传递 init 办法中指定的值。此办法将实例作为参数。当初它将主动实现，而不是手动实现。

接下来，咱们心愿可能执行某种操作。为此，咱们将向此类增加一个办法。假如我想要显示员工全名的性能。因而，让咱们理论实现这一点。

class employee:
    def __init__(self, first, last, sal):
        self.fname=first
        self.lname=last
        self.sal=sal
        self.email=first + '.' + last + '@company.com'
 
    def fullname(self):
            return '{}{}'.format(self.fname,self.lname)
 
emp_1=employee('aayushi','johari',350000)
emp_2=employee('test','test',100000)
print(emp_1.email)
print(emp_2.email)
print(emp_1.fullname())
print(emp_2.fullname())

输入–

aayushi.johari@company.com 
 test.test@company.com 
 aayushijohari 
 TESTTEST

正如你在下面看到的，我在一个类中创立了一个名为“全名”的办法。因而，python 类中的每个办法都会主动将实例作为第一个参数。当初在这个办法中，我编写了打印全名并返回这个而不是 emp_1 名字和姓氏的逻辑。接下来，我应用了“self”，以便它实用于所有实例。因而每次都打印这个，咱们应用一个办法。

持续应用 Python 类，有一些变量在类的所有实例之间共享。这些被称为类变量。实例变量对于每个实例都能够是惟一的，例如姓名、电子邮件、sal 等。简单吗？让咱们通过一个例子来了解这一点。请参阅上面的代码以理解工资的年度增长状况。

class employee:
    perc_raise =1.05
    def __init__(self, first, last, sal):
        self.fname=first
        self.lname=last
        self.sal=sal
        self.email=first + '.' + last + '@company.com'
 
    def fullname(self):
            return '{}{}'.format(self.fname,self.lname)
    def apply_raise(self):
        self.sal=int(self.sal*1.05)
 
emp_1=employee('aayushi','johari',350000)
emp_2=employee('test','test',100000)
 
print(emp_1.sal)
emp_1.apply_raise()
print(emp_1.sal)

输入–

350000
 367500

正如你在下面看到的，我先打印了工资，而后利用了 1.5% 的增长。为了拜访这些类变量，咱们须要通过类或类的实例来拜访它们。当初，让咱们理解 Python 类中的各种属性。

Python 中的属性定义了对象、元素或文件的属性。有两种类型的属性：

内置类属性： Python 类中存在各种内置属性。例如_dict_、_doc_、_name _ 等。让我举同样的例子，我想查看 employee1 的所有键值对。为此，您能够简略地编写以下蕴含类命名空间的语句：
打印（emp_1.__dict__）
执行之后，你会失去这样的输入：{‘fname’: ‘aayushi’, ‘lname’: ‘johari’, ‘sal’: 350000, ’email’: ‘aayushi.johari@company.com’}
用户定义的属性：属性是在类定义中创立的。咱们能够为类的现有实例动态创建新属性。属性也能够绑定到类名。
接下来，咱们有 public、protected 和 private 属性。让咱们具体理解它们：

接下来，让咱们理解一个 python 类中最重要的组件，即 Objects。

正如咱们下面探讨的，一个对象能够用来拜访不同的属性。它用于创立类的实例。实例是在运行时创立的类的对象。

给你一个疾速浏览，对象次要是看到四周的所有。例如：狗是动物类的对象，我是人类类的对象。同样，同一个电话类能够有不同的对象。这与咱们曾经探讨过的函数调用十分类似。让咱们通过一个例子来了解这一点：

class MyClass:
 
   def func(self):
      print('Hello')
 
# create a new MyClass
ob = MyClass()
ob.func()

持续应用 python 类，让咱们理解各种 OOP 概念。

OOPs 指的是 Python 中的面向对象编程。好吧，Python 并不是齐全面向对象的，因为它蕴含一些过程函数。当初，您肯定想晓得过程编程和面向对象编程之间有什么区别。为了打消您的疑难，在过程式编程中，整个代码都被写入一个长过程，即便它可能蕴含函数和子例程。因为数据和逻辑混合在一起，因而无奈治理。然而当咱们议论面向对象编程时，程序被拆分为独立的对象或几个小程序。每个对象代表应用程序的不同局部，这些局部有本人的数据和逻辑来在它们之间进行通信。例如，一个网站有不同的对象，如图像、视频等。

面向对象编程包含 Python 类、对象、继承、多态、形象等概念，上面让咱们具体理解这些主题。

继承容许咱们从基类 / 父类继承属性和办法。这很有用，因为咱们能够创立子类并从父类中获取所有性能。而后咱们能够在不影响父类的状况下笼罩和增加新性能。让咱们通过一个例子来了解父类和子类的概念。

正如咱们在图像中看到的，孩子继承了父亲的属性。同样，在 python 中，有两个类：

父类（Super 或 Base 类）

2. 子类（子类或派生类）

继承属性的类称为子类，而继承属性的类称为父类。

继承是指创立蕴含其父类的专业化的子类的能力。它进一步分为四种类型，即单继承、多级继承、分层继承和多重继承。请参考下图以取得更好的了解。

让咱们持续应用 python 类并理解继承是如何有用的。

比如说，我想为员工类型创立类。我将创立 ‘developers’ 和 ‘managers’ 作为子类，因为开发人员和经理都有姓名、电子邮件和薪水，所有这些性能都在员工类中。因而，咱们不用复制子类的代码，而是能够通过从员工那里继承来简略地重用代码。

class employee:
    num_employee=0
    raise_amount=1.04
    def __init__(self, first, last, sal):
        self.first=first
        self.last=last
        self.sal=sal
        self.email=first + '.' + last + '@company.com'
        employee.num_employee+=1
    def fullname (self):
        return '{} {}'.format(self.first, self.last)
    def apply_raise (self):
        self.sal=int(self.sal * raise_amount)
class developer(employee):
    pass
 
emp_1=developer('aayushi', 'johari', 1000000)
print(emp_1.email)

输入 - aayushi.johari@company.com
正如您在下面的输入中看到的，employee 类的所有详细信息都能够在 developer 类中找到。当初，如果我想将开发人员的 raise_amount 更改为 10% 怎么办？让咱们看看它是如何理论实现的。

class employee:
    num_employee=0
    raise_amount=1.04
    def __init__(self, first, last, sal):
        self.first=first
        self.last=last
        self.sal=sal
        self.email=first + '.' + last + '@company.com'
        employee.num_employee+=1
    def fullname (self):
        return '{} {}'.format(self.first, self.last)
    def apply_raise (self):
        self.sal=int(self.sal* raise_amount)
 
class developer(employee):
    raise_amount = 1.10
 
emp_1=developer('aayushi', 'johari', 1000000)
print(emp_1.raise_amount)

输入 - 1.1
如您所见，它已将工资增长百分比从 4% 更新为 10%。当初，如果我想再增加一个属性，比方在咱们的 init 办法中应用一种编程语言，但它在咱们的父类中不存在。有什么解决办法吗？是的！咱们能够复制整个员工逻辑并这样做，但它会再次减少代码大小。因而，为了防止这种状况，让咱们思考以下代码：

class employee:
    num_employee=0
    raise_amount=1.04
    def __init__(self, first, last, sal):
        self.first=first
        self.last=last
        self.sal=sal
        self.email=first + '.' + last + '@company.com'
        employee.num_employee+=1
    def fullname (self):
        return '{} {}'.format(self.first, self.last)
    def apply_raise (self):
        self.sal=int(self.sal* raise_amount)
class developer(employee):
    raise_amount = 1.10
    def __init__(self, first, last, sal, prog_lang):
        super().__init__(first, last, sal)
        self.prog_lang=prog_lang
 
emp_1=developer('aayushi', 'johari', 1000000, 'python')
print(emp_1.prog_lang)

因而，只用一点点代码，我就进行了更改。我应用了 super.__init__(first, last, pay) 它继承了基类的属性。总之，继承用于重用代码并升高程序的复杂性。

计算机科学中的多态性是为不同的底层模式出现雷同界面的能力。实际上，多态意味着如果类 B 从类 A 继承，它不用继承对于类 A 的所有内容，它能够做一些与类 A 不同的事件。它最罕用于解决继承。Python 是隐式多态的，它可能重载规范运算符，以便它们依据上下文具备适当的行为。

让咱们通过一个例子来了解：

class Animal:
    def __init__(self,name):
        self.name=name
        def talk(self):
            pass
class Dog(Animal):
            def talk(self):
                print('Woof')
class Cat(Animal):
    def talk(self):
        print('MEOW!')
c= Cat('kitty')
c.talk()
d=Dog(Animal)
d.talk()

输入 –

Meow!
Woof

接下来，让咱们转向另一个面向对象的编程概念，即形象。

形象用于通过建模适宜问题的类来简化简单的事实。在这里，咱们有一个无奈实例化的抽象类。这意味着您不能为这些类创建对象或实例。它只能用于继承您称为基类的某些性能。因而，您能够继承性能，但同时，您无奈创立此特定类的实例。让咱们通过上面的例子来了解抽象类的概念：

from abc import ABC, abstractmethod     
 
class Employee(ABC):
    @abstractmethod
 
    def calculate_salary(self,sal):
        pass
 
class Developer(Employee):
 
    def calculate_salary(self,sal):
        finalsalary= sal*1.10
        return  finalsalary
 
emp_1 = Developer()
print(emp_1.calculate_salary(10000))

输入–

11000.0
正如你在下面的输入中看到的，咱们曾经将基本工资减少到 10%，即当初的工资是 11000。当初，如果你真的持续创立一个“Employee”类的对象，它会抛出一个谬误，因为 python 不会 ’ 不容许你创立抽象类的对象。然而应用继承，您实际上能够继承属性并执行相应的工作。

点击关注，第一工夫理解华为云陈腐技术~

关于面向对象编程:一文讲全了Python-类和对象内容

什么是 Python 类？

Python 类中的办法和属性

Python 类中的属性

面向对象的概念

Python 类：继承

Python 类：多态性

Python 类：形象