Python 学习笔记4 - 函数式编程 Functional Programming

函数式编程虽然也可以归结到面向过程的程序设计，但其思想更接近数学计算

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

高阶函数 Higher-order function

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

一个最简单的高阶函数：

def add(x, y, f):
    return f(x) + f(y)
    
add(-5, 6, abs)

map/reduce

Python内建了 map() 和 reduce() 函数

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

r = map(f, list(range(0,10)))

# 结果r是一个Iterator，Iterator是惰性序列，因此通过list()函数让它把整个序列都计算出来并返回一个list
list(r)

for n in r:
    print(n)

# 把这个list所有数字转为字符串
# 函数 str() 依次作用到序列的每个元素
list(map(str, [1, 2, 3, 4, 5, 6, 7, 8, 9])) ==> ['1', '2', '3', '4', '5', '6', '7', '8', '9']
  • reduce()把一个函数作用在一个序列[x1, x2, x3, ...]上，这个函数必须接收两个参数，reduce把结果继续和序列的下一个元素做累积计算，效果如下：
reduce(f, [x1, x2, x3, x4]) = f(f(f(x1, x2), x3), x4)

from functools import reduce

def g(x, y):
    return x + y

reduce(g, list(range(0,10))) ==> 45

# 把list 转换为整数
from functools import reduce

def fn(x, y):
    return x * 10 + y

reduce(fn, [1, 3, 5, 7, 9])

# 把str转换为int
from functools import reduce

def fn(x, y):
    return x * 10 + y
    
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]
    
reduce(fn, map(char2num, '13579'))



# 整理成一个str2int的函数就是：
from functools import reduce

def str2int(s):
    def fn(x, y):
        return x * 10 + y
    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]
    return reduce(fn, map(char2num, s))
    


# 用lambda函数进一步简化成：
from functools import reduce

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 str2int(s):
    return reduce(lambda x, y: x * 10 + y, map(char2num, s))

def normalize(name):
    a = ''
    for i, value in enumerate(name):
        if i == 0:
            a += value.upper()
        else:
            a += value.lower()
    return a
    

L1 = ['adam', 'LISA', 'barT']
L2 = list(map(normalize, L1))
print(L2)

from functools import reduce

def prod(L):
    def fn(x, y):
        return x * y
    return reduce(fn, L)

print('3 * 5 * 7 * 9 =', prod([3, 5, 7, 9]))

def str2float(s):
    def fn(x, y):
        return x * 10 + y
    def fx(x, y):
        return x / 10 + y
    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]
    L = s.split('.', 1)
    print(L)
    return reduce(fn, map(char2num, L[0])) + reduce(fx, map(char2num, L[1][-1::-1]))/10

print('str2float(\'123.456\')=', str2float('123.456'))

filter

filter()函数用于过滤序列

filter()也接收一个函数和一个序列，filter()把传入的函数依次作用于每个元素，然后根据返回值是True还是False决定保留还是丢弃该元素

def is_odd(n):
    return n % 2 == 1

list(filter(is_odd, [1, 2, 4, 5, 6, 9, 10, 15])) ==> [1, 5, 9, 15]

def not_empty(s):
    return s and s.strip()

list(filter(not_empty, ['A', '', 'B', None, 'C', '  '])) ==> ['A', 'B', 'C']

# 求素数

def _odd_iter():
    n = 1
    while True:
        n = n + 2
        yield n

def _not_divisible(n):
    return lambda x: x % n > 0

def primes():
    yield 2
    it = _odd_iter() # 初始序列
    while True:
        n = next(it) # 返回序列的第一个数
        yield n
        # 这里相当于 it = filter(lambda x: x % n > 0, it)
        it = filter(_not_divisible(n), it) # 构造新序列
        
for n in primes():
    if n < 1000:
        print(n)
    else:
        break

sorted

sorted([36, 5, -12, 9, -21]) ==> [-21, -12, 5, 9, 36]

sorted() 函数也是一个高阶函数，它还可以接收一个key函数来实现自定义的排序。key指定的函数将作用于list的每一个元素上，并根据key函数返回的结果进行排序

sorted([36, 5, -12, 9, -21], key=abs) => [5, 9, -12, -21, 36]

对字符串排序，是按照ASCII的大小比较的

# 忽略大小写来比较两个字符串
sorted(['bob', 'about', 'Zoo', 'Credit'], key=str.lower) ==> ['about', 'bob', 'Credit', 'Zoo']

反向排序

