函数式编程与高阶函数

初步接触了以下几种高阶函数，还用的不是很熟练。

1、map()： 这个函数接受两个参数： ‘map(function, sequence)’ 第一个必需参数是一个编辑好的函数，第二个参数是一个序列，map()的作用是按照序列的顺序依次对元素使用function。个人理解就类似于批处理吧，比如由一大堆名字组成的序列，其中没有规范的使用大小写，那我们可以定义一个修改函数，并依次对列表元素使用。以下是廖雪峰大大布置的作业：

思路：1、用map()函数来处理列表。所以

map(func, ['aDam', 'BerT', 'JERRY'])

2、定义func函数，输入一个字符串，输出成为首字母大写，其余小写的字符串。

3、使用lower()函数，在此我遇到了一个错误，以为lower()还属于半自动化的函数，比如一个指令小写一个字母，因此我用了迭代的方法去使用这个函数：

def func(word):
     for s in word:
        return s.lower()

结果：

>>>func('Adam')
'a'

一时间没想通，后来在交互式界面中发现lower()可以直接将一整个字符串改写为小写。囧

于是修改后的函数：

def func(word):
    return word.lower()

这样就能得到全是小写的string。用map函数套用上，得到三个小写的string，想再定义一个函数，使所有字符串的首字母大写。

想到字符串也是一个列表，用string[0]可以定位到第一个字母，但是回想起之前所学的slice操作，发现可以减少不少步骤：

def func(s):
    return s[0].upper() + s[1:].lower()

于是这样就在一行里完成了这个函数。（其实这一步参考了大家的想法。。sad。。思维还是比较死板的，也反映出了基础打得不扎实）

接着套用map函数就可以完成作业了。

4、质数的判定：伪代码：

n是否是大于1 的正整数--T/F

大于1则生成2~n-1的列表a

迭代，若在a中有一个数使得n能被整除，则不是质数。

def is_prime(x):
    if type(x) != int or x <= 1:
        return False
    else:
        for n in range(2, x):
           if (x % n) == 0:
               return False
               break
        else:
            return True
        

虽然练过很多次了还是很艰难的写出来，主要是如何判断质数这里想了很久，数学也是很差=。=

继续努力吧

5、filter(func， sequence)    筛选函数， 对序列使用函数，返回true的留下返回false的抛弃

6、6、6、6、6、6、 闭包是什么鬼啊。。。。。s一头雾水，

首先：廖雪峰大大用返回值来引入：

def sum(*args):      #输入多个变量
    ax = 0
    for n in args:      #迭代输入的变量
         ax = ax + n   #依次相加求和
    return ax

这里的返回值是ax 是一个整数，代表着前面*args的总和

接下来老师说 “如果返回的是函数呢？”

def lazy_sum(*args):
    def sum():
        ax = 0
        for n in args:
             ax = ax + n
        return ax
    return sum

到这里已经开始有点迷惑了 来一步步分析：

交互式界面中调用lazy_sum(1,2,3,4,5)

返回一个函数<function ...............>

若要得到其值 要先将lazy_sum赋值给一个变量 比如F

再用F() 调用

这里就不是很懂，一点愚见“一开始定义了两个函数，所以要经过两次调用才能得出结果“ 这是初步的一种记忆的方法 接着看

#要注意的问题 返回的函数并没有立即执行，要经过F()才执行。

另一个开始不懂的例子：

def count():
     fs = []
     for i in range(1, 4):
         def f():
              return  i*i
         fs.append(f)
     return fs

f1, f2, f3 = count()

第一步 定义count()函数， 调用函数时，内部先创建一个空列表，接着生成一个从1-3的列表进行迭代

第二步 列表中取出 1 ，调用f() 返回1*1 （函数1），并将此函数添加到fs这个列表里

第三步 列表中取出 2 ，调用f() 返回2*2 （函数2），并将此函数添加到fs这个列表里

第四步 列表中………………………………………………………………………………

第五步 迭代完成 返回一个含有3个元素的列表 fs ，并且元素是函数f()

第六步 注意此时返回的函数并没有执行，要再次经过调用，而且调用的内容是i*i

第七步 注意之前的i是正在迭代的 从1 - 3 所以此时的i=3

第八步 将fs中的三个函数分别赋值给f1, f2, f3  再依次调用f()

第九步 发现结果全都是9 （3*3）

果然列出来了就是想清楚了 nice！

再来一波： 避免在返回的函数里(f())引用循环变量，或者后续会发生的变量，比如刚才的i*i

def count():
    fs = []
    for i in range(1, 4):
        def f(j):
            def g():
                return j*j
            return g
        fs.append(f(i))
    return fs

f1, f2, f3 = count()

第一步 定义count函数，函数中有一个空列表fs 生成1-3的列表。

第二部 定义f函数，参数是j ，在f函数内部定义函数g 返回j*j, 再将此函数返回f函数，此时函数f(j)返回一个函数j*j（g).

第三步 向fs列表中添加　参数是ｉ的f()， 此时j=i 代入运算返回 g1=i*i（此时i = 1） 所以g1 = 1*1

第四步 向fs列表中添加  参数是i的f()， 此时j=i 带入运算返回 g2 = i * i （此时 i=2 ）所以g2 = 2 * 2

第五步 同上

第六步 迭代完成后fs中有三个f() 分别为g1 g2 g3 要再次进行调用才能得出结果。分别赋值给f123 3个变量

第七步 运行 得到结果 不受i的影响，因为j取值是i是固定的 随后i改变时j不变 因此得以保存

弄了这么多还没有触及到闭包 囧。。。

教程说 “在外函数中定义了内函数，并且 内部函数可以引用外部函数的参数和局部变量。当外层函数返回内层函数时，相关参数和变量都保存在返回的函数（内函数）中，这种称为闭包的程序结构 巴拉巴拉” 似乎懂一点，

先拿它的作用来凑个数 [转载 来自  ] what？ 为啥连超链接和下面的url都不能用复制 我都写了转载。。