一 又见函数

1 python中的函数式

要点：

①函数式编程以函数为中心进行代码封装。

②函数是第一级对象，能像普通对象一样使用。

③函数式编程强调了函数的纯粹性。一个纯函数是没有副作用的，即这个函数的运行不会影响其他函数。

2 纯函数

为了达到纯函数的标准，函数式编程要求其变量都是不可变更的。

纯函数相互独立，我们不用担心函数调用对其他函数的影响。

纯函数也方便进行并行化运算。

函数式编程消灭了副作用，即无形中消除了竞跑条件的可能。

上面的两个函数中使用了关键字global. global说明了x是一个全局变量。函数对全局变量的修改能被其他函数看到，因此有副作用。如果两个进程并行地执行两个函数，函数执行顺序不确定，则结果可能是double()中地x=x*2先执行。这被称为竞跑条件，是并行编程需要极力避免地。

3 并行运算

并行运算，是指多条指令同时执行。

大规模并行运算通常是在有多个主机组成地集群(Cluster）上进行地。而单机地处理器按照“分时复用”地方式，通过进程间地切换，也能造成多个进程齐头并进地效果。

下面是一个多进程编程的例子：

4 多进程与多线程的区别

一个程序运行后，就成为一个进程。进程有自己的内存空间。但在一个进程内部，又可以有多个称为“线程”的任务。处理器可以i在多个线程之间切换，从而形成并行的多线程处理。但线程之间可以共享一个进程的内存空间。

---

二 被解放的函数

1 函数作为参数

函数可以像一个普通对象一样使用，成为其他函数的参数：

函数argument_demo()的第一个参数f就是一个函数对象，按照位置传参。

1.2 函数传参经常能起到回调（callback）的作用

2 函数作为返回值

既然函数是一个对象，那么它就可以成为另一个函数的返回结果

2.2 函数对象的作用域

和函数内部的对象一样，函数对象也有存活范围，也就是函数对象的作用域。函数对象的作用域与它的def的缩进层级相同

3 闭包

一个函数和它的环境变量（外部变量）何在一起，就构成了一个 闭包 （closure）。

在Python中 所谓的闭包是一个包含有环境变量取值的函数对象，环境变量取值被赋值到函数对象的__closure__属性中。如：

闭包可以提高代码的可复用性：

如果将上面的程序改为闭包，那么代码就会简单很多：

除了复用代码，闭包还能起到减少函数参数的作用：

三 装饰器

1 装饰器的基础用法

装饰器（decorator)是一种高级的Python语法。装饰器可以对一个函数、方法或者类进行加工。除此之外，装饰器还进一步用于类。

先定义两个简单的数学函数：

拥有了基本的数学功能后，我们像外函数增加其他功能：

除此之外，我们可以改用装饰器，定义功能拓展本身，再把装饰器用于两个函数：

从本质上看，装饰器起到的作用就是名称绑定（name bingding)，让同一个变量名指向一个新返回的函数对象，从而达到修改函数对象的目的。但我们很少彻底地修改函数对象，在使用装饰器时，我们往往会在新函数内部调用旧地函数，以便保留就函数地功能。

下面来看一个更有实用功能的装饰器。我们可以利用time包来测量程序的运行时间：

2 带参装饰器

在上面的装饰器调用中，我们常常默认它后面的函数时唯一的参数，但其他我们可以加上别的参数。比如@decorator(a)。这样九尾装饰器的编写和使用提供了更大的灵活性。

3 装饰类

装饰器还拓展到了类。一个装饰器可以接收一个类，并返回一个类，从而起到加工类的效果。

四 高阶函数

所谓高阶函数，就是能处理函数的函数。

1 lambda 与 map

除了def后还可以用 lambda语法来定义匿名函数：

>>>lambda_sum+lambdax,y:x+y #参数为x,y 返回值为x+y