sorted(['bob', 'about', 'Zoo', 'Credit'], key=str.lower, reverse=True) ==> ['Zoo', 'Credit', 'bob', 'about']

L = [('Bob', 75), ('Adam', 92), ('Bart', 66), ('Lisa', 88)]

def by_name(t):
    return t[0].lower()

def by_score(t):
    return t[1]

L1 = sorted(L, key=by_name)
print(L1)
L2 = sorted(L, key=by_score)
print(L2)

返回函数

高阶函数除了可以接受函数作为参数外，还可以把函数作为结果值返回

def lazy_sum(*args):
    # 内部函数sum可以引用外部函数lazy_sum的参数和局部变量
    def sum():
        ax = 0
        for n in args:
            ax = ax + n
        return ax
    # 当lazy_sum返回函数sum时，相关参数和变量都保存在返回的函数中，这种称为“闭包（Closure）”
    return sum

f = lazy_sum(1, 3, 5, 7, 9)
f() ==> 25

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

f1, f2, f3 = count()
f1() ==> 9
f2() ==> 9
f3() ==> 9

返回闭包时牢记的一点就是：返回函数不要引用任何循环变量，或者后续会发生变化的变量。

如果一定要引用循环变量怎么办？方法是再创建一个函数，用该函数的参数绑定循环变量当前的值

def count():
    def f(j):
        def g():
            return j*j
        return g
    fs = []
    for i in range(1, 4):
        # f(i)立刻被执行，因此i的当前值被传入f()
        fs.append(f(i)) 
    return fs

匿名函数

匿名函数类似如下：

lambda x: x * x

关键字lambda表示匿名函数，冒号前面的x表示函数参数
匿名函数有个限制，就是只能有一个表达式，不用写return，返回值就是该表达式的结果

装饰器 Decorator

假设我们要增强函数的功能，但又不希望修改函数的定义，这种在代码运行期间动态增加功能的方式，称之为“装饰器”（Decorator）

本质上，decorator 就是一个返回函数的高阶函数

# 接受一个函数作为参数，并返回一个函数
def log(func):
    # wrapper()函数的参数定义是(*args, **kw)，因此，wrapper()函数可以接受任意参数的调用
    def wrapper(*args, **kw):
        print('call %s():' % func.__name__)
        return func(*args, **kw)
    return wrapper

借助Python的@语法，把decorator置于函数的定义处：

# 把@log放到now()函数的定义处，相当于执行了语句：now = log(now)
@log
def now():
    print('2015-3-25')
    
now()

如果decorator本身需要传入参数，那就需要编写一个返回decorator的高阶函数

def log(text):
    def decorator(func):
        def wrapper(*args, **kw):
            print('%s %s():' % (text, func.__name__))
            return func(*args, **kw)
        return wrapper
    return decorator

这个3层嵌套的decorator用法如下：

# 和两层嵌套的decorator相比，3层嵌套的效果是这样的：now = log('execute')(now)
# 区别：log 是函数名，log('execute') 是函数执行后的返回结果
@log('execute')
def now():
    print('2015-3-25')

now()

按以上两种 decorator 装饰之后的函数，它们的 __name__ 已经从原来的'now'变成了'wrapper'：

now.__name__ ==> 'wrapper'

Python内置的 functools.wraps 原始函数的 __name__ 等属性复制到 decorator 替换的函数中，则前面两个 decorator 的完整写法为：

import functools


def log(func):
    @functools.wraps(func)
    def wrapper(*args, **kw):
        print('call %s():' % func.__name__)
        return func(*args, **kw)
    return wrapper
    
def 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

# 支持带和不带参数的 decorator 
def log(text):
    def decorator(func):
        @functools.wraps(func)
        def wrapper(*arg,**kw):
            # 能在函数调用的前后打印出的日志
            try:
                print('begin call')
                if isinstance(text, str):
                    print('param :', text)
                return func(*arg,**kw)
            finally:
                print('end call')
        return wrapper
    
    if hasattr(text,'__call__'):
        return decorator(text)
    else:
        return decorator
    
    

@log
def f():
    print('execute f()')

@log('with param')
def g():
    print('execute g()')
    

f()
g()

偏函数 Partial function

Python 的 functools 模块提供了很多有用的功能，其中一个就是偏函数

Python 的偏函数和数学意义上的偏函数不一样

functools.partial 的作用就是，把一个函数的某些参数给固定住（也就是设置默认值），返回一个新的函数

import functools

int2 = functools.partial(int, base=2)

int2('1000000') ==> 64

