python链式调用顺序_Python函数式介绍二 - 链式调用

上一篇文章中我们发现我们的代码越来越长了，而且都挤在一行，代码越长，越不易读。括号一层嵌一层，真的容易绕晕。我一直觉得代码要写给人看，一直追求代码即注释这种程度的简单。

那有什么办法来简化这个问题？答案在标题，链式调用。我们仿照C#LINQ的链式接口。直接上代码，这分代码是我自己写的，很简单。有兴趣可以自己研究。里面封装了我觉得比较重要的几个高阶函数。如果不够的话也可以简单地再封装一下。如下，

#文件名FT.py

from functools import reduce

from collections import Iterator

from itertools import chain,groupby,product

class From:

src=None

def __init__(self,src):

self.src=src

def toList(self):

return list(self.src)

def toSet(self):

return set(self.src)

def toTuple(self):

return tuple(self.src)

def getSource(self):

return self.src

def map(self,func):

return From(map(func,self.src))

def filter(self,predicate):

return From(filter(predicate,self.src))

def reduce(self,func,identity=None):

if identity is None:

return reduce(func,self.src)

else:

return reduce(func,self.src,identity)

def chain(self):

return From(chain.from_iterable(self.src))

def groupby(self,func=None):

return From(map(lambda it:(it[0],list(it[1])),groupby(self.src,func)))

def product(self,tag):

return From(product(self.src,tag))

def all(self,predicate):

return all(map(lambda it:predicate(it),self.src))

def any(self,predicate):

return any(map(lambda it:predicate(it),self.src))

def first(self,predicate=None):

if predicate is None:

if isinstance(self.src,Iterator):

return next(self.src)

return next(iter(self.src))

else :

return next(filter(predicate,self.src))

def firstOrNone(self,predicate=None):

try:

if predicate is None:

if isinstance(self.src,Iterator):

return next(self.src)

return next(iter(self.src))

else :

return next(filter(predicate,self.src))

except StopIteration:

return None

以上代码我写了一个From类，后面的代码会反反复复地用到这个类。

复习map/filter/reduce

例子1 ，过滤出列表中的偶数，再乘2

from FT import From

print(From((1,2,3,4))

.filter(lambda it:it % 2==0)

.map(lambda it:it*2).toList())

'''

结果:

[4,8]

'''

例子2，过滤出列表中地偶数，结果乘2，最后再求和。

from FT import From

print(From((1,2,3,4))

.filter(lambda it:it % 2==0)

.map(lambda it:it*2).reduce(lambda acc,it:acc+it))

#加幺元

print(From((1,2,3,4))

.filter(lambda it:it % 2==0)

.map(lambda it:it*2).reduce(lambda acc,it:acc+it))

'''

结果:

12

12

'''

对比上篇文章，有没有觉得清晰很多，清晰地看到数据流一步一步地往下一个函数流。这个也是函数式地特点之一。python本不提供这个流式接口，没关系，我们自己造一个，而且没有花几行代码。居然全部代码都能在一篇文章中显示出来，不过这个跟python自己动态语言有关，若换成静态语言的话那应该要花多不少功夫。下次找机会我用C++实现一遍。

下面我们学多几个高阶函数，丰富我们的武器库。

groupby

分组是一个很常见的需求，需要的代码其实也不少，封装成高阶函数后那方便太多了。请看下面的例子

testgroupdata=[{"id":1,"name":"wwb"},{"id":1,"name":"wxa"},{"id":1,"name":"wxb"},{"id":2,"name":"wxc"},{"id":2,"name":"wxd"}]

这个是数据集。是我随便造的，没什么特殊意义。

例子1，根据id分组，显示分组

print(From(testgroupdata).groupby(lambda it:it['id']).toList())

'''

结果:

[

(

1,

[

{

'id': 1,

'name': 'wwb'

},

{

'id': 1,

'name': 'wxa'

},

{

'id': 1,

'name': 'wxb'

}

]

),

(

2,

[

{

'id': 2,

'name': 'wxc'

},

{

'id': 2,

'name': 'wxd'

}

]

)

]

'''

