python类部分概念

参考链接: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()方式调用，是一种省略写法，由解释器填充必要参数。填充的第一个参数是当前类，第二个参数是self

isinstance

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)
100

---

getattr()、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

---

元类

具体请见：http://www.liaoxuefeng.com/wiki/0014316089557264a6b348958f449949df42a6d3a2e542c000/0014319106919344c4ef8b1e04c48778bb45796e0335839000

动态语言和静态语言最大的不同，就是函数和类的定义，不是编译时定义的，而是运行时动态创建的
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