# 这里仅仅是把base参数重新设定默认值为2，但也可以在函数调用时传入其他值
int2('1000000', base=10) ==> 1000000

# 创建偏函数时，实际上可以接收函数对象、*args和**kw这3个参数
int2 = functools.partial(int, base=2)

# 相当于
kw = { 'base': 2 }
int('10010', **kw)


# 因此，当传入
max2 = functools.partial(max, 10)
# 实际上会把10作为*args的一部分自动加到左边，也就是
max2(5, 6, 7)
# 相当于
args = (10, 5, 6, 7)
max(*args) ==> 10
最后编辑于 ：
©著作权归作者所有,转载或内容合作请联系作者
  • 人面猴
    序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
    沈念sama阅读 215,923评论 6赞 498
  • 死咒
    序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
    沈念sama阅读 92,154评论 3赞 392
  • 救了他两次的神仙让他今天三更去死
    文/潘晓璐 我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
    开封第一讲书人阅读 161,775评论 0赞 351
  • 道士缉凶录：失踪的卖姜人
    文/不坏的土叔 我叫张陵，是天一观的道长。 经常有香客问我，道长，这世上最难降的妖魔是什么？ 我笑而不...
    开封第一讲书人阅读 57,960评论 1赞 290
  • 港岛之恋（遗憾婚礼）
    正文 为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
    茶点故事阅读 66,976评论 6赞 388
  • 恶毒庶女顶嫁案：这布局不是一般人想出来的
    文/花漫 我一把揭开白布。 她就那样静静地躺着，像睡着了一般。 火红的嫁衣衬着肌肤如雪。 梳的纹丝不乱的头发上，一...
    开封第一讲书人阅读 50,972评论 1赞 295
  • 城市分裂传说
    那天，我揣着相机与录音，去河边找鬼。 笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。 我是一名探鬼主播，决...
    沈念sama阅读 39,893评论 3赞 416
  • 双鸳鸯连环套：你想象不到人心有多黑
    文/苍兰香墨 我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
    开封第一讲书人阅读 38,709评论 0赞 271
  • 万荣杀人案实录
    序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
    沈念sama阅读 45,159评论 1赞 308
  • 护林员之死
    正文 独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋 以下内容为张勋视角 年9月15日...
    茶点故事阅读 37,400评论 2赞 331
  • 白月光启示录
    正文 我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。 大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
    茶点故事阅读 39,552评论 1赞 346
  • 活死人
    序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
    沈念sama阅读 35,265评论 5赞 341
  • 日本核电站爆炸内幕
    正文 年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
    茶点故事阅读 40,876评论 3赞 325
  • 男人毒药：我在死后第九天来索命
    文/蒙蒙 一、第九天 我趴在偏房一处隐蔽的房顶上张望。 院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
    开封第一讲书人阅读 31,528评论 0赞 21
  • 一桩弑父案，背后竟有这般阴谋
    文/苍兰香墨 我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。 一阵脚步声响...
    开封第一讲书人阅读 32,701评论 1赞 268
  • 情欲美人皮
    我被黑心中介骗来泰国打工， 没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。 一个月前我还...
    沈念sama阅读 47,552评论 2赞 368
  • 代替公主和亲
    正文 我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。 传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
    茶点故事阅读 44,451评论 2赞 352

推荐阅读更多精彩内容

  • Python学习笔记[2]
    要点： 函数式编程：注意不是“函数编程”，多了一个“式” 模块：如何使用模块 面向对象编程：面向对象的概念、属性、...
    victorsungo阅读 1,495评论 0赞 6
  • Python函数式编程
    函数式编程就是一种抽象程度很高的编程范式，纯粹的函数式编程语言编写的函数没有变量，因此，任意一个函数，只要输入是确...
    齐天大圣李圣杰阅读 1,528评论 0赞 2
  • Python 进阶篇之函数式编程
    函数式编程 把函数作为参数 在2.1小节中，我们讲了高阶函数的概念，并编写了一个简单的高阶函数： 如果传入abs作...
    绩重KF阅读 561评论 0赞 0
  • Python进阶
    Python进阶框架 希望大家喜欢，点赞哦首先感谢廖雪峰老师对于该课程的讲解 一、函数式编程 1.1 函数式编程简...
    Gaolex阅读 5,497评论 6赞 53
  • 【转载】深入浅出 Python 函数式编程
    https://my.oschina.net/leejun2005/blog/503562 深入浅出 Python...
    点点渔火阅读 1,001评论 0赞 1