​​【本期推荐】你能否在直播间抢到秒杀商品的关键不仅仅是手速，还有它：大规模超低时延直播，点击就看华为云音视频的硬核解决方案。

摘要：这是一个关于 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 类？

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 类中的方法和属性

如果没有一些功能，现在创建一个类是不完整的。因此，可以通过设置各种属性来定义功能，这些属性充当与这些属性相关的数据和功能的容器。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 中的属性定义了对象、元素或文件的属性。有两种类型的属性：

 

• 内置类属性： 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 类：继承

继承允许我们从基类/父类继承属性和方法。这很有用，因为我们可以创建子类并从父类中获取所有功能。然后我们可以在不影响父类的情况下覆盖和添加新功能。让我们通过一个例子来理解父类和子类的概念。

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

1. 父类（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) 它继承了基类的属性。 总之，继承用于重用代码并降低程序的复杂性。

Python 类：多态性

计算机科学中的多态性是为不同的底层形式呈现相同界面的能力。实际上，多态意味着如果类 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 

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

Python 类：抽象

抽象用于通过建模适合问题的类来简化复杂的现实。在这里，我们有一个无法实例化的抽象类。这意味着您不能为这些类创建对象或实例。它只能用于继承您称为基类的某些功能。因此，您可以继承功能，但同时，您无法创建此特定类的实例。让我们通过下面的例子来理解抽象类的概念：

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 不会'不允许你创建抽象类的对象。但是使用继承，您实际上可以继承属性并执行相应的任务。

 

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