class Student(object):

    def __init__(self, name, score):

        self.name = name

        self.score = score

    def __str__(self):

        return '(%s: %s)' % (self.name, self.score)

    __repr__ = __str__

    def __cmp__(self, s):

        if self.score > s.score:

            return -1

        elif self.score < s.score:

            return 1

        else:

            if self.name < s.name:

                return -1

            elif self.name > s.name:

                return 1

            else:

                return 0

L = [Student('Tim', 99), Student('Bob', 88), Student('Alice', 99)]

print sorted(L)

import time, functools

def performance(unit):

    def performance_decorator(f):

        @functools.wraps(f)

        def fn(*args, **kw):

            print 'call ' + f.__name__ + '() in' + time.asctime(time.localtime(time.time()) ) + unit

            return f(*args, **kw)

        return fn

    return performance_decorator

@performance('ms')

def factorial(n):

    return reduce(lambda x,y: x*y, range(1, n+1))

print factorial.__name__

class Person(object):

    def __init__(self,name,gender,birth,**kw):

        self.name = name

        self.gender = gender

        self.birth = birth

        setattr(self,kw.items()[0][0],kw.items()[0][1])

xiaoming = Person('Xiao Ming', 'Male', '1990-1-1', job='Student')

print xiaoming.name

print xiaoming.job

make

函数isinstance()可以判断一个变量的类型，既可以用在Python内置的数据类型如str、list、dict，也可以用在我们自定义的类，它们本质上都是数据类型。

一定要用 super(Student, self).__init__(name, gender) 去初始化父类

属性有类属性和实例对象属性，当定义一个类时就有了类属性，当创建一个实例对象时，会拷贝一份类属性给实例对象，即实例对象属性

类属性和实例对象属性都分为私有属性和公有属性

类的私有属性通过类方法调用
类的公有属性通过类方法调用，或者直接 类名.属性

实例对象的私有属性通过实例方法调用，
实例对象的公有属性通过实例方法调用，或者 实例名.属性

偏函数

1：使用片函数functooils.partial(f,base = ...)保证f这个函数是已经定义了默认参数的。错。

2：print int ('12345',base = 8)和print int ('12345',8)结果是一样的。

3：片函数的作用是给一个已经定义好的函数，设置其某些参数的默认值，以便在调用的时候，减少传递参数的数量。

4：语法

newf = functools.partial(f,设置默认参数的值)

完善decorator

1：functools.wraps(f)

2：带参数的decorator，要完善的话@functools.wraps(f)依旧是放在和返回原函数的函数那里

def f(x):
    return x*x
print map(f, [1, 2, 3, 4, 5, 6, 7, 8, 9])

表示将list中每一个元素平方后输出一个新list

map()是 Python 内置的高阶函数，它接收一个函数 f 和一个 list，并通过把函数 f 依次作用在 list 的每个元素上，得到一个新的 list 并返回。

无参数的decorator

1：一个装饰函数（最外层的）在其内部在定义一个和被装饰函数接收参数相同的函数，在内部定义的这个函数，第一个作用是增加额外的功能（可称为装饰功能），第二个作用是执行被装饰的函数（可称为原有功能，保证被装饰后原函数执行结果）最后将内部定义的这个函数返回再复制给原函数。

2：可以利用Python的 *args 和 **kw，保证任意个数的参数总是能正常调用

装饰器

1：装饰器的作用是增强函数的功能，不能改变函数元本的执行结果

2：@log的意思是定义好了log函数后，将原函数作为参数传入log函数体，并返回一个新函数，再把原来的函数名指向返回的这个新函数。

3：装饰器函数定义过程

    1.有一个原函数f1,现在想给f1增加新的功能

        def f1(x):

             return x * x

    2.定义一个新的装饰函数f2,接收一个函数作为参数在其内部再定义一个与f1类似（接收的参数的数据类型以及个数相同）的函数f3

       在f3内部有两部分，第一部分是在中提到的要增加的功能；第二部分是返回f1的执行结果（不能改变原函数）

      之后在f2内返回f3

            def f2(f):

                 def f3(x):

                     print 'call ...'

                     return f(x)

               return f3

       3.调用f2，得到返回值，再将返回值赋值给f1。这样f1就增加了新功能，并且执行结果没变。

           f1 = f2(f1)

4：简化语法

       例子入3中，

      @f2

       def f1(x):

            return x * x

直接把 lambda 函数赋值给 self.get_grade 和绑定方法有所不同，函数调用不需要传入 self，但是方法调用需要传入 self

p1.get_grade = types.MethodType(fn_get_grade, p1, Person)