2. 类
描述鸟类
class Brid(object):
feather = True
reproduction = "egg"
关键字class来定义一个类。类的名字就是鸟(Brid)。括号里有一个关键词object,也就是“东西“的意思,即某一个个体。我们把个体称为对象。一个类别下,可以有多个个体。
冒号和缩进说明了属于这个类的代码。在隶属于这个类别的程序块中,我们定义了两个量,一个用于说明鸟类有羽毛(feather),一个用于说明鸟类的繁殖方式(reproduction),这两个量称为类的属性(attribute)。
我们除了用数据性的属性来分辨类别外,有时也会根据这类东西能做什么事情来区分。比如,鸟会移动。这样,鸟和房屋的类别就区分开了。这些动作会带来一定的结果,比如移动导致位置的变化。这样的一些“行为”属性称为方法(method)。Python中,一般是通过在类的内部定义函数来说明方法。
class Bird(object):
feather = True
reproduction = "egg"
def chirp(self, sound):
print(sound)
我们给鸟类新增一个方法属性,就是表示鸟叫的方法chirp()。方法chirp看起来很像一个函数。它的第一个参数是self,是为了在方法内部引用对象自身。需要强调的是,无论该参数是否用到,方法的第一个参数必须是用于指代对象自身的self。
3. 对象
**通过调用类,我们可以创造出这个类下面的一个对象。**比如,我养了一只小鸡,叫summer。它是个对象,且属于鸟类。我们使用前面已经定义好的鸟类,产生这个对象:
summer = Bird()
通过这一句创建对象,并说明summer是属于鸟类的一个对象。现在,我们就可以使用鸟类中已经写好的代码了。作为对象的summer将拥有鸟类的属性和方法。对属性的引用是通过对象.属性(object.attribute)的形式实现的。比如说:
print(summer.reproduction) # 打印'egg'
用上面的方式,我们得到summer所属类的繁殖方式。
此外,我们还可以调用方法,让summer执行鸟类允许的动作。比如:
summer.chirp("jijiji") # 打印jijiji
在调用方法时,我们只传递了一个参数,也就是字符串"jijiji"。这正是方法与函数有所区别的地方。**尽管在定义类的方法时,我们必须加上self参数,但self只能在类定义的内部,所以在调用方法时不需要对self传入数据。**通过调用chirp()方法,我的summer就可以叫了。
对于一个类下的全部个体来说,某些属性可能存在个体差异。
因此,为了完整描述个体,除了共性的类属性外,我们还需要用于说明个性的对象属性。在类中,我们可以通过self来操作对象的属性。现在,我们拓展Bird类:
class Bird(object):
def chirp(self, sound):
print(sound)
def set_color(self, color):
self.color = color
summer = Bird()
summer.set_color("yellow")
print(summer.color) # 打印yellow
在方法set_color()中,我们通过self参数设定了对象的属性color。和类属性一样,我们能通过对象.属性的方式来操作对象属性。由于对象属性依赖于self,所以我们必须在某个方法内部才能操作对象属性。因此,对象属性没办法像类属性一样,在类下方直接赋初值。
但Python还是提供了初始化对象属性的方法。Python定义了一系列特殊方法。特殊方法又被称为魔法方法(Magic Method)。特殊方法的方法名很特别,前后有两个下划线,比如__init__()
、__add__()
、__dict__()
等。程序员可以在类定义中设定特殊方法。Python会以特定的方式来处理各个特殊方法。对于类的__init__()
方法,Python会在每次创建对象时自动调用。因此,我们可以在__init__()
方法内部来初始化对象属性:
class Bird(object):
def __init__(self, sound):
self.sound = sound
print("my sound is: ", sound)
def chirp(self):
print(self.sound)
summer = Bird("ji")
summer.chirp()
在上面的类定义中,我们通过__init__()
方法说明了这个类的初始化方式。每当对象建立时,比如创建summer对象时,__init__()
方法就会被调用。它会设定sound这个对象属性。在后面的chirp()方法中,就可以通过self调用这一对象属性。除了设定对象属性外,我们还可以在__init__()
中加入其它指令。这些指令会在创建对象时执行。在调用类时,类的后面可以跟一个参数列表。这里放入的数据将传给__init__()
的参数。通过__init__()
方法,我们可以在创建对象时就初始化对象属性。
除了操作对象属性外,self参数还有另外一个功能,就是能让我们在一个方法内部调用同一类的其他方法,比如:
class Bird(object):
def chirp(self, sound):
print(sound)
def chirp_repeat(self, sound, n):
for i in range(n):
self.chirp(sound)
summer = Bird()
summer.chirp_repeat("ji", 10) # 重复打印'ji'十次
在方法chirp_repeat()中,我们通过self调用了类中的另一个方法chirp。
4.2 继承者们
1. 子类
类别本身还可以进一步细分成子类。在面向对象编程中,我们通过继承(Inheritance)来表达上述概念。
class Bird(object):
feather = True
reproduction = "egg"
def chirp(self, sound):
print(sound)
class Chicken(Bird):
how_to_move = "walk"
edible = True
class Swan(Bird):
how_to_move = "swim"
edible = False
summer = Chicken()
print(summer.feather) # 打印True
summer.chirp("ji") # 打印"ji"
新定义的鸡(Chicken)类,增加了两个属性:移动方式(how_to_move)和可以食用(edible)。
在类定义时,括号里面为Bird。这说明,鸡类是属于鸟类的一个子类,即Chicken继承自Bird。自然而然,鸟类就是鸡类的父类。Chicken将享有Bird的所有属性。尽管我们只声明了summer是鸡类,但它通过继承享有了父类的属性,比如数据性的属性feather,还有方法性的属性chirp()。新定义的天鹅(Swan)类,同样继承自鸟类。在创建一个天鹅对象时,该对象就自动拥有鸟类的属性。
继承提高了程序的可重复使用性。最基础的情况,是类定义括号中是object。类object其实是Python中的一个内置类,它充当了所有类的祖先。
2. 属性覆盖
如上所述,在继承的过程中,我们可以在子类中增加父类不存在的属性,从而增强子类的功能。此外,我们还可以在子类中替换父类已经存在了的属性,比如:
class Bird(object):
def chirp(self):
print("make sound")
class Chicken(Bird):
def chirp(self):
print("ji")
bird = Bird()
bird.chirp()
summer = Chicken()
summer.chirp() # 打印'make sound'和'ji'
鸡类(Chicken)是鸟类(Bird)的子类。在鸡类(Chicken)中,我们定义了方法chirp()。这个方法在鸟类中也有定义。通过调用可以看出,鸡类会调用自身定义的chirp()方法,而不是父类中的chirp()方法。从效果上看,这就好像是父类中的方法chirp()被子类中的同名属性覆盖(override)了一样。
通过对方法的覆盖,我们可以彻底地改变子类的行为。但有的时候,子类的行为是父类行为的拓展。这时,我们可以通过super关键字在子类中调用父类中被覆盖的方法,比如:
class Bird(object):
def chirp(self):
print("make sound")
class Chicken(Bird):
def chirp(self):
super().chirp()
print("ji")
bird = Bird()
bird.chirp() # 打印"make sound"
summer = Chicken()
summer.chirp() # 打印"make sound"和"ji"
在鸡类的chirp()方法中,我们使用了**super。它是一个内置类,能产生一个指代父类的对象。通过super,我们在子类的同名方法中调用了父类的方法。**这样,子类的方法技能执行父类中的相关操作,又能定义属于自己的额外操作。
调用super的语句可以出现在子类方法的第一句,也可以出现在子类方法的任意其它位置。
4.3 那些年,错过的对象
1. 列表对象
数据容器中的列表。它是一个类,用内置函数可以找到类的名字:
a = [1, 2, 5, 3, 5]
type(a)
根据返回的结果,我们知道a属于list类型,也就是列表类型。其实,所谓的类型就是对象所属类的名字。每个列表都属于list类。这个类时Python自带的,已经提前定义好的,所以称为内置类。当我们新建一个表时,实际上是在创建list类的一个对象。我们还可以用其他两个内置函数来进一步调查类的信息:dir()和help()。函数dir()用来查询一个类或者对象的所有属性。你可以尝试一下:
dir(list)
我们已经用help()函数查询了函数的说明文档。它还可以用于显示类的说明文档。你可以尝试一下:
help(list)
返回的不但有关于list类的描述,还简略的说明了它的各个属性。顺便提一下,制作类的说明文档的方式,与制作函数说明文档的方式类似,我们只需在类定义下用多行字符串加入自己想要的说明就可以了:
class HelpDemo(object):
"""
This is a demo for using help() on a class
"""
pass
print(help(HelpDemo))
程序中的pass是Python的一个特殊关键字,用于说明在该语法结构中“什么都不做”。这个关键字保留了程序结构的完整性。
通过上面的查询,我们看到类还有许多“隐藏技能”。比如下面一些list的方法,可以返回列表信息。
a = [1, 2, 3, 5, 9.0, "Good", -1, True, False, "Bye"]
a.count(5) # 计数,看总共有多少个元素5
a.index(3) # 查询元素3第一次出现时的下标
有些方法还允许我们对列表进行修改操作:
a.append(6) # 在列表的最后添加一个新元素6
a.sort() # 排序
a.reverse() # 颠倒次序
a.pop() # 去除最后一个元素,并将该元素返回
a.remove(2) # 去除第一次出现的元素2
a.insert(0, 9) # 在下标为0的位置插入9
a.clear() # 清空列表
通过对方法的调用,列表的功能大为增加。
2. 元组与字符串对象
元组与列表一样,都是序列。但元组不能变更内容。因此,元组只能进行查询操作,不能进行修改操作:
a = (1, 3, 5)
a.count(5) # 计数,看总共有多少个元素5
a.index(3) # 查询元素3第一次出现的下标
字符串是特殊的元组,因此可以执行元组的方法:
a = "abc"
a.index('c')
尽管字符串是元组的一种,但字符串(string)有一些方法能改变字符串。这听起来似乎违背了元组的不可变性。其实,这些方法并不是修改字符串对象,而是删除原有字符串,在建立一个新的字符串。所以并没有违背元组的不可变性。
下面总结了字符串对象的方法。str为一个字符串,sub为str的一个子字符串。s为一个序列,它的元素都是字符串。width为一个整数,用于说明新生成字符串的宽度。这些方法常用于字符串的处理。
str = "Hello World!"
sub = "World"
str.count(sub) # 返回:sub在str中出现的次数
str.find(sub) # 返回: 从左开始,查找sub在str中第一次出现的位置。如果str中不包含sub,返回-1
str.index(sub) # 返回,从左开始,查找sub在str中第一次出现的位置。如果str不包含sub,举出错误。
str.rfind(sub) # 返回:从右开始,查找sub在str中第一次出现的位置。如果str中不包含sub,返回-1
str.rindex(sub) # 返回,从右开始,查找sub在str中第一次出现的位置。如果str中不包含sub,举出错误
str.isalnum() # 返回:True,如果所有字符串都是字母或数字
str.isalpha() # 返回:True,如果所有的字符都是字母
str.isdigit() # 返回:True,如果所有的字符都是数字
str.istitle() # 返回:True,如果所有的词的首字母都是大小
str.isspace() # 返回:True,如果所有的字符都是空格
str.islower() # 返回:True,如果所有的字符都是小写字母
str.isupper() # 返回:True,如果所有的字符都是大写字母
str.split([sep, [max]]) # 返回:从左开始,以空格我分隔符(separator),将str分割为多个子字符串,总共分割max次。将所得的子字符串放在一个表中返回。可以以str.split(",")的方式使用其他分隔符
str.rsplit([sep, [max]]) # 返回:从右开始,以空格为分隔符(separator),将str分割为多个子字符串,总共分割max次。将所得的子字符串放在一个表中返回。可以以str.rsplit(",")的方式使用其他分隔符。
str.join(s) # 返回:将s中的元素,以str为分隔符,合并成一个字符串
str.strip([sub]) # 返回:去掉字符串开头和结尾的空格。
# 也可以提供参数sub,去掉位于字符串开头和结尾的sub
str.replace(sub, new_sub) # 返回:用一个新的字符串new_sub替换str中的sub
str.capitalize() # 返回:将str的第一个字母大写
str.lower() # 返回:将str全部字母改为小写
str.upper() # 返回:将str的全部字母改为大写
str.swapcase() # 返回:将str大写字母改为小写,小写字母改为大写
str.title() # 返回:将str的每个词(以空格分隔)的首字母大写
str.center(width) # 返回:长度为width的字符串,将原字符串放入该字符串的中心,其他空余位置为空格。
str.ljust(width) # 返回:长度我width的字符串,将原字符串左对齐放入该字符串,其他位置为空格。
str.rjust(width) # 返回:长度为width的字符串,将原字符串右对齐放入该字符串,其他空余位置为空格。
3. 词典对象
词典同样是一个类:
example_dict = {"a":1, "b":2}
type(example_dict)
我们可以通过词典的keys()方法,来循环遍历每个元素的键:
for k in example_dict.keys:
print(k)
for k in example_dict.keys():
print(example_dict[k])
通过values()方法,可以遍历每个元素的值。或者用items方法,直接遍历每个元素(items()方法得到的是一个元组,这里有两个变量参与循环,实际上相当于解打包元组了):
for v in example_dict.values():
print(v)
for k,v in example_dict.items():
print(k, v)
我们可以用clear()方法,清空整个词典:
example_dict.clear()
# 清空exampe_dict,example_dict变为{ }
4.4 意想不到的对象
1. 循环对象
Python中许多语法结构都是由对象实现的,循环就可以通过对象实现。在Python3时代,循环对象正在成为循环的标准形式。
那么,什么是循环对象呢?所谓的循环对象包含有一个__next__()
方法。这个方法的目的是生成循环的下一个结果。在生成循环的所有结果之后,该方法将抛出StopIteration异常。
当一个像for这样的循环语法调用循环对象时,它会在每次循环的时候调用__next__()
方法。我们多次调用__next__()
方法,将不断返回列表的值,直到出现异常:
example_iter = iter([1, 2])
example_iter.__next__() # 显示1
example_iter.__next__() # 显示2
example_iter.__next__() # 出现StopIteration异常。
我们上面重复调用__next__()
的过程,就相当于手动进行了循环。我们可以把循环对象包裹在for中自动进行循环:
for item in iter([1, 2]):
print(item)
在这里,for结构自动调用__next__()
方法,将该方法的返回值赋予给item。循环知道出现StopIteration的时候结束。当然,我们可以省去内置函数iter的转换。这是因为,for结构会自动执行这一转换。
相对于序列,循环对象的好处在于:不用在循环还没开始的时候,就生成要使用的元素。所有要使用的元素可以在循环过程中逐渐生成。这样,不仅节省了空间,提高了效率,还会使编程更加灵活。
我们可以借助生成器(generator)来自定义循环对象。生成器的编写方法和函数定义类似,只是在return的地方改为yield。生成器中可以有多个yield。当生成器遇到一个yied时,会暂停运行生成器,返回yield后面的值。当再次调用生成器的时候,会从刚才暂停的地方继续运行,直到下一个yield。生成器自身又构成一个循环对象,每次循环使用一个yield返回的值。
下面是一个生成器:
def gen():
a = 100
yield a
a = a*8
yield a
yield 1000
该生成器共有三个yield,如果用作循环对象时,会进行三次循环。
for i in gen():
print(i)
再考虑下面一个生成器:
def gen():
i = 0
while i < 10000000:
i = i + 1
yield i
这个生成器能产生10000000个元素。如果先创建序列保存这10000000个元素,再遍历循环,那么这个序列将占用大量的空间。出于同样的原因,Python中的内置函数range()返回的是一个循环对象,而不是一个序列。
2. 函数对象
在Python中,函数也是一种对象。实际上,任何一个有__call__()
特殊方法的对象都被当做是函数。比如下面的例子:
class SampleMore(object):
def __call__(self, a):
return a + 5
add_five = SampleMore() # 生成函数对象
print(add_five(2)) # 像一个函数一样调用函数对象,结果为7。
add_five为SampleMore类的一个对象,当被调用时,add_five执行加5操作。
3. 模块对象
Python中的模块对应一个.py文件。模块也是对象。比如:我们直接引入标准库中的模块time:
import time
print(dir(time))
可以看到,time有很多属性可以调用,例如sleep()方法。我们之前用import语句引入其他文件中定义的函数,实际上是引入模块对象的属性,比如:
from time import sleep
sleep(10)
print("wake up")
模块time的sleep()会中止程序。调用时的参数说明给了中止的时间。
一次性引入模块的所有属性:
from time import *
sleep(10)
既然知道了sleep()是time的一个方法,那么我们当然可以利用对象.属性的方式来调用它。
import time
time.sleep(10)
我们在调用方法时附带上了对象名。这样做的好处是可以拓展程序的命名空间,避免同名冲突。例如,如果两个模块中都有sleep()方法,那么我们可以通过不一样的模块名开区分开来。在my_time.py中写入函数:
def sleep(self):
print("I am sleeping.")
在main.py中引入内置模块time和自定义模块my_time:
import time
import my_time
time.sleep()
my_time.sleep()
上面的两次对sleep()方法的调用中,我们通过对象名区分出了不同的sleep()。
在引入模块时,我们还可以给模块换个名字:
import time as t
t.sleep(10)
在引入名字较长的模块时,这个换名字的办法能有效地挽救程序员的手指。
可以将功能相似的模块放在同一个文件夹中,构成一个模块包。比如放在this_dir中:
import this_dir.module
引入this_dir文件夹中的module模块。
该文件夹中必须包含一个__init__.py
的文件,提醒Python,该文件夹为一个模块包。__init__.py
可以是一个空文件。
每个模块对象都有一个__name__
属性,用来记录模块的名字,例如:
import time
print(time.__name__)
当一个.py文件作为主程序运行时,比如python foo.py,这个文件也会有一个对应的模块对象。但这个模块对象的__name__
属性会是__main__
。因此,我们在很多.py文件中可以看到下面的语句:
if __name__ == "__main__":
它的意思是说,如果这个文件作为一个主程序运行,那么将执行下面的操作。有的时候,一个.py文件中同时有类和对象的定义,以及对它们的调用。当这些.py文件作为库引入时,我们可能并不希望执行这些调用。通过吧调用语句放到上面的if中,就可以在调用时不执行这些调用语句了。
4. 异常对象
前面我们提到过,可以在程序中加入异常处理的try结构,捕捉程序中出现的异常。实际上,我们捕捉到的也是一个对象,比如:
try:
m = 1/0
except ZeroDivisionError as e:
print("Catch NameError in the sub-function")
print(type(e)) # 类型为“exceptions.ZeroDivisionError”
print(dir(e)) # 异常对象的属性
print(e.message) # 异常信息integer division or modulo by zero
利用except…as…的语法,我们在except结果中用e代表捕获到的类型对象。关键字except直接跟随的ZeroDivisionError实际上是异常对象的类。正因为如此,我们在举出异常时会创建一个异常对象:
raise ZeroDivisionError()
在Python中,循环、函数、模块、异常都是某种对象。
附录A 代码规范
类的命名采用首字母大写的英文单词。如果由多个单词连接而成,则每个单词的首字母都大写。单词之间不出现下划线。
对象名、属性名和方法名,全部用小写字母。单词之间用下划线连接。