Python函数式编程
2023-09-14 09:14:30 时间
目录
1 概述
在前面，我们已经对Python学习做了系统的知识梳理（ Python思维导图），上一节我们讲解了函数的基本知识，这一节我们分享函数式编程。
1.1 函数式编程
函数式编程（ functional programming ）是一种 编程范式（ Programming paradigm ） ，或者说编程模式，比如我们常见的过程式编程是一种编程范式，面向对象编程又是另一种编程范式。1.2 特征
函数式编程的一大特性就是：可以把函数当成变量来使用，比如将函数赋值给其他变量、把函数作为参数传递给其他函数、函数的返回值也可以是一个函数等等。Python 不是纯函数式编程语言，但它对函数式编程提供了一些支持。本章主要介绍 Python 中的函数式编程，主要包括以下几个方面：
2 高阶函数
在函数式编程中，我们可以将函数当作变量一样自由使用。一个函数接收另一个函数作为参数，这种函数称之为高阶函数（Higher-order Functions
）。
看一个简单的例子：
1. def func ( g , arr ):2. return [ g ( x ) for x in arr ]
上面的代码中，
func
是一个高阶函数，它接收两个参数，第
1
个参数是函数，第
2
个参数是数
组，
func
的功能是将函数
g
逐个作用于数组
arr
上，并返回一个新的数组，比如，我们可以这
样用：
1. def double ( x ):2. return 2 * x3.4. def square ( x ):5. return x * x6.7. arr1 = func ( double , [ 1 , 2 , 3 , 4 ])8. arr2 = func ( square , [ 1 , 2 , 3 , 4 ])
不难判断出，arr1 是 [2, 4, 6, 8]，arr2 是 [1, 4, 9, 16]。
3 匿名函数
3.1 定义
在
Python
中，我们使用
def
语句来定义函数，比如：
1. def double ( x ):2. return 2 * x
除了用上面的方式定义函数，
Python
还提供了一个关键字
lambda
，让我们可以创建一个匿名函
数，也就是没有名称的函数。它的形式如下：
1. lambda 参数 : 表达式
关键字
lambda
说明它是一个匿名函数，冒号
:
前面的变量是该匿名函数的参数，冒号后面
是函数的返回值，注意这里不需使用
return
关键字。
我们将上面的
double
函数改写成一个匿名函数，如下：
1. lambda x : 2 * x
那怎么调用匿名函数呢？可以直接这样使用：
1. >>> ( lambda x : 2 * x )( 8 )2. 16
由于匿名函数本质上是一个函数对象，也可以将其赋值给另一个变量，再由该变量来调用函数，如下：
1. >>> f = lambda x : 2 * x # 将匿名函数赋给变量 f2. >>> f3. < function < lambda > at 0x7f835a696578 >4. >>> f ( 8 )5. 16
3.2 使用场景
lambda
函数一般适用于创建一些临时性的，小巧的函数。比如上面的
double
函数，我们当
然可以使用
def
来定义，但使用
lambda
来创建会显得很简洁，尤其是在高阶函数的使用
中。
看一个例子：
1. def func ( g , arr ):2. return [ g ( x ) for x in arr ]
现在给一个列表
[1, 2, 3, 4]
，利用上面的函数，对列表中的元素加
1
，返回一个新的列表，你可
能这样用：
1. def add_one ( x ):2. return x + 13.4. arr = func ( add_one , [ 1 , 2 , 3 , 4 ])
这样做没什么错，可是
add_one
这个函数太简单了，使用
def
定义未免有点小题大作，我们
改用
lambda
：
1. arr = func ( lambda x : x + 1 , [ 1 , 2 , 3 , 4 ])
是不是很简洁、易懂？
4 map/reduce/filter
map/reduce/filter
是
Python
中较为常用的内建高阶函数，它们为函数式编程提供了不少便
利。
4.1 map
map
函数的使用形式如下：
1. map ( function , sequence )
解释：对
sequence
中的
item
依次执行
function(item)
，并将结果组成一个
List
返回，也
就是：
1. [ function ( item1 ), function ( item2 ), function ( item3 ), ...]
看一些简单的例子：
1. >>> def square ( x ):2. ... return x * x3.4. >>> map ( square , [ 1 , 2 , 3 , 4 ])5. [ 1 , 4 , 9 , 16 ]6.7. >>> map ( lambda x : x * x , [ 1 , 2 , 3 , 4 ]) # 使用 lambda8. [ 1 , 4 , 9 , 16 ]9.10. >>> map ( str , [ 1 , 2 , 3 , 4 ])11. [ '1' , '2' , '3' , '4' ]12.13. >>> map ( int , [ '1' , '2' , '3' , '4' ])14. [ 1 , 2 , 3 , 4 ]
再看一个例子：
1. def double ( x ):2. return 2 * x3.4. def triple ( x ):5. return 3 * x6.7. def square ( x ):8. return x * x9.10. funcs = [ double , triple , square ] # 列表元素是函数对象11.12. # 相当于 [double(4), triple(4), square(4)]13. value = list ( map ( lambda f ： f ( 4 ), funcs ))14.15. print value16.17. # output18. [ 8 , 12 , 16 ]
上面的代码中，我们加了
list
转换，是为了兼容
Python3
，在
Python2
中
map
直接返回列
表，
Python3
中返回迭代器。
4.2 reduce
reduce
函数的使用形式如下：
1. reduce ( function , sequence [, initial ])
解释：先将
sequence
的前两个
item
传给
function
，即
function(item1, item2)
，函数
的返回值和
sequence
的下一个
item
再传给
function
，即
function(function(item1,
item2), item3)
，如此迭代，直到
sequence
没有元素，如果有
initial
，则作为初始值调用。
也就是说：
1. reduece ( f , [ x1 , x2 , x3 , x4 ]) = f ( f ( f ( x1 , x2 ), x3 ), x4 )
看一些例子，就能很快理解了。
1. >>> reduce ( lambda x , y : x * y , [ 1 , 2 , 3 , 4 ]) # 相当于 ((1 * 2) * 3) * 42. 243. >>> reduce ( lambda x , y : x * y , [ 1 , 2 , 3 , 4 ], 5 ) # ((((5 * 1) * 2) * 3)) * 44. 1205. >>> reduce ( lambda x , y : x / y , [ 2 , 3 , 4 ], 72 ) # (((72 / 2) / 3)) / 46. 37. >>> reduce ( lambda x , y : x + y , [ 1 , 2 , 3 , 4 ], 5 ) # ((((5 + 1) + 2) + 3)) + 48. 159. >>> reduce ( lambda x , y : x - y , [ 8 , 5 , 1 ], 20 ) # ((20 - 8) - 5) - 110. 611. >>> f = lambda a , b : a if ( a > b ) else b # 两两比较，取最大值12. >>> reduce ( f , [ 5 , 8 , 1 , 10 ])13. 10
4.3 filter
filter
函数用于过滤元素，它的使用形式如下：
1. filter ( function , sequnce )
解释：将
function
依次作用于
sequnce
的每个
item
，即
function(item)
，将返回值为
True
的
item
组成一个
List/String/Tuple (
取决于
sequnce
的类型，
python3
统一返回
迭代器
)
返回。
看一些例子。
1. >>> even_num = list ( filter ( lambda x : x % 2 == 0 , [ 1 , 2 , 3 , 4 , 5 , 6 ]))2. >>> even_num3. [ 2 , 4 , 6 ]4. >>> odd_num = list ( filter ( lambda x : x % 2 , [ 1 , 2 , 3 , 4 , 5 , 6 ]))5. >>> odd_num6. [ 1 , 3 , 5 ]7. >>> filter ( lambda x : x < 'g' , 'hijack' )8. 'ac' # python29. >>> filter ( lambda x : x < 'g' , 'hijack' )10. < filter object at 0x1034b4080 > # python3
注意在
python2
和
python3
中，
map/reduce/filter
的返回值类型有所不同，
python2
返回的是基本数据类型，而
python3
则返回了迭代器；
5 闭包
5.1 定义
在
Python
中，函数也是一个对象。因此，我们在定义函数时，可以再嵌套定义一个函数，并将该嵌套函数返回，比如：
1. from math import pow2.3. def make_pow ( n ):4. def inner_func ( x ): # 嵌套定义了 inner_func5. return pow ( x , n ) # 注意这里引用了外部函数的 n6. return inner_func # 返回 inner_func
上面的代码中，函数
make_pow
里面又定义了一个内部函数
inner_func
，然后将该函数返
回。因此，我们可以使用
make_pow
来生成另一个函数：
1. >>> pow2 = make_pow ( 2 ) # pow2 是一个函数，参数 2 是一个自由变量2. >>> pow23. < function inner_func at 0x10271faa0 >4. >>> pow2 ( 6 )5. 36.0
我们还注意到，内部函数
inner_func
引用了外部函数
make_pow
的自由变量
n
，这也就
意味着，当函数
make_pow
的生命周期结束之后，
n
这个变量依然会保存在
inner_func
中，它被
inner_func
所引用。
1. >>> del make_pow # 删除 make_pow2. >>> pow3 = make_pow ( 3 )3. Traceback ( most recent call last ):4. File "<stdin>" , line 1 , in <module>5. NameError : name 'make_pow' is not defined6. >>> pow2 ( 9 ) # pow2 仍可正常调用，自由变量 2 仍保存在 pow2 中7. 81.0
像上面这种情况，一个函数返回了一个内部函数，该内部函数引用了外部函数的相关参数和变量，我们把该返回的内部函数称为闭包（Closure
）。
在上面的例子中，
inner_func
就是一个闭包，它引用了自由变量
n
。
5.2 闭包的作用
闭包的最大特点就是引用了自由变量，即使生成闭包的环境已经释放，闭包仍然存在。
闭包在运行时可以有多个实例，即使传入的参数相同。
1. >>> pow_a = make_pow ( 2 )2. >>> pow_b = make_pow ( 2 )3. >>> pow_a == pow_b4. False
利用闭包，我们还可以模拟类的实例。
这里构造一个类，用于求一个点到另一个点的距离：
1. from math import sqrt2.3. class Point ( object ):4. def __init__ ( self , x , y ):5. self . x , self . y = x , y6.7. def get_distance ( self , u , v ):8. distance = sqrt (( self . x - u ) ** 2 + ( self . y - v ) ** 2 )9. return distance10.11. >>> pt = Point ( 7 , 2 ) # 创建一个点12. >>> pt . get_distance ( 10 , 6 ) # 求到另一个点的距离13. 5.0
用闭包来实现：
1. def point ( x , y ):2. def get_distance ( u , v ):3. return sqrt (( x - u ) ** 2 + ( y - v ) ** 2 )4.5. return get_distance6.7. >>> pt = point ( 7 , 2 )8. >>> pt ( 10 , 6 )9. 5.0
可以看到，结果是一样的，但使用闭包实现比使用类更加简洁。
5.3 常见的误区
闭包的概念很简单，但实现起来却容易出现一些误区，比如下面的例子：
1. def count ():2. funcs = []3. for i in [ 1 , 2 , 3 ]:4. def f ():5. return i6. funcs . append ( f )7. return funcs
在该例子中，我们在每次
for
循环中创建了一个函数，并将它存到
funcs
中。现在，调用上
面的函数，你可能认为返回结果是
1, 2, 3
，事实上却不是：
1. >>> f1 , f2 , f3 = count ()2. >>> f1 ()3. 34. >>> f2 ()5. 36. >>> f3 ()7. 3
为什么呢？原因在于上面的函数
f
引用了变量
i
，但函数
f
并非立刻执行，当
for
循环结束时，此时变量
i
的值是
3
，
funcs
里面的函数引用的变量都是
3
，最终结果也就全为3。
因此，我们应尽量避免在闭包中引用循环变量，或者后续会发生变化的变量。
那上面这种情况应该怎么解决呢？我们可以再创建一个函数，并将循环变量的值传给该函数，如下：
1. def count ():2. funcs = []3. for i in [ 1 , 2 , 3 ]:4. def g ( param ):5. f = lambda : param # 这里创建了一个匿名函数6. return f7. funcs . append ( g ( i )) # 将循环变量的值传给 g8. return funcs9.10. >>> f1 , f2 , f3 = count ()11. >>> f1 ()12. 113. >>> f2 ()14. 215. >>> f3 ()16. 3
(1)闭包是携带自由变量的函数，即使创建闭包的外部函数的生命周期结束了，闭包所引用的自由变量仍会存在。
(2)闭包在运行可以有多个实例。
(3)尽量不要在闭包中引用循环变量，或者后续会发生变化的变量。
6 装饰器
我们知道，在 Python 中，我们可以像使用变量一样使用函数：(1)函数可以被赋值给其他变量(2)函数可以被删除(3)可以在函数里面再定义函数(4)函数可以作为参数传递给另外一个函数(5)函数可以作为另一个函数的返回简而言之，函数就是一个对象。
6.1 对一个简单的函数进行装饰
为了更好地理解装饰器，我们先从一个简单的例子开始，假设有下面的函数：
1. def hello ():2. return 'hello world'
现在我们想增强
hello()
函数的功能，希望给返回加上
HTML
标签，比如
<i>hello
world</i>
，但是有一个要求，不改变原来
hello()
函数的定义。这里当然有很多种方法，下面
给出一种跟本文相关的方法：
1. def makeitalic ( func ):2. def wrapped ():3. return "<i>" + func () + "</i>"4. return wrapped
在上面的代码中，我们定义了一个函数
makeitalic
，该函数有一个参数
func
，它是一个函
数；在
makeitalic
函数里面我们又定义了一个内部函数
wrapped
，并将该函数作为返回。
现在，我们就可以不改变
hello()
函数的定义，给返回加上
HTML
标签了：
1. >>> hello = makeitalic ( hello ) # 将 hello 函数传给 makeitalic2. >>> hello ()3. '<i>hello world</i>'
在上面，我们将
hello
函数传给
makeitalic
，再将返回赋给
hello
，此时调用
hello()
就得到了我们想要的结果。
不过要注意的是，由于我们将
makeitalic
的返回赋给了
hello
，此时
hello()
函数仍
然存在，但是它的函数名不再是
hello
了，而是
wrapped
，正是
makeitalic
返回函数的名
称，可以验证一下：
1. >>> hello . __name__2. 'wrapped'
对于这个小瑕疵，后文将会给出解决方法。
现在，我们梳理一下上面的例子，为了增强原函数
hello
的功能，我们定义了一个函数，它接收
原函数作为参数，并返回一个新的函数，完整的代码如下：
1. def makeitalic ( func ):2. def wrapped ():3. return "<i>" + func () + "</i>"4. return wrapped5.6. def hello ():7. return 'hello world'8.9. hello = makeitalic ( hello )
事实上，
makeitalic
就是一个装饰器（
decorator
），它『装饰』了函数
hello
，并返回一
个函数，将其赋给
hello
。
一般情况下，我们使用装饰器提供的
@
语法糖（
Syntactic Sugar
），来简化上面的写法：
1. def makeitalic ( func ):2. def wrapped ():3. return "<i>" + func () + "</i>"4. return wrapped5.6. @makeitalic7. def hello ():8. ` return 'hello world'
像上面的情况，可以动态修改函数（或类）功能的函数就是装饰器。本质上，它是一个高阶函数，以被装饰的函数（比如上面的 hello
）为参数，并返回一个包装后的函数（比如上面的
wrapped
）给被装饰函数（hello
）。
6.2 装饰器的使用形式
装饰器的一般使用形式如下：
1. @decorator2. def func ():3. pass
等价于下面的形式：
1. def func ():2. pass3. func = decorator ( func )
装饰器可以定义多个，离函数定义最近的装饰器先被调用，比如：
1. @decorator_one2. @decorator_two3. def func ():4. pass
等价于：
1. def func ():2. pass3.4. func = decorator_one ( decorator_two ( func ))
装饰器还可以带参数，比如：
1. @decorator ( arg1 , arg2 )2. def func ():3. pass
等价于：
1. def func ():2. pass3.4. func = decorator ( arg1 , arg2 )( func )
下面我们再看一些具体的例子，以加深对它的理解。
6.3 对带参数的函数进行装饰
前面的例子中，被装饰的函数
hello()
是没有带参数的，我们看看被装饰函数带参数的情况。对
前面例子中的
hello()
函数进行改写，使其带参数，如下：
1. def makeitalic ( func ):2. def wrapped (* args , ** kwargs ):3. ret = func (* args , ** kwargs )4. return '<i>' + ret + '</i>'5. return wrapped6.7. @makeitalic8. def hello ( name ):9. return 'hello %s' % name10.11. @makeitalic12. def hello2 ( name1 , name2 ):13. return 'hello %s, %s' % ( name1 , name2 )
由于函数
hello
带参数，因此内嵌包装函数
wrapped
也做了一点改变：
内嵌包装函数的参数传给了
func
，即被装饰函数，也就是说内嵌包装函数的参数跟被装饰函数
的参数对应，这里使用了
(*args, **kwargs)
，是为了适应可变参数。
看看使用：
1. >>> hello ( 'python' )2. '<i>hello python</i>'3. >>> hello2 ( 'python' , 'java' )4. '<i>hello python, java</i>'
6.4 带参数的装饰器
上面的例子，我们增强了函数
hello
的功能，给它的返回加上了标签
<i>...</i>
，现在，我
们想改用标签
<b>...</b>
或
<p>...</p>
。是不是要像前面一样，再定义一个类似
makeitalic
的装饰器呢？其实，我们可以定义一个函数，将标签作为参数，返回一个装饰器，比
如：
1. def wrap_in_tag ( tag ):2. def decorator ( func ):3. def wrapped (* args , ** kwargs ):4. ret = func (* args , ** kwargs )5. return '<' + tag + '>' + ret + '</' + tag + '>'6. return wrapped7.8. return decorator
现在，我们可以根据需要生成想要的装饰器了：
1. makebold = wrap_in_tag ( 'b' ) # 根据 'b' 返回 makebold 生成器2.3. @makebold4. def hello ( name ):5. return 'hello %s' % name6.7. >>> hello ( 'world' )8. '<b>hello world</b>'
上面的形式也可以写得更加简洁：
1. @wrap_in_tag ( 'b' )2. def hello ( name ):3. return 'hello %s' % name
这就是带参数的装饰器，其实就是在装饰器外面多了一层包装，根据不同的参数返回不同的装饰器。
6.5 多个装饰器
现在，让我们来看看多个装饰器的例子，为了简单起见，下面的例子就不使用带参数的装饰器。
1. def makebold ( func ):2. def wrapped ():3. return '<b>' + func () + '</b>'4.5. return wrapped6.7. def makeitalic ( func ):8. def wrapped ():9. return '<i>' + func () + '</i>'10.11. return wrapped12.13. @makebold14. @makeitalic15. def hello ():16. return 'hello world'
上面定义了两个装饰器，对
hello
进行装饰，上面的最后几行代码相当于：
1. def hello ():2. return 'hello world'3.4. hello = makebold ( makeitalic ( hello ))
调用函数
hello
：
1. >>> hello ()2. '<b><i>hello world</i></b>'
6.6 基于类的装饰器
前面的装饰器都是一个函数，其实也可以基于类定义装饰器，看下面的例子：
1. class Bold ( object ):2. def __init__ ( self , func ):3. self . func = func4.5. def __call__ ( self , * args , ** kwargs ):6. return '<b>' + self . func (* args , ** kwargs ) + '</b>'7.8. @Bold9. def hello ( name ):10. return 'hello %s' % name11.12. >>> hello ( 'world' )13. '<b>hello world</b>'
可以看到，类
Bold
有两个方法：
__init__()
：它接收一个函数作为参数，也就是被装饰的函数
__call__()
：让类对象可调用，就像函数调用一样，在调用被装饰函数时被调用
还可以让类装饰器带参数：
1. class Tag ( object ):2. def __init__ ( self , tag ):3. self . tag = tag4.5. def __call__ ( self , func ):6. def wrapped (* args , ** kwargs ):7. return "<{tag}>{res}</{tag}>" . format (8. res = func (* args , ** kwargs ), tag = self . tag9. )10. return wrapped11.12. @Tag ( 'b' )13. def hello ( name ):14. return 'hello %s' % name
需要注意的是，如果类装饰器有参数，则
__init__
接收参数，而
__call__
接收
func
。
6.7 装饰器的副作用
前面提到，使用装饰器有一个瑕疵，就是被装饰的函数，它的函数名称已经不是原来的名称了，回到最开始的例子：
1. def makeitalic ( func ):2. def wrapped ():3. return "<i>" + func () + "</i>"4. return wrapped5.6. @makeitalic7. def hello ():8. return 'hello world'
函数
hello
被
makeitalic
装饰后，它的函数名称已经改变了：
1. >>> hello . __name__2. 'wrapped'
为了消除这样的副作用，
Python
中的
functools
包提供了一个
wraps
的装饰器：
1. from functools import wraps2.3. def makeitalic ( func ):4. @wraps ( func ) # 加上 wraps 装饰器5. def wrapped ():6. return "<i>" + func () + "</i>"7. return wrapped8.9. @makeitalic10. def hello ():11. return 'hello world'12.13. >>> hello . __name__14. 'hello'
6.8 小结
(1)本质上，装饰器就是一个返回函数的高阶函数。
(2)装饰器可以动态地修改一个类或函数的功能，通过在原有的类或者函数上包裹一层修饰类或修饰函数实现。
(3)事实上，装饰器就是闭包的一种应用，但它比较特别，接收被装饰函数为参数，并返回一个函
数，赋给被装饰函数，闭包则没这种限制。
7 partial
Python
提供了一个
functools
的模块，该模块为高阶函数提供支持，
partial
就是其中的一个
函数，该函数的形式如下：
1. functools . partial ( func [,* args ][, ** kwargs ])
这里先举个例子，看看它是怎么用的。
假设有如下函数：
1. def multiply ( x , y ):2. return x * y
现在，我们想返回某个数的双倍，即：
1. >>> multiply ( 3 , y = 2 )2. 63. >>> multiply ( 4 , y = 2 )4. 85. >>> multiply ( 5 , y = 2 )6. 10
上面的调用有点繁琐，每次都要传入
y=2
，我们想到可以定义一个新的函数，把
y=2
作为默
认值，即：
1. def double ( x , y = 2 ):2. return multiply ( x , y )
现在，我们可以这样调用了：
1. >>> double ( 3 )2. 63. >>> double ( 4 )4. 85. >>> double ( 5 )6. 10
事实上，我们可以不用自己定义
double
，利用
partial
，我们可以这样：
partial
函数
1. from functools import partial2.3. double = partial ( multiply , y = 2 )
partial
接收函数
multiply
作为参数，固定
multiply
的参数
y=2
，并返回一个新
的函数给
double
，这跟我们自己定义
double
函数的效果是一样的。
所以，简单而言，
partial
函数的功能就是：把一个函数的某些参数给固定住，返回一个新的函
数。
需要注意的是，我们上面是固定了
multiply
的关键字参数
y=2
，如果直接使用：
1. double = partial ( multiply , 2 )
则
2
是赋给了
multiply
最左边的参数
x
，不信？我们可以验证一下：
1. from functools import partial2.3. def subtraction ( x , y ):4. return x - y5.6. f = partial ( subtraction , 4 ) # 4 赋给了 x7. >>> f ( 10 ) # 4 - 108. - 6
(1)partial
的功能：固定函数参数，返回一个新的函数。
(2)当函数参数太多，需要固定某些参数时，可以使用
functools.partial
创建一个新的函数。
相关文章
- Python基础21-网络编程
- Python 编程 | 连载 17 - 高阶函数与装饰器
- Python 编程 | 连载 23 - 常用函数与高阶函数
- 哪些软件是python编写出来的_用Python编程需要什么软件？
- python整除和取余写法_Python的整除和取余[通俗易懂]
- Python入门系列（六）一篇学会python函数
- 初学者python详细安装步骤_编程工具
- python监控网页内容变化_使用Python监控文件内容变化代码实例
- 日拱一卒，一起来上伯克利的实验课，Python函数式编程入门
- python社交网络分析_python编程:从入门到实践
- 【干货】Python 函数式编程，看这一篇就够了！
- Python编程 列表的常用方法
- Python函数式编程：返回函数与匿名函数
- python udp编程_Python核心编程
- Python 冒泡排序_python
- Python：利用python代码编程实现将视频的avi格式转换为MP4格式
- python里面的缩进是什么意思_Python缩进规则（一看即懂）[通俗易懂]
- 关于python中lambda函数的描述_Python全局变量
- Python编程经典案例【考题】自由落体运动球的运动轨迹
- 【测试开发】python系列教程：Python 运算符
- 通过 for 循环，比较 Python 与 Ruby 编程思想的差别
- python高级线程编程-线程间通信（三）
- Python学习：6.python内置函数详解编程语言
- 使用Python编程连接MySQL数据库（python连mysql）
- 使用Python连接SQL Server数据库（python连接sqlserver数据库）
- 如何在Linux上将Python脚本设置为后台运行？（linux后台运行python）
- Python高效编程技巧
- 实例讲解python函数式编程
- python网络编程学习笔记(三)：socket网络服务器