| 类成员 | 注释 |
|---|---|
| 字段 | - |
| 静态字段 | 每个对象数据相同 |
| 普通字段 | 每个对象数据不同 |
| 方法 | - |
| 静态方法 | @staticmethod，只能使用类来调用，无需实例化对象 |
| 类方法 | @classmethod，被调用时会自动传入“类名”参数 |
| 普通方法 | 使用对象中的数据 |
| 属性 | - |
| 普通属性 | 用于将方法伪造成字段 |
一般来说，有self就通过对象调用，无self就通过类来调用
一、字段
- 普通字段，属于对象，普通字段在每个对象中都要保存一份。
- 静态字段，属于类，在内存中只保存一份。
class Provice:
country = "China" # 静态字段，建议使用类来调用
def __init__(self, name):
temp = "xxx"
self.name = name # 普通字段，存在对象中
def show(self):
print('show') # 普通方法，存在类中
hebei = Provice("河北")
henan = Provice("河南")
print(hebei.country) #China
二、方法
- 普通方法，存在类中，建议使用对象调用。
- 静态方法，没有self，使用类来调用，无需实例化对象。
- 类方法，建议使用类调用，类方法在被调用时会自动在它的参数中传入类名（Provice）。
注：所有的方法，均属于类（非对象）中，所以，在内存中也只保存一份。
# 对象类成员
class Provice:
country = "China"
def __init__(self, name):
self.name = name
def show(self): #普通方法
print('show')
@staticmethod
def xo(): #静态方法
print('xo')
@classmethod #类方法
def xxoo(cls):
print('xxoo',cls)
hebei = Provice("河北")
print(Provice.country) # China
Provice.xo()
Provice.xxoo()
三、属性
可以把方法伪造成字段，普通字段通过“对象.字段”来获取，可以修改字段的值。那么属性同样可以获取和修改，只是实现方法不太一样。
属性的定义和调用要注意一下几点：
- 定义时，在普通方法的基础上添加 @property 装饰器；
- 定义时，属性仅有一个self参数
- 调用时，无需括号：
（a）方法：foo_obj.func()
（b）属性：foo_obj.prop
(1) 装饰器方式定义属性
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 # 删除商品原价
(2) 使用静态字段的方式创建属性
property的构造方法中有个四个参数：
第一个参数是方法名，调用“对象.属性”时自动触发执行方法
第二个参数是方法名，调用“对象.属性 ＝ XXX”时自动触发执行方法
第三个参数是方法名，调用“del 对象.属性”时自动触发执行方法
第四个参数是字符串，调用”对象.属性.doc” ，此参数是该属性的描述信息
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 # 获取商品价格，自动调用get_price方法
obj.PRICE = 200 # 修改商品原价，自动调用set_price方法
del obj.PRICE # 删除商品原价，自动调用del_price方法
四、成员修饰符
对于每一个类的成员而言都有两种形式：
- 公有成员，在任何地方都能访问
- 私有成员，只有在类的内部才能方法（但是可以间接调用）
默认情况下，python类的成员属性与方法都是“public”。python的“访问控制符”可以限定成员函数的访问。
- 双下划线(__)，在类里可见。
- 单下划线(_)，在模块内可见。还可以防止模块的属性用“from mymodule import *”来加载
class C:
def __init__(self):
self.name = '公有字段'
self.__foo = "私有字段"
私有静态字段：
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) _doc_
class Foo:
""" 描述类信息，这是用于看片的神奇 """
def func(self):
pass
print Foo.__doc__
#输出：类的描述信息
(2) _module_ 和 _class_
__module__表示当前操作的对象在那个模块
__class__表示当前操作的对象的类是 什么
#lib/aa.py
class C:
def __init__(self):
self.name = 'morra'
#test.py
from lib.aa import C
obj = C()
print obj.__module__ #lib.aa，即：输出模块
print obj.__class__ #lib.aa.C，即：输出类
(3) _init_
构造方法，通过类创建对象时，自动触发执行。
class Foo:
def __init__(self, name):
self.name = name
self.age = 18
obj = Foo('wupeiqi') # 自动执行类中的 __init__ 方法
(4) _del_
析构方法，当对象在内存中被释放时，自动触发执行。
注：此方法一般无须定义，因为Python是一门高级语言，程序员在使用时无需关心内存的分配和释放，因为此工作都是交给Python解释器来执行，所以，析构函数的调用是由解释器在进行垃圾回收时自动触发执行的。
class Foo:
def __del__(self):
pass
(5) _call_
对象后面加括号，触发执行。
注：构造方法的执行是由创建对象触发的，即：对象 = 类名() ；而对于 call 方法的执行是由对象后加括号触发的，即：对象() 或者 类()()
class Foo:
def __init__(self):
pass
def __call__(self, *args, **kwargs):
print '__call__'
obj = Foo() # 执行 __init__
obj() # 执行 __call__
(6) _dict_
获取类或对象中的所有成员，在自定义form框架的时候用的比较多。
class Foo:
"""我是类的注释"""
def __init__(self):
self.name = 'morra'
obj = Foo()
print(obj.__dict__) #{'name': 'morra'}，
for k,v in Foo.__dict__.items():
print(k,v)
#------------
#__doc__ 我是类的注释
#__init__ <function Foo.__init__ at 0x10197ba60>
#__dict__ <attribute '__dict__' of 'Foo' objects>
#__module__ __main__
#__#weakref__ <attribute '__weakref__' of 'Foo' objects>
(7) _str_
如果一个类中定义了__str__方法，那么在打印 对象 时，默认输出该方法的返回值。
class Foo:
def __init__(self,name):
self.name= name
def __str__(self):
return "我是对象的输出结果"
obj = Foo('morra')
print(obj) #执行print(obj)或者str(obj)的时候，会自动执行__str__
(8) _getitem_、_setitem_、_delitem_
class Foo:
def __init__(self):
print('init')
def __getitem__(self, item):
print(item)
def __setitem__(self, key, value):
print(key,value)
def __delitem__(self, key):
print(key)
r['xx'] #对象后加[]会直接执行__getitem__
r['xxx']=123 #自动执行__setitem__
del r['aaaa'] #自动执行__delitem__
r[1:3] #做切片操作的时候还是会执行__getitem__方法，python会自动把1:3封装成一个对象传入__getitem__
r[1:3]=123 #执行__setitem__
del[1:3]=456 #执行__delitem__
(9) _iter_
class Foo:
def __init__(self):
self.name = 'morra'
def __iter__(self):
yield 1
yield 2
yield 3
obj = Foo()
for i in obj: # 执行for循环的时候，会自动执行对象的__iter__方法
print(i)
(10) _metaclass_
class Foo(object):
def __init__(self):
pass
obj = Foo() # obj是通过Foo类实例化的对象
上述代码中，obj 是通过 Foo 类实例化的对象，其实，不仅 obj 是一个对象，Foo类本身也是一个对象，因为在Python中一切事物都是对象。
如果按照一切事物都是对象的理论：obj对象是通过执行Foo类的构造方法创建，那么Foo类对象应该也是通过执行某个类的 构造方法 创建。
print type(obj) # 输出：<class '__main__.Foo'> 表示，obj 对象由Foo类创建
print type(Foo) # 输出：<type 'type'> 表示，Foo类对象由 type 类创建
所以，obj对象是Foo类的一个实例，Foo类对象是 type 类的一个实例，即：Foo类对象 是通过type类的构造方法创建。
那么，创建类就可以有两种方式：
(a). 普通方式
class Foo(object):
def func(self):
print 'hello wupeiqi'
(b).特殊方式（type类的构造函数）
def func(self):
print 'hello wupeiqi'
Foo = type('Foo',(object,), {'func': func})
#type第一个参数：类名
#type第二个参数：当前类的基类
#type第三个参数：类的成员
类是由type类实例化产生的。
那么问题来了，类默认是由type类实例化产生，type类中如何实现的创建类？类又是如何创建对象？
答：类中有一个属性_metaclass_，其用来表示该类由谁来实例化创建，所以，我们可以为__metaclass__设置一个type类的派生类，从而查看类创建的过程。
