您的位置：首页 > 编程语言 > Python开发

python基础学习笔记<函数式编程与模块>

2015-08-06 10:15 671 查看


来自：http://www.liaoxuefeng.com/


高阶函数


变量可以指向函数

以Python内置的求绝对值的函数
abs()
为例，调用该函数用以下代码：
>>> abs(-10)
10


但是，如果只写
abs
呢？
>>> abs
<built-in function abs>


可见，
abs(-10)
是函数调用，而
abs
是函数本身。

要获得函数调用结果，我们可以把结果赋值给变量：
>>> x = abs(-10)
>>> x
10


但是，如果把函数本身赋值给变量呢？
>>> f = abs
>>> f
<built-in function abs>


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

如果一个变量指向了一个函数，那么，可否通过该变量来调用这个函数？用代码验证一下：
>>> f = abs
>>> f(-10)
10


成功！说明变量
f
现在已经指向了
abs
函数本身。


函数名也是变量

那么函数名是什么呢？函数名其实就是指向函数的变量！对于
abs()
这个函数，完全可以把函数名
abs
看成变量，它指向一个可以计算绝对值的函数！

如果把
abs
指向其他对象，会有什么情况发生？
>>> abs = 10
>>> abs(-10)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'int' object is not callable


把
abs
指向
10
后，就无法通过
abs(-10)
调用该函数了！因为
abs
这个变量已经不指向求绝对值函数了！

当然实际代码绝对不能这么写，这里是为了说明函数名也是变量。


传入函数

既然变量可以指向函数，函数的参数能接收变量，那么一个函数就可以接收另一个函数作为参数，这种函数就称之为高阶函数。

一个最简单的高阶函数：
def add(x, y, f):
    return f(x) + f(y)


当我们调用
add(-5, 6, abs)
时，参数
x
，
y
和
f
分别接收
-5
，
6
和
abs
，根据函数定义，我们可以推导计算过程为：
x ==> -5
y ==> 6
f ==> abs
f(x) + f(y) ==> abs(-5) + abs(6) ==> 11


map/reduce

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

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

举例说明，比如我们有一个函数f(x)=x2，要把这个函数作用在一个list
[1,
 2, 3, 4, 5, 6, 7, 8, 9]
上，就可以用
map()
实现如下：



现在，我们用Python代码实现：
>>> def f(x):
...     return x * x
...
>>> map(f, [1, 2, 3, 4, 5, 6, 7, 8, 9])
[1, 4, 9, 16, 25, 36, 49, 64, 81]


map()
传入的第一个参数是
f
，即函数对象本身。

你可能会想，不需要
map()
函数，写一个循环，也可以计算出结果：
L = []
for n in [1, 2, 3, 4, 5, 6, 7, 8, 9]:
    L.append(f(n))
print L


的确可以，但是，从上面的循环代码，能一眼看明白“把f(x)作用在list的每一个元素并把结果生成一个新的list”吗？

所以，
map()
作为高阶函数，事实上它把运算规则抽象了，因此，我们不但可以计算简单的f(x)=x2，还可以计算任意复杂的函数，比如，把这个list所有数字转为字符串：
>>> map(str, [1, 2, 3, 4, 5, 6, 7, 8, 9])
['1', '2', '3', '4', '5', '6', '7', '8', '9']


只需要一行代码。

再看reduce的用法。reduce把一个函数作用在一个序列[x1, x2, x3...]上，这个函数必须接收两个参数，reduce把结果继续和序列的下一个元素做累积计算，其效果就是：
reduce(f, [x1, x2, x3, x4]) = f(f(f(x1, x2), x3), x4)


比方说对一个序列求和，就可以用reduce实现：
>>> def add(x, y):
...     return x + y
...
>>> reduce(add, [1, 3, 5, 7, 9])
25


当然求和运算可以直接用Python内建函数
sum()
，没必要动用reduce。

但是如果要把序列
[1, 3, 5, 7, 9]
变换成整数13579，reduce就可以派上用场：
>>> def fn(x, y):
...     return x * 10 + y
...
>>> reduce(fn, [1, 3, 5, 7, 9])
13579


