13 类与对象1

简介：

我们都会将一些现实世界中的事物用代码来表示、实现，如函数关卡中的深夜食堂、工时计算器等。这一关也是如此。不过，会贪心一些，我们会将现实世界的所有事物都投射到代码中（比如让标题的“我们都是中国人”代码化）。为了达成这个目标，我们会接触到一种全新的编程思维：面向对象编程(Object Oriented Programming)。相信这种编程思维，会为你打开一个新的世界。可以说，要想利用Python做出更复杂更炫酷的程序，这种编程思维就是绕不过的坎。

类与对象

类

看到“类”这个字，你的第一反应是什么？人类？鸟类？鱼类？植物类？没错，我们常用类来划分一个个特定的群体。

想一想：你每次逛超市或网上购物时，是不是也被各种品类的商品所包围？

这便是生活中我们所说的类，是物以类聚的类，是分门别类的类，是多个类似事物组成的群体的统称。类的概念能帮助我们快速理解和判断事物的性质。类，是对某个群体的统称。

同样在编程世界里，其实我们从第一天开始就在接触类（class），比如整数、字符串、浮点数等，不同的数据类型就属于不同的类。准确来说，它们的全名是整数类、字符串类、浮点数类。我们可以用type()函数来验证一下：

编程世界中，每个类也会有众多实际的个例。比如数字1和2，都属于整数类；'第一个栗子'和'第二个栗子'，都属于字符串类。在Python的术语里，我们把类的个例就叫做实例 (instance)，可理解为“实际的例子”。

至此，我们已经认识了两个重要的新概念：类和实例，也知道它们之间的关系类似于：群体和个体。群体里的每个个体都有着相同/相似的特征和行为。有了这个基础，就可以谈“对象”了。

对象

对象是面向对象编程中的对象(object)。那么，它究竟是什么？一言以蔽之：Python中的对象等于类和实例的集合：即类可以看作是对象，实例也可以看作是对象，比如列表list是个类对象，[1,2]是个实例对象，它们都是对象。事实上现实生活中也类似，不论是类还是实例，都可以当作行动或思考的对象。例如：我们会说“电脑很强大”，也会说“我的电脑卡了”。前者说的是电脑类（类对象），后者说的是我的电脑（实例对象）。

所以，在Python中有这么一句话：

类的创建和调用

概念：

为了让你能顺利理解它，前面我用了很多现实和编程之间的类比。下面也会如此。

我们都是中国人

我们都属于中国人这个类，所以我们（作为实例）存在一些共同点。而这些共同点，就是我们区别于其他类的依据，细分的话其实可以分成两种。

第一种是描述事物是怎样的，有什么特征，比如黑眼睛、黄皮肤。

第二种是描述事物能做什么，有哪些行为和作用，比如能用筷子吃饭、会讲汉语。

在编程世界中，亦是如此。我们会把第一种共同点叫作属性（即what），第二种叫作方法（即how）。

比如列表的属性有：外层有中括号，元素之间用英文逗号隔开，方法有：都可以做增删改操作（如 append、del等）。

Python里的每个类都有自己独特的属性(attribute)和方法(method)，是这个类的所有实例都共享的。换言之，每个实例都可以调用类中所有的属性和方法。不过呢，编程中还是有一点和现实不同。那就是——现实世界中各个类的属性和方法是我们根据客观存在做出的抽象总结。而编程世界中各个类的属性和方法，是需要我们自行创建的（实际上整数、列表这些内置数据类型也是需要的，只不过Python预先创建好了，我们可以直接使用）。

类的创建

创建电脑类的示例代码：

应该能读懂吧？电脑类，都有屏幕，所以属性screen的值为True；开机时会显示“电脑正在开机中……”。

这是对代码的生活化解释，下面我们来看具体的含义：

可以看到：实例方法的创建语句，和函数的定义语句很类似，唯一不同的是：实例方法中有个必须放在首位的参数self。（关于self的特殊作用，我会在后面细讲）

除此之外，类名的首字母要大写，以便让我们轻松地辨认出“哦！这个是类！”

下面，请你现学现用，创建一个“中国人”的类，并为其创建一个属性和一个方法。

不过运行代码，终端会一片空白，这是因为我们只完成了创建，还没有调用。

类的调用

还是以那个电脑类为例

调用的关键在第7行代码：my_computer = Computer()。这个过程叫作：类的实例化，即在某个类下创建一个实例对象。

