上一篇博文贴出了博主学习Python的基础知识代码，这篇博文贴出博主学习Python中的函数式编程，简单说一下，函数式编程是一种编程思想，跟函数不一样。在这里将提到很多Python的内建函数，请看以下代码；
Ps:强烈建议看过博主的《Python入门基础》后再看这篇文章下的代码，这样你会很容易看懂；
欢迎大家学习交流，有问题可以再评论中提出，因为博主也是新手菜鸟，我们可以共同学习，共同进步~
#-*- coding: utf-8 -*-
# tython中的map()函数;
# map()函数不改变原有的list，而是返回一个新的list
def f(x):
return x*x
print map(f, [1,2,3,4,5,6,7,8,9])
def format_name(s):
return s[0].upper()+s[1:].lower()
print map(format_name, ['adam','LISA','barT'])
# reduce()函数;其传入的函数f必须接收两个参数；
# reduce()对list的每个元素反复调用函数f，并返回最终结果值。
def fs(x,y):
return x+y
print reduce(fs,[1,3,5,7,9])
# 先计算两个元素：f(1,3),结果为4，
# 再把结果和第3个元素计算：f(4,5),结果为9，
# 再把结果和第4个元素计算：f(9,7),结果为16，
# 再把结果和第5个元素计算：f(16,9),结果为25，
# 没有更多的元素了，返回结果25
def prop(x,y):
return x*y
print reduce(prop, [2,4,5,7,12])
# filter()函数也是接收一个函数f和一个list作为参数，
# filter()依据判断结果自动过滤掉不符合条件的元素，返回符合条件的元素组成的新list
def is_odd(x):
return x%2 == 1
print filter(is_odd,[1,4,6,7,9,12,17])
import math
def is_sqr(x):
r = int(math.sqrt(x))
return r*r == x
print filter(is_sqr, range(1,101))
# 删除None或者空字符串功能：
def is_not_empty(s):
return s and len(s.strip())>0
print filter(is_not_empty, ['test',None,'','str',' ','END'])
# 这里说一下s.strip()用于删除s字符串中开头、结尾处的rm序列的字符；
# 当rm为空时，默认删除空白符（包括：'\n','\r','\t',''）
# 这里rm只是个变量名
a = ' 123'
print a.strip()
b = '\t\t123\r\n'
print b.strip()
c = 'abstingaaabs'
d = 'absbbtingbbabs'
e = 'absaatingbbbs'
f = 'absfbas'
rm = 'abs'
print c.strip(rm) # ting
print d.strip(rm) # ting
print e.strip(rm) # ting
print f.strip(rm) # f
# 自定义排序
print sorted([36,5,12,9,21],cmp)
# sorted()也是高阶函数，他可以接受一个比较函数来实现自定义排序；
# 比较函数的定义是传入两个待比较的元素x，y，如果x应该排在y的前面，返回-1.
# 如果x应该排在y的后面，返回1，如果x和y相等，返回0
# cmp是函数的默认参数，如果直接传cmp则是从小到大的顺序排序；
def reversed_cmp(x,y):
if x>y:
return -1
if x<y:
return 1
return 0
print sorted([36,5,12,9,21], reversed_cmp)
# sorted()也可以对字符串进行排序；
def cmp_ignore_case(s1,s2):
u1 = s1.upper()
u2 = s2.upper()
if u1>u2:
return 1
if u1<u2:
return -1
return 0
print sorted(['bob','about','Zoo','Credit'], cmp_ignore_case)
# python 返回函数
def cacl_sum(lst):
return sum(lst)
print cacl_sum([1,2,3,4,5,6]) #21 这回立马执行并返回相加的结果
def cacl_sum1(lst):
def lazy_sum():
return sum(lst)
return lazy_sum
f = cacl_sum1([1,2,3,4,5,6,])
print f() # 21 所以这样你可以控制函数什么时候执行返回结果；
def calc_prop(lst):
def lazy_prop():
def f(x,y):
return x*y
return reduce(f, lst, 1)
return lazy_prop
f = calc_prop([1,2,3,4])
print f()
# python中的闭包
def count():
fs = []
for i in range(1,4):
def f():
return i*i
fs.append(f)
return fs
f1,f2,f3 = count()
# 当count()执行的时候，返回fs中有三个函数，这三个函数所引用的变量i已经变成了3
# 由于他们三个并没有被调用，所以也并没有计算i*i的值，f1()被调用的时候，才会输出3*3，结果是9；
#因此，返回函数不要引用任何循环变量，或者后续会发生变化的变量；
# 用闭包决绝这种情况
def count():
fs = []
for i in range(1,4):
def f(j):
def g():
return j*j
return g
r=f(i)
fs.append(r)
return fs
f1,f2,f3 = count()
print f1(), f2(), f3()
# python中匿名函数,关键字lambda表示匿名函数；
# 匿名函数有个限制，只能有一个表达式，不写return，返回值就是该表达式的结果
def is_not_empty1(s):
return s and len(s.strip())>0
print filter(is_not_empty1, ['test',None,'','str',' ','END'])
# 可用匿名函数简写成：
print filter(lambda s:s and len(s.strip())>0,['test',None,'','str',' ','END'])
# decorator装饰器：在函数调用的过程中，动态的给函数添加功能，又不想改动函数本身的代码
def f1(x):
return x*2
def new_fn(f):
def fn(x): # 这是装饰器函数，既可以调用f1()函数，也打出log；
print 'call'+f.__name__+'()'
return f(x)
return fn
#调用方法：
g1 = new_fn(f1)
print g1(5)
# 也可以将装饰器函数结果直接赋值给f1，这样隐藏了原始定义f1
f1 = new_fn(f1)
print f1(5)
# 简单调用；
@new_fn
def f2(x):
return x*3
print f2(10)
# 这是一个log的定义
# python中编写无参数decorator
def log(f):
def fn(x):
print 'call'+f.__name__+'()'
return f(x)
pass
return fn
pass
@log
def factorial(n):
return reduce(lambda x,y:x*y, range(1, n+1))
pass
print factorial(10)
# 若参数不是一个的函数，调用将报错
#@log
#def add(x,y):
# return x+y
# pass
#print add(1,2)
#这是因为上方定义的log函数写死了只含一个参数的返回函数——f(x)；
def log(f):
def fn(*args,**kw):
print 'call'+f.__name__+'()'
return f(*args, **kw)
return fn
@log
def add(x,y):
return x+y
pass
print add(1,2)
# 这样对于任意函数，@log都能正常工作；
# 编写无参数decorator
import time
def performance(f):
def fn(*args,**kw):
t1 = time.time()
r = f(*args, **kw)
t2 = time.time()
print 'call %s() in %fs' %(f.__name__,(t2-t1))
return r
return fn
@performance
def factorial(n):
return reduce(lambda x,y:x*y, range(1,n+1))
print factorial(1000)
# 编写带参数decorator
def log(param):
def log_decorator(f):
def fn(*args, **kw):
print '[%s]%s()'%(param, f.__name__)
return f(*args, **kw)
pass
return fn
pass
return log_decorator
pass
# 调用
@log("INFO")
def test(x):
return x*10
pass
print test(10) # [INFO]test() # 100
# 上面@performance只能打印秒，给他传个参数，允许打印's'或'ms'
def performance(s):
def performance_decorator(f):
def fn(*args,**kw):
t1 = time.time()
r = f(*args,**kw)
t2 = time.time()
t = (t2-t1)*1000 if s == 'ms' else (t2-t1)
print 'call%s() in %f %s'% (f.__name__, t, s)
return r
pass
return fn
pass
return performance_decorator
pass
@performance('ms')
def factorial(n):
return reduce(lambda x,y:x*y, range(1,n+1))
print factorial(10)
print factorial.__name__ # fn
# 完善decorator
import functools
def performance(untils):
def perf_decorator(f):
@functools.wraps(f)
def wapper(*args, **kw):
t1 = time.time()
f(*args, **kw)
t2 = time.time()
t = (t2-t1)*1000 if untils == 'ms' else (t2-t1)
print 'call %s() in %f %s'% (f.__name__, t, untils)
return r
pass
return wapper
pass
return perf_decorator
pass
@ performance('ms')
def factorial(n):
return reduce(lambda x,y:x*y, range(1,n+1))
pass
print factorial.__name__ # factorial打印出来的函数名仍是函数本身的函数名
#而不是函数wapper，因为functools工具把原函数的必要属性‘复制’到新函数上来了
#python中的偏函数
import functools
#int(x,base)这里的base参数默认为10，如果传入base参数，我们就可以做n进制的转换
print int ('12345',8)
print int ('12345',16)
def int1(x, base=2):
return int (x, base)
pass
print int1('101100')
int2 = functools.partial(int, base=8)
print int2 ('12345')
# 排序的偏函数改造
sorted_ignore_case = functools.partial(sorted, cmp = lambda s1,s2:cmp(s1.upper(), s2.upper()))
print sorted_ignore_case(['bob', 'about', 'Zoo', 'Credit'])
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