这个例子本身没多大用处，但是，如果考虑到字符串
str
也是一个序列，对上面的例子稍加改动，配合
map()
，我们就可以写出把
str
转换为
int
的函数：
>>> 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'))
13579


整理成一个
str2int
的函数就是：
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函数进一步简化成：
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))


也就是说，假设Python没有提供
int()
函数，你完全可以自己写一个把字符串转化为整数的函数，而且只需要几行代码！


filter

Python内建的
filter()
函数用于过滤序列。

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

例如，在一个list中，删掉偶数，只保留奇数，可以这么写：
def is_odd(n):
    return n % 2 == 1

filter(is_odd, [1, 2, 4, 5, 6, 9, 10, 15])
# 结果: [1, 5, 9, 15]


把一个序列中的空字符串删掉，可以这么写：
def not_empty(s):
    return s and s.strip()

filter(not_empty, ['A', '', 'B', None, 'C', '  '])
# 结果: ['A', 'B', 'C']


可见用
filter()
这个高阶函数，关键在于正确实现一个“筛选”函数。

Python内置的
sorted()
函数就可以对list进行排序：
>>> sorted([36, 5, 12, 9, 21])
[5, 9, 12, 21, 36]


此外，
sorted()
函数也是一个高阶函数，它还可以接收一个比较函数来实现自定义的排序。比如，如果要倒序排序，我们就可以自定义一个
reversed_cmp
函数：
def reversed_cmp(x, y):
    if x > y:
        return -1
    if x < y:
        return 1
    return 0


传入自定义的比较函数
reversed_cmp
，就可以实现倒序排序：
>>> sorted([36, 5, 12, 9, 21], reversed_cmp)
[36, 21, 12, 9, 5]


返回函数


函数作为返回值

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

我们来实现一个可变参数的求和。通常情况下，求和的函数是这样定义的：
def calc_sum(*args):
    ax = 0
    for n in args:
        ax = ax + n
    return ax


但是，如果不需要立刻求和，而是在后面的代码中，根据需要再计算怎么办？可以不返回求和的结果，而是返回求和的函数！
def lazy_sum(*args):
    def sum():
        ax = 0
        for n in args:
            ax = ax + n
        return ax
    return sum


当我们调用
lazy_sum()
时，返回的并不是求和结果，而是求和函数：
>>> f = lazy_sum(1, 3, 5, 7, 9)
>>> f
<function sum at 0x10452f668>


调用函数
f
时，才真正计算求和的结果：
>>> f()
25


在这个例子中，我们在函数
lazy_sum
中又定义了函数
sum
，并且，内部函数
sum
可以引用外部函数
lazy_sum
的参数和局部变量，当
lazy_sum
返回函数
sum
时，相关参数和变量都保存在返回的函数中，这种称为“闭包（Closure）”的程序结构拥有极大的威力。

请再注意一点，当我们调用
lazy_sum()
时，每次调用都会返回一个新的函数，即使传入相同的参数：
>>> f1 = lazy_sum(1, 3, 5, 7, 9)
>>> f2 = lazy_sum(1, 3, 5, 7, 9)
>>> f1==f2
False


f1()
和
f2()
的调用结果互不影响。


闭包

注意到返回的函数在其定义内部引用了局部变量
args
，所以，当一个函数返回了一个函数后，其内部的局部变量还被新函数引用，所以，闭包用起来简单，实现起来可不容易。

另一个需要注意的问题是，返回的函数并没有立刻执行，而是直到调用了
f()
才执行。我们来看一个例子：
def count():
    fs = []
    for i in range(1, 4):
        def f():
             return i*i
        fs.append(f)
    return fs

f1, f2, f3 = count()


在上面的例子中，每次循环，都创建了一个新的函数，然后，把创建的3个函数都返回了。

你可能认为调用
f1()
，
f2()
和
f3()
结果应该是
1
，
4
，
9
，但实际结果是：
>>> f1()
9
>>> f2()
9
>>> f3()
9


全部都是
9
！原因就在于返回的函数引用了变量
i
，但它并非立刻执行。等到3个函数都返回时，它们所引用的变量
i
已经变成了3，因此最终结果为
9
。

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