当然groupby后可以自己接其他高阶函数，如下例子

例子2，根据id分组后，过滤出分组的KEY为偶数的数据，也就是id为偶数的数据

print(From(testgroupdata).groupby(lambda it:it['id']).filter(lambda it:it[0]%2==0).toList())

'''

结果:

[

(

2,

[

{

'id': 2,

'name': 'wxc'

},

{

'id': 2,

'name': 'wxd'

}

]

)

]

'''

笛卡尔积

笛卡儿积太重要了，数据库两种表连接或join都可以解释为笛卡儿积，看下面的例子。

例子1，观察执行结果

print(From((1,2,3)).product(('a','b','c')).toList())

现在我们考虑一个图书馆管理系统，先观察以下数据集

students = [

{

"name":"wwb",

"book":[1,2,5]

},

{

"name":"wxa",

"book":[1,2,3]

},

{

"name":"wxb",

"book":[2,3,4]

}

]

books = [

{

"id":1,

"name":"C++ Primer"

},

{

"id":2,

"name":"Effecitve C++"

},

{

"id":3,

"name":"语文"

},{

"id":4,

"name":"数学"

},

{

"id":5,

"name":"英语"

}

]

students是图书馆借了数的同学，一个人可以借多本书，其中book记录的是图书的id；books是图书馆里面的书。现在可以看例子了。

例子2，求学生具体借了什么书

print(From(students).map(lambda s:

{

"name":s["name"],

"book":From(s["book"]).product(books).filter(lambda it:it[0]==it[1]["id"])

.map(lambda it:it[1]["name"]).toList()

}).toList())

'''

结果:

[

{

'name': 'wwb',

'book': [

'C++ Primer',

'Effecitve C++',

'英语'

]

},

{

'name': 'wxa',

'book': [

'C++ Primer',

'Effecitve C++',

'语文'

]

},

{

'name': 'wxb',

'book': [

'Effecitve C++',

'语文',

'数学'

]

}

]

'''

first/firstOrNone

这两个函数简单，就是找出符合条件的第一条数据。我常常需要这样的需求。直接看例子

#找出名字为wwb的同学，找不到的话则会抛出异常

print(From(students).first(lambda it:it["name"]=="wwb"))

#找出名字为wxx的同学，找不到的话返回None

print(From(students).firstOrNone(lambda it:it["name"]=="wxx"))

'''

结果:

{'name': 'wwb', 'book': [1, 2, 5]}

None

'''

first当找不到满足条件的数据会抛异常，而firstOrNone则会返回None。很简单。

chain

今天解释最后一个函数，chain。这个是一个非常重要的函数。我自己经常叫它扁平，用来变平数据。如

((a,b,c),(d,e,f),(g,h,i)) => (a,b,c,d,e,f,g,h,i)经过chain后，你会发现括号少了一层，原来'尖'的数据现在变'平'了，因为少了一层括号。看例子

print(From(((1,2,3),(4,5,6),(1,2))).chain().toList())

'''

结果:

[1, 2, 3, 4, 5, 6, 1, 2]

'''

回到上一篇文章统计选修数学的同学的平均分。数据集如下

students = [

{

"name":"wwb",

"sex":"1",

"course":[

{

"name":"Math",

"score":90

},

{

"name":"English",

"score":80

}

]

},

{

"name":"wxa",

"sex":"1",

"course":[

{

"name":"Music",

"score":90

},

{

"name":"English",

"score":80

}

]

},

{

"name":"wxb",

"sex":"1",

"course":[

{

"name":"Math",

"score":92

},

{

"name":"Music",

"score":80

}

]

},

]

求选修数学同学的平均分

studentmaths = From(students).map(lambda s: From(s["course"]).map(lambda c:

{

"name":s["name"],

"sex":s["sex"],

"course":c["name"],

"score":c["score"]

}).toList()).chain().filter(lambda it:it["course"]=="Math").toList()

