上一篇文章介绍了面向对象基本知识:
- 面向对象是一种编程方式,此编程方式的实现是基于对 类 和 对象 的使用
- 类 是一个模板,模板中包装了多个“函数”供使用(可以讲多函数中公用的变量封装到对象中)
- 对象,根据模板创建的实例(即:对象),实例用于调用被包装在类中的函数
- 面向对象三大特性:封装、继承和多态
本篇将详细介绍Python 类的成员、成员修饰符、类的特殊成员。
一、类的成员
类的成员可以分为三大类:属性、方法和包装
(很重要的一句话,实例可以访问实例属性和方法包括类中的所有属性和方法,但是类不可以访问实例中的属性和方法,实例中的属性和方法需要实例化后才能调用和访问,但类依然不可以访问和调用方法)
注:所有成员中,只有实例属性的内容保存对象中,即:根据此类创建了多少对象,在内存中就有多少个实例属性。而其他的成员,则都是保存在类中,即:无论对象的多少,在内存中只创建一份。
一、属性
属性包括:实例属性和类属性,他们在定义和使用中有所区别,而最本质的区别是内存中保存的位置不同
- 实例属性属于对象
- 类属性属于类
属性的定义和使用
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
|
class Province: #
类属性 country
= '中国' def __init__( self ,
name): #
实例属性 self .name = name #
实例属性需要类实例化,然后通过对象访问 obj = Province( '河北省' ) print obj.name #
直接访问类属性,访问类属性则不需要实例化 Province.country |
由上述代码可以看出【实例属性需要通过对象来访问】【类属性通过类访问】,在使用上可以看出实例属性和类属性的归属是不同的。其在内容的存储方式类似如下图:
由上图可是:
- 类属性在内存中只保存一份
- 实例属性在每个对象中都要保存一份
应用场景: 通过类创建对象时,如果每个对象都具有相同的属性,那么就使用类属性
二、方法
方法包括:普通方法、静态方法和类方法,三种方法在内存中都归属于类,区别在于调用方式不同。
- 普通方法:由对象调用;至少一个self参数;执行普通方法时,自动将调用该方法的对象赋值给self;self是实例的变量名;(类不能调用实例的方法)
- 静态方法:由类调用;默认无参数,可以任意参数;(对象也能调用)
- 类方法: 由类调用; 至少一个cls参数;执行类方法时,自动将调用该方法的类复制给cls;cls其实是类名,类方法其实是静态方法的一个变种;(对象也能调用)
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
|
class Province: country = "中国" def __init__( self ,name): self .name = name def show( self ): """普通方法,由对象调用执行(方法属于类),实例化才能调用""" print ( self .name) @staticmethod def f1(arg1,arg2): """静态方法,由类调用执行,可以没有参数,或者任意参数""" print (arg1,arg2) @classmethod def f2( cls ): """类方法至少要有cls一个参数,cls就是类名,python自动会传,就像self""" print ( cls ) obj = Province( 'python' ) #
类实例化成对象 print (obj.name) #
通过对象访问实例属性 obj.show() #
通过对象执行实例方法 Province.f1( 1111 , 2222 ) #
静态方法,通过类调用 Province.f2() #
类方法,通过类调用 obj.f1( 'python' , 'linux' ) #
对象也能调用静态方法 obj.f2() #
对象也能调用类方法 |
三、包装
如果你已经了解Python类中的方法,那么包装就非常简单了,因为Python中的包装其实是实例方法的变种。包装是将方法包装成属性,属性通过对象调用,包装后的方法也是通过一样的方式调用,并且无需()
对于包装,有以下三个知识点:
- 包装的基本使用
- 包装的两种定义方式
1、包装的基本使用
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
|
#
############### 定义 ############### class Foo: def func( self ): pass #
设置包装 @property def prop( self ): print ( "将方法包装成属性访问即包装" ) return 123 #
############### 调用 ############### foo_obj = Foo() foo_obj.func() ret = foo_obj.prop #调用属性并接收返回值 print (ret) |
由包装的定义和调用要注意一下几点:
- 定义时,在实例方法的基础上添加 @property 装饰器;
- 定义时,仅有一个self参数
- 调用时,无需括号
方法:foo_obj.func()
属性:foo_obj.prop
注意:包装存在意义是:访问属性时可以制造出和访问字段完全相同的假象
包装由方法变种而来,如果Python中没有包装,方法完全可以代替其功能。
实例:对于主机列表页面,每次请求不可能把数据库中的所有内容都显示到页面上,而是通过分页的功能局部显示,所以在向数据库中请求数据时就要显示的指定获取从第m条到第n条的所有数据(即:limit m,n),这个分页的功能包括:
- 根据用户请求的当前页和总数据条数计算出 m 和 n
- 根据m 和 n 去数据库中请求数据
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
|
#
############### 定义 ############### class Pager: def __init__( self ,
current_page): #
用户当前请求的页码(第一页、第二页...) self .current_page = current_page #
每页默认显示10条数据 self .per_items = 10 @property def start( self ): val = ( self .current_page - 1 ) * self .per_items return val @property def end( self ): val = self .current_page * self .per_items return val #
############### 调用 ############### p = Pager( 1 ) p.start
就是起始值,即:m p.end
就是结束值,即:n |
2、包装的两种定义方式
包装的定义有两种方式:
- 装饰器 即:在方法上应用装饰器
- 类属性 即:在类中定义值为property对象的类属性
(1)装饰器方式:在类的实例方法上应用@property装饰器
我们知道Python中的类有经典类和新式类,新式类的属性比经典类的属性丰富。( 如果类继承object,那么该类是新式类 )
经典类,具有一种@property装饰器(如上一步实例)
经典类中的属性只有一种访问方式,其对应被 @property 修饰的方法
1
2
3
4
5
6
7
8
9
|
#
############### 定义 ############### class Goods: @property def price( self ): return "python" #
############### 调用 ############### obj = Goods() result = obj.price #
自动执行 @property 修饰的 price 方法,并获取方法的返回值 |
新式类,具有三种@property装饰器
新式类中的属性有三种访问方式,并分别对应了三个被@property、@方法名.setter、@方法名.deleter修饰的方法
我们可以根据他们几个属性的访问特点,分别将三个方法定义为对同一个属性:获取、修改、删除
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
|
class Pager: def __init__( self ,all_count): self .all_count = all_count @property def all_pager( self ): a1,a2 = divmod ( self .all_count, 10 ) if a2 = = 0 : return a1 else : return a1 + 1 @all_pager .setter def all_pager( self ,value): print (value) @all_pager .deleter def all_pager( self ): print ( 'del
all_page' ) p = Pager( 101 ) ret = p.all_pager print (ret) p.all_pager = 115 del p.all_pager |
(2)类属性方式:创建值为property对象的类方法(经典类与新式类无差别)
property的构造方法中有个四个参数:
- 第一个参数是方法名,调用
对象.方法
时自动触发执行方法 - 第二个参数是方法名,调用
对象.方法 = XXX
时自动触发执行方法 - 第三个参数是方法名,调用
del 对象.方法
时自动触发执行方法 - 第四个参数是字符串,调用
对象.方法.__doc__
,此参数是该属性的描述信息
可以根据他们几个方法的访问特点,分别将三个方法定义为对同一个属性:获取、修改、删除
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
|
class Pager: def __init__( self ,all_count): self .all_count = all_count def f1( self ): return 123 def f2( self ,value): print (value) def f3( self ): print ( "del
p.foo" ) foo = property (fget = f1,fset = f2,fdel = f3) p = Pager( 101 ) result = p.foo #
自动调用第一个参数中定义的方法:f1方法,result用于接收返回值 print (result) p.foo = "python" #
自动调用第二个参数中定义的方法:f2方法,并将"python"当作参数传入 del p.foo #
自动调用第二个参数中定义的方法:f3方法 p.foo.__doc__ #
自动获取第四个参数中设置的值:description... |
注意:Python WEB框架 Django 的视图中 request.POST 就是使用的类属性的方式创建的方法
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
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
|
class WSGIRequest(http.HttpRequest): def __init__( self ,
environ): script_name = get_script_name(environ) path_info = get_path_info(environ) if not path_info: #
Sometimes PATH_INFO exists, but is empty (e.g. accessing #
the SCRIPT_NAME URL without a trailing slash). We really need to #
operate as if they'd requested '/'. Not amazingly nice to force #
the path like this, but should be harmless. path_info = '/' self .environ = environ self .path_info = path_info self .path = '%s/%s' % (script_name.rstrip( '/' ),
path_info.lstrip( '/' )) self .META = environ self .META[ 'PATH_INFO' ] = path_info self .META[ 'SCRIPT_NAME' ] = script_name self .method = environ[ 'REQUEST_METHOD' ].upper() _,
content_params = cgi.parse_header(environ.get( 'CONTENT_TYPE' ,
'')) if 'charset' in content_params: try : codecs.lookup(content_params[ 'charset' ]) except LookupError: pass else : self .encoding = content_params[ 'charset' ] self ._post_parse_error = False try : content_length = int (environ.get( 'CONTENT_LENGTH' )) except (ValueError,
TypeError): content_length = 0 self ._stream = LimitedStream( self .environ[ 'wsgi.input' ],
content_length) self ._read_started = False self .resolver_match = None def _get_scheme( self ): return self .environ.get( 'wsgi.url_scheme' ) def _get_request( self ): warnings.warn( '`request.REQUEST`
is deprecated, use `request.GET` or ' '`request.POST`
instead.' ,
RemovedInDjango19Warning, 2 ) if not hasattr ( self , '_request' ): self ._request = datastructures.MergeDict( self .POST, self .GET) return self ._request @cached_property def GET( self ): #
The WSGI spec says 'QUERY_STRING' may be absent. raw_query_string = get_bytes_from_wsgi( self .environ, 'QUERY_STRING' ,
'') return http.QueryDict(raw_query_string,
encoding = self ._encoding) #
############### 看这里看这里 ############### def _get_post( self ): if not hasattr ( self , '_post' ): self ._load_post_and_files() return self ._post #
############### 看这里看这里 ############### def _set_post( self ,
post): self ._post = post @cached_property def COOKIES( self ): raw_cookie = get_str_from_wsgi( self .environ, 'HTTP_COOKIE' ,
'') return http.parse_cookie(raw_cookie) def _get_files( self ): if not hasattr ( self , '_files' ): self ._load_post_and_files() return self ._files #
############### 看这里看这里 ############### POST = property (_get_post,
_set_post) FILES = property (_get_files) REQUEST = property (_get_request) |
所以,定义包装共有两种方式,分别是【装饰器】和【类属性】,而【装饰器】方式针对经典类和新式类又有所不同。
二、类成员的修饰符
类的所有成员在上一步骤中已经做了详细的介绍,对于每一个类的成员而言都有两种形式:
- 公有成员,在任何地方都能访问
- 私有成员,只有在类的内部才能方法
私有成员和公有成员的定义不同:私有成员命名时,前两个字符是下划线。(特殊成员除外,例如:__init__、__call__、__dict__等)
1
2
3
4
5
6
7
|
class C: age = 12 #
'公有类属性' __age = 35 #
"私有类属性" def __init__( self ): self .name = '公有实例属性' self .__foo = "私有实例属性" |
私有成员和公有成员的访问限制不同:
- 公有属性(公有类属性和公有实例属性):类可以访问;类内部可以访问;派生类中可以访问
- 私有属性(私有类属性和私有实例属性):仅类内部可以访问;派生类中无法访问
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
|
class C: age = 12 #
'公有类属性' __age1 = 35 #
"私有类属性" def __init__( self ): self .name = '公有实例属性' self .__name1 = "私有实例属性" def f1( self ): """实例方法""" print (C.age) print (C.__age1) print ( self .name) print ( self .__name1) @staticmethod def f2(): """类方法""" print (C.age) print (C.__age1) obj = C() print (C.age) #
类外部直接访问公有类属性 #print(C.__age1)
# 错误,私有类属性外部无法访问 C.f2() #
通过类内部的静态方法方法属性 print (obj.age) #
类外部直接访问类的公有属性 #print(obj.__age1)
# 错误,对象没法在外部访问类属性 print (obj.name) #
类外部直接访问公有实例属性 #print(obj.__name1)
# 错误,对象也没法在外部访问实例属性 obj.f1() #
通过内部的实例方法可以访问类属性和实例属性 |
如果想要强制访问私有字段,可以通过 【对象._类名__私有字段明 】访问(如:obj._C__foo),不建议强制访问私有成员。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
|
class C: def __init__( self ): self .foo = "公有属性" self .__foo1 = "私有属性" def func( self ): print ( self .foo) #
类内部访问 print ( self .__foo1) class D(C): def show( self ): print ( self .foo) #
派生类中访问公有属性 print ( self .__foo1) #
私有属性派生类中也无法访问 obj = C() print (obj.foo) #
通过对象访问 print (obj._C__foo1) #访问私有属性 obj.func() #
类内部访问 obj_son = D() #obj_son._show()
# 会报错 |
方法、属性的访问于上述方式相似,即:私有成员只能在类内部使用
ps:非要访问私有属性的话,可以通过 对象._类__属性名
三、类的特殊成员
上文介绍了Python的类成员以及成员修饰符,从而了解到类中有属性、方法和包装三大类成员,并且成员名前如果有两个下划线,则表示该成员是私有成员,私有成员只能由类内部调用。无论人或事物往往都有不按套路出牌的情况,Python的类成员也是如此,存在着一些具有特殊含义的成员,详情如下:
1. __doc__
表示类的描述信息
1
2
3
4
5
6
7
8
|
class Foo: """
描述类信息,这是用于看片的神奇 """ def func( self ): pass print Foo.__doc__ #输出:类的描述信息 |
2. __module__ 和 __class__
__module__ 表示当前操作的对象在那个模块
__class__ 表示当前操作的对象的类是什么
例如lib/aa.py
1
2
3
4
5
6
7
|
#!/usr/bin/env
python #
-*- coding:utf-8 -*- class C: def __init__( self ): self .name = "python" |
index.py
1
2
3
4
5
|
from lib.aa import C obj = C() print obj.__module__ #
输出 lib.aa,即:输出模块 print obj.__class__ #
输出 lib.aa.C,即:输出类 |
3. __init__
构造方法,通过类创建对象时,自动触发执行。
1
2
3
4
5
6
7
8
|
class Foo: def __init__( self ,
name): self .name = name self .age = 18 obj = Foo( 'python' ) #
自动执行类中的 __init__ 方法 |
4. __del__
析构方法,当对象在内存中被释放时,自动触发执行。
注:此方法一般无须定义,因为Python是一门高级语言,程序员在使用时无需关心内存的分配和释放,因为此工作都是交给Python解释器来执行,所以,析构函数的调用是由解释器在进行垃圾回收时自动触发执行的。
1
2
3
4
|
class Foo: def __del__( self ): pass |
5. __call__
对象后面加括号,触发执行。
注:构造方法的执行是由创建对象触发的,即:对象 = 类名() ;而对于 __call__ 方法的执行是由对象后加括号触发的,即:对象() 或者 类()()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
|
class Foo: def __init__( self ,name,age): print ( 'init' ) self .name = name self .age = age def __call__( self , * args, * * kwargs): print ( "call" ) obj = Foo( 'python' , 27 ) obj() #
对象() 会执行类中__call__方法 Foo( 'python' , 27 )() #
这一句相当于上两句 |
6. __dict__
类或对象中的所有成员
上文中我们知道:类的普通字段属于对象;类中的静态字段和方法等属于类,即:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
|
class Province: country = 'China' def __init__( self ,
name, count): self .name = name self .count = count def func( self , * args, * * kwargs): print 'func' #
获取类的成员,即:类属性、方法、 print (Province.__dict__) #
输出:{'country': 'China', '__module__': '__main__', 'func': <function func at 0x10be30f50>, '__init__': <function __init__ at 0x10be30ed8>, '__doc__': None} obj1 = Province( 'HeBei' , 10000 ) print (obj1.__dict__) #
获取 对象obj1 的成员 #
输出:{'count': 10000, 'name': 'HeBei'} obj2 = Province( 'HeNan' , 3888 ) print (obj2.__dict__) #
获取 对象obj2 的成员 #
输出:{'count': 3888, 'name': 'HeNan'} |
7. __str__
如果一个类中定义了__str__方法,那么在打印 对象 时,默认输出该方法的返回值。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
|
class Foo: def __init__( self ,name,age): print ( 'init' ) self .name = name self .age = age def __str__( self ): #
将实例化对象友好的输出 return "%s
- %d" % ( self .name, self .age) obj1 = Foo( 'tom' , 73 ) obj2 = Foo( 'jerry' , 90 ) print (obj1) print (obj2) ret = str (obj1) print ( type (ret),ret) ret = obj1 + obj2 print (ret) |
8、__getitem__、__setitem__、__delitem__
用于索引操作,如字典。以上分别表示获取、设置、删除数据
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
|
class Foo: def __init__( self ,name,age): print ( 'init' ) self .name = name self .age = age def __getitem__( self ,
item): return 123 def __setitem__( self ,
key, value): print ( 'setitem' ) def __delitem__( self ,
key): print ( 'del
item' ) obj = Foo( 'python' , 27 ) ret = obj[ 'ad' ] #
自动触发执行 __getitem__ print (ret) obj[ 'k1' ] = 111 #
自动触发执行 __setitem__ del obj[ 'k1' ] #
自动触发执行 __delitem__ |
9、__getslice__、__setslice__、__delslice__(此方法只适用于python2.x)
该三个方法用于分片操作,如:列表
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
|
#!/usr/bin/env
python #
-*- coding:utf-8 -*- class Foo( object ): def __getslice__( self ,
i, j): print '__getslice__' ,i,j def __setslice__( self ,
i, j, sequence): print '__setslice__' ,i,j def __delslice__( self ,
i, j): print '__delslice__' ,i,j obj = Foo() obj[ - 1 : 1 ] #
自动触发执行 __getslice__ obj[ 0 : 1 ] = [ 11 , 22 , 33 , 44 ] #
自动触发执行 __setslice__ del obj[ 0 : 2 ] #
自动触发执行 __delslice__ |
python3.x依然使用__getitem__、__setitem__、__delitem__
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
|
class Foo: def __init__( self ,name,age): print ( 'init' ) self .name = name self .age = age def __getitem__( self ,
item): print (item.start) print (item.stop) print (item.step) return 123 def __setitem__( self ,
key, value): print ( type (key), type (value)) def __delitem__( self ,
key): print ( type (key)) obj = Foo( 'python' , 27 ) #
语法对应关系,将'ad'赋值给__getitem__中的item ret2 = obj[ 1 : 4 : 2 ] obj[ 1 : 4 ] = [ 11 , 22 , 33 , 44 , 55 ] del obj[ 1 : 4 ] |
10. __iter__
用于迭代器,之所以列表、字典、元组可以进行for循环,是因为类型内部定义了 __iter__
1
2
3
4
5
6
7
8
9
10
11
12
|
class Foo( object ): def __init__( self ,
sq): self .sq = sq def __iter__( self ): return iter ( self .sq) obj = Foo([ 11 , 22 , 33 , 44 ]) for i in obj: print i |
或者使用yeild生成器
1
2
3
4
5
6
7
8
9
10
11
12
|
class Foo( object ): def __init__( self ,
sq): self .sq = sq def __iter__( self ): return iter ( self .sq) obj = Foo([ 11 , 22 , 33 , 44 ]) for i in obj: print i |
11. __new__ 和 __metaclass__
阅读以下代码:
1
2
3
4
5
6
|
class Foo( object ): def __init__( self ): pass obj = Foo() #
obj是通过Foo类实例化的对象 |
上述代码中,obj 是通过 Foo 类实例化的对象,其实,不仅 obj 是一个对象,Foo类本身也是一个对象,因为在Python中一切事物都是对象。
如果按照一切事物都是对象的理论:obj对象是通过执行Foo类的构造方法创建,那么Foo类对象应该也是通过执行某个类的 构造方法 创建。
1
2
|
print type (obj) #
输出:<class '__main__.Foo'> 表示,obj 对象由Foo类创建 print type (Foo) #
输出:<type 'type'> 表示,Foo类对象由 type 类创建 |
所以,obj对象是Foo类的一个实例,Foo类对象是 type 类的一个实例,即:Foo类对象 是通过type类的构造方法创建。
那么,创建类就可以有两种方式:
a). 普通方式
1
2
3
4
|
class Foo( object ): def func( self ): print 'hello
python' |
b).特殊方式(type类的构造函数)
1
2
3
4
5
6
7
|
def func( self ): print 'hello
wupeiqi' Foo = type ( 'Foo' ,( object ,),
{ 'func' :
func}) #type第一个参数:类名 #type第二个参数:当前类的基类 #type第三个参数:类的成员 |
==》 类 是由 type 类实例化产生
那么问题来了,类默认是由 type 类实例化产生,type类中如何实现的创建类?类又是如何创建对象?
答:类中有一个属性 __metaclass__,其用来表示该类由 谁 来实例化创建,所以,我们可以为 __metaclass__ 设置一个type类的派生类,从而查看 类 创建的过程。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
|
class MyType( type ): def __init__( self ,
what, bases = None , dict = None ): super (MyType, self ).__init__(what,
bases, dict ) def __call__( self , * args, * * kwargs): obj = self .__new__( self , * args, * * kwargs) self .__init__(obj) class Foo( object ): __metaclass__ = MyType def __init__( self ,
name): self .name = name def __new__( cls , * args, * * kwargs): return object .__new__( cls , * args, * * kwargs) #
第一阶段:解释器从上到下执行代码创建Foo类 #
第二阶段:通过Foo类创建obj对象 obj = Foo() |