如果一定要引用循环变量怎么办？方法是再创建一个函数，用该函数的参数绑定循环变量当前的值，无论该循环变量后续如何更改，已绑定到函数参数的值不变：
>>> def count():
...     fs = []
...     for i in range(1, 4):
...         def f(j):
...             def g():
...                 return j*j
...             return g
...         fs.append(f(i))
...     return fs
... 
>>> f1, f2, f3 = count()
>>> f1()
1
>>> f2()
4
>>> f3()
9


缺点是代码较长，可利用lambda函数缩短代码


什么是闭包?

简单说,闭包就是根据不同的配置信息得到不同的结果

再来看看专业的解释:闭包（Closure）是词法闭包（Lexical Closure）的简称，是引用了自由变量的函数。这个被引用的自由变量将和这个函数一同存在，即使已经离开了创造它的环境也不例外。所以，有另一种说法认为闭包是由函数和与其相关的引用环境组合而成的实体。


python实例

看概念总是让人摸不着头脑,看几个python小例子就会了


例1

def make_adder(addend):
    def adder(augend):
        return augend + addend
    return adder

p = make_adder(23)
q = make_adder(44)

print p(100)
print q(100)


运行结果:
123
144


分析一下:

我们发现,
make_adder
是一个函数,包括一个参数
addend
,比较特殊的地方是这个函数里面又定义了一个新函数,这个新函数里面的一个变量正好是外部
make_adder
的参数.也就是说,外部传递过来的
addend
参数已经和
adder
函数绑定到一起了,形成了一个新函数,我们可以把
addend
看做新函数的一个配置信息,配置信息不同,函数的功能就不一样了,也就是能得到定制之后的函数.

再看看运行结果,我们发现,虽然p和q都是
make_adder
生成的,但是因为配置参数不同,后面再执行相同参数的函数后得到了不同的结果.这就是闭包.


例2

def hellocounter (name):
    count=[0] 
    def counter():
        count[0]+=1
        print 'Hello,',name,',',str(count[0])+' access!'
    return counter

hello = hellocounter('ma6174')
hello()
hello()
hello()


执行结果
Hello, ysisl , 1 access!
Hello, ysisl , 2 access!
Hello, ysisl , 3 access!


分析一下

这个程序比较有趣,我们可以把这个程序看做统计一个函数调用次数的函数.
count[0]
可以看做一个计数器,没执行一次
hello
函数,
count[0]
的值就加1。也许你会有疑问:为什么不直接写
count
而用一个列表?这是python2的一个bug,如果不用列表的话,会报这样一个错误:

UnboundLocalError: local variable 'count' referenced before assignment
.

什么意思?就是说
conut
这个变量你没有定义就直接引用了,我不知道这是个什么东西,程序就崩溃了.于是,再python3里面,引入了一个关键字:
nonlocal
,这个关键字是干什么的?就是告诉python程序,我的这个
count
变量是再外部定义的,你去外面找吧.然后python就去外层函数找,然后就找到了
count=0
这个定义和赋值,程序就能正常执行了.

python3 代码

def hellocounter (name):
    count=0 
    def counter():
        nonlocal count
        count+=1
        print 'Hello,',name,',',str(count[0])+' access!'
    return counter

hello = hellocounter('ma6174')
hello()
hello()
hello()


关于这个问题的研究您可以参考http://linluxiang.iteye.com/blog/789946


例3

def makebold(fn):
    def wrapped():
        return "<b>" + fn() + "</b>"
    return wrapped

def makeitalic(fn):
    def wrapped():
        return "<i>" + fn() + "</i>"
    return wrapped

@makebold
@makeitalic
def hello():
    return "hello world"

print hello()


执行结果
<b><i>hello world</i></b>


简单分析

怎么样?这个程序熟悉吗?这不是传说的的装饰器吗?对,这就是装饰器,其实,装饰器就是一种闭包,我们再回想一下装饰器的概念:对函数(参数,返回值等)进行加工处理,生成一个功能增强版的一个函数。再看看闭包的概念,这个增强版的函数不就是我们配置之后的函数吗?区别在于,装饰器的参数是一个函数或类,专门对类或函数进行加工处理。

