python 函数式编程

1.高阶函数 Higher-order function
能将函数作为自己参数的函数 称为高阶函数

2.map/reduce

#将func作用在  iterables  中每一个元素上，将结果用一个Iterator返回.
map(func, *iterables) --> map object

#格式化姓名，第一个字母大写，后面的都小写
def normalize(name):
    if len(name) < 3:
        return print("name is not suitable!")

    new_name = name[0].upper()
    for char in map(str.lower,name[1:]):
        new_name += char
    return new_name


from functools import reduce
reduce(function, sequence[, initial])
#将 function 作用在序列上，进行累加操作。

#求一个列表的乘积
def prod(L):
    return reduce(lambda x,y:x*y,L)


##将浮点数字符串转换为浮点数
def str2float(L):
    for i in range(len(L)):
        if L[i] == '.':
            break
    def str2int(char):
        return {'0':0,'1':1,'2':2,'3':3,'4':4,'5':5,'6':6,'7':7,'8':8,'9':9,}[char]

    int_part = reduce(lambda x,y:x*10+y,map(str2int,L[:i]))
    float_lst = list(map(str2int,L[i+1:]))
    float_part = reduce(lambda x,y:x*0.1+y,float_lst[::-1])
    return int_part + 0.1*float_part

print('str2float(\'123456789.123456789\') = %.10f' %str2float('123456789.123456789'))

3.filter() 过滤序列

#将 function 作用在  iterable  中的每一个元素上，保留  function 返回值为   true 的元素。
filter(function or None, iterable) --> filter object

#回数是指从左向右读和从右向左读都是一样的数,输出10000内的回数
def is_palindrome(num):
    num_lst = []
    while num >= 1:
        num_lst.append(num % 10)
        num = int(num/10)
    i,length = 0,len(num_lst) - 1
    while i < length and num_lst[i] == num_lst[length]:
        i += 1
        length -= 1

    if i >= length:
        return True
    else:
         return False

output = filter(is_palindrome, range(1, 10000))
print(list(output))

4.sort() 排序

sorted(iterable, key=None, reverse=False)
#首先用 key 指定的函数作用于 iterable 中的每一个元素，然后在该函数返回的序列上进行排序，参数reverse 用于指定正序或者逆序排序。

5.返回函数
在函数F内部定义函数f，并将f作为F的返回值返回，那么返回的函数 f 将在下次调用的时候运行。
注意：
a.函数内部定义的函数 f 可以使用 F 函数的参数和变量，当函数 f 作为返回值返回时，这些参数和变量都会保存在函数 f 中，这种性质称为闭包

b.每次返回的函数 f 是不同的，即使传给 f 的参数相同

c.如果 f 函数使用了函数 F 的变量，由于函数 f 在下次调用时才执行，因此，要特别注意，调用 f 前函数 f 使用的变量在函数 F 中还会发生变化的情况，这会导致多个返回的内部函数 f 得到相同的结果。

def count():
    fs = []
    def f(n):
        def f_child():
            return n * n
        return f_child#返回内部函数

    for i in range(1, 4):
        fs.append(f(i))
    return fs

f1, f2, f3 = count()
print(f1())
print(f2())
print(f3())

6.装饰器
用于调试，查看程序运行情况
使用情形：如果想知道某个程序的运行情况，一般要在具体的函数体内加上 print 等相应的函数，但是如果系统中需要检查的函数过多，总不能一直这样一直将已经写好的函数修改掉，这样增加了程序的运行风险。因此，可以这样来解决：将需要监视的函数，传入到一个用于监视函数的函数中，由此可见这个监视函数是个高阶函数。这个监视函数就可以对传入的函数的运行情况进行监视，这样做具有一般性，不用修改原来已经写好的程序了，降低了修改程序的风险。这里的监视函数就是所说的装饰器，下面来具体看一下。

#装饰器
def log(func):
    def wrapper():
        print('call %s():' % func.__name__)
        return func()
    return wrapper#记住这里是返回函数

@log
def show_time():
    print(time.strftime('%Y-%m-%d %H:%M:%S',time.localtime(time.time())))

show_time()#相当于运行了show_time = log(show_time)


#当装饰器需要传入自己的参数时可以这样做：
def log_txt(text):
    def decorator(func):
        def wrapper(*args, **kw):
            print('%s %s():' % (text, func.__name__))
            return func()
        return wrapper
    return decorator#记住这里是返回函数


#下面这两句相当于 show_time = log_txt("run")(show_time)
@log_txt("run")
def show_time_log_txt():
    print(time.strftime('%Y-%m-%d %H:%M:%S',time.localtime(time.time())))