文章目录
转载于http://c.biancheng.net/python/
Python 语言在设计之初,就定位为一门面向对象的编程语言,“Python 中一切皆对象”就是对 Python 这门编程语言的完美诠释。
类和对象是 Python 的重要特征,相比其它面向对象语言,Python 很容易就可以创建出一个类和对象。同时,Python 也支持面向对象的三大特征:封装、继承和多态。
本章不仅会教你掌握 Python 类和对象的基本语法,还可以带你深入底层,了解 Python 面向对象的实现原理。
什么是面向对象,Python面向对象(一切皆对象)
读者肯定听过 Python 中“一切皆对象”的说法,但可能并不了解它的具体含义,只是在学习的时候听说 Python 是面向对象的编程语言,本节将向大家详细介绍 Python 面向对象的含义。
面向对象编程是在面向过程编程的基础上发展来的,它比面向过程编程具有更强的灵活性和扩展性。面向对象编程是程序员发展的分水岭,很多初学者会因无法理解面向对象而放弃学习编程。
面向对象编程(Object-oriented Programming,简称 OOP),是一种封装代码的方法。其实,在前面章节的学习中,我们已经接触了封装,比如说,将乱七八糟的数据扔进列表中,这就是一种简单的封装,是数据层面的封装;把常用的代码块打包成一个函数,这也是一种封装,是语句层面的封装。
代码封装,其实就是隐藏实现功能的具体代码,仅留给用户使用的接口,就好像使用计算机,用户只需要使用键盘、鼠标就可以实现一些功能,而根本不需要知道其内部是如何工作的。
本节所讲的面向对象编程,也是一种封装的思想,不过显然比以上两种封装更先进,它可以更好地模拟真实世界里的事物(将其视为对象),并把描述特征的数据和代码块(函数)封装到一起。
打个比方,若在某游戏中设计一个乌龟的角色,应该如何来实现呢?使用面向对象的思想会更简单,可以分为如下两个方面进行描述:
- 从表面特征来描述,例如,绿色的、有 4 条腿、重 10 kg、有外壳等等。
- 从所具有的的行为来描述,例如,它会爬、会吃东西、会睡觉、会将头和四肢缩到壳里,等等。
如果将乌龟用代码来表示,则其表面特征可以用变量来表示,其行为特征可以通过建立各种函数来表示。参考代码如下所示:
class tortoise:
bodyColor = "绿色"
footNum = 4
weight = 10
hasShell = True
#会爬
def crawl(self):
print("乌龟会爬")
#会吃东西
def eat(self):
print("乌龟吃东西")
#会睡觉
def sleep(self):
print("乌龟在睡觉")
#会缩到壳里
def protect(self):
print("乌龟缩进了壳里")
注意,以上代码仅是为了演示面向对象的编程思想,具体细节后续会做详细介绍。
因此,从某种程序上,相比较只用变量或只用函数,使用面向对象的思想可以更好地模拟现实生活中的事物。
不仅如此,在 Python 中,所有的变量其实也都是对象,包括整形(int)、浮点型(float)、字符串(str)、列表(list)、元组(tuple)、字典(dict)和集合(set)。以字典(dict)为例,它包含多个函数供我们使用,例如使用 keys() 获取字典中所有的键,使用 values() 获取字典中所有的值,使用 item() 获取字典中所有的键值对,等等。
面向对象相关术语
在系统学习面向对象编程之前,初学者要了解有关面向对象的一些术语。当和其他人讨论代码的时候,或者尝试查找我们遇到的问题的解决方案时,知道正确的术语会很有帮助。
面向对象中,常用术语包括:
- 类:可以理解是一个模板,通过它可以创建出无数个具体实例。比如,前面编写的 tortoise 表示的只是乌龟这个物种,通过它可以创建出无数个实例来代表各种不同特征的乌龟(这一过程又称为类的实例化)。
- 对象:类并不能直接使用,通过类创建出的实例(又称对象)才能使用。这有点像汽车图纸和汽车的关系,图纸本身(类)并不能为人们使用,通过图纸创建出的一辆辆车(对象)才能使用。
- 属性:类中的所有变量称为属性。例如,tortoise 这个类中,bodyColor、footNum、weight、hasShell 都是这个类拥有的属性。
- 方法:类中的所有函数通常称为方法。不过,和函数所有不同的是,类方法至少要包含一个 self 参数(后续会做详细介绍)。例如,tortoise 类中,crawl()、eat()、sleep()、protect() 都是这个类所拥有的方法,类方法无法单独使用,只能和类的对象一起使用。
Python class:定义类(入门必读)
前面章节中已经提到,类仅仅充当图纸的作用,本身并不能直接拿来用,而只有根据图纸造出的实际物品(对象)才能直接使用。因此,Python 程序中类的使用顺序是这样的:
- 创建(定义)类,也就是制作图纸的过程;
- 创建类的实例对象(根据图纸造出实际的物品),通过实例对象实现特定的功能。
本节先教大家如何创建(定义)一个类,如何使用定义好的类将放到后续章节进行讲解。
Python类的定义
Python 中定义一个类使用 class 关键字实现,其基本语法格式如下:
class 类名:
多个(≥0)类属性…
多个(≥0)类方法…
注意,无论是类属性还是类方法,对于类来说,它们都不是必需的,可以有也可以没有。另外,Python 类中属性和方法所在的位置是任意的,即它们之间并没有固定的前后次序。
和变量名一样,类名本质上就是一个标识符,因此我们在给类起名字时,必须让其符合 Python 的语法。有读者可能会问,用 a、b、c 作为类的类名可以吗?从 Python 语法上讲,是完全没有问题的,但作为一名合格的程序员,我们必须还要考虑程序的可读性。
因此,在给类起名字时,最好使用能代表该类功能的单词,例如用“Student”作为学生类的类名;甚至如果必要,可以使用多个单词组合而成,例如初学者定义的第一个类的类名可以是“TheFirstDemo”。
注意,如果由单词构成类名,建议每个单词的首字母大写,其它字母小写。
给类起好名字之后,其后要跟有冒号(:),表示告诉 Python 解释器,下面要开始设计类的内部功能了,也就是编写类属性和类方法。
其实,类属性指的就是包含在类中的变量;而类方法指的是包含类中的函数。换句话说,类属性和类方法其实分别是包含类中的变量和函数的别称。需要注意的一点是,同属一个类的所有类属性和类方法,要保持统一的缩进格式,通常统一缩进 4 个空格。
Python 变量和函数的使用,前面章节中已经做了详细的介绍,这里不再重复赘述。
通过上面的分析,可以得出这样一个结论,即 Python 类是由类头(class 类名)和类体(统一缩进的变量和函数)构成。例如,下面程序定义一个 TheFirstDemo 类:
class TheFirstDemo:
'''这是一个学习Python定义的第一个类'''
# 下面定义了一个类属性
add = 'http://c.biancheng.net'
# 下面定义了一个say方法
def say(self, content):
print(content)
和函数一样,我们也可以为类定义说明文档,其要放到类头之后,类体之前的位置,如上面程序中第二行的字符串,就是 TheFirstDemo 这个类的说明文档。
另外分析上面的代码可以看到,我们创建了一个名为 TheFirstDemo 的类,其包含了一个名为 add 的类属性。注意,根据定义属性位置的不同,在各个类方法之外定义的变量称为类属性或类变量(如 add 属性),而在类方法中定义的属性称为实例属性(或实例变量),它们的区别和用法可阅读《Python类变量和实例变量》一节。
同时,TheFirstDemo 类中还包含一个 say() 类方法,细心的读者可能已经看到,该方法包含两个参数,分别是 self 和 content。可以肯定的是,content 参数就只是一个普通参数,没有特殊含义,但 self 比较特殊,并不是普通的参数,它的作用会在后续章节中详细介绍。
更确切地说,say() 是一个实例方法,除此之外,Python 类中还可以定义类方法和静态方法,这 3 种类方法的区别和具体用法,可阅读《Python实例方法、静态方法和类方法》。
事实上,我们完全可以创建一个没有任何类属性和类方法的类,换句话说,Python 允许创建空类,例如:
class Empty:
pass
可以看到,如果一个类没有任何类属性和类方法,那么可以直接用 pass 关键字作为类体即可。但在实际应用中,很少会创建空类,因为空类没有任何实际意义。
Python init()类构造方法
在创建类时,我们可以手动添加一个 init() 方法,该方法是一个特殊的类实例方法,称为构造方法(或构造函数)。
构造方法用于创建对象时使用,每当创建一个类的实例对象时,Python 解释器都会自动调用它。Python 类中,手动添加构造方法的语法格式如下:
def init(self,…):
代码块
注意,此方法的方法名中,开头和结尾各有 2 个下划线,且中间不能有空格。Python 中很多这种以双下划线开头、双下划线结尾的方法,都具有特殊的意义,后续会一一为大家讲解。
另外,init() 方法可以包含多个参数,但必须包含一个名为 self 的参数,且必须作为第一个参数。也就是说,类的构造方法最少也要有一个 self 参数。例如,仍以 TheFirstDemo 类为例,添加构造方法的代码如下所示:
class TheFirstDemo:
'''这是一个学习Python定义的第一个类'''
#构造方法
def __init__(self):
print("调用构造方法")
# 下面定义了一个类属性
add = 'http://c.biancheng.net'
# 下面定义了一个say方法
def say(self, content):
print(content)
注意,即便不手动为类添加任何构造方法,Python 也会自动为类添加一个仅包含 self 参数的构造方法。
仅包含 self 参数的 init() 构造方法,又称为类的默认构造方法。
在上面代码的后面,顶头(不缩进)直接添加如下代码:
zhangsan = TheFirstDemo()
这行代码的含义是创建一个名为 zhangsan 的 TheFirstDemo 类对象。运行代码可看到如下结果:
调用构造方法
显然,在创建 zhangsan 这个对象时,隐式调用了我们手动创建的 init() 构造方法。
不仅如此,在 init() 构造方法中,除了 self 参数外,还可以自定义一些参数,参数之间使用逗号“,”进行分割。例如,下面的代码在创建 init() 方法时,额外指定了 2 个参数:
class CLanguage:
'''这是一个学习Python定义的一个类'''
def __init__(self,name,add):
print(name,"的网址为:",add)
#创建 add 对象,并传递参数给构造函数
add = CLanguage("C语言中文网","http://c.biancheng.net")
注意,由于创建对象时会调用类的构造方法,如果构造函数有多个参数时,需要手动传递参数,传递方式如代码中所示(后续章节会做详细讲解)。
运行以上代码,执行结果为:
C语言中文网 的网址为: http://c.biancheng.net
可以看到,虽然构造方法中有 self、name、add 3 个参数,但实际需要传参的仅有 name 和 add,也就是说,self 不需要手动传递参数。
关于 self 参数,后续章节会做详细介绍,这里只需要知道,在创建类对象时,无需给 self 传参即可。
Python类对象的创建和使用
通过前面章节的学习,我们已经学会如何定义一个类,但要想使用它,必须创建该类的对象。
创建类对象的过程,又称为类的实例化。
Python类的实例化
对已定义好的类进行实例化,其语法格式如下:
类名(参数)
定义类时,如果没有手动添加 init() 构造方法,又或者添加的 init() 中仅有一个 self 参数,则创建类对象时的参数可以省略不写。
例如,如下代码创建了名为 CLanguage 的类,并对其进行了实例化:
class CLanguage : # 下面定义了2个类变量 name = "C语言中文网" add = "http://c.biancheng.net" def __init__(self,name,add): #下面定义 2 个实例变量 self.name = name self.add = add print(name,"网址为:",add) # 下面定义了一个say实例方法 def say(self, content): print(content)# 将该CLanguage对象赋给clanguage变量clanguage = CLanguage("C语言中文网","http://c.biancheng.net")
在上面的程序中,由于构造方法除 self 参数外,还包含 2 个参数,且这 2 个参数没有设置默认参数,因此在实例化类对象时,需要传入相应的 name 值和 add 值(self 参数是特殊参数,不需要手动传值,Python 会自动传给它值)。
类变量和实例变量,简单地理解,定义在各个类方法之外(包含在类中)的变量为类变量(或者类属性),定义在类方法中的变量为实例变量(或者实例属性),二者的具体区别和用法可阅读《Python类变量和实例变量》
Python类对象的使用
定义的类只有进行实例化,也就是使用该类创建对象之后,才能得到利用。总的来说,实例化后的类对象可以执行以下操作:
- 访问或修改类对象具有的实例变量,甚至可以添加新的实例变量或者删除已有的实例变量;
- 调用类对象的方法,包括调用现有的方法,以及给类对象动态添加方法。
类对象访问变量或方法
使用已创建好的类对象访问类中实例变量的语法格式如下:
类对象名.变量名
使用类对象调用类中方法的语法格式如下:
对象名.方法名(参数)
注意,对象名和变量名以及方法名之间用点 “.” 连接。
例如,下面代码演示了如何通过 clanguage 对象调用类中的实例变量和方法:
#输出name和add实例变量的值
print(clanguage.name,clanguage.add)
#修改实例变量的值
clanguage.name="Python教程"
clanguage.add="http://c.biancheng.net/python"
#调用clanguage的say()方法
clanguage.say("人生苦短,我用Python")
#再次输出name和add的值
print(clanguage.name,clanguage.add)
程序运行结果为:
C语言中文网 网址为: http://c.biancheng.net
C语言中文网 http://c.biancheng.net
人生苦短,我用Python
Python教程 http://c.biancheng.net/python
给类对象动态添加/删除变量
Python 支持为已创建好的对象动态增加实例变量,方法也很简单,举个例子:
# 为clanguage对象增加一个money实例变量
clanguage.money= 159.9
print(clanguage.money)
运行结果为:
159.9
可以看到,通过直接增加一个新的实例变量并为其赋值,就成功地为 clanguage 对象添加了 money 变量。
既然能动态添加,那么是否能动态删除呢?答案是肯定的,使用 del 语句即可实现,例如:
#删除新添加的 money 实例变量
del clanguage.money
#再次尝试输出 money,此时会报错
print(clanguage.money)
运行程序会发现,结果显示 AttributeError 错误:
Traceback (most recent call last):
File “C:/Users/mengma/Desktop/1.py”, line 29, in
print(clanguage.money)
AttributeError: ‘CLanguage’ object has no attribute ‘money’
给类对象动态添加方法
注意,初学者在理解下面内容之前,需明白 self 参数的含义和作用,可阅读《Python self用法》详细了解。
Python 也允许为对象动态增加方法。以本节开头的 Clanguage 类为例,由于其内部只包含一个 say() 方法,因此该类实例化出的 clanguage 对象也只包含一个 say() 方法。但其实,我们还可以为 clanguage 对象动态添加其它方法。
需要注意的一点是,为 clanguage 对象动态增加的方法,Python 不会自动将调用者自动绑定到第一个参数(即使将第一个参数命名为 self 也没用)。例如如下代码:
# 先定义一个函数
def info(self):
print("---info函数---", self)
# 使用info对clanguage的foo方法赋值(动态绑定方法)
clanguage.foo = info
# Python不会自动将调用者绑定到第一个参数,
# 因此程序需要手动将调用者绑定为第一个参数
clanguage.foo(clanguage) # ①
# 使用lambda表达式为clanguage对象的bar方法赋值(动态绑定方法)
clanguage.bar = lambda self: print('--lambda表达式--', self)
clanguage.bar(clanguage) # ②
上面的第 5 行和第 11 行代码分别使用函数、lambda 表达式为 clanguage 对象动态增加了方法,但对于动态增加的方法,Python 不会自动将方法调用者绑定到它们的第一个参数,因此程序必须手动为第一个参数传入参数值,如上面程序中 ① 号、② 号代码所示。
有读者可能会问,有没有不用手动给 self 传值的方法呢?通过借助 types 模块下的 MethodType 可以实现,仍以上面的 info() 函数为例:
def info(self,content):
print("C语言中文网地址为:%s" % content)
# 导入MethodType
from types import MethodType
clanguage.info = MethodType(info, clanguage)
# 第一个参数已经绑定了,无需传入
clanguage.info("http://c.biancheng.net")
可以看到,由于使用 MethodType 包装 info() 函数时,已经将该函数的 self 参数绑定为 clanguage,因此后续再使用 info() 函数时,就不用再给 self 参数绑定值了。
Python self用法详解
在定义类的过程中,无论是显式创建类的构造方法,还是向类中添加实例方法,都要求将 self 参数作为方法的第一个参数。例如,定义一个 Person 类:
class Person:
def __init__(self):
print("正在执行构造方法")
# 定义一个study()实例方法
def study(self,name):
print(name,"正在学Python")
那么,self 到底扮演着什么样的角色呢?本节就对 self 参数做详细的介绍。
事实上,Python 只是规定,无论是构造方法还是实例方法,最少要包含一个参数,并没有规定该参数的具体名称。之所以将其命名为 self,只是程序员之间约定俗成的一种习惯,遵守这个约定,可以使我们编写的代码具有更好的可读性(大家一看到 self,就知道它的作用)。
那么,self 参数的具体作用是什么呢?打个比方,如果把类比作造房子的图纸,那么类实例化后的对象是真正可以住的房子。根据一张图纸(类),我们可以设计出成千上万的房子(类对象),每个房子长相都是类似的(都有相同的类变量和类方法),但它们都有各自的主人,那么如何对它们进行区分呢?
当然是通过 self 参数,它就相当于每个房子的门钥匙,可以保证每个房子的主人仅能进入自己的房子(每个类对象只能调用自己的类变量和类方法)。
如果你接触过其他面向对象的编程语言(例如 C++),其实 Python 类方法中的 self 参数就相当于 C++ 中的 this 指针。
也就是说,同一个类可以产生多个对象,当某个对象调用类方法时,该对象会把自身的引用作为第一个参数自动传给该方法,换句话说,Python 会自动绑定类方法的第一个参数指向调用该方法的对象。如此,Python解释器就能知道到底要操作哪个对象的方法了。
因此,程序在调用实例方法和构造方法时,不需要手动为第一个参数传值。例如,更改前面的 Person 类,如下所示:
class Person:
def __init__(self):
print("正在执行构造方法")
# 定义一个study()实例方法
def study(self):
print(self,"正在学Python")
zhangsan = Person()
zhangsan.study()
lisi = Person()
lisi.study()
上面代码中,study() 中的 self 代表该方法的调用者,即谁调用该方法,那么 self 就代表谁。因此,该程序的运行结果为:
正在执行构造方法
<main.Person object at 0x0000021ADD7D21D0> 正在学Python
正在执行构造方法
<main.Person object at 0x0000021ADD7D2E48> 正在学Python
另外,对于构造函数中的 self 参数,其代表的是当前正在初始化的类对象。举个例子:
class Person:
name = "xxx"
def __init__(self,name):
self.name=name
zhangsan = Person("zhangsan")
print(zhangsan.name)
lisi = Person("lisi")
print(lisi.name)
运行结果为:
zhangsan
lisi
可以看到,zhangsan 在进行初始化时,调用的构造函数中 self 代表的是 zhangsan;而 lisi 在进行初始化时,调用的构造函数中 self 代表的是 lisi。
值得一提的是,除了类对象可以直接调用类方法,还有一种函数调用的方式,例如:
class Person:
def who(self):
print(self)
zhangsan = Person()
#第一种方式
zhangsan.who()
#第二种方式
who = zhangsan.who
who()#通过 who 变量调用zhangsan对象中的 who() 方法
运行结果为:
<main.Person object at 0x0000025C26F021D0>
<main.Person object at 0x0000025C26F021D0>
显然,无论采用哪种方法,self 所表示的都是实际调用该方法的对象。
总之,无论是类中的构造函数还是普通的类方法,实际调用它们的谁,则第一个参数 self 就代表谁。
Python类变量和实例变量(类属性和实例属性)
无论是类属性还是类方法,都无法像普通变量或者函数那样,在类的外部直接使用它们。我们可以将类看做一个独立的空间,则类属性其实就是在类体中定义的变量,类方法是在类体中定义的函数。
前面章节提到过,在类体中,根据变量定义的位置不同,以及定义的方式不同,类属性又可细分为以下 3 种类型:
- 类体中、所有函数之外:此范围定义的变量,称为类属性或类变量;
- 类体中,所有函数内部:以“self.变量名”的方式定义的变量,称为实例属性或实例变量;
- 类体中,所有函数内部:以“变量名=变量值”的方式定义的变量,称为局部变量。
不仅如此,类方法也可细分为实例方法、静态方法和类方法,后续章节会做详细介绍。
那么,类变量、实例变量以及局部变量之间有哪些不同呢?接下来就围绕此问题做详细地讲解。
类变量(类属性)
类变量指的是在类中,但在各个类方法外定义的变量。举个例子:
class CLanguage :
# 下面定义了2个类变量
name = "C语言中文网"
add = "http://c.biancheng.net"
# 下面定义了一个say实例方法
def say(self, content):
print(content)
上面程序中,name 和 add 就属于类变量。
类变量的特点是,所有类的实例化对象都同时共享类变量,也就是说,类变量在所有实例化对象中是作为公用资源存在的。类方法的调用方式有 2 种,既可以使用类名直接调用,也可以使用类的实例化对象调用。
比如,在 CLanguage 类的外部,添加如下代码:
#使用类名直接调用
print(CLanguage.name)
print(CLanguage.add)
#修改类变量的值
CLanguage.name = "Python教程"
CLanguage.add = "http://c.biancheng.net/python"
print(CLanguage.name)
print(CLanguage.add)
程序运行结果为:
C语言中文网
http://c.biancheng.net
Python教程
http://c.biancheng.net/python
可以看到,通过类名不仅可以调用类变量,也可以修改它的值。
当然,也可以使用类对象来调用所属类中的类变量(此方式不推荐使用,原因后续会讲)。例如,在 CLanguage 类的外部,添加如下代码:
clang = CLanguage()
print(clang.name)
print(clang.add)
运行程序,结果为:
C语言中文网
http://c.biancheng.net
注意,因为类变量为所有实例化对象共有,通过类名修改类变量的值,会影响所有的实例化对象。例如,在 CLanguage 类体外部,添加如下代码:
print("修改前,各类对象中类变量的值:")
clang1 = CLanguage()
print(clang1.name)
print(clang1.add)
clang2 = CLanguage()
print(clang2.name)
print(clang2.add)
print("修改后,各类对象中类变量的值:")
CLanguage.name = "Python教程"
CLanguage.add = "http://c.biancheng.net/python"
print(clang1.name)
print(clang1.add)
print(clang2.name)
print(clang2.add)
程序运行结果为:
修改前,各类对象中类变量的值:
C语言中文网
http://c.biancheng.net
C语言中文网
http://c.biancheng.net
修改后,各类对象中类变量的值:
Python教程
http://c.biancheng.net/python
Python教程
http://c.biancheng.net/python
显然,通过类名修改类变量,会作用到所有的实例化对象(例如这里的 clang1 和 clang2)。
注意,通过类对象是无法修改类变量的。通过类对象对类变量赋值,其本质将不再是修改类变量的值,而是在给该对象定义新的实例变量(在讲实例变量时会进行详细介绍)。
值得一提的是,除了可以通过类名访问类变量之外,还可以动态地为类和对象添加类变量。例如,在 CLanguage 类的基础上,添加以下代码:
clang = CLanguage()
CLanguage.catalog = 13
print(clang.catalog)
运行结果为:
13
实例变量(实例属性)
实例变量指的是在任意类方法内部,以“self.变量名”的方式定义的变量,其特点是只作用于调用方法的对象。另外,实例变量只能通过对象名访问,无法通过类名访问。
举个例子:
class CLanguage :
def __init__(self):
self.name = "C语言中文网"
self.add = "http://c.biancheng.net"
# 下面定义了一个say实例方法
def say(self):
self.catalog = 13
此 CLanguage 类中,name、add 以及 catalog 都是实例变量。其中,由于 init() 函数在创建类对象时会自动调用,而 say() 方法需要类对象手动调用。因此,CLanguage 类的类对象都会包含 name 和 add 实例变量,而只有调用了 say() 方法的类对象,才包含 catalog 实例变量。
例如,在上面代码的基础上,添加如下语句:
clang = CLanguage()
print(clang.name)
print(clang.add)
#由于 clang 对象未调用 say() 方法,因此其没有 catalog 变量,下面这行代码会报错
#print(clang.catalog)
clang2 = CLanguage()
print(clang2.name)
print(clang2.add)
#只有调用 say(),才会拥有 catalog 实例变量
clang2.say()
print(clang2.catalog)
运行结果为:
C语言中文网
http://c.biancheng.net
C语言中文网
http://c.biancheng.net
13
前面讲过,通过类对象可以访问类变量,但无法修改类变量的值。这是因为,通过类对象修改类变量的值,不是在给“类变量赋值”,而是定义新的实例变量。例如,在 CLanguage 类体外,添加如下程序:
clang = CLanguage()
#clang访问类变量
print(clang.name)
print(clang.add)
clang.name = "Python教程"
clang.add = "http://c.biancheng.net/python"
#clang实例变量的值
print(clang.name)
print(clang.add)
#类变量的值
print(CLanguage.name)
print(CLanguage.add)
程序运行结果为:
C语言中文网
http://c.biancheng.net
Python教程
http://c.biancheng.net/python
C语言中文网
http://c.biancheng.net
显然,通过类对象是无法修改类变量的值的,本质其实是给 clang 对象新添加 name 和 add 这 2 个实例变量。
类中,实例变量和类变量可以同名,但这种情况下使用类对象将无法调用类变量,它会首选实例变量,这也是不推荐“类变量使用对象名调用”的原因。
另外,和类变量不同,通过某个对象修改实例变量的值,不会影响类的其它实例化对象,更不会影响同名的类变量。例如:
class CLanguage :
name = "xxx" #类变量
add = "http://" #类变量
def __init__(self):
self.name = "C语言中文网" #实例变量
self.add = "http://c.biancheng.net" #实例变量
# 下面定义了一个say实例方法
def say(self):
self.catalog = 13 #实例变量
clang = CLanguage()
#修改 clang 对象的实例变量
clang.name = "python教程"
clang.add = "http://c.biancheng.net/python"
print(clang.name)
print(clang.add)
clang2 = CLanguage()
print(clang2.name)
print(clang2.add)
#输出类变量的值
print(CLanguage.name)
print(CLanguage.add)
程序运行结果为:
python教程
http://c.biancheng.net/python
C语言中文网
http://c.biancheng.net
xxx
http://
不仅如此,Python 只支持为特定的对象添加实例变量。例如,在之前代码的基础上,为 clang 对象添加 money 实例变量,实现代码为:
clang.money = 30
print(clang.money)
局部变量
除了实例变量,类方法中还可以定义局部变量。和前者不同,局部变量直接以“变量名=值”的方式进行定义,例如:
class CLanguage :
# 下面定义了一个say实例方法
def count(self,money):
sale = 0.8*money
print("优惠后的价格为:",sale)
clang = CLanguage()
clang.count(100)
通常情况下,定义局部变量是为了所在类方法功能的实现。需要注意的一点是,局部变量只能用于所在函数中,函数执行完成后,局部变量也会被销毁。
Python实例方法、静态方法和类方法详解(包含区别和用法)
和类属性一样,类方法也可以进行更细致的划分,具体可分为类方法、实例方法和静态方法。
和类属性的分类不同,对于初学者来说,区分这 3 种类方法是非常简单的,即采用 @classmethod 修饰的方法为类方法;采用 @staticmethod 修饰的方法为静态方法;不用任何修改的方法为实例方法。
其中 @classmethod 和 @staticmethod 都是函数装饰器,后续章节会对其做详细介绍。
接下来就给大家详细的介绍这 3 种类方法。
Python类实例方法
通常情况下,在类中定义的方法默认都是实例方法。前面章节中,我们已经定义了不只一个实例方法。不仅如此,类的构造方法理论上也属于实例方法,只不过它比较特殊。
比如,下面的类中就用到了实例方法:
class CLanguage:
#类构造方法,也属于实例方法
def __init__(self):
self.name = "C语言中文网"
self.add = "http://c.biancheng.net"
# 下面定义了一个say实例方法
def say(self):
print("正在调用 say() 实例方法")
实例方法最大的特点就是,它最少也要包含一个 self 参数,用于绑定调用此方法的实例对象(Python 会自动完成绑定)。实例方法通常会用类对象直接调用,例如:
clang = CLanguage()
clang.say()
运行结果:
正在调用 say() 实例方法
当然,Python 也支持使用类名调用实例方法,但此方式需要手动给 self 参数传值。例如:
#类名调用实例方法,需手动给 self 参数传值
clang = CLanguage()
CLanguage.say(clang)
运行结果为:
正在调用 say() 实例方法
有关使用类名直接调用实例方法的更多介绍,可阅读《Python类调用实例方法》一节。
Python类方法
Python 类方法和实例方法相似,它最少也要包含一个参数,只不过类方法中通常将其命名为 cls,Python 会自动将类本身绑定给 cls 参数(注意,绑定的不是类对象)。也就是说,我们在调用类方法时,无需显式为 cls 参数传参。
和 self 一样,cls 参数的命名也不是规定的(可以随意命名),只是 Python 程序员约定俗称的习惯而已。
和实例方法最大的不同在于,类方法需要使用@classmethod
修饰符进行修饰,例如:
class CLanguage:
#类构造方法,也属于实例方法
def __init__(self):
self.name = "C语言中文网"
self.add = "http://c.biancheng.net"
#下面定义了一个类方法
@classmethod
def info(cls):
print("正在调用类方法",cls)
注意,如果没有 @classmethod,则 Python 解释器会将 fly() 方法认定为实例方法,而不是类方法。
类方法推荐使用类名直接调用,当然也可以使用实例对象来调用(不推荐)。例如,在上面 CLanguage 类的基础上,在该类外部添加如下代码:
#使用类名直接调用类方法
CLanguage.info()
#使用类对象调用类方法
clang = CLanguage()
clang.info()
运行结果为:
正在调用类方法 <class ‘main.CLanguage’>
正在调用类方法 <class ‘main.CLanguage’>
Python类静态方法
静态方法,其实就是我们学过的函数,和函数唯一的区别是,静态方法定义在类这个空间(类命名空间)中,而函数则定义在程序所在的空间(全局命名空间)中。
静态方法没有类似 self、cls 这样的特殊参数,因此 Python 解释器不会对它包含的参数做任何类或对象的绑定。也正因为如此,类的静态方法中无法调用任何类属性和类方法。
静态方法需要使用@staticmethod
修饰,例如:
class CLanguage:
@staticmethod
def info(name,add):
print(name,add)
静态方法的调用,既可以使用类名,也可以使用类对象,例如:
#使用类名直接调用静态方法
CLanguage.info("C语言中文网","http://c.biancheng.net")
#使用类对象调用静态方法
clang = CLanguage()
clang.info("Python教程","http://c.biancheng.net/python")
运行结果为:
C语言中文网 http://c.biancheng.net
Python教程 http://c.biancheng.net/python
在实际编程中,几乎不会用到类方法和静态方法,因为我们完全可以使用函数代替它们实现想要的功能,但在一些特殊的场景中(例如工厂模式中),使用类方法和静态方法也是很不错的选择。
Python类调用实例方法
通过前面的学习,类方法大体分为 3 类,分别是类方法、实例方法和静态方法,其中实例方法用的是最多的。我们知道,实例方法的调用方式其实有 2 种,既可以采用类对象调用,也可以直接通过类名调用。
通常情况下,我们习惯使用类对象调用类中的实例方法。但如果想用类调用实例方法,不能像如下这样:
class CLanguage:
def info(self):
print("我正在学 Python")
#通过类名直接调用实例方法
CLanguage.info()
运行上面代码,程序会报出如下错误:
Traceback (most recent call last):
File “D:\python3.6\demo.py”, line 5, in
CLanguage.info()
TypeError: info() missing 1 required positional argument: ‘self’
其中,最后一行报错信息提示我们,调用 info() 类方式时缺少给 self 参数传参。这意味着,和使用类对象调用实例方法不同,通过类名直接调用实例方法时,Python 并不会自动给 self 参数传值。
读者想想也应该明白,self 参数需要的是方法的实际调用者(是类对象),而这里只提供了类名,当然无法自动传值。
因此,如果想通过类名直接调用实例方法,就必须手动为 self 参数传值。例如修改上面的代码为:
class CLanguage:
def info(self):
print("我正在学 Python")
clang = CLanguage()
#通过类名直接调用实例方法
CLanguage.info(clang)
再次运行程序,结果为:
我正在学 Python
可以看到,通过手动将 clang 这个类对象传给了 self 参数,使得程序得以正确执行。实际上,这里调用实例方法的形式完全是等价于 clang.info()。
值得一提的是,上面的报错信息只是让我们手动为 self 参数传值,但并没有规定必须传一个该类的对象,其实完全可以任意传入一个参数,例如:
class CLanguage:
def info(self):
print(self,"正在学 Python")
#通过类名直接调用实例方法
CLanguage.info("zhangsan")
运行结果为:
zhangsan 正在学 Python
可以看到,“zhangsan” 这个字符串传给了 info() 方法的 self 参数。显然,无论是 info() 方法中使用 self 参数调用其它类方法,还是使用 self 参数定义新的实例变量,胡乱的给 self 参数传参都将会导致程序运行崩溃。
总的来说,Python 中允许使用类名直接调用实例方法,但必须手动为该方法的第一个 self 参数传递参数,这种调用方法的方式被称为“非绑定方法”。
用类的实例对象访问类成员的方式称为绑定方法,而用类名调用类成员的方式称为非绑定方法。
浅谈Python类命名空间
前面章节已经不只一次提到,Python 类体中的代码位于独立的命名空间(称为类命名空间)中。换句话说,所有用 class 关键字修饰的代码块,都可以看做是位于独立的命名空间中。
和类命名空间相对的是全局命名空间,即整个 Python 程序默认都位于全局命名空间中。而类体则独立位于类命名空间中。
我们一开始学习类时就已经提到,类其实是由多个类属性和类方法构成,而类属性其实就是定义在类这个独立空间中的变量,而类方法其实就是定义在类空间中的函数,和定义在全局命名空间中的变量和函数相比,并没有明显的不同。
举个例子:
#全局空间定义变量
name = "C语言中文网"
add = "http://c.biancheng.net"
# 全局空间定义函数
def say ():
print("我在学习Python--全局")
class CLanguage:
# 定义CLanguage空间的say函数
def say():
print("我在学习Python--CLanguage独立空间")
# 定义CLanguage空间的catalog变量
name = "C语言中文网"
add = "http://c.biancheng.net"
#调用全局的变量和函数
print(name,add)
say()
#调用类独立空间的变量和函数
print(CLanguage.name,CLanguage.add)
CLanguage.say()
运行结果为:
C语言中文网 http://c.biancheng.net
我在学习Python–全局
C语言中文网 http://c.biancheng.net
我在学习Python–CLanguage独立空间
可以看到,相比位于全局命名空间的变量和函数,位于类命名空间中的变量和函数在使用时,只需要标注 CLanguage 前缀即可。
甚至,Python 还允许直接在类命名空间中编写可执行程序(例如输出语句、分支语句等),例如:
class CLanguage:
#直接编写可执行代码
print('正在执行 CLanguage 类空间中的代码')
for i in range(5):
print(i)
运行结果为:
正在执行 CLanguage 类空间中的代码
0
1
2
3
4
显然,上面这些位于类命名空间的可执行程序,和位于全局命令空间相比,并没有什么不同。
但需要注意的一点是,当使用类对象调用类方法时,在传参方面是和外界的函数有区别的,因为 Python 会自动会第一个参数绑定方法的调用者,而位于全局空间中的函数,则必须显式为第一个参数传递参数。
Python封装机制及实现方法
不光是 Python,大多数面向对象编程语言(诸如 C++、Java 等)都具备 3 个典型特征,即封装、继承和多态。其中,本节重点讲解 Python 类的封装特性,继承和多态会在后续章节给大家做详细讲解。
简单的理解封装(Encapsulation),即在设计类时,刻意地将一些属性和方法隐藏在类的内部,这样在使用此类时,将无法直接以“类对象.属性名”(或者“类对象.方法名(参数)”)的形式调用这些属性(或方法),而只能用未隐藏的类方法间接操作这些隐藏的属性和方法。
就好比使用电脑,我们只需要学会如何使用键盘和鼠标就可以了,不用关心内部是怎么实现的,因为那是生产和设计人员该操心的。
注意,封装绝不是将类中所有的方法都隐藏起来,一定要留一些像键盘、鼠标这样可供外界使用的类方法。
那么,类为什么要进行封装,这样做有什么好处呢?
首先,封装机制保证了类内部数据结构的完整性,因为使用类的用户无法直接看到类中的数据结构,只能使用类允许公开的数据,很好地避免了外部对内部数据的影响,提高了程序的可维护性。
除此之外,对一个类实现良好的封装,用户只能借助暴露出来的类方法来访问数据,我们只需要在这些暴露的方法中加入适当的控制逻辑,即可轻松实现用户对类中属性或方法的不合理操作。
并且,对类进行良好的封装,还可以提高代码的复用性。
Python 类如何进行封装?
和其它面向对象的编程语言(如 C++、Java)不同,Python 类中的变量和函数,不是公有的(类似 public 属性),就是私有的(类似 private),这 2 种属性的区别如下:
- public:公有属性的类变量和类函数,在类的外部、类内部以及子类(后续讲继承特性时会做详细介绍)中,都可以正常访问;
- private:私有属性的类变量和类函数,只能在本类内部使用,类的外部以及子类都无法使用。
但是,Python 并没有提供 public、private 这些修饰符。为了实现类的封装,Python 采取了下面的方法:
- 默认情况下,Python 类中的变量和方法都是公有(public)的,它们的名称前都没有下划线(_);
- 如果类中的变量和函数,其名称以双下划线“__”开头,则该变量(函数)为私有变量(私有函数),其属性等同于 private。
除此之外,还可以定义以单下划线“_”开头的类属性或者类方法(例如 _name、_display(self)),这种类属性和类方法通常被视为私有属性和私有方法,虽然它们也能通过类对象正常访问,但这是一种约定俗称的用法,初学者一定要遵守。
注意,Python 类中还有以双下划线开头和结尾的类方法(例如类的构造函数__init__(self)),这些都是 Python 内部定义的,用于 Python 内部调用。我们自己定义类属性或者类方法时,不要使用这种格式。
例如,如下程序示范了 Python 的封装机制:
class CLanguage :
def setname(self, name):
if len(name) < 3:
raise ValueError('名称长度必须大于3!')
self.__name = name
def getname(self):
return self.__name
#为 name 配置 setter 和 getter 方法
name = property(getname, setname)
def setadd(self, add):
if add.startswith("http://"):
self.__add = add
else:
raise ValueError('地址必须以 http:// 开头')
def getadd(self):
return self.__add
#为 add 配置 setter 和 getter 方法
add = property(getadd, setadd)
#定义个私有方法
def __display(self):
print(self.__name,self.__add)
clang = CLanguage()
clang.name = "C语言中文网"
clang.add = "http://c.biancheng.net"
print(clang.name)
print(clang.add)
程序运行结果为:
C语言中文网
http://c.biancheng.net
上面程序中,CLanguage 将 name 和 add 属性都隐藏了起来,但同时也提供了可操作它们的“窗口”,也就是各自的 setter 和 getter 方法,这些方法都是公有(public)的。
不仅如此,以 add 属性的 setadd() 方法为例,通过在该方法内部添加控制逻辑,即通过调用 startswith() 方法,控制用户输入的地址必须以“http://”开头,否则程序将会执行 raise 语句抛出 ValueError 异常。
有关 raise 的具体用法,后续章节会做详细的讲解,这里可简单理解成,如果用户输入不规范,程序将会报错。
通过此程序的运行逻辑不难看出,通过对 CLanguage 类进行良好的封装,使得用户仅能通过暴露的 setter() 和 getter() 方法操作 name 和 add 属性,而通过对 setname() 和 setadd() 方法进行适当的设计,可以避免用户对类中属性的不合理操作,从而提高了类的可维护性和安全性。
细心的读者可能还发现,CLanguage 类中还有一个 __display() 方法,由于该类方法为私有(private)方法,且该类没有提供操作该私有方法的“窗口”,因此我们无法在类的外部使用它。换句话说,如下调用 __display() 方法是不可行的:
#尝试调用私有的 display() 方法
clang.__display()
这会导致如下错误:
Traceback (most recent call last):
File “D:\python3.6\1.py”, line 33, in
clang.__display()
AttributeError: ‘CLanguage’ object has no attribute ‘__display’
那么,类似 __display() 这样的类方法,就没有办法调用了吗?并非如此,读者在了解《Python封装实现原理》之后,就可以轻松搞定它。
Python继承机制及其使用
Python 类的封装、继承、多态 3 大特性,前面章节已经详细介绍了 Python 类的封装,本节继续讲解 Python 类的继承机制。
继承机制经常用于创建和现有类功能类似的新类,又或是新类只需要在现有类基础上添加一些成员(属性和方法),但又不想直接将现有类代码复制给新类。也就是说,通过使用继承这种机制,可以轻松实现类的重复使用。
举个例子,假设现有一个 Shape 类,该类的 draw() 方法可以在屏幕上画出指定的形状,现在需要创建一个 Form 类,要求此类不但可以在屏幕上画出指定的形状,还可以计算出所画形状的面积。要创建这样的类,笨方法是将 draw() 方法直接复制到新类中,并添加计算面积的方法。实现代码如下所示:
class Shape:
def draw(self,content):
print("画",content)
class Form:
def draw(self,content):
print("画",content)
def area(self):
#....
print("此图形的面积为...")
当然还有更简单的方法,就是使用类的继承机制。实现方法为:让 From 类继承 Shape 类,这样当 From 类对象调用 draw() 方法时,Python 解释器会先去 From 中找以 draw 为名的方法,如果找不到,它还会自动去 Shape 类中找。如此,我们只需在 From 类中添加计算面积的方法即可,示例代码如下:
class Shape:
def draw(self,content):
print("画",content)
class Form(Shape):
def area(self):
#....
print("此图形的面积为...")
上面代码中,class From(Shape) 就表示 From 继承 Shape。
Python 中,实现继承的类称为子类,被继承的类称为父类(也可称为基类、超类)。因此在上面这个样例中,From 是子类,Shape 是父类。
子类继承父类时,只需在定义子类时,将父类(可以是多个)放在子类之后的圆括号里即可。语法格式如下:
class 类名(父类1, 父类2, …):
#类定义部分
注意,如果该类没有显式指定继承自哪个类,则默认继承 object 类(object 类是 Python 中所有类的父类,即要么是直接父类,要么是间接父类)。另外,Python 的继承是多继承机制(和 C++ 一样),即一个子类可以同时拥有多个直接父类。
注意,有读者可能还听说过“派生”这个词汇,它和继承是一个意思,只是观察角度不同而已。换句话话,继承是相对子类来说的,即子类继承自父类;而派生是相对于父类来说的,即父类派生出子类。
了解了继承机制的含义和语法之后,下面代码演示了继承机制的用法:
class People:
def say(self):
print("我是一个人,名字是:",self.name)
class Animal:
def display(self):
print("人也是高级动物")
#同时继承 People 和 Animal 类
#其同时拥有 name 属性、say() 和 display() 方法
class Person(People, Animal):
pass
zhangsan = Person()
zhangsan.name = "张三"
zhangsan.say()
zhangsan.display()
运行结果,结果为:
我是一个人,名字是: 张三
人也是高级动物
可以看到,虽然 Person 类为空类,但由于其继承自 People 和 Animal 这 2 个类,因此实际上 Person 并不空,它同时拥有这 2 个类所有的属性和方法。
没错,子类拥有父类所有的属性和方法,即便该属性或方法是私有(private)的。至于为什么,可阅读《Python封装实现原理》一节。
关于Python的多继承
事实上,大部分面向对象的编程语言,都只支持单继承,即子类有且只能有一个父类。而 Python 却支持多继承(C++也支持多继承)。
和单继承相比,多继承容易让代码逻辑复杂、思路混乱,一直备受争议,中小型项目中较少使用,后来的 Java、C#、PHP 等干脆取消了多继承。
使用多继承经常需要面临的问题是,多个父类中包含同名的类方法。对于这种情况,Python 的处置措施是:根据子类继承多个父类时这些父类的前后次序决定,即排在前面父类中的类方法会覆盖排在后面父类中的同名类方法。
举个例子:
class People:
def __init__(self):
self.name = People
def say(self):
print("People类",self.name)
class Animal:
def __init__(self):
self.name = Animal
def say(self):
print("Animal类",self.name)
#People中的 name 属性和 say() 会遮蔽 Animal 类中的
class Person(People, Animal):
pass
zhangsan = Person()
zhangsan.name = "张三"
zhangsan.say()
程序运行结果为:
People类 张三
可以看到,当 Person 同时继承 People 类和 Animal 类时,People 类在前,因此如果 People 和 Animal 拥有同名的类方法,实际调用的是 People 类中的。
虽然 Python 在语法上支持多继承,但逼不得已,建议大家不要使用多继承。