Python面向对象–进阶原文
一、类的成员
类的成员可以分为三大类：字段、方法和属性。
注：所有成员中，只有普通字段的内容保存对象中，即：根据此类创建了多少对象，在内存中就有多少个普通字段。而其他的成员，则都是保存在类中，即：无论对象的多少，在内存中只创建一份
字段
字段包括：普通字段和静态字段，他们在定义和使用中有所区别，而最本质的区别是内存中保存的位置不同，普通字段属于对象，静态字段属于类。
class Province:
#静态字段---->属于类
country = '中国'
def __init__(self,name):
#普通字段
self.name = name
#直接访问普通字段
henan = Province('河南')
print(henan.name)#河南
tianjin = Province('天津')
print(tianjin.name)#天津
obj = Province('四川')
print(obj.country,obj.name)#中国 四川
#直接访问静态字段
print(Province.country)
由上述代码可以看出**【普通字段需要通过对象来访问】【静态字段通过类访问】**，在使用上可以看出普通字段和静态字段的归属是不同的。其在内容的存储方式类似如下图：
由上图可是：
静态字段在内存中只保存一份
普通字段在每个对象中都要保存一份
应用场景： 通过类创建对象时，如果每个对象都具有相同的字段，那么就使用静态字段
方法
方法包括：普通方法、静态方法和类方法，三种方法在内存中都归属于类，区别在于调用方式不同。
普通方法：由对象调用；至少一个self参数；执行普通方法时，自动将调用该方法的对象赋值给self；
类方法：由类调用； 至少一个cls参数；执行类方法时，自动将调用该方法的类复制给cls；
静态方法：由类调用；无默认参数；
class Foo:
#普通方法
def bar(self):
#self是对象
print('bar')
#静态方法
@staticmethod
def fun():
print('123')
@staticmethod
def sta(n,m):
print("%s--%s" % (n,m))
#类方法
@classmethod
def classmd(cls):
#cls 是类名
print(cls)
print('classmd')
#普通方法的调用
obj = Foo()
obj.bar()#bar
obj = Foo()
Foo.bar(obj)#bar
#静态方法的调用
Foo.fun()#123
Foo.sta('hs','yy')#hs--yy
#类方法的调用
Foo.classmd()#<class '__main__.Foo'>
#classmd
相同点：对于所有的方法而言，均属于类（非对象）中，所以，在内存中也只保存一份。
不同点：方法调用者不同、调用方法时自动传入的参数不同。
属性
如果你已经了解Python类中的方法，那么属性就非常简单了，因为Python中的属性其实是普通方法的变种。
对于属性，有三个知识点：属性的基本使用、属性的两种定义方式。
1、属性的基本使用
# ############### 定义 ###############
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中没有属性，方法完全可以代替其功能。
'''
利用属性是实现分页
'''
class Pergination:
def __init__(self,current_page):
try:
p = int(current_page)
except Exception as e:
p = 1
self.page = p
@property
def start(self):
val = (self.page - 1) * 10
return val
@property
def end(self):
val = self.page * 10
return val
li = []
for i in range(1000):
li.append(i)
while True:
p = input('请输入要查看的页码：') #每页显示10条
obj = Pergination(p)
print(li[obj.start:obj.end])
从上述可见，Python的属性的功能是：属性内部进行一系列的逻辑计算，最终将计算结果返回。
2、属性的两种定义方式
属性的定义有两种方式：
装饰器 即：在方法上应用装饰器
静态字段 即：在类中定义值为property对象的静态字段
注意：但是在Python2.x中，默认都是经典类，只有显式继承了object才是新式类；Python 3.x中默认都是新式类,经典类被移除，不必显式的继承object
装饰器方式：在类的普通方法上应用@property装饰器
经典类，具有一种@property装饰器
# ############### 定义 ###############
class Goods:
@property
def price(self):
return "hongsong"
# ############### 调用 ###############
obj = Goods()
result = obj.price # 自动执行 @property 修饰的 price 方法，并获取方法的返回值
新式类，具有三种@property装饰器
# ############### 定义 ###############
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修饰的方法
静态字段方式，创建值为property对象的静态字段
class Foo:
def f1(self):
return 123
def f2(self,val):
print(val)
def f3(self):
print('del')
per = property(fget=f1,fset=f2,fdel=f3)
'''上面这种写法等同于'''
# @property
# def f1(self):
# return 123
# @f2.setter
# def f2(self,val):
# print(val)
# @f3.deleter
# def f3(self):
# print('del')
obj = Foo()
obj.per # 自动调用第一个参数中定义的方法：f1
obj.per = "hs" # 自动调用第二个参数中定义的方法：f2方法，并将“hs”当作参数传入
del Foo.ber # 自动调用第三个参数中定义的方法：f3方法
所以，定义属性共有两种方式，分别是【装饰器】和【静态字段】，而【装饰器】方式针对经典类和新式类又有所不同。
二、类成员的修饰符
对于每一个类的成员而言都有两种形式：公有成员，在任何地方都能访问；私有成员，只有在类的内部才能方法。
私有成员和公有成员的定义不同：私有成员命名时，前两个字符是下划线。（特殊成员除外，例如：init、call、__dict__等）
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() # 派生类中可以访问
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() # 派生类中可以访问 ==> 错误
普通字段
公有普通字段：对象可以访问；类内部可以访问；派生类中可以访问
私有普通字段：仅类内部可以访问；
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() # 派生类中访问
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() # 派生类中访问 ==> 错误
方法、属性的访问于上述方式相似，即：私有成员只能在类内部使用
三、类的特殊成员
Python的类成员中也存在着一些具有特殊含义的成员。
1. __doc__:表示类的描述信息
class Foo:
""" 描述类信息"""
def func(self):
pass
print (Foo.__doc__)
#输出：描述类信息
2. __module__ 和 __class__
__module__ 表示当前操作的对象在那个模块
__class__ 表示当前操作的对象的类是什么
class C:
def __init__(self):
self.name = 'hongsong'
---------------------------------------------
from test import C
obj = C()
print(obj.__module__) #输出 test，即：输出模块
print(obj.__class__) # 输出 <class 'test.C'>，即：输出类
3. __init__:构造方法，通过类创建对象时，自动触发执行。
class Foo:
def __init__(self, name):
self.name = name
self.age = 18
obj = Foo('yangyang') # 自动执行类中的 __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__:类或对象中的所有成员
上文中我们知道：类的普通字段属于对象；类中的静态字段和方法等属于类。
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__)
#输出：{'__module__': '__main__', 'country': 'China', '__init__': <function Province.__init__ at 0x000002240CFFA840>, 'func': <function Province.func at 0x000002240CFFABF8>, '__dict__': <attribute '__dict__' of 'Province' objects>, '__weakref__': <attribute '__weakref__' of 'Province' objects>, '__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__方法，那么在打印对象时，默认输出该方法的返回值。
class Foo:
def __str__(self):
return 'yy'
obj = Foo()
print(obj)
# 输出：yy
8、__getitem__、__setitem__、__delitem__：用于索引操作，如字典。以上分别表示获取、设置、删除数据
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'] = 'wupeiqi' # 自动触发执行 __setitem__
del obj['k1']
输出：
__getitem__ k1
__setitem__ k2 wupeiqi
__delitem__ k1
9、__getslice__、__setslice__、__delslice__：该三个方法用于分片操作，如：列表
10. __iter__ ：用于迭代器，之所以列表、字典、元组可以进行for循环，是因为类型内部定义了 __iter__
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
22
33
44
补充：type()廖雪峰官方网站
class Hello(object):
def hello(self, name='world'):
print('Hello, %s.' % name)
h = Hello()
h.hello()#Hello, world.
print(type(Hello))#<class 'type'>
print(type(h))#<class '__main__.Hello'>
type()函数可以查看一个类型或变量的类型，Hello是一个class，它的类型就是type，而h是一个实例，它的类型就是class Hello。class的定义是运行时动态创建的，而创建class的方法就是使用type()函数。
type()函数既可以返回一个对象的类型，又可以创建出新的类型，比如，我们可以通过type()函数创建出Hello类，而无需通过class Hello(object)…的定义：
def fn(self, name='world'): # 先定义函数
print('Hello, %s.' % name)
Hello = type('Hello', (object,), dict(hello=fn)) # 创建Hello class
h = Hello()
h.hello()#Hello, world.
print(type(Hello))#<class 'type'>
print(type(h))#<class '__main__.Hello'>
要创建一个class对象，type()函数依次传入3个参数：
1、class的名称；
2、继承的父类集合，注意Python支持多重继承，如果只有一个父类，别忘了tuple的单元素写法；
3、class的方法名称与函数绑定，这里我们把函数fn绑定到方法名hello上。
通过type()函数创建的类和直接写class是完全一样的，因为Python解释器遇到class定义时，仅仅是扫描一下class定义的语法，然后调用type()函数创建出class。
正常情况下，我们都用class Xxx…来定义类，但是，type()函数也允许我们动态创建出类来，也就是说，动态语言本身支持运行期动态创建类，这和静态语言有非常大的不同，要在静态语言运行期创建类，必须构造源代码字符串再调用编译器，或者借助一些工具生成字节码实现，本质上都是动态编译，会非常复杂。
metaclass
除了使用type()动态创建类以外，要控制类的创建行为，还可以使用metaclass。metaclass，直译为元类，简单的解释就是：
当我们定义了类以后，就可以根据这个类创建出实例，所以：先定义类，然后创建实例。但是如果我们想创建出类呢？那就必须根据metaclass创建出类，所以：先定义metaclass，然后创建类。连接起来就是：先定义metaclass，就可以创建类，最后创建实例。所以，metaclass允许你创建类或者修改类。换句话说，你可以把类看成是metaclass创建出来的“实例”。
**
定义ListMetaclass，按照默认习惯，metaclass的类名总是以Metaclass结尾，以便清楚地表示这是一个metaclass：
# metaclass是类的模板，所以必须从`type`类型派生：
class ListMetaclass(type):
def __new__(cls, name, bases, attrs):
attrs['add'] = lambda self, value: self.append(value)
return type.__new__(cls, name, bases, attrs)
有了ListMetaclass，我们在定义类的时候还要指示使用ListMetaclass来定制类，传入关键字参数metaclass：
class MyList(list, metaclass=ListMetaclass):
pass
当我们传入关键字参数metaclass时，魔术就生效了，它指示Python解释器在创建MyList时，要通过ListMetaclass.new()来创建，在此，我们可以修改类的定义，比如，加上新的方法，然后，返回修改后的定义。
new()方法接收到的参数依次是：当前准备创建的类的对象；类的名字；类继承的父类集合；类的方法集合。
测试一下MyList是否可以调用add()方法：
L = MyList()
L.add(1)
print(L)#输出：[1]
而普通的list没有add()方法。
动态修改有什么意义？直接在MyList定义中写上add()方法不是更简单吗？正常情况下，确实应该直接写，通过metaclass修改纯属变态。
但是，总会遇到需要通过metaclass修改类定义的。ORM就是一个典型的例子。
ORM全称“Object Relational Mapping”，即对象-关系映射，就是把关系数据库的一行映射为一个对象，也就是一个类对应一个表，这样，写代码更简单，不用直接操作SQL语句。
要编写一个ORM框架，所有的类都只能动态定义，因为只有使用者才能根据表的结构定义出对应的类来。
让我们来尝试编写一个ORM框架。
编写底层模块的第一步，就是先把调用接口写出来。比如，使用者如果使用这个ORM框架，想定义一个User类来操作对应的数据库表User，我们期待他写出这样的代码：
class User(Model):
# 定义类的属性到列的映射：
id = IntegerField('id')
name = StringField('username')
email = StringField('email')
password = StringField('password')
# 创建一个实例：
u = User(id=12345, name='Michael', email='[email protected]', password='my-pwd')
# 保存到数据库：
u.save()
其中，父类Model和属性类型StringField、IntegerField是由ORM框架提供的，剩下的魔术方法比如save()全部由metaclass自动完成。虽然metaclass的编写会比较复杂，但ORM的使用者用起来却异常简单。
现在，我们就按上面的接口来实现该ORM。首先来定义Field类，它负责保存数据库表的字段名和字段类型：
在Field的基础上，进一步定义各种类型的Field，比如StringField，IntegerField等等：
class Field(object):
def __init__(self, name, column_type):
self.name = name
self.column_type = column_type
def __str__(self):
return '<%s:%s>' % (self.__class__.__name__, self.name)
class StringField(Field):
def __init__(self, name):
super(StringField, self).__init__(name, 'varchar(100)')
class IntegerField(Field):
def __init__(self, name):
super(IntegerField, self).__init__(name, 'bigint')
下一步，就是编写最复杂的ModelMetaclass了：
class ModelMetaclass(type):
def __new__(cls, name, bases, attrs):
if name=='Model':
return type.__new__(cls, name, bases, attrs)
print('Found model: %s' % name)
mappings = dict()
for k, v in attrs.items():
if isinstance(v, Field):
print('Found mapping: %s ==> %s' % (k, v))
mappings[k] = v
for k in mappings.keys():
attrs.pop(k)
attrs['__mappings__'] = mappings # 保存属性和列的映射关系
attrs['__table__'] = name # 假设表名和类名一致
return type.__new__(cls, name, bases, attrs)
以及基类Model：
class Model(dict, metaclass=ModelMetaclass):
def __init__(self, **kw):
super(Model, self).__init__(**kw)
def __getattr__(self, key):
try:
return self[key]
except KeyError:
raise AttributeError(r"'Model' object has no attribute '%s'" % key)
def __setattr__(self, key, value):
self[key] = value
def save(self):
fields = []
params = []
args = []
for k, v in self.__mappings__.items():
fields.append(v.name)
params.append('?')
args.append(getattr(self, k, None))
sql = 'insert into %s (%s) values (%s)' % (self.__table__, ','.join(fields), ','.join(params))
print('SQL: %s' % sql)
print('ARGS: %s' % str(args))
当用户定义一个class User(Model)时，Python解释器首先在当前类User的定义中查找metaclass，如果没有找到，就继续在父类Model中查找metaclass，找到了，就使用Model中定义的metaclass的ModelMetaclass来创建User类，也就是说，metaclass可以隐式地继承到子类，但子类自己却感觉不到。
在ModelMetaclass中，一共做了几件事情：
排除掉对Model类的修改；
在当前类（比如User）中查找定义的类的所有属性，如果找到一个Field属性，就把它保存到一个__mappings__的dict中，同时从类属性中删除该Field属性，否则，容易造成运行时错误（实例的属性会遮盖类的同名属性）；
把表名保存到__table__中，这里简化为表名默认为类名。
在Model类中，就可以定义各种操作数据库的方法，比如save()，delete()，find()，update等等。
我们实现了save()方法，把一个实例保存到数据库中。因为有表名，属性到字段的映射和属性值的集合，就可以构造出INSERT语句。