python advanced programming ( I )

函数式编程

---

函数是Python内建支持的一种封装，通过把大段代码拆成函数，通过一层一层的函数调用，就可以把复杂任务分解成简单的任务，这种分解可以称之为面向过程的程序设计。函数就是面向过程的程序设计的基本单元。

函数式编程就是一种抽象程度很高的编程范式，纯函数式编程语言编写的函数没有变量。由于Python允许使用变量，因此Python不是纯函数式编程语言。函数式编程的一个特点就是 ，允许把函数本身作为参数传入另一个函数，还允许返回一个函数。

变量可以指向函数：>>> abs(-10) 10√   abs×   >>> x = abs(-10) >>> x 10√   >>> f = abs×   >>>f = abs >>>f(-10) 10√
    函数名也是变量：函数名其实就是指向函数的变量，可以指向其他对象但用原先函数指向作废。

高阶函数：函数能传入别的函数作为参数。
    map()：接收两个参数，一个是函数一个是Iterable，将传入的函数依次作用到序列的每个元素，并把结果作为新的Iterator返回.list(map(str, [1, 2, 3, 4, 5, 6, 7, 8, 9]))

reduce():接收两个参数，把一个函数作用在一个序列[x1, x2, x3, ...]上，依次作用把结果继续和下一个元素做累积计算，在functools模块中。reduce(f, [x1, x2, x3, x4]) = f(f(f(x1, x2), x3) x4)

filter()：用于过滤序列，接收一个函数和一个序列，把传入的函数依次作用于每个元素，然后根据返回值是True还是False决定保留还是丢弃该元素。list(filter(is_odd, [1, 2, 4, 5])) list(filter(not_empty, ['A', '', 'B', None, 'C', ' ']))

sorted()：可以对list排序，字符串按照ASCII的大小比较。还可以接收一个key函数来实现自定义的排序 >>> sorted([36, 5, -12, 9, -21], key=abs)

返回函数：把函数作为结果值返回。
    def lazy_sum(*args):
        def sum():
            ax = 0
            for n in args:
                ax = ax + n
            return ax
    return sum
调用lazy_sum()时，返回的并不是求和结果，而是求和函数：>>> f = lazy_sum(1, 3, 5, 7, 9) >>> f
调用函数f时，才真正计算求和的结果：>>> f(1, 3, 5, 7, 9) 25
调用lazy_sum()时，每次调用都会返回一个新的函数，使得调用结果互不影响。
在这个例子中函数lazy_sum中又定义了函数sum，并且内部函数sum可以引用外部函数lazy_sum的参数和局部变量，当lazy_sum返回函数sum时相关参数和变量都保存在返回的函数中，

这种称为“闭包（Closure）”的程序结构拥有极大的威力。
返回闭包时牢记的一点就是：返回的函数并没有立刻执行，直到调用了才执行，所以return的函数不要用后续会发生变化的变量，比如循环变量(可通过创建函数绑定循环变量当前值破例）。

匿名函数：在传入函数时，有些时候不需要显式地定义函数，直接传入匿名函数更方便。比如>>> list(map(lambda x: x * x, [1, 2, 3, 4, 5, 6, 7, 8, 9]))
关键字lambda表示匿名函数，冒号前面的x表示函数参数。
匿名函数有个限制就是只能有一个表达式。
匿名函数也是一个函数对象，也可以把匿名函数赋值给一个变量，再利用变量来调用该函数：>>> f = lambda x: x * x>>> f(5)
匿名函数也可以作为返回值返回>>>return lambda: x * x + y * y

装饰器：想要增强一个函数的功能，但又不希望修改函数的定义，这种在代码运行期间动态增加功能的方式，称之为“装饰器”（Decorator）。
>>> def now():
             print('2015-3-25') __name__属性，可以拿到函数的名字：>>> now.__name__ 'now'
想加一个打印日志的功能，decorator本质上就是一个返回函数的高阶函数。所以要定义一个能打印日志的装饰器
>>>def log(func):
            def wrapper(*args, **kw):
                  print('call %s():' % func.__name__)
                  return func(*args, **kw)
       return wrapper
装饰器需要借助@语法接受一个函数作为参数，
>>>@log
def now():
     print('2015-3-25')
这里相当于执行了语句now = log(now)，返回的wrapper()函数。原来的now()函数仍然存在，只是同名的now变量指向了新的函数。
想要自定义log的文本，decorator本身就需要传入参数，所以要编写一个返回decorator的高阶函数
>>>def log(text):
             def decorator(func):
                   def wrapper(*args, **kw):
                         print('%s %s():' % (text, func.__name__))
                   return func(*args, **kw)
             return wrapper
       return decorator
3层嵌套的decorator用法
>>>@log('execute')
       def now():
             print('2015-3-25')
这里相当于执行了语句now = log('execute')(now)，首先执行log('execute')，返回的是decorator函数，再调用返回的函数，参数是now函数，返回值最终是wrapper函数。
最后一步在最终返回函数的定义前加functools模块中的@functools.wraps(func)把原始函数的__name__等属性复制wrapper()函数中，防止有些依赖函数签名的代码执行出错。

偏函数：当函数的参数个数太多，需要简化时使用functools.partial可以创建一个新的函数，这个新函数可以固定住原函数的部分参数，从而在调用时更简单。
int()进制参数默认为10，>>> int2 = functools.partial(int, base=2)#用functools模块中的partial方法固定某些参数，创建新函数将对象转化为2进制整数。

注：

计算机（Computer）和计算（Compute）这两个概念概念。
计算机的层次上，CPU执行的是加减乘除的指令代码，以及各种条件判断和跳转指令，所以，汇编

语言是最贴近计算机的语言。计算则指数学意义上的计算，越是抽象的计算，离计算机硬件越远。
对应到编程语言，就是越低级的语言，越贴近计算机，抽象程度低，执行效率高，比如C语言；越

高级的语言，越贴近计算，抽象程度高，执行效率低，比如Lisp语言。

返回Iterator的函数，返回的属于惰性序列，所以需要用list()函数要强迫函数完成所有结果并返回list。

在面向对象（OOP）的设计模式中，decorator被称为装饰模式。OOP的装饰模式需要通过继承和组
合来实现，而Python除了能支持OOP的decorator外，直接从语法层次支持decorator。Python的

decorator可以用函数实现，也可以用类实现。