当实例my_computer一被创建出来，就可以调用类中的属性和方法。一句话概括就是：类有的实例都会有。

调用的语法是实例名.属性和实例名.方法

可能会有这样的疑惑：为什么实例调用方法时不用传参，定义时不是有个参数self吗？这就是参数self的特殊之处：在定义时不能丢，在调用时要忽略。

归纳一下三个步骤就是：创建一个类 —— 类的实例化 —— 用实例调用类的属性和方法。

类中创建的属性和方法可以被其所有的实例调用，而且，实例的数目在理论上是无限的。我们可以同时“新建”多个实例：

类的两个关键点

特殊参数：self

正式揭秘特殊参数self的作用：self会接收实例化过程中传入的数据，当实例对象创建后，实例便会代替 self，在代码中运行。

换言之，self 是所有实例的替身，“替身”是什么意思呢？我们来看一个例子。

刚刚我们列举的类方法都只有一个self参数，实际上和一般函数一样，类的方法也可以设置多个参数：

比如说你想在类的内部使用方法调用属性

这样写虽然没错，但实际上是多此一举，因为只要在say方法内部调用类属性'吴枫'，就可以实现同样的功能，不必【重复传参】。

怎么在方法内部调用类属性呢？你可能会想着这样写：

但这样会报错，系统会告诉你name在say方法中没有被定义

如果要在类的外部调用类属性，我们得先创建一个实例，再用实例名.属性的格式调用。那么如果想在类的内部调用类属性，而实例又还没创建之前，我们就需要有个变量先代替实例接收数据，这个变量就是参数self

当最后一行代码运行时，实例person会像参数一样传给self，替换掉self，第六行的self.name等价于person.name。person.name就相当于调用了类属性name(即'吴枫')，然后跑完整个方法。

可以这么理解：在执行person = Chinese()的时候，person已经具有name='xx'这个属性，在调用say方法时，person自动取代self，从而self.name变成person.name，及‘xx’，最后打印出xx是中国人

可见，self的作用相当于先给实例占了个位置，等到实例创建好就“功成身退，退位让贤”。

同理，如果想在类的方法内部调用其他方法时，我们也需要用到self来代表实例。

此时self.greeting()就变成person.greeting()，也就是调用实例方法greeting()，打印出'很高兴遇见你'，再打印出'我来自中国'。综上，所以我们说self代表的是类的实例本身，目的是【方便数据的流转】

对此，我们需要记住两点(死记住)：

第一点：只要在类中用def创建方法时，就必须把第一个参数位置留给 self，并在调用方法时忽略它（不用给self传参）。

第二点：当在类的方法内部想调用类属性或其他方法时，就要采用self.属性名或self.方法名的格式。

在self的基础上，下面我们来看第二个特殊点：初始化方法（也叫构造函数）

定义初始化方法的格式是def init(self)，是由init加左右两边的【双】下划线组成（ initialize “初始化”的缩写）。

初始化方法的作用在于：当每个实例对象创建时，该方法内的代码无须调用就会自动运行。

利用这个特性，在编写习惯上，我们（习惯地）会在初始化方法内部完成类属性的创建，为类属性设置初始值，这样类中的其他方法就能直接、随时调用。

除了设置固定常量，初始化方法同样可以接收其他参数，让传入的这些数据能作为属性在类的方法之间流转。我们再来看个例子（好好对比一下）：

最初方式：

使用__init__传参（函数归并到__init__函数）

虽然代码量并没有减少，但我们可以看到使用初始化方法，至少我们不必重复传参，传入的数据还可以被多次调用，比如这里的'xx'。随着我们想实现的功能愈发复杂，我们会在类内部编写很多的方法，如果我们需要传入的数据能在类中长久保存并能被随时调用，初始化方法就是一个不错的解决方案。如果有10个方法，在【每个方法中都要调用】name，最后每次【实例化后调用方法】都要传参就非常麻烦了

课堂上的案例都很简单，而类一般是用在较复杂的项目里。所以课堂的最后一部分，我会具体阐述类与实例在实际编程中的应用，也对一开始提出的问题：什么是面向对象编程做一个具体的阐释。

面向对象编程

与面向对象编程相对应的是面向过程编程，这是这关以前的关卡里我们所采用的编程思维。

面向过程编程：首先分析出解决问题所需要的步骤（即“第一步做什么，第二步做什么，第三步做什么”），然后用函数实现各个步骤，再依次调用。

