章节十三：类与对象1
章节十三：类与对象1
1. 类与对象
1.1 事情要从“类”开始讲起
看到“类”这个字，你的第一反应是什么，想到了什么词语？
人类？鸟类？鱼类？植物类？没错，我们常用类来划分一个个特定的群体。
现在，请你用几秒的时间，让眼睛离开屏幕，留意一下周围，看看都有哪些种类的物品。
发现了吗？在我们的身边，事物被井井有条地划分成了各个种类，如电子类、家具类、服饰类、食品类……
再想一想：你每次逛超市或网上购物时，是不是也被各种品类的商品所包围？
这便是生活中我们所说的类，是物以类聚的类，是分门别类的类，是多个类似事物组成的群体的统称。类的概念能帮助我们快速理解和判断事物的性质。
同样在编程世界里，其实我们从第一天开始就在接触类（class），比如整数、字符串、浮点数等，不同的数据类型就属于不同的类。
准确来说，它们的全名是整数类、字符串类、浮点数类。我们可以用type()函数来验证一下：
输出结果是<class 'str'>，表明1属于字符串类，以此类推。
不难发现，类之所以为类是因为每一个类之下都包含无数相似的不同个例。比如你正在看的这台电脑和我写稿的电脑，都属于电脑类；你和我，都属于人类。
编程世界中，每个类也会有众多实际的个例。比如数字1和2，都属于整数类；'第一个栗子'和'第二个栗子'，都属于字符串类。
在Python的术语里，我们把类的个例就叫做实例 (instance)，可理解为“实际的例子”。
下面有个选择题，测试一下你是否理解了类和实例这两个概念。
单选题
请问：狗、秋田犬、忠犬八公、list、[1,2]分别是：
A.类 实例 实例 类 实例
B.类 类 实例 类 类
C.类 类 实例 类 实例
答案是C
类，是对某个群体的统称。所以，狗和秋田犬都是类。毕竟，秋田犬是群体而非个体。我们可以这么想：类是某个特定的群体，实例是群体中某个具体的个体。
至此，我们已经认识了两个重要的新概念：类和实例，也知道它们之间的关系类似于：群体和个体。群体里的每个个体都有着相同/相似的特征和行为。
有了这个基础，就可以谈“对象”了。
1.2 万事万物，皆为对象
当然，这里说的不是“找对象”的对象，也不是🐘🐘，而是面向对象编程中的对象(object)。那么，它究竟是什么？
一言以蔽之：Python中的对象等于类和实例的集合：即类可以看作是对象，实例也可以看作是对象，比如列表list是个类对象，[1,2]是个实例对象，它们都是对象。
事实上现实生活中也类似，不论是类还是实例，都可以当作行动或思考的对象。
例如：我们会说“电脑很强大”，也会说“我的电脑卡了”。前者说的是电脑类（类对象），后者说的是我的电脑（实例对象）。
所以，在Python中有这么一句话：
现在我们明白类、实例、对象三者之间的关系，接下来我们就可以用代码制造一个对象，也就是类与实例的创建。
2. 类的创建和调用
对你来说，今天是第一次正式接触编程中“类”这个概念。为了让你能顺利理解它，前面我用了很多现实和编程之间的类比。下面也会如此。
2.1 我们都是中国人
我和你，都是中国人——这句话里隐藏着一个共识：我们都属于中国人这个类，所以我们（作为实例）存在一些共同点。例如：黑眼睛、黄皮肤、用筷子吃饭、会讲汉语……
而这些共同点，就是我们区别于其他类的依据，细分的话其实可以分成两种。
哪两种呢？想三秒，我再给答案。3、2、1……
第一种是描述事物是怎样的，有什么特征，比如黑眼睛、黄皮肤。
第二种是描述事物能做什么，有哪些行为和作用，比如能用筷子吃饭、会讲汉语。
在编程世界中，亦是如此。我们会把第一种共同点叫作属性（即what），第二种叫作方法（即how）。
比如列表的属性有：外层有中括号，元素之间用英文逗号隔开，方法有：都可以做增删改操作（如 append、del等）。
Python里的每个类都有自己独特的属性(attribute)和方法(method)，是这个类的所有实例都共享的。换言之，每个实例都可以调用类中所有的属性和方法。
不过呢，编程中还是有一点和现实不同。那就是——现实世界中各个类的属性和方法是我们根据客观存在做出的抽象总结。
而编程世界中各个类的属性和方法，是需要我们自行创建的（实际上整数、列表这些内置数据类型也是需要的，只不过Python预先创建好了，我们可以直接使用）。
那么，接下来我们就来学习如何自定义一个类吧～
2.2 类的创建
我们先来看一个创建电脑类的示例代码：
class Computer:
screen = True
def start(self):
print('电脑正在开机中……')
应该能读懂吧？电脑类，都有屏幕，所以属性screen的值为True；开机时会显示“电脑正在开机中……”。
这是对代码的生活化解释，下面我们来看具体的含义：
可以看到：实例方法的创建语句，和函数的定义语句很类似，唯一不同的是：实例方法中有个必须放在首位的参数self。（关于self的特殊作用，我会在后面细讲）
除此之外，类名的首字母要大写，以便让我们轻松地辨认出“哦！这个是类！”
下面，请你现学现用，创建一个“中国人”的类，并为其创建一个属性和一个方法。
# 类名首字母大写
class Chinese:
# 用赋值语句，创建类的属性
eye = 'black'
# 创建实例方法时，不要漏了 self
def eat(self):
print('吃饭，选择用筷子。')
不过运行代码，终端会一片空白，这是因为我们只完成了创建，还没有调用。
下面，就让我们将创建好的属性和方法用起来吧~
2.3 类的调用
还是以那个电脑类为例（重点看最后三行代码）：
class Computer:
screen = True
def start(self):
print('电脑正在开机中……')
my_computer = Computer()
print(my_computer.screen)
my_computer.start()
调用的关键在第7行代码：my_computer = Computer()。这个过程叫作：类的实例化，即在某个类下创建一个实例对象。
我们来试下打印实例类型和直接打印出实例，会是什么结果。
class Computer:
screen = True
def start(self):
print('电脑正在开机中……')
my_computer = Computer()
print(type(my_computer))
print(my_computer)
第一行：<class '__main__.Computer'>验证了my_computer属于Computer这个类；
第二行打印出Computer类的一个实例对象(object)，后面的一串字符表示这个对象的内存地址。
当实例my_computer一被创建出来，就可以调用类中的属性和方法。一句话概括就是：类有的实例都会有。
调用的语法是实例名.属性和实例名.方法，仔细看最后两行代码，然后点击运行：
class Computer:
screen = True
def start(self):
print('电脑正在开机中……')
my_computer = Computer()
print(my_computer.screen)
my_computer.start()
倒数第二行：my_computer.screen先是获取到类属性screen对应的值True，再用print()打印出来。
最后一行：my_computer.start()调用方法start()，这个方法的功能是直接打印出'电脑正在开机中……'。
细心的同学可能会有这样的疑惑：为什么实例调用方法时不用传参，定义时不是有个参数self吗？
这就是参数self的特殊之处：在定义时不能丢，在调用时要忽略。至于它的作用，容我再卖个关子。
下面，就请趁热打铁，完成对类属性和方法的调用。在下面的代码区完整地走完类的创建和调用。
再看下参考代码吧：
class Chinese: # 创建一个类
eye = 'black'
def eat(self):
print('吃饭，选择用筷子。')
wufeng = Chinese() # 类的实例化
print(wufeng.eye) # 实例调用类属性
wufeng.eat() # 调用类中的方法（传参不用管self）
归纳一下三个步骤就是：创建一个类 —— 类的实例化 —— 用实例调用类的属性和方法。
再啰嗦一句：类中创建的属性和方法可以被其所有的实例调用，而且，实例的数目在理论上是无限的。我们可以同时“新建”多个实例：
# 阅读代码后点击运行
class Chinese:
eye = 'black'
def eat(self):
print('吃饭，选择用筷子。')
# 类的实例化：创建多个实例
wufeng = Chinese()
jiangjiang = Chinese()
kaxi = Chinese()
print(jiangjiang.eye)
wufeng.eat()
kaxi.eat()
因此，类也被称为“实例工厂”，因其为所有实例提供了一套蓝图（即预先设定好有什么属性和方法）。
3. 创建类的两个关键点
3.1 特殊参数：self
正式揭秘特殊参数self的作用：self会接收实例化过程中传入的数据，当实例对象创建后，实例便会代替 self，在代码中运行。
换言之，self 是所有实例的替身，“替身”是什么意思呢？我们来看一个例子。
刚刚我们列举的类方法都只有 一个self参数，实际上和一般函数一样，类的方法也可以设置多个参数：
这样写虽然没错，但实际上是多此一举，因为只要在say方法内部调用类属性'吴枫'，就可以实现同样的功能，不必重复传参。
怎么在方法内部调用类属性呢？
但这样会报错，系统会告诉你name在say方法中没有被定义，那怎么办呢？
还记得我们刚说的，如果要在类的外部调用类属性，我们得先创建一个实例，再用实例名.属性的格式调用吗？
那么如果想在类的内部调用类属性，而实例又还没创建之前，我们就需要有个变量先代替实例接收数据，这个变量就是参数self。
正确的写法是这样子的：（留意第六行）
class Chinese:
name = '吴枫' # 类属性name
def say(self):
print(self.name + '是中国人')
person = Chinese() # 创建Chinese的实例person
person.say() # 调用实例方法
当最后一行代码运行时，实例person会像参数一样传给self，替换掉self，第六行的self.name等价于person.name。
person.name就相当于调用了类属性name(即'吴枫')，然后跑完整个方法。
它的作用相当于：
可见，self的作用相当于先给实例占了个位置，等到实例创建好就“功成身退，退位让贤”。
同理，如果想在类的方法内部调用其他方法时，我们也需要用到self来代表实例。
阅读代码后点击运行：（重点看第七行）
class Chinese:
def greeting(self):
print('很高兴遇见你')
def say(self):
self.greeting()
print('我来自中国')
person = Chinese()
# 创建实例person
person.say()
# 调用say()方法
当最后一行实例person调用say()方法时，便会执行say()内部的语句（第七行开始）。
此时self.greeting()就变成person.greeting()，也就是调用实例方法greeting()，打印出'很高兴遇见你'，再打印出'我来自中国'。
综上，所以我们说self代表的是类的实例本身，方便数据的流转。对此，我们需要记住两点：
第一点：只要在类中用def创建方法时，就必须把第一个参数位置留给 self，并在调用方法时忽略它（不用给self传参）。
第二点：当在类的方法内部想调用类属性或其他方法时，就要采用self.属性名或self.方法名的格式。
好，self这个神奇的参数就讲解到这里。对初学者来说，确实不是那么容易理解，如果不熟悉，可以多多温习，做做课后练习巩固一下哦。
在self的基础上，下面我们来看第二个特殊点：初始化方法（也叫构造函数）
3.2 特殊方法：初始化方法
定义初始化方法的格式是def __init__(self)，是由init加左右两边的【双】下划线组成（ initialize “初始化”的缩写）。
初始化方法的作用在于：当每个实例对象创建时，该方法内的代码无须调用就会自动运行。
是不是很神奇？我们只是创建了实例，还没有调用，初始化方法就自动执行了！
利用这个特性，在编写习惯上，我们会在初始化方法内部完成类属性的创建，为类属性设置初始值，这样类中的其他方法就能直接、随时调用。我们来看个例子：
除了设置固定常量，初始化方法同样可以接收其他参数，让传入的这些数据能作为属性在类的方法之间流转。我们再来看个例子：
class Chinese:
def __init__(self, name, birth, region):
self.name = name # self.name = '吴枫'
self.birth = birth # self.birth = '广东'
self.region = region # self.region = '深圳'
def born(self):
print(self.name + '出生在' + self.birth)
def live(self):
print(self.name + '居住在' + self.region)
person = Chinese('吴枫','广东','深圳') # 传入初始化方法的参数
person.born()
person.live()
先看14行：当初始化方法有多个参数的时候，在实例化的时候就要传入相应的值，这里'吴枫'传给参数name, '广东'传给birth，'深圳'传给region。
当实例person创建完成后，初始化方法会自动执行，此时第三行的self.name = name就等价于self.name = '吴枫'，以此类推。（self.name中的name可以换成其他名称，只是我们习惯上这么写）
如此一来，类的其他方法就能通过self.属性名的形式调用传入的数据了。（还记得self是实例的替身吧）
我猜你可能会有这样的疑惑：不用初始化方法不是也能实现吗？写多个方法不是更麻烦吗？
确实可以，比如上述的代码，我们也可以这么写：
class Chinese:
def born(self, name, birthplace):
print(name + '出生在' + birthplace)
def live(self, name, region):
print(name + '居住在' + region)
person = Chinese()
person.born('吴枫','广东')
person.live('吴枫','深圳')
虽然代码量并没有减少，但我们可以看到使用初始化方法，至少我们不必重复传参，传入的数据还可以被多次调用，比如这里的'吴枫'。
class Chinese:
def __init__(self, name, birth, region):
self.name = name # self.name = '吴枫'
self.birth = birth # self.birth = '广东'
self.region = region # self.region = '深圳'
def born(self):
print(self.name + '出生在' + self.birth)
def live(self):
print(self.name + '居住在' + self.region)
person = Chinese('吴枫','广东','深圳') # 传入初始化方法的参数
person.born()
person.live()
随着我们想实现的功能愈发复杂，我们会在类内部编写很多的方法，如果我们需要传入的数据能在类中长久保存并能被随时调用，初始化方法就是一个不错的解决方案。
等你自己开始用类来写代码时，就会发现初始化方法又实在又好用。所以只要用到了类，一般都少不了它。
说了这么多，我们来做个小练习吧。请你在下列代码的基础上补充一个初始化方法（其余部分不变），要求最后的打印结果是:你在哪里出生？我出生在广东。
看下参考代码，多看多写，慢慢熟悉。
class Chinese:
# 初始化方法的创建，init两边双下划线。
def __init__(self, hometown):
self.hometown = hometown
print('你在哪里出生？')
def born(self):
print('我生在%s。' % self.hometown)
wufeng = Chinese('广东') # 传给参数hometown
wufeng.born()
再次恭喜～你已经掌握了创建类的两个特殊点。至此，你已经将课堂的主要知识都收入囊中了。
学到这，可能你会觉得类看起来平平无奇，这主要是老师为了让你能快速掌握相关概念和语法，课堂上的案例都很简单，而类一般是用在较复杂的项目里。
所以课堂的最后一部分，我会具体阐述类与实例在实际编程中的应用，也对一开始提出的问题：什么是面向对象编程做一个具体的阐释。
4. 面向对象编程
与面向对象编程相对应的是面向过程编程，这是这关以前的关卡里我们所采用的编程思维。
面向过程编程：首先分析出解决问题所需要的步骤（即“第一步做什么，第二步做什么，第三步做什么”），然后用函数实现各个步骤，再依次调用。
比如我们之前所完成的项目二：（扫一眼代码即可）
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类，在类中定义好属性和方法，再创建一个实例。
代码就是这样的，大致感受一下即可：
import math
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()
可以发现，在此例中，用类编写一个直观的好处就是参数的传递会比普通函数要省事很多，也不必考虑全局变量和局部变量，因为类中的方法可以直接调用属性。
可想而知，当项目难度越大，需要的参数越多，用类编写在程序的可拓展性、可读性、维护成本都会更胜一筹。
这就是面向对象编程：以对象为中心，将计算机程序看作一组对象的集合。对比图如下：
总结一下：和之前说过的函数类似，面向对象编程实际上也是一种对代码的封装。只不过，类能封装更多的东西，既能包含操作数据的方法，又能包含数据本身。所以，代码的可复用性也更高。
而且，对于需要长期更新的代码而言，面向对象编程写成的代码结构会更清晰。所以，代码的可读性、可拓展性和可维护性这几个方面都会优于面向过程编程。
还有一点不得不提的是：面向对象编程，将代码具体的数据和处理方法都封装在类中，让我们不用完全了解过程也可以调用类中的各种方法。
这个优势让我们可以在 Python 中轻松地调用各种标准库、第三方库和自定义模块（可以简单理解成别人写好的类），这是Python 之所以这么强大和热门的主要原因之一。
这也是为什么我在开头说“面向对象编程，会为你打开一个新的世界”。将他人封装好的代码为自己所用，效率和能做的事情自然是天壤之别。
不过万丈高楼平地起，这些我们以后能够做到的事，都是建立在今天的基础学习和练习之上。
5. 习题练习
5.1 习题一
1.练习介绍
通过今天的作业，学会在某个实例方法中调用其他方法。
2.练习要求：
在课堂上，我们看过Chinese类有这样两个代码案例：
一个会打印某个人现在的居住地，一个会打印出生地。
下面，我们会通过课堂中的一个小知识一次性“说完”这两个信息。
3.知识复习
先通过代码复习一下在课堂中的这个小知识：在实例方法里调用其他方法。
class Chinese:
def greeting(self):
print('很高兴遇见你')
def say(self):
# 在say()方法中调用greeting()方法
self.greeting()
print('我来自中国')
person = Chinese()
# 创建实例person
person.say()
# 调用say()方法
4.代码实操：一次性说完
现在，请你趁热打铁，在右侧的代码中新建一个方法，在这个方法中调用实例方法born和live。
class Chinese:
def __init__(self,hometown,region):
self.hometown = hometown
self.region = region
print('程序持续更新中……')
def born(self):
print('我生在%s。'%(self.hometown))
def live(self):
print('我在%s。'%(self.region))
# 新建方法，调用上面的两个方法（注：方法名可自定义）。
def citys(self):
self.born()
self.live()
wufeng = Chinese('广东', '深圳')
wufeng.citys()
# 调用方法后，程序运行方法中的代码（即依次调用方法`born`和`live`）。
5.2 习题二
1.练习介绍
我们会通过今天的作业，再次运用在课堂上学过的关于类的基础知识。
2.练习要求：
请用今天学到的知识创建一个机器人，让其具备以下功能：
一是会让你给ta 起名，也会问你的名字，然后跟你打招呼（如“你好，吴枫。我是瓦力。遇见你，真好。”）；
二是会让你说一个愿望，然后帮你重复三次（因为 ta 觉得重要）。
3.先打招呼
要让机器人跟我们打招呼，至少要告诉 ta 两个信息：一是 ta 的名字，二是你的称呼。
请你根据课堂所学（初始化方法即可）及之前已经掌握的知识，让 ta 先和你打个招呼。
class Robot:
def __init__(self):
# 因为要输入两个信息，所以，下面需要用到两个 input
self.name = input('我现在刚诞生，还没有名字，帮我起一个吧。')
self.master = input('对了，我要怎么称呼你呢？')
print('你好%s，我叫%s。很开心，遇见你~'%(self.master,self.name))
robot1 = Robot() # 每个实例创建时，初始化方法就会运行。
4.再来复述
假设你说了一个愿望：学会 Python 基础！
那么，机器人就会复述如下：
**（你的称呼）的愿望是：
学会 Python 基础！
学会 Python 基础！
学会 Python 基础！
这个功能可以用一个实例方法来实现，可命名为“say_wish”。
# 请将你在上一步写好的代码复制黏贴，在其基础上加实例方法。
class Robot:
def __init__(self):
self.name = input('我现在刚诞生，还没有名字，帮我起一个吧。')
self.master = input('对了，我要怎么称呼你呢？')
print('你好%s，我叫%s。很开心，遇见你~'%(self.master,self.name))
def say_wish(self):
wish = input('告诉一个你的愿望吧：')
print(self.master+'的愿望是：')
for i in range(3):
print(wish)
robot1 = Robot()
robot1.say_wish()
