程序博客网 > 淘宝促销海报

Python学习笔记（四）--函数式编程

来源：互联网 发布：淘宝促销海报 编辑：程序博客网 时间：2024/05/17 05:06

Functional Programming：函数是Python内建支持的一种封装，我们通过把大段代码拆成函数，通过一层一层的函数调用，就可以把复杂任务分解成简单的任务，这种分解可以称之为面向过程的程序设计。函数就是面向过程的程序设计的基本单元。

函数式编程就是一种抽象程度很高的编程范式，纯粹的函数式编程语言编写的函数没有变量，因此，任意一个函数，只要输入是确定的，输出就是确定的，这种纯函数我们称之为没有副作用。而允许使用变量的程序设计语言，由于函数内部的变量状态不确定，同样的输入，可能得到不同的输出，因此，这种函数是有副作用的。

函数式编程的一个特点就是，允许把函数本身作为参数传入另一个函数，还允许返回一个函数！

Python对函数式编程提供部分支持。由于Python允许使用变量，因此，Python不是纯函数式编程语言。


一、高阶函数

函数本身也可以赋值给变量，即：变量可以指向函数。

函数名其实就是指向函数的变量

注：由于abs函数实际上是定义在import builtins模块中的，所以要让修改abs变量的指向在其它模块也生效，要用import builtins; builtins.abs = 10。

一个函数就可以接收另一个函数作为参数，这种函数就称之为高阶函数。

1、map()

map()函数接收两个参数，一个是函数，一个是Iterable。map将传入的函数依次作用到序列的每个元素，并把结果作为新的Iterator返回。

def add(x, y, f):    return f(x)+f(y)print(add(5,-6,abs))def f(x):    return x*xr = map(f, [1,2,3,4,5,6,7,8,9])print(list(r)[:])


2、reduce()
reduce把一个函数作用在一个序列[x1, x2, x3, ...]上，这个函数必须接收两个参数，reduce把结果继续和序列的下一个元素做累积计算
reduce(f, [x1, x2, x3, x4]) = f(f(f(x1, x2), x3), x4)
from functools import reducedef add(x,y):    return x+ya = reduce(add,[1,3,5,7,9])print(a)
from functools import  reducedef char2num(s):    return {'0': 0, '1': 1, '2': 2, '3': 3, '4': 4, '5': 5, '6': 6, '7': 7, '8': 8, '9': 9}[s]def str2int(s):    return reduce(lambda x,y:x*10+y,map(char2num,s))a = str2int('13579')print(a)

#Test3：
# -*- coding: utf-8 -*-from functools import reducedef str2float(s):    def char2num(s):        return {'0': 0, '1': 1, '2': 2, '3': 3, '4': 4, '5': 5, '6': 6, '7': 7, '8': 8, '9': 9}[s]    def fn(x,y):        return x*10+y    n = s.index('.')    p = len(s) - n - 1    return reduce(fn, map(char2num, s[0:n]+s[n+1:]))/10**p
def str2float(s):    def char2num(m):        return {'0': 0, '1': 1, '2': 2, '3': 3, '4': 4, '5': 5, '6': 6, '7': 7, '8': 8, '9': 9, '.': '.'}[m]    def fn(x, y):        if y == '.':            return x        else:            return x*10+y    l = list(map(char2num, s))    n = l.index('.')    p = len(l) - n - 1    return reduce(fn, l)/10**p
print('str2float(\'123.456\') =', str2float('123.456'))