而面向对象编程，会将程序看作是一组对象的集合（还记得对象包括类对象和实例对象吧）。用这种思维设计代码时，考虑的不是程序具体的执行过程（即先做什么后做什么），而是考虑先创建某个类，在类中设定好属性和方法，即是什么，和能做什么。

接着，再以类为模版创建一个实例对象，用这个实例去调用类中定义好的属性和方法即可。

比如这段代码

import math

# 变量key代表循环运行程序的开关
key = 1

# 采集信息的函数
def myinput():
    choice = input('请选择计算类型：（1-工时计算，2-人力计算）')
    if choice == '1':
        size = float(input('请输入项目大小：（1代表标准大小，请输入小数）'))
        number = int(input('请输入人力数量：（请输入整数）'))
        time = None
        return size,number,time
        # 这里返回的数据是一个元组
    if choice == '2':
        size = float(input('请输入项目大小：（1代表标准大小，请输入小数）'))
        number = None
        time = float(input('请输入工时数量：（请输入小数）'))
        return size,number,time
        # 这里返回的是一个元组

# 完成计算的函数
def estimated(my_input):
    # 把元组中的数据取出来
    size = my_input[0]
    number = my_input[1]
    time = my_input[2]
    # 人力计算
    if (number == None) and (time != None):
        number = math.ceil(size * 80 / time)
        print('项目大小为%.1f个标准项目，如果需要在%.1f个工时完成，则需要人力数量为：%d人' %(size,time,number)) 
    # 工时计算
    elif (number != None) and (time == None):
        time = size * 80 / number
        print('项目大小为%.1f个标准项目，使用%d个人力完成，则需要工时数量为：%.1f个' %(size,number,time))  

# 询问是否继续的函数
def again():
    # 声明全局变量key，以便修改该变量
    global key
    a = input('是否继续计算？继续请输入y，输入其他键将结束程序。')
    if a != 'y':
        # 如果用户不输入'y'，则把key赋值为0
        key = 0  

# 主函数
def main():
    print('欢迎使用工作量计算小程序！')
    while key == 1:
        my_input = myinput()
        estimated(my_input)
        again()
    print('感谢使用工作量计算小程序！')

main()

我们根据“采集信息——计算数据——继续采集信息”这个过程封装了三个函数，再依次调用，按规定顺序执行程序。

如果把上述面向过程编程的代码改成面向对象编程，我们可以先创建一个Project类，在类中定义好属性和方法，再创建一个实例。

修改后：

class Project:
    
    def __init__(self):
        self.key = 1

    def input(self):
        choice = input('请选择计算类型：（1-工时计算，2-人力计算）')
        if choice == '1':
            self.size = float(input('请输入项目大小：（1代表标准大小，请输入小数）'))
            self.number = int(input('请输入人力数量：（请输入整数）'))
            self.time = None
        if choice == '2':
            self.size = float(input('请输入项目大小：（1代表标准大小，请输入小数）'))
            self.number = None
            self.time = float(input('请输入工时数量：（请输入小数）'))

    def estimated(self):
        # 人力计算
        if (self.number == None) and (self.time != None):
            self.number = math.ceil(self.size * 80 / self.time)
            print('项目大小为%.1f个标准项目，如果需要在%.1f个工时完成，则需要人力数量为：%d人' %(self.size,self.time,self.number)) 
        # 工时计算
        elif (self.number != None) and (self.time == None):
            self.time = self.size * 80 / self.number
            print('项目大小为%.1f个标准项目，使用%d个人力完成，则需要工时数量为：%.1f个' %(self.size,self.number,self.time))  
    
    def again(self):
        a = input('是否继续计算？继续请输入y，输入其他键将结束程序。')
        if a != 'y':
            # 如果用户不输入'y'，则把key赋值为0
            self.key = 0  

    # 主函数
    def main(self):
        print('欢迎使用工作量计算小程序！')
        while self.key == 1:
            self.input()
            self.estimated()
            self.again()
        print('感谢使用工作量计算小程序！')

project1 = Project()
#创建实例
project1.main()

可以发现，在此例中，用类编写一个直观的好处就是参数的传递会比普通函数要省事很多，也【不必考虑全局变量和局部变量】，因为类中的方法可以直接调用属性。

可想而知，当项目难度越大，需要的参数越多，用类编写在程序的可拓展性、可读性、维护成本都会更胜一筹。

这就是面向对象编程：以对象为中心，将计算机程序看作一组对象的集合。对比图如下：