参考链接:http://www.liaoxuefeng.com/
多重继承的写法
example 1:
class A(object):
def __init__(self, a=None, b=None, *args, **kwargs):
super().__init__(*args, **kwargs)
print('Init {} with arguments {}'.format(self.__class__.__name__, (a, b)))
class B(object):
def __init__(self, q=None, *args, **kwargs):
super().__init__(*args, **kwargs)
print('Init {} with arguments {}'.format(self.__class__.__name__, (q)))
class C(A, B):
def __init__(self):
super().__init__(a=1, b=2, q=3)
example 2:
class BenmBaseData:
def __init__(self, db_conn, *args, **kwargs):
super().__init__() # mro链中的下一个类是object的时候就不需要参数了
self._db_conn = db_conn
class BenmDateData:
def __init__(self, db_conn, *args, **kwargs): # *args, **kwargs用于接受所有参数, 本身用不到的参数在初始化mro链中的其他类的时候可能会用到
super().__init__(db_conn=db_conn, *args, **kwargs) # 要把 db_conn 也传进去, 因为mro链中的其他类可能会用到
self._db_conn = db_conn
class BenmDate(BenmDateData, BenmBaseData):
def __init__(self, db_conn): # 初始化使用的类可以不使用*args, **kwargs, 应该也可以使用
super().__init__(db_conn=db_conn) # 使用位置参数初始化, 方便父类捕获
print(BenmDate.mro()) # [<class '__main__.BenmDate'>, <class '__main__.BenmDateData'>, <class '__main__.BenmBaseData'>, <class 'object'>]
b = BenmDate(None)
super详解参见: http://www.cnblogs.com/crazyrunning/p/7095014.html
方法super([type[, object-or-type]])，返回的是对type的父类或兄弟类的代理。
如果第二个参数省略，返回的super对象是未绑定到确定的MRO上的：
如果第二个参数是对象，那么isinstance(obj, type)必须为True；
如果第二个参数是类型，那么issubclass(type2, type)必须为True，即第二个参数类型是第一个参数类型的子类。
super函数是要求有参数的，不存在无参的super函数。在类定义中以super()方式调用，是一种省略写法，由解释器填充必要参数。填充的第一个参数是当前类，第二个参数是selfisinstance
isinstance()判断的是一个对象是否是该类型本身，或者位于该类型的父继承链上。
isinstance([1, 2, 3], (list, tuple))
True类中特殊属性和方法
类似__xxx__的属性和方法在Python中都是有特殊用途的，比如__len__方法返回长度。在Python中，如果你调用len()函数试图获取一个对象的长度，实际上，在len()函数内部，它自动去调用该对象的__len__()方法
我们自己写的类，如果也想用len(myObj)的话，就自己写一个__len__()方法：
class MyDog(object):
def __len__(self):
return 100
dog = MyDog()
len(dog)
100getattr()、setattr()以及hasattr()
通过getattr()、setattr()以及hasattr()，我们可以直接操作一个对象的状态
>>hasattr(obj, 'x') # 有属性'x'吗？
True
>>obj.x
9
>>hasattr(obj, 'y') # 有属性'y'吗？
False
>>setattr(obj, 'y', 19) # 设置一个属性'y'
>>hasattr(obj, 'y') # 有属性'y'吗？
True
>>getattr(obj, 'y') # 获取属性'y'
19
>>obj.y # 获取属性'y'
19__slots__
正常情况下，当我们定义了一个class，创建了一个class的实例后，我们可以给该实例绑定任何属性和方法，这就是动态语言的灵活性
但是，如果我们想要限制实例的属性怎么办？比如，只允许对Student实例添加name和age属性
为了达到限制的目的，Python允许在定义class的时候，定义一个特殊的__slots__变量，来限制该class实例能添加的属性：
class Student(object):
__slots__ = ('name', 'age') # 用tuple定义允许绑定的属性名称
s = Student() # 创建新的实例
s.name = 'Michael' # 绑定属性'name'
s.age = 25 # 绑定属性'age'
s.score = 99 # 绑定属性'score'
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
AttributeError: 'Student' object has no attribute 'score'使用__slots__要注意，__slots__定义的属性仅对当前类实例起作用，对继承的子类是不起作用的除非在子类中也定义__slots__，这样，子类实例允许定义的属性就是自身的__slots__加上父类的__slots__
__str__ and __repr__
控制实例化类时，实例对象的值
两者的区别是__str__()返回用户看到的字符串，而__repr__()返回程序开发者看到的字符串，也就是说，__repr__()是为调试服务的
class Student(object):
def __init__(self, name):
self.name = name
def __str__(self):
return 'Student object (name=%s)' % self.name
__repr__ = __str__
>>> print(Student('Michael')) # 由__str__控制
Student object (name: Michael)
>>> Student('Michael') # 由__repr__控制
Student object (name: Michael)__iter__
如果一个类想被用于for … in循环，类似list或tuple那样，就必须实现一个__iter__()方法，该方法返回一个迭代对象，然后，Python的for循环就会不断调用该迭代对象的__next__()方法拿到循环的下一个值，直到遇到StopIteration错误时退出循环
class Fib(object):
def __init__(self):
self.a, self.b = 0, 1 # 初始化两个计数器a，b
def __iter__(self):
return self # 实例本身就是迭代对象，故返回自己
def __next__(self):
self.a, self.b = self.b, self.a + self.b # 计算下一个值
if self.a > 100000: # 退出循环的条件
raise StopIteration()
return self.a # 返回下一个值
>>> for n in Fib():
... print(n)
...
1
1
2
3
5
...
46368
75025__getitem__
__getitem__, __setitem__, __delitem__ 等方法可以是类具有list或dict的特性，但想要实现完善的话还是比较复杂，这里不做研究
__getattr__
当调用不存在的属性时，比如score，Python解释器会试图调用__getattr__(self, ‘score’)来尝试获得属性，这样，我们就有机会返回score的值
只有在没有找到属性的情况下，才调用__getattr__，已有的属性，比如name，不会在__getattr__中查找
class Student(object):
def __getattr__(self, attr):
if attr=='age':
return lambda: 25
raise AttributeError('\'Student\' object has no attribute \'%s\'' % attr)__call__
一个对象实例可以有自己的属性和方法，当我们调用实例方法时，我们用instance.method()来调用。能不能直接在实例本身上调用呢？答案是肯定的。
任何类，只需要定义一个__call__()方法，就可以直接对实例进行调用
class Student(object):
def __init__(self, name):
self.name = name
def __call__(self):
print('My name is %s.' % self.name)
>>> s = Student('Michael')
>>> s() # self参数不要传入
My name is Michael.更多的时候，我们需要判断一个对象是否能被调用，能被调用的对象就是一个Callable对象
>>> callable(max)
True
>>> callable([1, 2, 3])
False元类
动态语言和静态语言最大的不同，就是函数和类的定义，不是编译时定义的，而是运行时动态创建的
type()函数可以查看一个类型或变量的类型，Hello是一个class，它的类型就是type，而h是一个实例，它的类型就是class Hello
>>> from hello import Hello
>>> h = Hello()
>>> h.hello()
Hello, world.
>>> print(type(Hello))
<class 'type'>
>>> print(type(h))
<class 'hello.Hello'>type()函数既可以返回一个对象的类型，又可以创建出新的类型，比如，我们可以通过type()函数创建出Hello类
>>> def fn(self, name='world'): # 先定义函数
... print('Hello, %s.' % name)
...
>>> Hello = type('Hello', (object,), dict(hello=fn)) # 创建Hello class通过type()函数创建的类和直接写class是完全一样的，因为Python解释器遇到class定义时，仅仅是扫描一下class定义的语法，然后调用type()函数创建出class
