Python学习笔记（七）——面向对象
Python面向对象
概述php
- 面向过程：根据业务逻辑从上到下写垒代码
- 函数式：将某功能代码封装到函数中，往后便无需重复编写，仅调用函数便可
- 面向对象：对函数进行分类和封装，让开发“更快更好更强...”
面向过程编程最易被初学者接受，其每每用一长段代码来实现指定功能，开发过程当中最多见的操做就是粘贴复制，即：将以前实现的代码块复制到现需功能处，此为1.0。html
随着时间的推移，开始使用了函数式编程，加强代码的重用性和可读性，此为2.0。java
而从如今开始，咱们即未来学习编程方式的升级版——面向对象编程(Object Oriented Programming, OOP, 面向对象程序设计)，华丽丽的3.0。python
PS:Java和C#来讲只支持面向对象编程，而python比较灵活即支持面向对象编程也支持函数式编程。程序员
建立类和对象面试
面向对象编程是一种编程方式，此编程方式须要使用 “类” 和 “对象” 来实现，因此，面向对象编程其实就是对 “类” 和 “对象” 的使用。数据库
- 类就是一个模板，模板里能够包含多个函数，函数里实现一些功能；
- 对象则是根据模板建立的实例，经过实例对象能够执行类中的函数；
- class是关键字，表示类
- 建立对象，类名称后加括号便可
ps：类中的函数第一个参数必须是self（详细见：类的三大特性之封装）
类中定义的函数叫作 “方法”。编程
|
1
2
3
4
5
6
7
8
9
10
11
12
|
# 建立类
class
foo:
def
bar(
self
):
print
"bar"
def
hello(
self
,name):
print
"I am %s"
%
name
# 根据类foo建立对象obj
obj
=
foo()
obj.bar()
# 执行bar方法
obj.hello(
'korala'
)
# 执行hello方法
|
运行结果：c#
|
1
2
|
bar
I am korala
|
看了上面的例子是否是有点困惑啊？使用函数式编程和面向对象编程方式来执行一个“方法”时函数要比面向对象简便。ruby
- 面向对象：【建立对象】【经过对象执行方法】
- 函数编程：【执行函数】
看了上述的对比函数的确要比面向对象简便，然而事情的真相是。。。不一样的场景中其适合的编程方式也是不同滴。
总结：函数式的应用场景 --> 各个函数之间是独立且无共用的数据。
至于面向对象该如何应用呢？别急，接着往下看。
面向对象的三大特性
想知道面向对象应用在哪些场景，先来了解它的三大特性：
- 封装
- 继承
- 多态
1、 封装
封装，顾名思义就是将内容封装到某个地方，之后再去调用被封装在某处的内容。
因此，在使用面向对象的封装特性时，须要：
- 将内容封装到某处
- 从某处调用被封装的内容
第一步：将内容封装到某处
|
1
2
3
4
5
6
7
8
9
10
11
12
13
|
# 建立类
class
foo:
def
__int__(
self
, name, age):
# 称为构造方法，根据类建立对象时自动执行
self
.name
=
name
self
.age
=
age
# 根据类foo建立对象
# 自动执行foo类的 __init__ 方法
obj1
=
foo(
'wxy'
,
20
)
# 将wxy和20分别封装到 obj1 self 的name和age属性中
# 根据类foo建立对象
# 自动执行foo类的 __init__ 方法
obj2
=
foo(
'korala'
,
18
)
# 将korala和18分别封装到 obj2 self 的name和age属性中
|
self 是一个形式参数，当执行 obj1 = Foo('wxy',20) 时，self 等于 obj1；当执行 obj2 = Foo('korala', 18 ) 时，self 等于 obj2。
因此，内容其实被封装到了对象 obj1 和 obj2 中，每一个对象中都有 name 和 age 属性，在内存里相似于下图来保存。
第二步：从某处调用被封装的内容
调用被封装的内容时，有两种状况：
- 经过对象直接调用
- 经过self间接调用
一、经过对象直接调用被封装的内容
上图展现了对象 obj1 和 obj2 在内存中保存的方式，根据保存格式能够如此调用被封装的内容：对象.属性名
|
1
2
3
4
5
6
7
8
9
10
11
12
|
class
foo:
def
__int__(
self
, name, age):
self
.name
=
name
self
.age
=
age
obj1
=
foo(
'wxy'
,
20
)
print
obj1.name
# 直接调用obj1对象的name属性
print
obj1.age
# 直接调用obj1对象的age属性
obj2
=
foo(
'korala'
,
18
)
print
obj2.name
# 直接调用obj2对象的name属性
print
obj2.age
# 直接调用obj2对象的age属性
|
二、经过self间接调用被封装的内容
执行类中的方法时，须要经过self间接调用被封装的内容
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
class
foo:
def
__int__(
self
, name, age):
self
.name
=
name
self
.age
=
age
def
detail(
self
):
print
self
.name
print
self
.age
obj1
=
foo(
'wxy'
,
20
)
obj1.detail()
# python默认会将obj1传给self参数，即：obj1.detail(obj1)，故此时方法内部的 self.name 是 wxy; self.age 是 20
obj2
=
foo(
'korala'
,
18
)
obj2.detail()
# python默认会将obj2传给self参数，即：obj2.detail(obj2)，故此时方法内部的 self.name 是 korala ; self.age 是 18
|
综上所述，对于面向对象的封装来讲，其实就是使用构造方法将内容封装到 对象 中，而后经过对象直接或者self间接获取被封装的内容。
练习一：在终端输出以下信息
小明，10岁，男，上山去砍柴
小明，10岁，男，开车去东北
小明，10岁，男，最爱大保健
老李，90岁，男，上山去砍柴
老李，90岁，男，开车去东北
老李，90岁，男，最爱大保健
# 函数式编程
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
|
def
kanchai(name, age, gender):
print
"%s,%s岁,%s,上山去砍柴"
%
(name, age, gender)
def
qudongbei(name, age, gender):
print
"%s,%s岁,%s,开车去东北"
%
(name, age, gender)
def
dabaojian(name, age, gender):
print
"%s,%s岁,%s,最爱大保健"
%
(name, age, gender)
kanchai(
'小明'
,
10
,
'男'
)
qudongbei(
'小明'
,
10
,
'男'
)
dabaojian(
'小明'
,
10
,
'男'
)
kanchai(
'老李'
,
90
,
'男'
)
qudongbei(
'老李'
,
90
,
'男'
)
dabaojian(
'老李'
,
90
,
'男'
)
|
# 面向对象
|
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
Foo:
def
__init__(
self
, name, age ,gender):
self
.name
=
name
self
.age
=
age
self
.gender
=
gender
def
kanchai(
self
):
print
"%s,%s岁,%s,上山去砍柴"
%
(
self
.name,
self
.age,
self
.gender)
def
qudongbei(
self
):
print
"%s,%s岁,%s,开车去东北"
%
(
self
.name,
self
.age,
self
.gender)
def
dabaojian(
self
):
print
"%s,%s岁,%s,最爱大保健"
%
(
self
.name,
self
.age,
self
.gender)
xiaoming
=
Foo(
'小明'
,
10
,
'男'
)
xiaoming.kanchai()
xiaoming.qudongbei()
xiaoming.dabaojian()
laoli
=
Foo(
'老李'
,
90
,
'男'
)
laoli.kanchai()
laoli.qudongbei()
laoli.dabaojian()
|
上述对比能够看出，若是使用函数式编程，须要在每次执行函数时传入相同的参数，若是参数多的话，就须要n次粘贴复制了；而对于面向对象只须要在建立对象时，将全部须要的参数封装到当前对象中，以后再次使用时，经过self间接去当前对象中取值便可。
练习二：游戏人生程序
一、建立三个游戏人物，分别是：
苍井井，女，18，初始战斗力1000
东尼木木，男，20，初始战斗力1800
波多多，女，19，初始战斗力2500
二、游戏场景，分别：
草丛战斗，消耗200战斗力
自我修炼，增加100战斗力
多人游戏，消耗500战斗力
|
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
|
# ##################### 定义实现功能的类 #####################
class
Person:
def
__init__(
self
, na, gen, age, fig):
self
.name
=
na
self
.gender
=
gen
self
.age
=
age
self
.fight
=
fig
def
grassland(
self
):
"""注释：草丛战斗，消耗200战斗力"""
self
.fight
=
self
.fight
-
200
def
practice(
self
):
"""注释：自我修炼，增加100战斗力"""
self
.fight
=
self
.fight
+
200
def
incest(
self
):
"""注释：多人游戏，消耗500战斗力"""
self
.fight
=
self
.fight
-
500
def
detail(
self
):
"""注释：当前对象的详细状况"""
temp
=
"姓名:%s ; 性别:%s ; 年龄:%s ; 战斗力:%s"
%
(
self
.name,
self
.gender,
self
.age,
self
.fight)
print
temp
# ##################### 开始游戏 #####################
cang
=
Person(
'苍井井'
,
'女'
,
18
,
1000
)
# 建立苍井井角色
dong
=
Person(
'东尼木木'
,
'男'
,
20
,
1800
)
# 建立东尼木木角色
bo
=
Person(
'波多多'
,
'女'
,
19
,
2500
)
# 建立波多多角色
cang.incest()
#苍井空参加一次多人游戏
dong.practice()
#东尼木木自我修炼了一次
bo.grassland()
#波多多参加一次草丛战斗
#输出当前全部人的详细状况
cang.detail()
dong.detail()
bo.detail()
cang.incest()
#苍井空又参加一次多人游戏
dong.incest()
#东尼木木也参加了一个多人游戏
bo.practice()
#波多多自我修炼了一次
#输出当前全部人的详细状况
cang.detail()
dong.detail()
bo.detail()
|
小结：
封装：一、将数据进行封装，便于使用时取出数据；
二、根据一个模板建立使用对象（相同属性）；
执行过程：
类对象指针 ——> 经过指针找到类，类中找方法，方法执行（对象中隐含着类中的指针 ==> 关联）
2、继承
继承，面向对象中的继承和现实生活中的继承相同，即：子能够继承父的内容。
例如：
猫能够：喵喵叫、吃、喝、拉、撒
狗能够：汪汪叫、吃、喝、拉、撒
若是咱们要分别为猫和狗建立一个类，那么就须要为 猫 和 狗 实现他们全部的功能，以下所示：
# 伪代码
|
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
猫：
def
喵喵叫(
self
):
print
'喵喵叫'
def
吃(
self
):
# do something
def
喝(
self
):
# do something
def
拉(
self
):
# do something
def
撒(
self
):
# do something
class
狗：
def
汪汪叫(
self
):
print
'喵喵叫'
def
吃(
self
):
# do something
def
喝(
self
):
# do something
def
拉(
self
):
# do something
def
撒(
self
):
# do something
|
上述代码不难看出，吃、喝、拉、撒是猫和狗都具备的功能，而咱们却分别的猫和狗的类中编写了两次。若是使用 继承 的思想，以下实现：
动物：吃、喝、拉、撒
猫：喵喵叫（猫继承动物的功能）
狗：汪汪叫（狗继承动物的功能）
# 伪代码
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
|
class
动物:
def
吃(
self
):
# do something
def
喝(
self
):
# do something
def
拉(
self
):
# do something
def
撒(
self
):
# do something
# 在类后面括号中写入另一个类名，表示当前类继承另一个类
class
猫(动物)：
def
喵喵叫(
self
):
print
'喵喵叫'
# 在类后面括号中写入另一个类名，表示当前类继承另一个类
class
狗(动物)：
def
汪汪叫(
self
):
print
'喵喵叫'
|
# 代码实例
|
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
|
class
Animal:
def
eat(
self
):
print
"%s 吃 "
%
self
.name
def
drink(
self
):
print
"%s 喝 "
%
self
.name
def
shit(
self
):
print
"%s 拉 "
%
self
.name
def
pee(
self
):
print
"%s 撒 "
%
self
.name
class
Cat(Animal):
def
__init__(
self
, name):
self
.name
=
name
self
.breed
=
'猫'
def
cry(
self
):
print
'喵喵叫'
class
Dog(Animal):
def
__init__(
self
, name):
self
.name
=
name
self
.breed
=
'狗'
def
cry(
self
):
print
'汪汪叫'
# ######### 执行 #########
c1
=
Cat(
'小白家的小黑猫'
)
c1.eat()
c2
=
Cat(
'小黑的小白猫'
)
c2.drink()
d1
=
Dog(
'胖子家的小瘦狗'
)
d1.eat()
|
因此，对于面向对象的继承来讲，其实就是将多个类共有的方法提取到父类中，子类仅需继承父类而没必要一一实现每一个方法。
PS:除了子类和父类的称谓，你可能看到过 派生类 和 基类 ，他们与子类和父类只是叫法不一样而已。
学习了继承的写法以后，咱们用代码来是上述阿猫阿狗的功能：
|
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
|
class
Animal:
def
eat(
self
):
print
"%s 吃 "
%
self
.name
def
drink(
self
):
print
"%s 喝 "
%
self
.name
def
shit(
self
):
print
"%s 拉 "
%
self
.name
def
pee(
self
):
print
"%s 撒 "
%
self
.name
class
Cat(Animal):
def
__init__(
self
, name):
self
.name
=
name
self
.breed ＝
'猫'
def
cry(
self
):
print
'喵喵叫'
class
Dog(Animal):
def
__init__(
self
, name):
self
.name
=
name
self
.breed ＝
'狗'
def
cry(
self
):
print
'汪汪叫'
# ######### 执行 #########
c1
=
Cat(
'小白家的小黑猫'
)
c1.eat()
c2
=
Cat(
'小黑的小白猫'
)
c2.drink()
d1
=
Dog(
'胖子家的小瘦狗'
)
d1.eat()
|
那么问题又来了，多继承呢？
- 是否能够继承多个类
- 若是继承的多个类每一个类中都定了相同的函数，那么那一个会被使用呢？
一、Python的类能够继承多个类，Java和C#中则只能继承一个类
二、Python的类若是继承了多个类，那么其寻找方法的方式有两种，分别是：深度优先 和 广度优先
- 当类是经典类时，多继承状况下，会按照深度优先方式查找
- 当类是新式类时，多继承状况下，会按照广度优先方式查找
经典类和新式类，从字面上能够看出一个老一个新，新的必然包含了跟多的功能，也是以后推荐的写法，从写法上区分的话，若是 当前类或者父类继承了object类，那么该类即是新式类，不然即是经典类。
# 经典类多继承
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
|
class
D:
def
bar(
self
):
print
'D.bar'
class
C(D):
def
bar(
self
):
print
'C.bar'
class
B(D):
def
bar(
self
):
print
'B.bar'
class
A(B, C):
def
bar(
self
):
print
'A.bar'
a
=
A()
# 执行bar方法时
# 首先去A类中查找，若是A类中没有，则继续去B类中找，若是B类中么有，则继续去D类中找，若是D类中么有，则继续去C类中找，若是仍是未找到，则报错
# 因此，查找顺序：A --> B --> D --> C
# 在上述查找bar方法的过程当中，一旦找到，则寻找过程当即中断，便不会再继续找了
a.bar()
|
# 新式类多继承
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
|
class
D(
object
):
def
bar(
self
):
print
'D.bar'
class
C(D):
def
bar(
self
):
print
'C.bar'
class
B(D):
def
bar(
self
):
print
'B.bar'
class
A(B, C):
def
bar(
self
):
print
'A.bar'
a
=
A()
# 执行bar方法时
# 首先去A类中查找，若是A类中没有，则继续去B类中找，若是B类中么有，则继续去C类中找，若是C类中么有，则继续去D类中找，若是仍是未找到，则报错
# 因此，查找顺序：A --> B --> C --> D
# 在上述查找bar方法的过程当中，一旦找到，则寻找过程当即中断，便不会再继续找了
a.bar()
|
经典类：首先去A类中查找，若是A类中没有，则继续去B类中找，若是B类中么有，则继续去D类中找，若是D类中么有，则继续去C类中找，若是仍是未找到，则报错。
新式类：首先去A类中查找，若是A类中没有，则继续去B类中找，若是B类中么有，则继续去C类中找，若是C类中么有，则继续去D类中找，若是仍是未找到，则报错。
注意：在上述查找过程当中，一旦找到，则寻找过程当即中断，便不会再继续找了。
小结：
继承：只跟类有关系；
父类、子类
基类、派生类
函数式 ==> 函数式面向对象（低级）经典类 ==> 函数式面向对象（添加新功能）新式类(直接或间接继承)
java,c#：只能继承一个类，不能继承多个类
python,ruby,php：多继承支持——>
广度（横向）优先（新式类）：离谁越近就先找谁
深度（纵向）优先（经典类）
一个类D继承了多个类A,B,C,对于新式类来讲，对于类中的同一功能，寻找顺序为：C,B,A
深度优先则顺序为：A,B,C
3、多态
Pyhon不支持多态而且也用不到多态，多态的概念是应用于Java和C#这一类强类型语言中，而Python崇尚“鸭子类型”。
# python伪代码实现java或c#的多态
|
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
F1:
pass
class
S1(F1):
def
show(
self
):
print
'S1.show'
class
S2(F1):
def
show(
self
):
print
'S2.show'
# 因为在Java或C#中定义函数参数时，必须指定参数的类型
# 为了让Func函数既能够执行S1对象的show方法，又能够执行S2对象的show方法，因此，定义了一个S1和S2类的父类
# 而实际传入的参数是：S1对象和S2对象
def
Func(F1 obj):
"""Func函数须要接收一个F1类型或者F1子类的类型"""
print
obj.show()
s1_obj
=
S1()
Func(s1_obj)
# 在Func函数中传入S1类的对象 s1_obj，执行 S1 的show方法，结果：S1.show
s2_obj
=
S2()
Func(s2_obj)
# 在Func函数中传入Ss类的对象 ss_obj，执行 Ss 的show方法，结果：S2.show
|
# python “鸭子类型”
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
|
class
F1:
pass
class
S1(F1):
def
show(
self
):
print
'S1.show'
class
S2(F1):
def
show(
self
):
print
'S2.show'
def
Func(obj):
print
obj.show()
s1_obj
=
S1()
Func(s1_obj)
s2_obj
=
S2()
Func(s2_obj)
|
基础知识总结：
- 面向对象是一种编程方式，此编程方式的实现是基于对 类 和 对象 的使用
- 类 是一个模板，模板中包装了多个“函数”供使用
- 对象，根据模板建立的实例（即：对象），实例用于调用被包装在类中的函数
- 面向对象三大特性：封装、继承和多态
问答专区
问题一：什么样的代码才是面向对象？
答：从简单来讲，若是程序中的全部功能都是用 类 和 对象 来实现，那么就是面向对象编程了。
问题二：函数式编程 和 面向对象 如何选择？分别在什么状况下使用？
答：须知：对于 C# 和 Java 程序员来讲不存在这个问题，由于该两门语言只支持面向对象编程（不支持函数式编程）。而对于 Python 和 PHP 等语言却同时支持两种编程方式，且函数式编程能完成的操做，面向对象均可以实现；而面向对象的能完成的操做，函数式编程不行（函数式编程没法实现面向对象的封装功能）。
因此，通常在Python开发中，所有使用面向对象 或 面向对象和函数式混合使用。
面向对象的应用场景:
1. 多函数需使用共同的值，如：数据库的增、删、改、查操做都须要链接数据库字符串、主机名、用户名和密码。
|
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
SqlHelper:
def
__init__(
self
, host, user, pwd):
self
.host
=
host
self
.user
=
user
self
.pwd
=
pwd
def
增(
self
):
# 使用主机名、用户名、密码（self.host 、self.user 、self.pwd）打开数据库链接
# do something
# 关闭数据库链接
def
删(
self
):
# 使用主机名、用户名、密码（self.host 、self.user 、self.pwd）打开数据库链接
# do something
# 关闭数据库链接
def
改(
self
):
# 使用主机名、用户名、密码（self.host 、self.user 、self.pwd）打开数据库链接
# do something
# 关闭数据库链接
def
查(
self
):
# 使用主机名、用户名、密码（self.host 、self.user 、self.pwd）打开数据库链接
# do something
# 关闭数据库链接# do something
|
2. 须要建立多个事物，每一个事物属性个数相同，可是值的需求
如：张3、李4、杨五，他们都有姓名、年龄、血型，但其都是不相同。即：属性个数相同，但值不相同。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
|
class
Person:
def
__init__(
self
, name ,age ,blood_type):
self
.name
=
name
self
.age
=
age
self
.blood_type
=
blood_type
def
detail(
self
):
temp
=
"i am %s, age %s , blood type %s "
%
(
self
.name,
self
.age,
self
.blood_type)
print
temp
zhangsan
=
Person(
'张三'
,
18
,
'A'
)
lisi
=
Person(
'李四'
,
73
,
'AB'
)
yangwu
=
Person(
'杨五'
,
84
,
'A'
)
|
问题三：类和对象在内存中是如何保存？
答：类以及类中的方法在内存中只有一份，而根据类建立的每个对象都在内存中须要存一份，大体以下图：
如上图所示，根据类建立对象时，对象中除了封装 name 和 age 的值以外，还会保存一个类对象指针，该值指向当前对象的类。
当经过 obj1 执行 【方法一】 时，过程以下：
1. 根据当前对象中的 类对象指针 找到类中的方法
2. 将对象 obj1 看成参数传给 方法的第一个参数 self
进阶篇
类的成员
类的成员能够分为三大类：字段、方法和属性。
PS：全部成员中，只有普通字段的内容保存对象中，即：根据此类建立了多少对象，在内存中就有多少个普通字段。而其余的成员，则都是保存在类中，即：不管对象的多少，在内存中只建立一份。
1、字段
字段包括：普通字段和静态字段，他们在定义和使用中有所区别，而最本质的区别是内存中保存的位置不一样，
- 普通字段属于对象
- 静态字段属于类
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
|
# 字段的定义和使用
class
Province:
# 静态字段
country
=
'中国'
def
__init__(
self
, name):
# 普通字段
self
.name
=
name
# 直接访问普通字段
obj
=
Province(
'河北省'
)
print
obj.name
# 直接访问静态字段
Province.country
|
由上述代码能够看出【普通字段须要经过对象来访问】【静态字段经过类访问】，在使用上能够看出普通字段和静态字段的归属是不一样的。其在内容的存储方式相似以下图：
由上图可知：
- 静态字段在内存中只保存一份
- 普通字段在每一个对象中都要保存一份
应用场景： 经过类建立对象时，若是每一个对象都具备相同的字段，那么就使用静态字段
PS：普通字段——保存在对象中
静态字段——保存在类中
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
|
# 方法的定义和使用
class
Foo:
def
__init__(
self
, name):
self
.name
=
name
def
ord_func(
self
):
""" 定义普通方法，至少有一个self参数 """
# print self.name
print
'普通方法'
@classmethod
def
class_func(
cls
):
""" 定义类方法，至少有一个cls参数 """
print
'类方法'
@staticmethod
def
static_func():
""" 定义静态方法 ，无默认参数"""
print
'静态方法'
# 调用普通方法
f
=
Foo()
f.ord_func()
# 调用类方法
Foo.class_func()
# 调用静态方法
Foo.static_func()
|
相同点：对于全部的方法而言，均属于类（非对象）中，因此，在内存中也只保存一份。
不一样点：方法调用者不一样、调用方法时自动传入的参数不一样。
PS：普通方法——对象触发，至少一个self参数
类方法——类调用，只能一个cls参数 ==> 无需建立对象
静态方法——类调用，无默认参数 ==> 类+静态方法=函数（节省内存），不用单首创建内存
3、属性
若是你已经了解Python类中的方法，那么属性就很是简单了，由于Python中的属性实际上是普通方法的变种。
对于属性，有如下三个知识点：
- 属性的基本使用
- 属性的两种定义方式
一、 属性的基本使用
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
|
# 属性的定义和使用
# ############### 定义 ###############
class
Foo:
def
func(
self
):
pass
# 定义属性
@property
def
prop(
self
):
pass
# ############### 调用 ###############
foo_obj
=
Foo()
foo_obj.func()
foo_obj.prop
#调用属性
|
由属性的定义和调用要注意一下几点：
- 定义时，在普通方法的基础上添加 @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
|
# ############### 定义 ###############
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
|
从上述可见，Python的属性的功能是：属性内部进行一系列的逻辑计算，最终将计算结果返回。
2、属性的两种定义方式
属性的定义有两种方式：
- 装饰器 即：在方法上应用装饰器
- 静态字段 即：在类中定义值为property对象的静态字段
装饰器方式：在类的普通方法上应用@property装饰器
咱们知道Python中的类有经典类和新式类，新式类的属性比经典类的属性丰富。（ 若是类继object，那么该类是新式类 ）
经典类，具备一种@property装饰器（如上一步实例）
|
1
2
3
4
5
6
7
8
|
# ############### 定义 ###############
class
Goods:
@property
def
price(
self
):
return
"wupeiqi"
# ############### 调用 ###############
obj
=
Goods()
result
=
obj.price
# 自动执行 @property 修饰的 price 方法，并获取方法的返回值
|
新式类，具备三种@property装饰器
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
|
# ############### 定义 ###############
class
Goods(
object
):
@property
def
price(
self
):
print
'@property'
@price
.setter
def
price(
self
, value):
print
'@price.setter'
@price
.deleter
def
price(
self
):
print
'@price.deleter'
# ############### 调用 ###############
obj
=
Goods()
obj.price
# 自动执行 @property 修饰的 price 方法，并获取方法的返回值
obj.price
=
123
# 自动执行 @price.setter 修饰的 price 方法，并将 123 赋值给方法的参数
del
obj.price
# 自动执行 @price.deleter 修饰的 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
|
class
Goods(
object
):
def
__init__(
self
):
# 原价
self
.original_price
=
100
# 折扣
self
.discount
=
0.8
@property
def
price(
self
):
# 实际价格 = 原价 * 折扣
new_price
=
self
.original_price
*
self
.discount
return
new_price
@price
.setter
def
price(
self
, value):
self
.original_price
=
value
@price
.deltter
def
price(
self
, value):
del
self
.original_price
obj
=
Goods()
obj.price
# 获取商品价格
obj.price
=
200
# 修改商品原价
del
obj.price
# 删除商品原价
|
静态字段方式，建立值为property对象的静态字段
当使用静态字段的方式建立属性时，经典类和新式类无区别
|
1
2
3
4
5
6
7
8
9
|
class
Foo:
def
get_bar(
self
):
return
'wupeiqi'
BAR
=
property
(get_bar)
obj
=
Foo()
reuslt
=
obj.BAR
# 自动调用get_bar方法，并获取方法的返回值
print
reuslt
|
property的构造方法中有个四个参数
- 第一个参数是方法名，调用 对象.属性 时自动触发执行方法
- 第二个参数是方法名，调用 对象.属性 ＝ XXX 时自动触发执行方法
- 第三个参数是方法名，调用 del 对象.属性 时自动触发执行方法
- 第四个参数是字符串，调用 对象.属性.__doc__ ，此参数是该属性的描述信息
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
|
class
Foo：
def
get_bar(
self
):
return
'wxy'
# *必须两个参数
def
set_bar(
self
, value):
return
return
'set value'
+
value
def
del_bar(
self
):
return
'wxy'
BAR ＝
property
(get_bar, set_bar, del_bar,
'description...'
)
obj
=
Foo()
obj.BAR
# 自动调用第一个参数中定义的方法：get_bar
obj.BAR
=
"korala"
# 自动调用第二个参数中定义的方法：set_bar方法，并将“korala”看成参数传入
del
Foo.BAR
# 自动调用第三个参数中定义的方法：del_bar方法
obj.BAE.__doc__
# 自动获取第四个参数中设置的值：description...
|
因为静态字段方式建立属性具备三种访问方式，咱们能够根据他们几个属性的访问特色，分别将三个方法定义为对同一个属性：获取、修改、删除。
|
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
Goods(
object
):
def
__init__(
self
):
# 原价
self
.original_price
=
100
# 折扣
self
.discount
=
0.8
def
get_price(
self
):
# 实际价格 = 原价 * 折扣
new_price
=
self
.original_price
*
self
.discount
return
new_price
def
set_price(
self
, value):
self
.original_price
=
value
def
del_price(
self
, value):
del
self
.original_price
PRICE
=
property
(get_price, set_price, del_price,
'价格属性描述...'
)
obj
=
Goods()
obj.PRICE
# 获取商品价格
obj.PRICE
=
200
# 修改商品原价
del
obj.PRICE
# 删除商品原价
|
注意：Python WEB框架 Django 的视图中 request.POST 就是使用的静态字段的方式建立的属性。
# Django源码
|
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)
|
因此，定义属性共有两种方式，分别是【装饰器】和【静态字段】，而【装饰器】方式针对经典类和新式类又有所不一样。
小结：
属性：将方法伪形成字段
定义方式：
装饰器 即：在方法上应用装饰器 @property
静态字段 即：在类中定义值为property对象的静态字段
新式类属性能够设置读写删；
类成员的修饰符
类的全部成员在上一步骤中已经作了详细的介绍，对于每个类的成员而言都有两种形式：
- 公有成员，在任何地方都能访问
- 私有成员，只有在类的内部才能方法
私有成员和公有成员的定义不一样：私有成员命名时，前两个字符是下划线。（特殊成员除外，例如：__init__、__call__、__dict__等）
|
1
2
3
4
|
class
C:
def
__init__(
self
):
self
.name
=
'公有字段'
self
.__foo
=
"私有字段"
|
静态字段
- 公有静态字段：类能够访问；类内部能够访问；派生类中能够访问
- 私有静态字段：仅类内部能够访问；
# 公有静态字段
|
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
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
16
|
class
C:
__name
=
"私有静态字段"
def
func(
self
):
print
C.__name
class
D(C):
def
show(
self
):
print
C.__name
C.__name
# 类访问 ==> 错误
obj
=
C()
obj.func()
# 类内部能够访问 ==> 正确
obj_son
=
D()
obj_son.show()
# 派生类中能够访问 ==> 错误
|
普通字段
- 公有普通字段：对象能够访问；类内部能够访问；派生类中能够访问
- 私有普通字段：仅类内部能够访问；
ps：若是想要强制访问私有字段，能够经过 【对象._类名__私有字段明 】访问（如：obj._C__foo），不建议强制访问私有成员。
# 公有字段
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
|
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()
# 派生类中访问
|
# 私有字段
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
|
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()
# 派生类中访问 ==> 错误
|
方法、属性的访问于上述方式类似，即：私有成员只能在类内部使用
ps：非要访问私有属性的话，能够经过 对象._类__属性名
类的特殊成员
上文介绍了Python的类成员以及成员修饰符，从而了解到类中有字段、方法和属性三大类成员，而且成员名前若是有两个下划线，则表示该成员是私有成员，私有成员只能由类内部调用。不管人或事物每每都有不按套路出牌的状况，Python的类成员也是如此，存在着一些具备特殊含义的成员，详情以下：
1. __doc__
表示类的描述信息。
|
1
2
3
4
5
6
7
|
class
Foo:
""" 描述类信息，这是用于看片的神奇 """
def
func(
self
):
pass
print
Foo.__doc__
#输出：类的描述信息
|
2. __module__ 和 __class__
__module__ 表示当前操做的对象在那个模块
__class__ 表示当前操做的对象的类是什么
# lib/aa.py
# 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
|
class
Foo:
def
__init__(
self
, name):
self
.name
=
name
self
.age
=
18
obj
=
Foo(
'wupeiqi'
)
# 自动执行类中的 __init__ 方法
|
4. __del__
析构方法，当对象在内存中被释放时，自动触发执行。
注：此方法通常无须定义，由于Python是一门高级语言，程序员在使用时无需关心内存的分配和释放，由于此工做都是交给Python解释器来执行，因此，析构函数的调用是由解释器在进行垃圾回收时自动触发执行的。
|
1
2
3
|
class
Foo:
def
__del__(
self
):
pass
|
5. __call__
对象后面加括号，触发执行。
注：构造方法的执行是由建立对象触发的，即：对象 = 类名() ；而对于 __call__ 方法的执行是由对象后加括号触发的，即：对象() 或者 类()()
|
1
2
3
4
5
6
7
8
9
|
class
Foo:
def
__init__(
self
):
pass
def
__call__(
self
,
*
args,
*
*
kwargs):
print
'__call__'
obj
=
Foo()
# 执行 __init__
obj()
# 执行 __call__
|
6. __dict__
类或对象中的全部成员
上文中咱们知道：类的普通字段属于对象；类中的静态字段和方法等属于类，即：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
|
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__
# 获取 对象obj1 的成员
# 输出：{'count': 3888, 'name': 'HeNan'}
|
7. __str__
若是一个类中定义了__str__方法，那么在打印 对象 时，默认输出该方法的返回值。
|
1
2
3
4
5
6
7
|
class
Foo:
def
__str__(
self
):
return
'korala'
obj
=
Foo()
print
obj
# 输出korala
|
8、__getitem__、__setitem__、__delitem__
用于索引操做，如字典。以上分别表示获取、设置、删除数据。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
|
#!/usr/bin/env python
# -*- coding:utf-8 -*-
class
Foo(
object
):
def
__getitem__(
self
, key):
print
'__getitem__'
,key
def
__setitem__(
self
, key, value):
print
'__setitem__'
,key,value
def
__delitem__(
self
, key):
print
'__delitem__'
,key
obj
=
Foo()
result
=
obj[
'k1'
]
# 自动触发执行 __getitem__
obj[
'k2'
]
=
'korala'
# 自动触发执行 __setitem__
del
obj[
'k1'
]
# 自动触发执行 __delitem__
|
9、__getslice__、__setslice__、__delslice__
该三个方法用于分片操做，如：列表。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
|
#!/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__
|
10. __iter__
用于迭代器，之因此列表、字典、元组能够进行for循环，是由于类型内部定义了 __iter__。
|
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
|
# 第一步
class
Foo(
object
):
pass
obj
=
Foo()
for
i
in
obj:
print
i
# 报错：TypeError: 'Foo' object is not iterable
# 第二步
#!/usr/bin/env python
# -*- coding:utf-8 -*-
class
Foo(
object
):
def
__iter__(
self
):
pass
obj
=
Foo()
for
i
in
obj:
print
i
# 报错：TypeError: iter() returned non-iterator of type 'NoneType'
# 第三步
#!/usr/bin/env python
# -*- coding:utf-8 -*-
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
|
以上步骤能够看出，for循环迭代的实际上是 iter([11,22,33,44]) ，因此执行流程能够变动为：
|
1
2
3
4
5
6
|
#!/usr/bin/env python
# -*- coding:utf-8 -*-
obj
=
iter
([
11
,
22
,
33
,
44
])
for
i
in
obj:
print
i
|
11. __new__ 和 __metaclass__
阅读如下代码：
|
1
2
3
4
|
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
|
class
Foo(
object
):
def
func(
self
):
print
'hello korala'
|
b).特殊方式（type类的构造函数）
|
1
2
3
4
5
6
7
|
ef func(
self
):
print
'hello korala'
Foo
=
type
(
'Foo'
,(
object
,), {
'func'
: func})
#type第一个参数：类名
#type第二个参数：当前类的基类
#type第三个参数：类的成员<span style="font-family: 宋体; font-size: 16px; color: #ff0000;"><strong> </strong></span>
|
＝＝》 类 是由 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
|
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()
|
总结：一、面向对象的三大特性 封装、继承、多态（用不到）二、python ——> 封装 两种状况：（1）多个方法共用一组变量，变量封装到对象中； （2）游戏 模板三、继承 （1）基类、派生类 （2）多继承 新式类、经典类 广度优先（规则）、深度优先 ==> 面试四、类，对象，内存 ==> 关系图五、类成员 字段：普通（对象）、静态（类） 方法：普通（对象触发）至少一个self，self=当前对象 类 ==> 类触发 只有一个cls，cls=当前类 静态 ==> 类触发 任意参数 属性：方法的变种，变成访问时跟字段类似 定义方式：@property data = property(方法名) # obj.data = 执行方法，并获取方法的返回值 新式类中的属性： @property 修改 @方法名.setter 设置 @方法名.deleter 删除六、类成员修饰符 公有 私有 以"__"开头，只能内部访问 非要访问，对象._类名__成员七、对象后面加括号执行__call__方法，类后面加括号执行__init__方法八、__dict__ 类或对象中的全部成员对象由类建立，一切事物都是对象 ==> 类也是对象对象.__dict__ 查看对象里有什么东西类.__dict__ 查看类里有什么东西九、__str__输出时会输出返回值对象转成字符串，类里找方法，并获取返回值
- 1. Python面向对象-学习笔记
- 2. Python学习笔记--面向对象
- 3. Python中面向对象（学习笔记）
- 4. Python学习笔记-面向对象篇
- 5. Python面向对象学习笔记（一）
- 6. python学习笔记14——面向对象
- 7. python学习笔记(七):面向对象编程、类
- 8. python面向对象笔记
- 9. Python 面向对象学习
- 10. Java学习笔记——面向对象
- 更多相关文章...
- • PHP 面向对象 - PHP教程
- • Lua 面向对象 - Lua 教程
- • Tomcat学习笔记（史上最全tomcat学习笔记）
- • 适用于PHP初学者的学习线路和建议
-
每一个你不满意的现在，都有一个你没有努力的曾经。
- 1. 字节跳动21届秋招运营两轮面试经验分享
- 2. Java 3 年，25K 多吗？
- 3. mysql安装部署
- 4. web前端开发中父链和子链方式实现通信
- 5. 3.1.6 spark体系之分布式计算-scala编程-scala中trait特性
- 6. dataframe2
- 7. ThinkFree在线
- 8. 在线画图
- 9. devtools热部署
- 10. 编译和链接
- 1. Python面向对象-学习笔记
- 2. Python学习笔记--面向对象
- 3. Python中面向对象（学习笔记）
- 4. Python学习笔记-面向对象篇
- 5. Python面向对象学习笔记（一）
- 6. python学习笔记14——面向对象
- 7. python学习笔记(七):面向对象编程、类
- 8. python面向对象笔记
- 9. Python 面向对象学习
- 10. Java学习笔记——面向对象