python中多重继承

除了从一个父类继承外，Python允许从多个父类继承，称为多重继承。

多重继承的继承链就不是一棵树了，它像这样：

class A(object):     def __init__(self, a):         print 'init A...'         self.a = a class B(A):     def __init__(self, a):         super(B, self).__init__(a)         print 'init B...' class C(A):     def __init__(self, a):         super(C, self).__init__(a)         print 'init C...' class D(B, C):     def __init__(self, a):         super(D, self).__init__(a)         print 'init D...'

看下图:

像这样，D 同时继承自 B 和 C，也就是 D 拥有了 A、B、C 的全部功能。多重继承通过 super()调用__init__()方法时，A 虽然被继承了两次，但__init__()只调用一次：

>>> d = D('d') init A... init C... init B... init D...

多重继承的目的是从两种继承树中分别选择并继承出子类，以便组合功能使用。

举个例子，Python的网络服务器有TCPServer、UDPServer、UnixStreamServer、UnixDatagramServer，而服务器运行模式有 多进程ForkingMixin 和 多线程ThreadingMixin两种。

要创建多进程模式的 TCPServer：

class MyTCPServer(TCPServer, ForkingMixin)     pass

要创建多线程模式的 UDPServer：

class MyUDPServer(UDPServer, ThreadingMixin):     pass

如果没有多重继承，要实现上述所有可能的组合需要 4x2=8 个子类。

python中继承一个类

如果已经定义了Person类，需要定义新的Student和Teacher类时，可以直接从Person类继承：

class Person(object):     def __init__(self, name, gender):         self.name = name         self.gender = gender

定义Student类时，只需要把额外的属性加上，例如score：

class Student(Person):     def __init__(self, name, gender, score):         super(Student, self).__init__(name, gender)         self.score = score

一定要用 super(Student, self).__init__(name, gender) 去初始化父类，否则，继承自 Person 的 Student 将没有 name 和 gender。

函数super(Student, self)将返回当前类继承的父类，即 Person ，然后调用__init__()方法，注意self参数已在super()中传入，在__init__()中将隐式传递，不需要写出（也不能写）。

python中定义类方法

和属性类似，方法也分实例方法和类方法。

在class中定义的全部是实例方法，实例方法第一个参数 self 是实例本身。

要在class中定义类方法，需要这么写：

class Person(object):     count = 0     @classmethod     def how_many(cls):         return cls.count     def __init__(self, name):         self.name = name         Person.count = Person.count + 1 print Person.how_many() p1 = Person('Bob') print Person.how_many()

通过标记一个 @classmethod，该方法将绑定到 Person 类上，而非类的实例。类方法的第一个参数将传入类本身，通常将参数名命名为 cls，上面的 cls.count 实际上相当于 Person.count。

因为是在类上调用，而非实例上调用，因此类方法无法获得任何实例变量，只能获得类的引用。

python中定义实例方法

一个实例的私有属性就是以__开头的属性，无法被外部访问，那这些属性定义有什么用？

虽然私有属性无法从外部访问，但是，从类的内部是可以访问的。除了可以定义实例的属性外，还可以定义实例的方法。

实例的方法就是在类中定义的函数，它的第一个参数永远是 self，指向调用该方法的实例本身，其他参数和一个普通函数是完全一样的：

class Person(object):     def __init__(self, name):         self.__name = name     def get_name(self):         return self.__name

get_name(self) 就是一个实例方法，它的第一个参数是self。__init__(self, name)其实也可看做是一个特殊的实例方法。

调用实例方法必须在实例上调用：

p1 = Person('Bob') print p1.get_name()  # self不需要显式传入 # => Bob

在实例方法内部，可以访问所有实例属性，这样，如果外部需要访问私有属性，可以通过方法调用获得，这种数据封装的形式除了能保护内部数据一致性外，还可以简化外部调用的难度。

python中创建类属性

类是模板，而实例则是根据类创建的对象。

绑定在一个实例上的属性不会影响其他实例，但是，类本身也是一个对象，如果在类上绑定一个属性，则所有实例都可以访问类的属性，并且，所有实例访问的类属性都是同一个！也就是说，实例属性每个实例各自拥有，互相独立，而类属性有且只有一份。

定义类属性可以直接在 class 中定义：

class Person(object):     address = 'Earth'     def __init__(self, name):         self.name = name

因为类属性是直接绑定在类上的，所以，访问类属性不需要创建实例，就可以直接访问：

print Person.address # => Earth

对一个实例调用类的属性也是可以访问的，所有实例都可以访问到它所属的类的属性：

p1 = Person('Bob') p2 = Person('Alice') print p1.address # => Earth print p2.address # => Earth

高阶函数：可以接收参数为函数的函数就是高阶函数

变量可以指向函数

def log(f):
    def fn(*args, **kw):
        print 'call ' + f.__name__ + '()...'
        return f(*args, **kw)
    return fn

@log
def factorial(n):
    return reduce(lambda x,y: x*y, range(1, n+1))
print factorial(10)

在父类的限制属性基础上添加：

    __slots__ = ( 'score',)

要让 @log 自适应任何参数定义的函数，可以利用Python的 *args 和 **kw，保证任意个数的参数总是能正常调用：

def log(f):
    def fn(*args, **kw):
        print 'call ' + f.__name__ + '()...'
        return f(*args, **kw)
    return fn

现在，对于任意函数，@log 都能正常工作。

斐波那契数列

def __init__(self, num):

        a,b,L=0,1,[]

        for n in range(num):

            L.append(a)

            a,b=b,a+b

        self.numbers=L

def __cmp__(self, s):

        if self.score==s.score:

            return cmp(self.name,s.name)

        return -cmp(self.score,s.score)

__repr__

python class read

import json

class Students(object):

    def read(self):

        return r'["Tim", "Bob", "Alice"]'

s = Students()

print json.load(s)

闭包不可以引用循环变量,所以再包一层,将他的变量变成从上一层的函数中传递过来的. 然后上层函数返回闭包;

最终在外面调用上层函数,返回值就是闭包  

def count():

    fs = []

    for i in range(1, 4):

        def f(j):

            def g():

                return j*j

            return g

        r = f(i)

        fs.append(r)

    return fs