什么是类和对象？
python中，一切皆为对象，比如人就是一个对象，汽车、房子都是对象。
每一个对象都有自己的属性，比如人这个对象的属性有性别、身高、年龄等等
房子的属性有房价、面积、户型等等
在python中，一个对象的特征也称为属性（attribute）。它所具有的行为也称为方法（method）
所以：对象=属性+方法
在python中，我们把具有相同属性和方法的对象归为一个类（class）
比如：人、动物、植物、建筑等等
类是对象的模板和蓝图，对象是类的实例化。类不代表具体的事物，而对象表示具体的事物。
注意：属性为对象所有，类不具有对象的属性！！！
初始化对象：
创建类时，可以定义一个特定的方法为__init__()。只要创建类的实例，就会运行该方法。可以向
__init__()方法传递参数，这样可以在实例化对象时，把属性设置为你希望的值
例如：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
|
#!/usr/bin/env python
#-*-coding:utf-8-*-
class person:
def __init__(self,name,age):
self.name = name
self.age = age
#self.__private = flag
def action(self):
return
self.name +
' 在上班'
p1 = person(
'laowang'
,50)
print p1.name
print p1.age
输出结果：
|
|
1
2
|
laowang
50
|
什么是静态字段和动态字段？
上面的self是什么？Name、Age是什么？name、age又是什么？
self是创建对象的值，也就是说它表示对象本身，在上面的例子中self就是p1，而Name、Age是对象的属性，这种属于对象的字段叫做动态字段。name、age是创建对象时需要传递的参数。
上面的例子中memo是什么？它属于类还是某一个对象？
memo属于类，这种属于类的字段通常被称为静态字段。self.xx才是属于对象的
属于类的字段，静态字段使用类名.字段名来访问，例如上例中 person.memo
动态字段使用对象名.字段名,例如上例中p1.Name、p1.Age
类能否访问动态字段？对象能否访问静态字段？
类不能访问动态字段，因为动态字段是对象的一个属性，只属于对象。对象可以访问静态字段。访问方法:对象名.静态字段名，在前面的例子中为
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
|
#!/usr/bin/env python
#-*-coding:utf-8-*-
class person:
memo =
'我是静态字段'
def __init__(self,name,age):
self.name = name
self.age = age
#self.__private = flag
def action(self):
return
self.name +
' 在上班'
p1 = person(
'laowang'
,50)
print person.memo
|
输出结果：
|
1
|
我是静态字段
|
注意：为了避免歧义，尽量避免对象访问静态字段
什么是静态方法和动态方法？
在最开始，我们说过
对象=属性+方法
那么什么是方法？
方法就是对象的一个行为，在python中方法就是一个函数，它可以被对象所调用，对象调用方法的可以这样写：对象名.方法名，
例如：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
#!/usr/bin/env python
#-*-coding:utf-8-*-
class person:
def __init__(self,name,age):
self.name = name
self.age = age
#self.__private = flag
def action(self):
return
self.name +
' 在上班'
p1 = person(
'laowang'
,50)
print p1.action()
|
输出结果：
|
1
|
laowang 在上班
|
上例中action(self)这种带有参数的方法叫动态方法，动态方法只能被对象访问，而不能被类访问。
有了动态方法则也有静态方法，那么如果定义一个静态方法？
定义一个静态方法，有两个要求：
1、需要在动态方法上加一个装饰器“@staticmethod”
2、去掉self，因为静态方法属于类，而self属于对象
创建静态方法：
|
1
2
3
|
@staticmethod
def foo():
print
'这是一个静态方法'
|
|
1
2
3
4
5
6
7
8
9
10
11
12
13
|
class person:
# #静态字段
# memo = '众多物种之一'
# #__init__函数用来对类进行实例化
def __init__(self,name,age,male):
pass
#静态方法
@staticmethod
def static():
return
"这是一个静态方法"
print person.static()
|
输出结果：
|
1
|
这是一个静态方法
|
总结：静态方法和动态方法的区别
静态方法能被类和对象访问，而动态方法只能被对象访问。静态方法需要@staticmethod装饰器修饰，并且不带有self
什么是特性（property）？
特性是字段和方法之外的一个定义，他不同于字段和方法，通常用来返回值，特性能被对象调用，
调用方法：对象名.方法名 注意方法名后面没有括号
如果定义一个特性？
在动态方法上加一个装饰器@property
例如：
|
1
2
3
|
@property
def bar(self):
return
self.Name
|
class person: # #静态字段 # memo = '众多物种之一' # #__init__函数用来对类进行实例化 def __init__(self,name,age,male): #动态字段 self.Name=name self.Age=age self.__male = male #动态方法 # def action(self): # return self.Name + '正在上班' #静态方法 @staticmethod def static(): return "这是一个静态方法" #特性 @property def Bar(self): return self.Name
静态方法什么情况下使用？
场景：假设我们需要操作数据库，会执行增删改查动作,每一个动作就是一个方法，如果使用动态方法，那么每一次查询需要创建一个对象，每一次修改需要创建一个对象，如果使用静态方法，则不需要创建多个对象了。因为静态方法可以使用类.静态方法来访问。
其实静态方法和一个普通的函数没有什么区别。用的也并不多。Python是一个模块化的语言，为了面向对象编程，才弄出一个和其他语言一样的静态方法出来。这是历史遗留问题。
私有字段和私有方法
如何定义私有字段？
定义私有字段时，使用self.__name = name的方式，即在字段名前面加两个下划线。
私有字段能够被对象访问？
默认情况下，私有字段不能直接被对象访问。
例如：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
|
#!/usr/bin/env python
#-*-coding:utf-8-*-
class person:
memo =
'我是静态字段'
def __init__(self,name,age,flag):
self.name = name
self.age = age
#私有字段
self.__heigtht = flag
def action(self):
return
self.name +
' 在上班'
p1 = person(
'laowang'
,50,True)
#print p1.name
print p1.__height
|
输出结果：
|
1
2
3
4
|
Traceback (most recent call last):
File
"C:/Users/zenge/PycharmProjects/2/day4/.py"
, line 17,
in
<module>
print p1.__height
AttributeError: person instance has no attribute
'__height'
|
如何使私有字段被对象访问？
私有字段只有被定义到方法中，并return出来然后使用对象.方法的方式才能访问
还是上面的例子，我们修改下
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
|
#!/usr/bin/env python
#-*-coding:utf-8-*-
class person:
memo =
'我是静态字段'
def __init__(self,name,age,flag):
self.name = name
self.age = age
#私有字段
self.__heigtht = flag
def action(self):
return
self.name +
' 在上班'
def show(self):
return
self.__heigtht
p1 = person(
'laowang'
,50,True)
#print p1.name
print p1.show()
|
输出结果：
|
1
|
True
|
所以，要访问私有字段，必须将私有字段定义成一个访问，并return这个字段。
我们还可以使用@property来获取私有字段
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
|
#!/usr/bin/env python
#-*-coding:utf-8-*-
class person:
memo =
'我是静态字段'
def __init__(self,name,age,flag):
self.name = name
self.age = age
#私有字段
self.__heigtht = flag
def action(self):
return
self.name +
' 在上班'
def show(self):
return
self.__heigtht
@property
def foo(self):
return
self.__heigtht
p1 = person(
'laowang'
,50,True)
#print p1.name
print p1.foo
|
输出结果：
|
1
|
True
|
私有方法
如何定义一个私有方法？
在方法名前面加加两个下划线即可。
私有方法能否直接被对象访问呢？
看下面的例子
|
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 person:
memo =
'我是静态字段'
def __init__(self,name,age,flag):
self.name = name
self.age = age
#私有字段
self.__heigtht = flag
def action(self):
return
self.name +
' 在上班'
def show(self):
return
self.__heigtht
#私有方法
def __sha(self):
return
'我是私有方法'
p1 = person(
'laowang'
,50,True)
#print p1.name
print p1.__sha()
|
输出结果：
|
1
2
3
4
|
Traceback (most recent call last):
File
"C:/Users/zenge/PycharmProjects/2/day4/.py"
, line 25,
in
<module>
print p1.sha()
AttributeError: person instance has no attribute
'__sha'
|
如何使私有方法被对象访问?
我们可以通过定义一个公有方法，在这个公有方法中return私有方法，这样对象就可以使用对象.方法的方式访问私有方法啦
例如：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
|
#!/usr/bin/env python
#-*-coding:utf-8-*-
class person:
memo =
'我是静态字段'
def __init__(self,name,age,flag):
self.name = name
self.age = age
#私有字段
self.__heigtht = flag
def action(self):
return
self.name +
' 在上班'
def show(self):
return
self.__heigtht
#私有方法
def __sha(self):
return
'我是私有方法'
def public(self):
return
self.__heigtht
p1 = person(
'laowang'
,50,True)
#print p1.name
print p1.public()
|
输出结果
|
1
|
True
|
私有字段和私有方法什么情况下使用？
私有字段和私有方法是不能被外部调用的，只有在你定义的类里面被调用，所以如果你不想某个方法或者字段被外部调用时，就可以使用私有方法和私有方法，例如你写的接口的中的账号密码等字段。
前面有介绍如何调用私有字段和私有方法，但是不建议这个做，
如何修改私有字段？
前面介绍了私有字段默认不能被访问，但是可以通过@property特性来使私有字段被访问，那么私有字段如何能被修改呢？
要修改私有字段，需要对返回私有字段的函数添加装饰器。并且在类名后面加（object）
例如
|
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
|
#!/usr/bin/env python
#-*-coding:utf-8-*-
class person(object):
memo =
'我是静态字段'
def __init__(self,name,age,flag):
self.name = name
self.age = age
#私有字段
self.__height = flag
def action(self):
return
self.name +
' 在上班'
def show(self):
return
self.__height
#只读私有字段
@property
def foo(self):
return
self.__height
#修改私有字段，需要加参数
@foo.setter
def foo(self,value):
self.__height = value
p1 = person(
'laowang'
,50,True)
print p1.foo
p1.foo = False
print p1.foo
|
输出结果
|
1
2
|
True
False
|
