闭包：内层函数引用了外层函数的变量，返回内层函
数的情况，称为闭包（closure）
特点：确保引用的局部变量在函数返回后不能变
不然在引用函数时就会出现问题。
解决办法：返回函数不要饮用任何循环变量，或是会
发生变化的变量。

返回函数：在函数f内部再定义一个函数g，g指向函数
g的变量。
返回函数是返回一个函数，返回值是函数调用的结果，
是一个数值。
将计算延迟执行，定义一个新函数返回结果，但原函数
返回的是新函数，若要获得结果就要调用新函数。

sorted函数：对list进行排序，接收一个比较函数
list在前面。
如果 x 应该排在 y 的前面，返回 -1，如果 x 应该排在 y 的后面，返回 1。
如果 x 和 y 相等，返回 0。
对于字符串：按照ASCII大小比较
排在前面字码小，大写字母字码比小写字母小

filter函数：一个f和一个list
filter对每个元素进行判断，然后根据判断结果自动
过滤掉不符合条件的元素组成新的list

reduce函数：一个函数f，一个list
函数f必须接收两个参数，然后返回最终结果值
reduce函数还可以接收第三个可选参数作为初始值

map函数：接收一个函数f和一个list，并把f作用在
list的每一个元素上，返回新的list。（不改变原来
的list）
传入的list可以包含任意类型的元素，只需f能够处理
这种数据。

变量可以指向函数，并且可以调用
函数名（与普通变量没有区别）就是指向函数的变量
高阶函数：能接收函数做参数的函数（变量名可以指向函数）

在Python中，函数其实是一个对象：>>> f = abs
>>> f.__name__
'abs'
>>> f(-123)
123
由于 f 可以被调用，所以，f 被称为可调用对象。所有的函数都是可调用对象。一个类实例也可以变成一个可调用对象，只需要实现一个特殊方法__call__()。我们把 Person 类变成一个可调用对象：class Person(object):    def __init__(self, name, gender):        self.name = name        self.gender = gender    def __call__(self, friend):        print 'My name is %s...' % self.name        print 'My friend is %s...' % friend现在可以对 Person 实例直接调用：>>> p = Person('Bob', 'male')>>> p('Tim')My name is Bob...My friend is Tim...单看 p('Tim') 你无法确定 p 是一个函数还是一个类实例，所以，在Python中，函数也是对象，对象和函数的区别并不显著

由于Python是动态语言，任何实例在运行期都可以动态地添加属性。如果要限制添加的属性，例如，Student类只允许添加 name、gender和score 这3个属性，就可以利用Python的一个特殊的__slots__来实现。顾名思义，__slots__是指一个类允许的属性列表：class Student(object):    __slots__ = ('name', 'gender', 'score')    def __init__(self, name, gender, score):        self.name = name        self.gender = gender        self.score = score现在，对实例进行操作：>>> s = Student('Bob', 'male', 59)>>> s.name = 'Tim' # OK>>> s.score = 99 # OK>>> s.grade = 'A'Traceback (most recent call last):  ...AttributeError: 'Student' object has no attribute 'grade'__slots__的目的是限制当前类所能拥有的属性，如果不需要添加任意动态的属性，使用__slots__也能节省内存。

python中 @property考察 Student 类：class Student(object):     def __init__(self, name, score):         self.name = name         self.score = score当我们想要修改一个 Student 的 scroe 属性时，可以这么写：s = Student('Bob', 59) s.score = 60但是也可以这么写：s.score = 1000显然，直接给属性赋值无法检查分数的有效性。如果利用两个方法：class Student(object):     def __init__(self, name, score):         self.name = name         self.__score = score     def get_score(self):         return self.__score     def set_score(self, score):         if score < 0 or score > 100:             raise ValueError('invalid score')         self.__score = score这样一来，s.set_score(1000) 就会报错。这种使用 get/set 方法来封装对一个属性的访问在许多面向对象编程的语言中都很常见。但是写 s.get_score() 和 s.set_score() 没有直接写 s.score 来得直接。有没有两全其美的方法？----有。因为Python支持高阶函数，在函数式编程中我们介绍了装饰器函数，可以用装饰器函数把 get/set 方法“装饰”成属性调用：class Student(object):     def __init__(self, name, score):         self.name = name         self.__score = score     @property     def score(self):         return self.__score     @score.setter     def score(self, score):         if score < 0 or score > 100:             raise ValueError('invalid score')         self.__score = score注意: 第一个score(self)是get方法，用@property装饰，第二个score(self, score)是set方法，用@score.setter装饰，@score.setter是前一个@property装饰后的副产品。现在，就可以像使用属性一样设置score了：>>> s = Student('Bob', 59) >>> s.score = 60 >>> print s.score 60 >>> s.score = 1000 Traceback (most recent call last):   ... ValueError: invalid score说明对 score 赋值实际调用的是 set方法。

方法1：
直接修改原函数。

方法2：

通通过高阶函数返回新函数。

@new fn

def f1(x):
    return x*2

==

def f1(x):
    return x*2

f1=new fn

python中reduce()函数

reduce()函数也是Python内置的一个高阶函数。reduce()函数接收的参数和 map()类似，一个函数 f，一个list，但行为和 map()不同，reduce()传入的函数 f 必须接收两个参数，reduce()对list的每个元素反复调用函数f，并返回最终结果值。

例如，编写一个f函数，接收x和y，返回x和y的和：

def f(x, y):     return x + y

s[0].upper() + s[1:].lower() 首字母大写，后续字母小写

upper()-字母变成大写
lower()-字母变成小写