3、filter
Python内建的filter()函数用于过滤序列。
和map()类似，filter()也接收一个函数和一个序列。和map()不同的是，filter()把传入的函数依次作用于每个元素，然后根据返回值是True还是False决定保留还是丢弃该元素。
def is_odd(n):    return n%2 == 0a = list(filter(is_odd,[1,2,3,4,5,6,7]))print(a)
def not_empty(s):    return s and s.strip(' ')  # 默认删除whitespaceprint(list(filter(not_empty,['A',' B',None, 'C', ' '])))
def odd_iter():    n = 1    while True:        n = n + 2        yield n     # odd orderdef not_divisible(n):    return lambda x: x % n > 0def primes():    yield 2    it = odd_iter()     # odd order    while True:        m = next(it)        yield m        it = filter(not_divisible(m), it)for n in primes():    if n < 1000:        print(n)    else:        break
注意到Iterator是惰性计算的序列，所以我们可以用Python表示“全体自然数”，“全体素数”这样的序列，而代码非常简洁。
总结
filter()的作用是从一个序列中筛出符合条件的元素。由于filter()使用了惰性计算，所以只有在取filter()结果的时候，才会真正筛选并每次返回下一个筛出的元素。

4、sorted排序算法
sorted()比较两个元素的大小,比较的过程必须通过函数抽象出来。.sorted()也是一个高阶函数。用sorted()排序的关键在于实现一个映射函数。
sorted()函数也是一个高阶函数，它还可以接收一个key函数来实现自定义的排序，例如按绝对值大小排序：
sorted([36, 5, -12, 9, -21], key=abs)
key指定的函数将作用于list的每一个元素上，并根据key函数返回的结果进行排序。
然后sorted()函数按照keys进行排序，并按照对应关系返回list相应的元素：
keys排序结果 => [5, 9,  12,  21, 36]                |  |    |    |   |最终结果     => [5, 9, -12, -21, 36]
实现忽略大小写的排序：
>>> sorted(['bob', 'about', 'Zoo', 'Credit'], key=str.lower)
要进行反向排序，不必改动key函数，可以传入第三个参数reverse=True：
sorted(['bob', 'about', 'Zoo', 'Credit'], key=str.lower, reverse=True
二、返回函数
函数作为返回值：
def lazy_sum(*args):    def sum():        ax = 0        for n in args:            ax += n        return ax    return sumf = lazy_sum(1,3,5,7,9)print(f())
闭包：
返回的函数在其定义内部引用了局部变量args，所以，当一个函数返回了一个函数后，其内部的局部变量还被新函数引用。
需要注意的问题是，返回的函数并没有立刻执行，而是直到调用了f()才执行：
def count():    fs = []    for i in range(1, 4):        def f():             return i*i        fs.append(f)    return fsf1, f2, f3 = count()
>>> f1()9>>> f2()9>>> f3()9
全部都是9！原因就在于返回的函数引用了变量i，但它并非立刻执行。等到3个函数都返回时，它们所引用的变量i已经变成了3，因此最终结果为9
回闭包时牢记的一点就是：返回函数不要引用任何循环变量，或者后续会发生变化的变量。
如果一定要引用循环变量怎么办？方法是再创建一个函数，用该函数的参数绑定循环变量当前的值，无论该循环变量后续如何更改，已绑定到函数参数的值不变：
def count():    def f(j):        def g():            return j*j        return g    fs = []    for i in range(1, 4):        fs.append(f(i)) # f(i)立刻被执行，因此i的当前值被传入f()    return fs


总结：
一个函数可以返回一个计算结果，也可以返回一个函数。
返回一个函数时，牢记该函数并未执行，返回函数中不要引用任何可能会变化的变量。
三、匿名函数
在传入函数时，有些时候，不需要显式地定义函数，直接传入匿名函数更方便。
>>> list(map(lambda x: x * x, [1, 2, 3, 4, 5, 6, 7, 8, 9]))[1, 4, 9, 16, 25, 36, 49, 64, 81]
关键字lambda表示匿名函数，冒号前面的x表示函数参数。
匿名函数有个限制，就是只能有一个表达式，不用写return，返回值就是该表达式的结果。

好处：
1、因为函数没有名字，不必担心函数名冲突。
2、此外，匿名函数也是一个函数对象，也可以把匿名函数赋值给一个变量，再利用变量来调用该函数
>>> f = lambda x: x * x>>> f<function <lambda> at 0x101c6ef28>>>> f(5)25
3、也可以把匿名函数作为返回值返回，比如：
def build(x, y):    return lambda: x * x + y * y
小结
Python对匿名函数的支持有限，只有一些简单的情况下可以使用匿名函数。

四、装饰器 Decorator
定义：这种在代码运行期间动态增加功能的方式，称之为“装饰器”（Decorator）。（比如，在函数调用前后自动打印日志，但又不希望修改now()函数的定义）
由于函数也是一个对象，而且函数对象可以被赋值给变量，所以，通过变量也能调用该函数。

函数对象有一个__name__属性，可以拿到函数的名字：
>>> now.__name__'now'>>> f.__name__'now'

本质上，decorator就是一个返回函数的高阶函数
定义一个能打印日志的decorator：
# 两层嵌套
def log(func):    def wrapper(*args, **kw):        print('call %s():' % func.__name__)        return func(*args, **kw)    return wrapper
@logdef now():    print('2015-3-25')
print(now())
上面的log，因为它是一个decorator，所以接受一个函数作为参数，并返回一个函数。我们要借助Python的@语法，把decorator置于函数的定义处。
调用now()函数，不仅会运行now()函数本身，还会在运行now()函数前打印一行日志：
call now():2015-3-25
相当于执行了语句：now = log(now)
由于log()是一个decorator，返回一个函数，所以，原来的now()函数仍然存在，只是现在同名的now变量指向了新的函数，于是调用now()将执行新函数，即在log()函数中返回的wrapper()函数。
wrapper()函数的参数定义是(*args, **kw)，因此，wrapper()函数可以接受任意参数的调用。在wrapper()函数内，首先打印日志，再紧接着调用原始函数。
# 三层嵌套
def log(text):    def decorator(func):        def wrapper(*args, **kw):            print('%s %s():' % (text, func.__name__))            return func(*args, **kw)        return wrapper    return decorator
@log('execute')def now(x):    print(sum(x))print(now([1,3,5,7]))
>>>execute, now():16

3层嵌套的效果是这样的：>>>now = log('execute')(now)
但函数也是对象，它有__name__等属性，但你去看经过decorator装饰之后的函数，它们的__name__已经从原来的'now'变成了'wrapper'：
print(now.__name__)>>>wrapper
因为返回的那个wrapper()函数名字就是'wrapper'，所以，需要把原始函数的__name__等属性复制到wrapper()函数中，否则，有些依赖函数签名的代码执行就会出错。不需要编写wrapper.__name__ = func.__name__这样的代码，Python内置的functools.wraps就是干这个事的，所以，一个完整的decorator的写法如下：
import functoolsdef log(func):    @functools.wraps(func)    def wrapper(*args, **kw):        print('call %s():' % func.__name__)        return func(*args, **kw)    return wrapper
或者针对带参数的decorator：
import functoolsdef log(text):    def decorator(func):        @functools.wraps(func)        def wrapper(*args, **kw):            print('%s %s():' % (text, func.__name__))            return func(*args, **kw)        return wrapper    return decorator
import functools是导入functools模块。模块的概念稍候讲解。现在，只需记住在定义wrapper()的前面加上@functools.wraps(func)即可。
小结：
在面向对象（OOP）的设计模式中，decorator被称为装饰模式。OOP的装饰模式需要通过继承和组合来实现，而Python除了能支持OOP的decorator外，直接从语法层次支持decorator。Python的decorator可以用函数实现，也可以用类实现。
decorator可以增强函数的功能，定义起来虽然有点复杂，但使用起来非常灵活和方便。

什么情况下装饰器不适用？装饰器不能对函数的一部分应用，只能作用于整个函数。
一个变通的办法是“提取函数”，我们将这行语句提取成函数，然后对提取出来的函数应用装饰器：
def printdebug(func):    def __decorator(user):        print('enter the login')        result = func(user)        print('exit the login')        return result    return __decoratordef login(user):    print('in login:' + user)    msg = validate(user)  # exact to a method    return msg@printdebug  # apply the decorator for exacted methoddef validate(user):    msg = "success" if user == "jatsz" else "fail"    return msgresult1 = login('jatsz')print(result1)
# 有时候validate是个耗时的过程。为了提高应用的性能，我们会将validate的结果cache一段时间(30 seconds)，借助decorator和上面的方法
，我们可以这样实现：
import time
dictcache = {} def cache(func):    def __decorator(user):            now = time.time()        if (user in dictcache):            result,cache_time = dictcache[user]            if (now - cache_time) > 30:  #cache expired, 缓存30s                result = func(user)                dictcache[user] = (result, now)  # cache the result by user            else:                  print('cache hits')        else:            result = func(user)            dictcache[user] = (result, now)        return result          return __decorator   def login(user):    print('in login:' + user)    msg = validate(user)      return msg   @cache  #apply the cache for this slow validationdef validate(user):    time.sleep(5)  #simulate 10 second block    msg = "success" if user == "jatsz" else "fail"    return msg result1 = login('jatsz'); print result1  result2 = login('jatsz'); print result2    # this login will return immediately by hit the cacheresult3 = login('candy'); print result3
>>>in login:jatszsuccessin login:jatszcache hitssuccessin login:candyfail


五、偏函数 Partial function
简单总结functools.partial的作用就是，把一个函数的某些参数给固定住（也就是设置默认值），返回一个新的函数，调用这个新函数会更简单。
print(int('12345', base=8))# int()函数参数默认看作十进制，传入base参数，数看作N进制数，将其转换为十进制
# 或 print(int('12345', 8))
>>>5349

functools.partial就是帮助我们创建一个偏函数的：
import functools>>> int2 = functools.partial(int, base=2)>>> int2('1000000')64
小结
当函数的参数个数太多，需要简化时，使用functools.partial可以创建一个新的函数，这个新函数可以固定住原函数的部分参数，从而在调用时更简单
                                             
        0        0           
	
				
		









 淘宝促销海报
    		淘宝促销海报



原创粉丝点击



		

热门IT博客


阿里经典java面试题阿里经典java面试题




淘宝洗车用品大全淘宝洗车用品大全




最早电脑钢琴软件




淘宝商城床




网络监控工程师




qq游戏hd登录网络异常




adobe音频编辑软件




怎么加入淘宝充值平台




数据分析是干什么的




成都电视台网络直播




局域网ip mac扫描软件




淘宝审核部门电话




软件评测师真题2015




女士马丁靴品牌知乎




js获取表单radio




java多泛型




库里职业生涯数据




小程序域名白名单




access数据库创建表




php tp框架分页



		

热门问题
    老师的惩罚
    人脸识别
    我在镇武司摸鱼那些年
    重生之率土为王
    我在大康的咸鱼生活
    盘龙之生命进化
    天生仙种
    凡人之先天五行
    春回大明朝
    姑娘不必设防，我是瞎子
    去痣后注意事项
    泪痣千万不能去
    2018医院去痣价目
    白醋去痣
    自己动手去黑痣怎么去
    怎么去痣
    怎样自己去痣
    去痣的危害
    去痣危害
    自己去痣
    去痣后不能吃什么
    药水去痣过程痊愈图
    怎么样去痣
    如何去黑痣
    去痣挂什么科
    去痣多久可以洗脸
    去痣图片
    去痣医院
    去痣不能吃什么
    医院去痣挂什么科
    简单去肉痣小妙招
    脸上长黑痣
    去痣的方法
    脸上痣
    祛痣平瘊
    女人脸上的痣
    面部痣
    祛痣费用
    面部去痣图
    怎样可以去痣
    去脸上的痣
    面痣
    去痣吧
    除痣
    脸部去痣
    如何取痣
    如何去脸上的痣
    袪痣
    脸上黑痣怎么去除
    去痣的方法小窍门
    如何祛痣


	










程序博客网，程序员的互联网技术博客家园。csdn论坛精品 msdn技术资料都在这里