如果一个属性由双下划线开头(__)，该属性就无法被外部访问。

class Person(object):
    def __init__(self, name):
        self.name = name
        self._title = 'Mr'
        self.__job = 'Student'

AttributeError: 'Person' object has no attribute '__job'

class Person(object):

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

        self.name = name

        self.gender = gender

        self.birth = birth   

        for k,v in kw.iteritems():

            setattr(self, k, v) #self.k = v

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

import time    #调用函数参数

def performance(f):    #定义装饰器函数

    def fn(*args,**kw):    #定义接收任何参数的子函数

        t1=time.time()    #获取当前电脑时间

        r=f(*args,**kw)   #传入并运行factorial()函数

        t2=time.time()    #获取当前电脑时间

        print 'call %s() in %fs' % (f.__name__,(t2-t1))

#%s表示该位置应填入字符串，%f表示该位置应填入浮点型数字（即包含小数尾数的数字），()和s没任何意义（还是()和s），(f.__name__,(t2-t1))以元组形式表示需要填入的字符串(本处f.__name__=factorial)和浮点型数字

        return r    #返回执行factorial()函数后的值

    return fn    #返回子函数fn

@performance    #定义装饰器

def factorial(n):   #定义原函数factorial()

    return reduce(lambda x,y: x*y, range(1, n+1))    #以匿名函数定义原函数运算规则和返回值

print factorial(10)    #此时的factorial经过装饰器@performance包装，已经是performance(factorial)，该命令等价于 print performance(factorial)(10)

#输出fn()运算结果：1、给出装饰器添加的部分：call factorial() in 0.0000s；2、给出原函数factorial(10)元算结果，3628800

倒序

def reversed_cmp(x, y):
    if x > y:
        return -1
    if x < y:
        return 1
    return 0

正序

def cmp(x, y):
    if x < y:
        return -1
    if x > y:
        return 1
    return 0

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
f1, f2, f3 = count()
print f1(), f2(), f3()

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

reduce()对list的每个元素反复调用函数f，并返回最终结果值。

sorted(集合名，排序方法)

定义类class Person(object):

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

这种行为称为多态。也就是说，方法调用将作用在 x 的实际类型上。s 是Student类型，它实际上拥有自己的 whoAmI()方法以及从 Person继承的 whoAmI方法，但调用 s.whoAmI()总是先查找它自身的定义，如果没有定义，则顺着继承链向上查找，直到在某个父类中找到为止。

由于Python是动态语言，所以，传递给函数 who_am_i(x)的参数x 不一定是 Person 或 Person 的子类型。任何数据类型的实例都可以，只要它有一个whoAmI()的方法即可：

class Book(object):
    def whoAmI(self):
        return 'I am a book'

这是动态语言和静态语言（例如Java）最大的差别之一。动态语言调用实例方法，不检查类型，只要方法存在，参数正确，就可以调用。

如果已经定义了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__()中将隐式传递，不需要写出（也不能写）。

functools.partial可以把一个参数多的函数变成一个参数少的新函数，少的参数需要在创建时指定默认值

int()函数还提供额外的base参数，默认值为10。如果传入base参数，就可以做 N 进制的转换

带参数的log函数首先返回一个decorator函数，再让这个decorator函数接收my_func并返回新函数：
def log(prefix):
    def log_decorator(f):
        def wrapper(*args, **kw):
            print '[%s] %s()...' % (prefix, f.__name__)
            return f(*args, **kw)
        return wrapper
    return log_decorator

a if b else c
相当于三元运算符：
当b成立时，返回a，b不成立时返回c