我的施工之路

目前已完成，以下五期Python专题总结：

今天是Python函数专题，目录结构：

Python 函数专题

基础部分

1 函数组成

2 引用传参

3 默认参数与关键字参数

4 可变参数

5 内置函数

进阶部分

6 偏函数

7 递归函数

8 匿名函数

9 高阶函数

10 嵌套函数

总结

Python 函数专题

函数是一个接受输入、进行特定计算并产生输出的语句集。

我们把一些经常或反复被使用的任务放在一起，创建一个函数，而不是为不同的输入反复编写相同的代码。

Python提供了print、sorted、max、map等内置函数，但我们也可以创建自己的函数，称为用户定义函数。

基础部分

1 函数组成

如下自定义函数：

def foo(nums):

""" 返回偶数序列"""

evens = []

for num in nums:

if num%2==0:

evens.append(num)

return evens

可以看到函数主要组成部分：

函数名：

foo

函数形参：

nums

:: 函数体的控制字符，作用类似

Java或

C++的一对

{}

缩进：一般为4个字符

"""：为函数添加注释

return: 函数返回值

以上函数求出列表nums中的所有偶数并返回，通过它了解Python函数的主要组成部分。

2 引用传参

定义好一个函数后，使用：函数名+()+实参，调用函数，如下方法：

foo([10,2,5,4])

其中[10,2,5,4]为实参，它通过by reference方式传给形参nums，即nums指向列表头，而不是重新复制一个列表给nums.

再看一个引用的例子：

def myFun(x):

x[0] = 20

如下调用：

lst = [10, 11, 12, 13, 14, 15]

myFun(lst)

实参lst和形参x都指向同一个列表：

因此，对x[0]修改实际就是对实参lst的修改，结果如下：

但是，有时在函数内部形参指向改变，因此实参与形参的指向分离，如下例子：

def myFun(x):

x = [20, 30, 40]

x[0] = 0

调用：

lst = [10, 11, 12, 13, 14, 15]

myFun(lst)

x 被传参后初始指向lst，如下所示：

但是，执行x = [20, 30, 40]后，对象x重新指向一个新的列表对象[20,30,40]：

因此，对于x内元素的任何修改，都不会同时影响到lst，因为指向已经分离。

3 默认参数与关键字参数

Python函数的参数，可以有初始默认值，在调用时如果不赋值，则取值为默认值，如下例子：

def foo(length,width,height=1.0):

return length*width*height

调用foo函数，没有为height传参，所以取为默认值1.0：

r = foo(1.2,2.0)

print(r) # 2.4

使用默认值有一点需要区分，有的朋友会与关键字参数混淆，因为它们都是para=value的结构，但是有一个很明显的不同：默认值是声明在函数定义时，关键字参数是在函数调用时使用的此结构。如下例子：

def foo(length,width,height=1.0): # height是默认参数

return length*width*height

foo(width=2.0,length=1.2) #确定这种调用后才确定width和length是关键字参数

确定以上调用后，才确定width和length是关键字参数，并且关键字参数不必按照形参表的顺序调用。

4 可变参数

Java和C++在解决同一个函数但参数个数不同时，会使用函数重载的方法。Python使用可变参数的方法，非常灵活。

可变参数是指形参前带有*的变量，如下所示：

def foo(length,*others):

s = length

for para in others:

s *= para

return s

我们可以像下面这样方便的调用：

foo(1.2,2.0,1.0) # 2.4

如上，带一个星号的参数被传参后，实际被解释为元组对象。我们还可以这样调用：

foo(1.2) # 1.2

5 内置函数

总结完函数的参数后，再举几个Python内置的常用函数。

pow

大部分朋友应该知道pow是个幂次函数，比如求：

pow(2,3)

除此以外，pow还有第三个参数，使用更高效的算法实现求幂后再求余数：

pow(2,3,5) # 3

max,min

max,min用来求解最大最小值，实现relu函数：

def relu(x):

return max(x,0)

sorted

sorted函数完成对象排序，它能接收一个指定排序规则的函数，完成定制排序。如下，根据字典值绝对值从小到大排序：

d = {'a':0,'b':-2,'c':1}

dr = sorted(d.items(),key=lambda x:abs(x[1]))

print(dr) # [('a', 0), ('c', 1), ('b', -2)]

进阶部分

Python有一个专门操作函数的模块：functools，能实现一些关于函数的特殊操作。

6 偏函数

偏函数固定函数的某些参数后，重新生成一个新的函数。

通常用法，当函数的参数个数太多，需要简化时，使用partial创建一个新的函数。

假设我们要经常调用int函数转换二进制字符，设置参数base为2:

int('1010',base=2)

为了避免每次都写一个参数base，我们重新定义一个函数：

def int2(s):

return int(s,base=2)

以后每次转化字符串时，只需int2('1010)即可，更加简便。

偏函数也能实现上述功能：

from functools import partial

intp = partial(int,base=2)

那么有的朋友会问，偏函数就是个鸡肋，重新定义的int2更加直观容易理解，这个角度讲确实是这样。但是int2不能再接收base参数，但是intp函数还是能接收base参数，依然保留了原来的参数：

intp('10',base=16) # 16

可能看到这里的读者还是有些迷糊，不太确定怎么使用偏函数。可以先记住：修改内置函数的默认参数，就像内置函数int默认参数base等于10，使用偏函数调整默认base值为2.

7 递归函数

递归函数是指调用自身的函数。如下使用递归反转字符串：

def reverseStr(s):

if not s:

return s

return reverseStr(s[1:])+s[0]

print(reverseStr('nohtyp')) # python

reverseStr函数里面又调用了函数reverseStr，所以它是递归函数。

使用递归函数需要注意找到正确的递归基，防止陷入无限递归。

更多使用递归的例子大家可参考此公众号之前推送。

8 匿名函数

匿名函数是指使用lambda关键字创建的函数。它的标准结构如下：

lambda 形参列表: 含有形参列表的表达式

表达式的计算值即为lambda函数的返回值。

如下lambda函数：

lambda x,y: x+y

它等价于下面的f函数:

def f(x,y):

return x+y

lambda函数常做为max,sorted,map,filter等函数的key参数。

9 高阶函数

可以用来接收另一个函数作为参数的函数叫做高阶函数。

如下f有一个参数g，而g又是函数，所以f是高阶函数：

def f(g):

g()

Python 中经常会遇到高阶函数，今天介绍几个内置的常用的高阶函数。

map

map 函数第一个参数为函数，它作用于列表中每个的元素。

如下，列表中的单词未按照首字母大写其他字符小写的规则，使用map一一capitalize每个元素：

m = map(lambda s: s.capitalize(), ['python','Very','BEAUTIFUL'])

print(list(m))

结果：

['Python', 'Very', 'Beautiful']

reduce

reduce 高阶函数实现化简列表，它实现的效果如下：

如下例子，函数f等于x+y，求得两数之和，然后再与第三个数相加，依次下去，直到列表尾部，进而得到整个列表的和：

from functools import reduce

def f(x,y):

return x+y

r = reduce(f, [1,3,2,4])

print(r) # 10

以上reduce求解过程等于：

需要注意：reduce函数要求f必须带2个参数，只有这样才能完成归约化简。

10 嵌套函数

嵌套函数是指里面再嵌套函数的函数。

如下例子，将列表转化为二叉树。已知列表nums，

nums = [3,9,20,None,None,15,7]，转化为下面二叉树:

二叉树定义：

class TreeNode:

def __init__(self, x):

self.val = x

self.left = None

self.right = None

构建满足以上结构的二叉树，可以观察到：树的父节点和左右子节点的关系：

基于以上公式，再使用递归构建二叉树。

递归基情况：

if index >= len(nums) or nums[index] is None:

return None

递归方程：

根据以上分析，得到如下代码，list_to_binarytree函数是嵌套函数，它里面还有一个level子函数：

def list_to_binarytree(nums):

def level(index):

if index >= len(nums) or nums[index] is None:

return None

root = TreeNode(nums[index])

root.left = level(2 * index + 1)

root.right = level(2 * index + 2)

return root

return level(0)

binary_tree = list_to_binarytree([3,9,20,None,None,15,7])

通常使用嵌套函数的场景：实现一个功能只需要编写2个函数，写成一个class好像显得有些不必要，写成嵌套后更简洁，并且某些参数能共享，亲和性会更好。不妨体会上面的nums参数。

总结

函数专题主要总结了以下：

Python 函数专题

基础部分

1 函数组成

2 引用传参

3 默认参数与关键字参数

4 可变参数

5 内置函数

进阶部分

6 偏函数

7 递归函数

8 匿名函数

9 高阶函数

10 嵌套函数

总结

《end》

送书福利活动：送北大出版社《Python数据分析与可视化》，4 本。关于此书详情，请点击最下角阅读原文了解详情，明、后天当当网有每满100减50的活动。

送书规则：综合考虑公众号的参与度，留言走心程度等，三天后我会在文章下回复哪4条留言被送书。

施工计划第6篇完成，全文3000多字

一字一字敲出来的

原创不易，欢迎点赞和转发支持。