Python 中的类(1)
在Python中,可以通过class关键字定义自己的类,然后通过自定义的类对象类创建实例对象。
例如,下面创建了一个Student的类,并且实现了这个类的初始化函数”__init__”:
1
2
3
4
5
6
7
|
class
Student(object):
count
= 0
books
= []
def
__init__(self,
name,
age):
self.name
= name
self.age
= age
pass
|
接下来就通过上面的Student类来看看Python中类的相关内容。
数据属性
在上面的Student类中,”count””books””name”和”age”都被称为类的数据属性,但是它们又分为类数据属性和实例数据属性。
类数据属性和实例数据属性
首先看一段代码,代码中分别展示了对类数据属性和实例数据属性的访问:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
|
Student.books.extend(["python",
"javascript"])
print "Student book list: %s"
%Student.books
# class can add class attribute after class defination
Student.hobbies
= ["reading",
"jogging",
"swimming"]
print
"Student hobby list: %s"
%Student.hobbies
print dir(Student)
print
wilber =
Student("Wilber",
28)
print
"%s is %d years old"
%(wilber.name,
wilber.age)
# class instance can add new attribute
# "gender" is the instance attribute only belongs to wilber
wilber.gender
= "male"
print
"%s is %s" %(wilber.name,
wilber.gender)
# class instance can access class attribute
print
dir(wilber)
wilber.books.append("C#")
print
wilber.books
print
will
= Student("Will",
27)
print "%s is %d years old"
%(will.name,
will.age)
# will shares the same class attribute with wilber
# will don't have the "gender" attribute that belongs to wilber
print
dir(will)
print will.books
|
通过内建函数dir(),或者访问类的字典属性__dict__,这两种方式都可以查看类有哪些属性,代码的输出为:
对于类数据属性和实例数据属性,可以总结为:
- 类数据属性属于类本身,可以通过类名进行访问/修改
- 类数据属性也可以被类的所有实例访问/修改
- 在类定义之后,可以通过类名动态添加类数据属性,新增的类属性也被类和所有实例共有
- 实例数据属性只能通过实例访问
- 在实例生成后,还可以动态添加实例数据属性,但是这些实例数据属性只属于该实例
特殊的类属性
对于所有的类,都有一组特殊的属性:
类属性 | 含义 |
__name__ | 类的名字(字符串) |
__doc__ | 类的文档字符串 |
__bases__ | 类的所有父类组成的元组 |
__dict__ | 类的属性组成的字典 |
__module__ | 类所属的模块 |
__class__ | 类对象的类型 |
通过这些属性,可以得到 Student类的一些信息:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
|
class
Student(object):
'''
this is a Student class
'''
count
= 0
books
= []
def
__init__(self,
name,
age):
self.name
= name
self.age
= age
pass
print Student.__name__
print
Student.__doc__
print Student.__bases__
print
Student.__dict__
print Student.__module__
print
Student.__class
|
代码输出为:
属性隐藏
从上面的介绍了解到,类数据属性属于类本身,被所有该类的实例共享;并且,通过实例可以去访问/修改类属性。但是,在通过实例中访问类属性的时候一定要谨慎,因为可能出现属性”隐藏”的情况。
继续使用上面的Student类,来看看属性隐藏:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
|
wilber
= Student("Wilber",
28)
print
"Student.count is wilber.count: ",
Student.count
is wilber.count
wilber.count
= 1
print
"Student.count is wilber.count: ",
Student.count
is wilber.count
print Student.__dict__
print
wilber.__dict__
del wilber.count
print
"Student.count is wilber.count: ",
Student.count
is wilber.count
print
wilber.count
+= 3
print "Student.count is wilber.count: ",
Student.count
is wilber.count
print
Student.__dict__
print wilber.__dict__
del wilber.count
print
print
"Student.books is wilber.books: ",
Student.books
is wilber.books
wilber.books
= ["C#",
"Python"]
print
"Student.books is wilber.books: ",
Student.books
is wilber.books
print Student.__dict__
print
wilber.__dict__
del wilber.books
print
"Student.books is wilber.books: ",
Student.books
is wilber.books
print
wilber.books.append("CSS")
print "Student.books is wilber.books: ",
Student.books
is wilber.books
print
Student.__dict__
print wilber.__dict__
|
代码的输出为:
分析一下上面代码的输出:
- 对于不可变类型的类属性Student.count,可以通过实例wilber进行访问,并且”Student.count is wilber.count”
- 当通过实例赋值/修改count属性的时候,都将为实例wilber新建一个count实例属性,这时,”Student.count is not wilber.count”
- 当通过”del wilber.count”语句删除实例的count属性后,再次成为”Student.count is wilber.count”
- 同样对于可变类型的类属性Student.books,可以通过实例wilber进行访问,并且”Student. books is wilber. books”
- 当通过实例赋值books属性的时候,都将为实例wilber新建一个books实例属性,这时,”Student. Books is not wilber. books”
- 当通过”del wilber. books”语句删除实例的books属性后,再次成为”Student. books is wilber. books”
- 当通过实例修改books属性的时候,将修改wilber.books指向的内存地址(即Student.books),此时,”Student. Books is wilber. books”
注意,虽然通过实例可以访问类属性,但是,不建议这么做,最好还是通过类名来访问类属性,从而避免属性隐藏带来的不必要麻烦。
方法
在一个类中,可能出现三种方法,实例方法、静态方法和类方法,下面来看看三种方法的不同。
实例方法
实例方法的第一个参数必须是”self”,”self”类似于C++中的”this”。
实例方法只能通过类实例进行调用,这时候”self”就代表这个类实例本身。通过”self”可以直接访问实例的属性。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
|
class
Student(object):
'''
this is a Student class
'''
count
= 0
books
= []
def
__init__(self,
name,
age):
self.name
= name
self.age
= age
def
printInstanceInfo(self):
print
"%s is %d years old"
%(self.name,
self.age)
pass
wilber
= Student("Wilber",
28)
wilber.printInstanceInfo()
|
类方法
类方法以cls作为第一个参数,cls表示类本身,定义时使用@classmethod装饰器。通过cls可以访问类的相关属性。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
|
class
Student(object):
'''
this is a Student class
'''
count
= 0
books
= []
def
__init__(self,
name,
age):
self.name
= name
self.age
= age
@classmethod
def
printClassInfo(cls):
print
cls.__name__
print
dir(cls)
pass
Student.printClassInfo()
wilber =
Student("Wilber",
28)
wilber.printClassInfo()
|
代码的输出为,从这段代码可以看到,类方法可以通过类名访问,也可以通过实例访问。
静态方法
与实例方法和类方法不同,静态方法没有参数限制,既不需要实例参数,也不需要类参数,定义的时候使用@staticmethod装饰器。
同类方法一样,静态法可以通过类名访问,也可以通过实例访问。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
|
class
Student(object):
'''
this is a Student class
'''
count
= 0
books
= []
def
__init__(self,
name,
age):
self.name
= name
self.age
= age
@staticmethod
def
printClassAttr():
print
Student.count
print
Student.books
pass
Student.printClassAttr()
wilber =
Student("Wilber",
28)
wilber.printClassAttr()
|
这三种方法的主要区别在于参数,实例方法被绑定到一个实例,只能通过实例进行调用;但是对于静态方法和类方法,可以通过类名和实例两种方式进行调用。
访问控制
Python中没有访问控制的关键字,例如private、protected等等。但是,在Python编码中,有一些约定来进行访问控制。
单下划线”_”
在Python中,通过单下划线”_”来实现模块级别的私有化,一般约定以单下划线”_”开头的变量、函数为模块私有的,也就是说”from moduleName import *”将不会引入以单下划线”_”开头的变量、函数。
现在有一个模块lib.py,内容用如下,模块中一个变量名和一个函数名分别以”_”开头:
1
2
3
4
5
6
7
8
9
10
|
numA
= 10
_numA =
100
def printNum():
print
"numA is:",
numA
print
"_numA is:",
_numA
def _printNum():
print
"numA is:",
numA
print "_numA is:",
_numA
|
当通过下面代码引入lib.py这个模块后,所有的以”_”开头的变量和函数都没有被引入,如果访问将会抛出异常:
1
2
3
4
5
6
|
from
lib import
*
print numA
printNum()
print
_numA
#print _printNum()
|
双下划线”__”
对于Python中的类属性,可以通过双下划线”__”来实现一定程度的私有化,因为双下划线开头的属性在运行时会被”混淆”(mangling)。
在Student类中,加入了一个”__address”属性:
1
2
3
4
5
6
7
8
9
10
|
class
Student(object):
def
__init__(self,
name,
age):
self.name
= name
self.age
= age
self.__address
= "Shanghai"
pass
wilber
= Student("Wilber",
28)
print wilber.__address
|
当通过实例wilber访问这个属性的时候,就会得到一个异常,提示属性”__address”不存在。
其实,通过内建函数dir()就可以看到其中的一些原由,”__address”属性在运行时,属性名被改为了”_Student__address”(属性名前增加了单下划线和类名)
1
2
3
4
5
6
7
|
>>>
wilber =
Student("Wilber",
28)
>>> dir(wilber)
['_Student__address',
'__class__',
'__delattr__',
'__dict__',
'__doc__',
'__form
at__',
'__getattribute__',
'__hash__',
'__init__',
'__module__',
'__new__',
'__r
educe__',
'__reduce_ex__',
'__repr__',
'__setattr__',
'__sizeof__',
'__str__',
'
__subclasshook__',
'__weakref__',
'age',
'name']
>>>
|
所以说,即使是双下划线,也没有实现属性的私有化,因为通过下面的方式还是可以直接访问”__address”属性:
1
2
3
4
|
>>>
wilber =
Student("Wilber",
28)
>>> print
wilber._Student__address
Shanghai
>>>
|
双下划线的另一个重要的目地是,避免子类对父类同名属性的冲突。
看下面一个例子:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
|
class
A(object):
def
__init__(self):
self.__private()
self.public()
def
__private(self):
print
'A.__private()'
def
public(self):
print
'A.public()'
class B(A):
def
__private(self):
print
'B.__private()'
def
public(self):
print
'B.public()'
b
= B()
|
当实例化B的时候,由于没有定义__init__函数,将调用父类的__init__,但是由于双下划线的”混淆”效果,”self.__private()”将变成 “self._A__private()”。
看到这里,就清楚为什么会有如下输出了:
“_”和” __”的使用 更多的是一种规范/约定,不没有真正达到限制的目的:
“_”:以单下划线开头的表示的是protected类型的变量,即只能允许其本身与子类进行访问;同时表示弱内部变量标示,如,当使用”from moduleNmae import *”时,不会将以一个下划线开头的对象引入。
“__”:双下划线的表示的是私有类型的变量。只能是允许这个类本身进行访问了,连子类也不可以,这类属性在运行时属性名会加上单下划线和类名。