您的位置：首页 > 编程语言 > Python开发

Python 学习笔记 - 面向对象（类成员）

2017-04-05 00:00 302 查看

上一篇学习了Python面向对象的3大特性，封装，继承和多态，这一篇继续学习类成员，包括字段，方法，属性以及他们的修饰符。

1.字段

字段分为静态字段和普通字段。静态字段属于类，而普通字段属于对象，因此静态字段在内存中只保存一份，而普通字段在每个对象中都保存了一份。定义的时候静态字段定义在类的范围里面，而普通字段定义在方法里面。

例如：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

>>>

class

Foo:

# 字段（静态字段）

CC

def

__init__(

self

):

# 字段（普通的字段）

self

.name

'alex'

def

show(

self

):

print

self

.name)

obj

Foo()

print

(obj.name)

print

(Foo.CC)

print

(obj.CC)

alex

注意上面，尽管我们通过对象也能调用静态字段，这种方式应该尽量避免！

2.方法

方法包括静态方法，普通方法和类方法。

静态方法：由类调用，无默认参数；

普通方法：由对象调用，至少一个self参数，执行的时候，自动把对象赋值给self

类方法：由类调用，至少一个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
31
32
33
34
35
36

class

Province:

#静态字段

country

"中国"

def

__init__(

self

,name):

self

.name

name

# 普通方法，由对象去调用执行（方法属于类）

def

 show(
self
):

# print(self.name)

print
(
123
)


@
staticmethod

def
 f1(cla,a1,a2):

# 静态方法，由类调用执行。（当方法内部不需要对象中封装的值时，可以将方法写成静态方法）

print
(a1,a2)


@
classmethod

def
 f2(
cls
):
# class

cls
 # 类名，（）创建对象

# cls()

print
(
cls
)


def
 f3(
self
):

return
 self
.name[
1
]


obj
=
 Province(
"河南"
)

obj.show()

Province.f1(Province,
1
,
2
)

Province.f2()

obj
=
 Province(
'alex'
)

ret
=
 obj.f3()

print
(ret)

-
-
-
-
-
-
-
-
-
-
-
-
-

123

1
 2

<
class
 '__main__.Province'
>

l

3.属性

属性的本质就是一个方法，不过我们通过调用字段的方式去调用他。字段可以调用a=obj.name，可以赋值obj.name='alex'，可以删除del obj.name，属性自然也需要实现这些功能

属性有2种方式来定义：装饰器方式或者静态字段的方式

首先看看装饰器方式，分别在普通方法上面添加@property, @xx.settler @xx.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
28

class

Foo:

def

func(

self

):

pass

# 定义属性

property

def

prop(

self

):

print

'property'

@prop.setter

def

prop(

self

,value):

print

"settle"

@prop.deleter

def

prop(

self

):

print

"deletter"

# ############### 调用 ###############

foo_obj

Foo()

foo_obj.func()

foo_obj.prop

foo_obj.prop

del

foo_obj.prop

property

settle

deletter

第二种方式是通过静态字段的方式

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

def

f2(

self

,value):

print

'setup'

def

f3(

self

):

print

'del'

foo

property

(fget

f1,fset

f2, fdel

f3)

Pager(

result

p.foo

print

(result)

p.foo

"alex"

del

p.foo

setup

del

第一个参数是方法名，调用

对象.属性

时自动触发执行方法

第二个参数是方法名，调用

对象.属性 ＝ XXX

时自动触发执行方法

第三个参数是方法名，调用

del 对象.属性

时自动触发执行方法

第四个参数是字符串，调用

对象.属性.__doc__

，此参数是该属性的描述信息

4.修饰符

所有的类成员都有两种形式

公有成员：任何地方都能访问

私有成员：只有类的内部可以访问

命名形式很简单，就是前两个字符是下划线__（注意和特殊成员区分开）

静态字段

公有静态字段：类可以访问；类内部可以访问；派生类中可以访问

私有静态字段：仅类内部可以访问；

例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

class

C:

name

"公有静态字段"

def

func(

self

):

print

(C.name)

class

D(C):

def

show(

self

):

print

(C.name)

print

(C.name)

# 类访问

obj

C()

obj.func()

# 类内部可以访问

obj_son

D()

obj_son.show()

# 派生类中可以访问

公有静态字段

公有静态字段

公有静态字段

如果改成私有静态字段，那么类不可以访问，派生类也不可以访问

1
2
3
4
5
6
7
8
9
10
11
12
13
14

class

C:

__name

"私有静态字段"

def

func(

self

):

print

(C.__name)

class

D(C):

def

show(

self

):

print

(C.__name)

# print(C.__name) # 类无法访问

obj

C()

obj.func()

# 类内部可以访问

obj_son

D()

# obj_son.show()# 派生类中不可以访问

私有静态字段

普通字段

公有普通字段：对象可以访问；类内部可以访问；派生类中可以访问

私有普通字段：仅类内部可以访问；

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

class

C:

def

__init__(

self

):

self

.__foo

"私有普通字段"

def

func(

self

):

print

self

.__foo)

class

D(C):

def

show(

self

):

print

self

.__foo)

obj

C()

# obj.__foo# 通过对象访问==> 错误

obj.func()

# 类内部访问==> 正确

obj_son

D();

# obj_son.show() # 派生类中访问  ==> 错误

私有字段

方法和属性的访问方式和上面相似。

登录乐搏学院官网http://www.learnbo.com/

或关注我们的官方微博微信，还有更多惊喜哦~

本文出自 “麻婆豆腐” 博客，请务必保留此出处http://beanxyz.blog.51cto.com/5570417/1858670

3ff0

内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理

标签：

相关文章推荐

新的分享

章节导航