print(lambda_sum(3,4)

函数map()是内置函数，它第一个参数就是函数对象。函数map()把这一个函数对象作用域多个元素，第二个参数是一个可循环对象，对于data_list每个元素，lambda函数都会调用一次，

data_list=[1,3,5,6]

result=map(lambdax: x+3,datallist)

上面的lambda函数只有一个参数，这个函数也可以是一个多参数的函数，这时候map()的参数列表就需要提供相应数目的可循环对象：

2 filter函数

内置函数filter（）的第一个参数也是一个函数对象，它也将这个函数对象作用于可循环对象的多个元素，如果函数对象返回的是True，则该次元素被放到返回的迭代器中，也就是说filter（）通过调用函数来筛选数据。

一个例子

3 reduce函数

函数reduce（）在标准库的functools中，使用之前需要引入。reduce函数的第一个参数是函数，但你reduce（）对作为参数的函数对象有一个特殊的要求：就是这个作为参数的函数必须能接收两个参数。Reduce（）可以把函数对象累进的作用于各个参数

4 并行处理

下面的程序就是在多进程的条件下使用了多线程map（）方法，这段程序多线程地下载同一个URL下地资源。程序使用了第三方包requests来进行HTTP下载：

import time

from multiprocessing import Poll

import requests

def decorator_timer(old_function): 

      def new_function(*arg,**dict__arg):

      t1=time.time()

      result=old_function(*arg,**dict_arg):

      t2=time.time()

      print("time:",t2-t1)

      return result

return new_function

def visit_once(1,address="http://www.cnblogs.com"):

       r=requests.get(address)

        return r.status_code

@decorator_timer

def single_thread(f,counts):

      result=map(f,range(counts))

      return list(result)

@decorator_timer

def multiple_thread(f,counts,process_number=10):

        P=Pool(process_number)

       return p.map(f,range(counts))

if __name__=="__main__":

        TOTAL=100

        print(single_thread(visit_once,TOTAL))

        print(multiple_thread(visit_once,TOTAL))

五 自上而下

1 便捷表达式

自动生成器：

可便捷表达为：

gen=（x for x in range (4))

列表普通表达：

便捷表达式：

l=[x**2  for x in range(10)]

2 懒惰求值

迭代器的元素是实时计算出来的，在使用该元素之前，元素并不会占据内存空间。迭代器地工作方法正是函数式编程中地懒惰求值(Lazy Evaluation)

懒惰求值可以最小化计算机要做的工作。

除了运算资源，懒惰求值还能节约内存空间。

3 itertools包

标准库中的itertools包提供了更加灵活的生成迭代器的工具。这个包中提供了很多有用的生成器。

count（5，2） #从5开始的整数迭代器，每次增加2

cycle("abc") #重复序列的元素即a,b,c,a,b,c,……

repeat(1,2) #重复1，2构成无穷迭代器

repeat（10，5） #重复10，共重复5次

chain([1,2,3],[4,5,7]) #连接两个迭代器陈给一个。1，2，3，4，5，7

product("abc",[1,2]) #多个迭代器集合的笛卡儿积，相当于嵌套循环。

所谓笛卡儿积可以得到集合元组的所有可能方式

for m,n in product("abc",[1,2]):

     print(m,n)

permutations("abc",2) #从“abc“中挑两个元素，比如ab，bc……#将所有结果排序，返回新的且带起#上面的组合区分顺序，即ab、ba都返回

combinations("abc",2) #从“abc“中挑两个元素，比如ab，bc……#将所有结果排序，返回新的且带起#上面的组合不区分顺序，即ab,ba只返回一个ab

combinations_with_replacement("abc",2) #与上面类似，#但允许两次选出的元素重复，即多了aa，bb，cc

itertools包还提供了许多有用的高阶函数：

starmap(pow,[(1,1),[2,2],[3,3]) #pow将一次作用与每个tuple

takewhile(lambda x :x<5,[1,3,6,7,1])#当函数返回True市，收集元素到迭代器，一旦函数返回False，则停止。#输出结果为1，3

dropwhile(lambda x:x<5,[1,3,6,7,1])#当函数返回False时，跳过元素，一旦函数返回True，则收集剩下的所有元素到迭代器。输出结果为6，7，1

包中提供了groupby()函数，能将一个key（）函数作用与原迭代器的各个元素，从而获得各个函数的键值。

如果有一个迭代其，包含一群人的身高，我们可以使用这样一个key()函数。如果身高大于180,返回“tall”。如果身高低于160，返回“short”中间分会“middle”。最终所有身高将分为三个迭代器，即“tall”、“short”、“middle”