python里面的好多高级功能，比如装饰器，生成器，列表推到，闭包，匿名函数等，开发中用一下，可能会达到事半功倍的效果！
可以理解为makibold(makeitalic(hello()))
参考自：http://www.cnblogs.com/ma6174/archive/2013/04/15/3022548.html




匿名函数

当我们在传入函数时，有些时候，不需要显式地定义函数，直接传入匿名函数更方


>>> 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
，返回值就是该表达式的结果。

用匿名函数有个好处，因为函数没有名字，不必担心函数名冲突。此外，匿名函数也是一个函数对象，也可以把匿名函数赋值给一个变量，再利用变量来调用该函数：
>>> f = lambda x: x * x
>>> f
<function <lambda> at 0x10453d7d0>
>>> f(5)
25


同样，也可以把匿名函数作为返回值返回，比如：
def build(x, y):
    return lambda: x * x + y * y


偏函数

int()
函数可以把字符串转换为整数，当仅传入字符串时，
int()
函数默认按十进制转换：
>>> int('12345')
12345


但
int()
函数还提供额外的
base
参数，默认值为
10
。如果传入
base
参数，就可以做N进制的转换：
>>> int('12345', base=8)
5349
>>> int('12345', 16)
74565


假设要转换大量的二进制字符串，每次都传入
int(x, base=2)
非常麻烦，于是，我们想到，可以定义一个
int2()
的函数，默认把
base=2
传进去：
def int2(x, base=2):
    return int(x, base)


functools.partial
就是帮助我们创建一个偏函数的，不需要我们自己定义
int2()
，可以直接使用下面的代码创建一个新的函数
int2
：
>>> import functools
>>> int2 = functools.partial(int, base=2)
>>> int2('1000000')
64
>>> int2('1010101')
85


所以，简单总结
functools.partial
的作用就是，把一个函数的某些参数给固定住（也就是设置默认值），返回一个新的函数，调用这个新函数会更简单
如果不同的人编写的模块名相同怎么办？为了避免模块名冲突，Python又引入了按目录来组织模块的方法，称为包（Package）

引入了包以后，只要顶层的包名不与别人冲突，那所有模块都不会与别人冲突，每一个包目录下面都会有一个
__init__.py
的文件，这个文件是必须存在的，否则，Python就把这个目录当成普通目录，而不是一个包。
__init__.py
可以是空文件，也可以有Python代码，因为
__init__.py
本身就是一个模块，Python本身就内置了很多非常有用的模块，只要安装完毕，这些模块就可以立刻使用




导入模块时，还可以使用别名，这样，可以在运行时根据当前环境选择最合适的模块。比如Python标准库一般会提供
StringIO
和
cStringIO
两个库，这两个库的接口和功能是一样的，但是
cStringIO
是C写的，速度更快，所以，你会经常看到这样的写法：
try:
    import cStringIO as StringIO
except ImportError: # 导入失败会捕获到ImportError
    import StringIO


这样就可以优先导入
cStringIO
。如果有些平台不提供
cStringIO
，还可以降级使用
StringIO
。导入
cStringIO
时，用
import
 ... as ...
指定了别名
StringIO
，因此，后续代码引用
StringIO
即可正常工作。

正常的函数和变量名是公开的（public），可以被直接引用，比如：
abc
，
x123
，
PI
等；

类似
__xxx__
这样的变量是特殊变量，可以被直接引用，但是有特殊用途，比如上面的
__author__
，
__name__
就是特殊变量，
hello
模块定义的文档注释也可以用特殊变量
__doc__
访问，我们自己的变量一般不要用这种变量名；

类似
_xxx
和
__xxx
这样的函数或变量就是非公开的（private），不应该被直接引用，比如
_abc
，
__abc
等；

之所以我们说，private函数和变量“不应该”被直接引用，而不是“不能”被直接引用，是因为Python并没有一种方法可以完全限制访问private函数或变量，但是，从编程习惯上不应该引用private函数或变量。
在Python中，安装第三方模块，是通过setuptools这个工具完成的。Python有两个封装了setuptools的包管理工具：
easy_install
和
pip
。目前官方推荐使用
pip
。

内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理 点击这里给我发消息
标签： 
相关文章推荐
新的分享
章节导航