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())))