#先打印出来看看

print(From(studentmaths).reduce(lambda acc,s:acc+s["score"],0)/len(studentmaths))

'''

结果:

[{'score': 90, 'name': 'wwb', 'sex': '1', 'course': 'Math'}, {'score': 92, 'name': 'wxb', 'sex': '1', 'course': 'Math'}]

91.0

'''

总结

高阶函数和链式调用终于讲完了，有没有发现这些例子都好简洁，基本上多复杂的需求都只用一条链子，一直连击。而且不失可读性。高阶函数需要练习才会熟悉，像sql语句一样，既简单又复杂。预告下篇文章讲组合，就用我一年前写的玩具模板引擎为例子，200行左右。

测试代码

同样我自己把测试代码贴出来吧，当然需要和文章开篇的FT.py放在一起才可以执行。

from FT import From

print(From((1,2,3,4))

.filter(lambda it:it % 2==0)

.map(lambda it:it*2).toList())

print(From((1,2,3,4))

.filter(lambda it:it % 2==0)

.map(lambda it:it*2).reduce(lambda acc,it:acc+it))

print(From((1,2,3,4))

.filter(lambda it:it % 2==0)

.map(lambda it:it*2).reduce(lambda acc,it:acc+it,0))

testgroupdata=[{"id":1,"name":"wwb"},{"id":1,"name":"wxa"},{"id":1,"name":"wxb"},{"id":2,"name":"wxc"},{"id":2,"name":"wxd"}]

print(From(testgroupdata).groupby(lambda it:it['id']).toList())

print(From(testgroupdata).groupby(lambda it:it['id']).filter(lambda it:it[0]%2==0).toList())

#笛卡尔积

print(From((1,2,3)).product(('a','b','c')).toList())

students = [

{

"name":"wwb",

"book":[1,2,5]

},

{

"name":"wxa",

"book":[1,2,3]

},

{

"name":"wxb",

"book":[2,3,4]

}

]

books = [

{

"id":1,

"name":"C++ Primer"

},

{

"id":2,

"name":"Effecitve C++"

},

{

"id":3,

"name":"语文"

},{

"id":4,

"name":"数学"

},

{

"id":5,

"name":"英语"

}

]

print(From(students).map(lambda s:

{

"name":s["name"],

"book":From(s["book"]).product(books).filter(lambda it:it[0]==it[1]["id"])

.map(lambda it:it[1]["name"]).toList()

}).toList())

#只找一个

print(From(students).first(lambda it:it["name"]=="wwb"))

print(From(students).firstOrNone(lambda it:it["name"]=="wxx"))

#chain是一个很重要的函数

# 目的 ((a,b,c),(d,e,f),(g,h,i)) => (a,b,c,d,e,f,g,h,i),去掉一层括号

print(From(((1,2,3),(4,5,6),(1,2))).chain().toList())

#回到上次的例子

students = [

{

"name":"wwb",

"sex":"1",

"course":[

{

"name":"Math",

"score":90

},

{

"name":"English",

"score":80

}

]

},

{

"name":"wxa",

"sex":"1",

"course":[

{

"name":"Music",

"score":90

},

{

"name":"English",

"score":80

}

]

},

{

"name":"wxb",

"sex":"1",

"course":[

{

"name":"Math",

"score":92

},

{

"name":"Music",

"score":80

}

]

},

]

#求选修数学同学的平均分

print(From(students).map(lambda s: From(s["course"]).map(lambda c:

{

"name":s["name"],

"sex":s["sex"],

"course":c["name"],

"score":c["score"]

}).toList()).chain().toList())

studentmaths = From(students).map(lambda s: From(s["course"]).map(lambda c:

{

"name":s["name"],

"sex":s["sex"],

"course":c["name"],

"score":c["score"]

}).toList()).chain().filter(lambda it:it["course"]=="Math").toList()

print(studentmaths)

print(From(studentmaths).reduce(lambda acc,s:acc+s["score"],0)/len(studentmaths))