Python编程核心内容 ---- Function（函数）

什么“大事”呢？下面将要介绍Python编程的核心内容之一——函数。

对于Python编程，函数的重要性不言而喻。重要的事情讲三遍：函数实在是太重要，太关键了。

引入函数

之前，我们编写程序遵循的原则：根据业务逻辑从上到下实现功能，其往往用一长段代码来实现指定功能，开发过程中最常见的操作就是粘贴复制，也就是将之前实现的代码块复制到现需功能处。这种编程方式虽然可以应付一般性问题，但是不能对付大多数问题。这不，下面就来个例子。

r1 = 12.3r2 = 9.1r3 = 64.21s1 = 2 * 3.14 * r15 s2 = 2 * 3.14 * r26 s3 = 2 * 3.14 * r3

圆是个神奇的图形。特别是π，它让人类陷入无限的遐想。OK，回归正题。为了求圆的周长，我们需要引入公式：周长 = 2 * π * r(半径)。看到这儿，某些读者可能会有疑惑：这跟函数有什么关系，之前的方式依然适用。是的，这的确是可以的，但这很麻烦，太重复啦。那如果现在需要把 π 更改为3.1415926535，那该怎么办呢？难道我们要一个一个地去改？？？Oh，my god！！！这时，我嗅到了函数的味道。

有了函数，我们就不再每次写c = 2 * 3.14 * x，而是写成更有意义的函数调用c = perimeter_of_circle(x)，而函数perimeter_of_circle本身只需要写一次，就可以多次调用。

Python不但能非常灵活地定义函数，而且本身内置了很多有用的函数，可以直接调用。

是的，函数最大的优点：增强代码的重用性和可读性。Python中，函数就是最基本的一种代码抽象的方式。.

函数定义

在Python中，函数有五大要点，分别是def、函数名、函数体、参数、返回值，以及两个英文版符号，分别是括号（括号内为参数）和冒号（:）。

• def：函数的关键字，没它可不行。

• 函数名：函数的名称，根据函数名调用函数。

• 函数体：函数中进行一系列的具体操作。

• 参数：为函数体提供数据。

• 返回值：当函数执行完毕后，可以给调用者返回数据。

上述函数的要点中，最重要的是参数和返回值。

1.返回值

函数是一个功能块，该功能到底执行成功与否，需要通过返回值来告知调用者。

2.参数

定义函数时，参数是一定需要考虑的。Python的函数定义非常简单，但灵活度却非常大。

对于函数的调用者来说，只需要知道如何传递正确的参数，以及函数将返回什么样的值就够了，函数内部的复杂逻辑被封装起来，调用者无需了解。

Python中，参数类型有：必选参数、默认参数、可变参数、关键字参数和命名关键字参数。函数中，参数定义的顺序必须是：必选参数、默认参数、可变参数、命名关键字参数和关键字参数。

3.空函数

空函数：什么事也不做，可以用pass语句。既然“一事不做”，那空函数还有什么用处？实际上pass可以用来作为占位符，比如现在还没想好怎么写函数的代码，就可以先放一个pass，让代码能运行起来。如此，运行代码程序就不会出现错误了。

#空函数 def nop():pass

函数参数

Python中，参数是非常灵活的。掌握参数就能领悟函数的真谛了。这是真的。参数是比较难理解的，特别是参数组合。

1.位置参数

既然说函数，就需要展示函数：

''' 遇到问题没人解答？小编创建了一个Python学习交流QQ群：857662006 寻找有志同道合的小伙伴，互帮互助,群里还有不错的视频学习教程和PDF电子书！ ''' #位置参数（必选参数） def involution(x):return x * x >>>involution(3) 9 >>>involution(5) 25

如代码所示，参数x就是一个位置参数。

2.默认参数

Python函数支持默认参数，即可以给函数的参数指定默认值。当该参数没有传入相应的值时，该参数就使用默认值。

#默认参数 def involution(x,n = 2):s = 1while n > 0:n = n - 1s = s * xreturn s >>>involution(6) 36 >>>involution(5,3) 125

如代码所示，当我们调用involution(5)，就相当于调用involution(5,2)。

注：
1.设置默认参数时，必选参数在前，默认参数在后，否则Python的解释器会报错；

2.定义默认参数要牢记：默认参数必须指向不可变对象！

''' 遇到问题没人解答？小编创建了一个Python学习交流QQ群：857662006 寻找有志同道合的小伙伴，互帮互助,群里还有不错的视频学习教程和PDF电子书！ ''' >>>def add_end(L=[]): ... L.append('END') ... return L ... >>>add_end() ['END'] >>>add_end() ['END','END'] >>>add_end() ['END','END','END']

上述代码展示的是默认参数不为不可变对象的现象。因此，默认参数必须指向不可变对象【字符串、None……】。

3.可变参数

在Python函数中，还可以定义可变参数。顾名思义，可变参数就是传入的参数个数是可变的，可以是1个、2个到任意个，还可以是0个。

我们以数学题为例子，给定一组数字a，b，c……，请计算a2 + b2 + c2 + ……。

要定义出这个函数，我们必须确定输入的参数。由于参数个数不确定，我们首先想到可以把a，b，c……作为一个list或tuple传进来，这样，函数可以定义如下：

#一般性函数 def calc(numbers):sum = 0for n in numbers:sum = sum + n * nreturn sum

如何调用calc()函数呢？需要调用时，需要为参数引入list或者tuple。

''' 遇到问题没人解答？小编创建了一个Python学习交流QQ群：857662006 寻找有志同道合的小伙伴，互帮互助,群里还有不错的视频学习教程和PDF电子书！ ''' #函数调用 >>> calc([1, 2, 3]) 14 >>> calc((1, 3, 5, 7)) 84

然而，如果我们使用可变参数，我们可以进行简化，方法如下：

#可变参数 def calc(*numbers):sum = 0for n in numbers:sum = sum + n * nreturn sum

咋调用呢？这个可简单啦，再也不用list或者tuple了。参数调用只需如下所示：

#可变参数的魅力 >>> calc(1, 2, 3) 14 >>> calc(1, 3, 5, 7) 84#参数调用不用calc([1,2,3])，括号内还用写中括号，好麻烦~~~

定义可变参数和定义一个list或tuple参数相比，仅仅在参数前面加了一个*号。在函数内部，参数numbers接收到的是一个tuple，因此，函数代码完全不变。但是，调用该函数时，可以传入任意个参数，包括0个参数：

>>> calc(1, 2) 5 >>> calc() 0

如果已经有一个list或者tuple，要调用一个可变参数怎么办？可以这样做：

>>> nums = [1, 2, 3]>>> calc(nums[0], nums[1], nums[2])14

这种写法当然是可行的，问题是太繁琐，所以Python允许你在list或tuple前面加一个*号，把list或tuple的元素变成可变参数传进去：

>>> nums = [1, 2, 3]>>> calc(*nums)14

4.关键字参数

可变参数允许你传入0个或任意个参数，这些可变参数在函数调用时自动组装为一个tuple。而关键字参数允许你传入0个或任意个含参数名的参数，这些关键字参数在函数内部自动组装为一个dict。dict就是字典，它是键值对组合，益处多多~~~

#引入关键字参数，默认为**kwdef person(name, age, **kw):print('name:', name, 'age:', age, 'other:', kw)

函数person除了必选参数name和age外，还接受关键字参数kw。在调用该函数时，可以只传入必选参数（必选参数必须全部传入，否则会出错），也可以传入关键字参数。注：关键字参数可是任意个的。

''' 遇到问题没人解答？小编创建了一个Python学习交流QQ群：857662006 寻找有志同道合的小伙伴，互帮互助,群里还有不错的视频学习教程和PDF电子书！ ''' #调用关键字参数 >>>def person(name,age,**kw): ... print('name:',name,'age:',age,'other:',kw) ... >>>person('Jack') Traceback (most recent call last):File "<stdin>", line 1, in <module> TypeError: person() missing 1 required positional argument: 'age' >>>person('Jack',36) name:Jack age:36 other:{} >>>person('Jack',36,city='Hangzhou') name:Jack age:36 other:{'city':'Hangzhou'} >>>person('Jack',36,city='Hangzhou',job='Engineer') name:Jack age:36 other:{'city':'Hangzhou','job':'Engineer'}

关键字参数有什么用呢？其实，既然存在就有它的强大之处。就像自然界中的万物，物竞天择，适者生存。如果它能够在自然界中生存下来，那么它就有独特的生存本领。因此，关键字参数还是有用武之地的。

它可以扩展函数的功能。比如，在person函数里，我们保证能接收到name和age这两个参数，但是，如果调用者愿意提供更多的参数，我们也能收到。试想你正在做一个用户注册的功能，除了用户名和年龄是必填项外，其他都是可选项，利用关键字参数来定义这个函数就能满足注册的需求。

如何操作呢？我们可以先组装出一个dict，然后，把该dict转换为关键字参数传进去：

>>> extra = {'city': 'Hangzhou', 'job': 'Engineer'}>>> person('Jack', 36, city=extra['city'], job=extra['job'])name: Jack age: 36 other: {'city': 'Hangzhou', 'job': 'Engineer'}

当然了，上面代码调用方式有点烦，通过dict键来查找值。我们可以通过关键字简化一下：

>>> extra = {'city': 'Hangzhou', 'job': 'Engineer'}>>> person('Jack', 36, **extra)name: Jack age: 36 other: {'city': 'Hangzhou', 'job': 'Engineer'}

extra表示把extra这个dict的所有key-value用关键字参数传入到函数的kw参数，kw将获得一个dict。

5.命名关键字参数

对于关键字参数，函数的调用者可以传入任意不受限制的关键字参数。至于到底传入了哪些，就需要在函数内部通过kw检查。

仍以person()函数为例，我们希望检查是否有city和job参数：

''' 遇到问题没人解答？小编创建了一个Python学习交流QQ群：857662006 寻找有志同道合的小伙伴，互帮互助,群里还有不错的视频学习教程和PDF电子书！ ''' def person(name, age, **kw):if 'city' in kw:# 有city参数passif 'job' in kw:# 有job参数passprint('name:', name, 'age:', age, 'other:', kw)

如果要限制关键字参数的名字，就可以用命名关键字参数，例如，只接收city和job作为关键字参数。这种方式定义的函数如下：

def person(name, age, *, city, job):print(name, age, city, job)

和关键字参数*kw不同，命名关键字参数需要一个特殊分隔符，*后面的参数被视为命名关键字参数。
调用命名关键字参数方式如下：

#调用命名关键字参数>>> person('Jack', 36, city='Hangzhou', job='Engineer')Jack 36 Hangzhou Engineer

那如果参数中有可变参数，那该怎么办呢？

若可变参数后面跟着命名关键字参数，后面跟着的命名关键字参数就不再需要一个特殊分隔符*了。

def person(name, age, *args, city, job):print(name, age, args, city, job)

命名关键字参数必须传入参数名，这和位置参数不同。如果没有传入参数名，调用将报错。而命名关键字参数可以有缺省值，从而简化调用：

def person(name, age, *, city='Hangzhou', job):print(name, age, city, job)

由于命名关键字参数city具有默认值，调用时，可不传入city参数：

>>> person('Jack', 36, job='Engineer')Jack 36 Hangzhou Engineer

6.参数组合

目前，函数中共有5种常用的参数类型。若只传入一种类型的参数，这太简单了。难点在哪？难点就在参数组合使用，那是相当恶心。不过，平时最好不要混合使用参数，不然容易搞得“乌烟瘴气”。

OK！言归正传，不然跑题啦。

Python中，定义一个函数，我们可以用必选参数、默认参数、可变参数、关键字参数和命名关键字参数，这5种参数都可以组合使用。但是请注意，参数定义的顺序必须是：必选参数、默认参数、可变参数、命名关键字参数和关键字参数。

下面来定义一个函数，该函数参数包含一种或几种参数。

def f1(a, b, c=0, *args, **kw):print('a =', a, 'b =', b, 'c =', c, 'args =', args, 'kw =', kw)def f2(a, b, c=0, *, d, **kw):print('a =', a, 'b =', b, 'c =', c, 'd =', d, 'kw =', kw)

在函数调用的时候，Python解释器自动按照参数位置和参数名把对应的参数传进去。

>>> f1(1, 2) a = 1 b = 2 c = 0 args = () kw = {} >>> f1(1, 2, c=3) a = 1 b = 2 c = 3 args = () kw = {} >>> f1(1, 2, 3, 'a', 'b') a = 1 b = 2 c = 3 args = ('a', 'b') kw = {} >>> f1(1, 2, 3, 'a', 'b', x=99) a = 1 b = 2 c = 3 args = ('a', 'b') kw = {'x': 99} >>> f2(1, 2, d=99, ext=None) a = 1 b = 2 c = 0 d = 99 kw = {'ext': None}

最神奇的是通过一个tuple和dict，你也可以调用上述函数：

''' 遇到问题没人解答？小编创建了一个Python学习交流QQ群：857662006 寻找有志同道合的小伙伴，互帮互助,群里还有不错的视频学习教程和PDF电子书！ ''' >>> args = (1, 2, 3, 4) >>> kw = {'d': 99, 'x': '#'} >>> f1(*args, **kw) a = 1 b = 2 c = 3 args = (4,) kw = {'d': 99, 'x': '#'} >>> args = (1, 2, 3) >>> kw = {'d': 88, 'x': '#'} >>> f2(*args, **kw) a = 1 b = 2 c = 3 d = 88 kw = {'x': '#'}

所以，对于任意函数，都可以通过类似func(*args, **kw)的形式调用它，无论它的参数是如何定义的。

然而，虽然函数参数类型多达5种，但不要同时使用太多的组合，否则函数接口的可理解性很差。哎，简简单单才是真啊。

7.函数参数小结

参数，作为函数传入值的媒介，这里有必要做一个总结。

一、Python的函数具有非常灵活的参数形态，既可以实现简单的调用，又可以传入非常复杂的参数；

二、默认参数一定要用不可变对象，如果是可变对象，程序运行时会有逻辑错误；

三、*args是可变参数，args接收的是一个tuple；

四、**kw是关键字参数，kw接收的是一个dict；

五、可变参数既可以直接传入：func(1, 2, 3)，又可以先组装list或tuple，再通过args传入：func((1, 2, 3))；

六、关键字参数既可以直接传入：func(a=1, b=2)，又可以先组装dict，再通过kw传入：func({‘a’: 1, ‘b’: 2})；

七、使用*args和**kw是Python的习惯写法，当然也可以用其他参数名，但最好使用习惯用法；

八、命名的关键字参数是为了限制调用者可以传入的参数名，同时可以提供默认值；

九、定义命名的关键字参数在没有可变参数的情况下不要忘了写分隔符*，否则定义的将是位置参数。

故而，为了学好Python中的函数部分，参数不容忽视。

函数调用

在学习了函数的定义之后，我们应该需要调用函数，获取我们想要的数据。

如何调用函数呢？语法：函数名(参数)

Python中，大佬们内置了许多有点用的函数，而我们只需拿来就行（这让我想起了鲁迅的“拿来主义”）。

若要调用Python中的内置函数，我们首先要知道函数名和参数。哈哈，又是参数~~~

比如我想要求某数的绝对值。如果你不知道Python有相关的内置函数，就只能这么做：

#求取绝对值 >>>def abs(num): ... if num >= 0: ... return num ... else: ... return (-num) ... >>>abs(9) 9 >>>abs(0) 0 >>>abs(-8) 8

上述代码虽然可以实现求绝对值的功能，但是太繁琐，需要敲几行代码才能实现该功能。然而，Python中有这个函数可以直接调用并输出结果。

#Python内置函数：abs() >>>abs(-9) 9 >>>abs(9) 9 #获取帮助文档 >>>help(abs) Help on built-in function abs in module builtins:abs(x, /)Return the absolute value of the argument.

对于函数参数，通常会遇到以下两个问题：

1.如果函数传入参数的数量错误，会如何呢？简单，直接Error呗。比如abs()：

#函数传入参数的数量错误>>> abs(-9,89)Traceback (most recent call last):File "<stdin>", line 1, in <module>TypeError: abs() takes exactly one argument (2 given)

2.如果传入的参数数量是对的，但参数类型不能被函数所接受，也会报TypeError的错误，并且给出错误信息：str是错误的参数类型：

#传入的参数类型错误>>> abs('a')Traceback (most recent call last):File "<stdin>", line 1, in <module>TypeError: bad operand type for abs(): 'str'

常见内置函数（Built-in Functions）

Python 3.x版本下官方网站：https://docs.python.org/3/library/functions.html。该网址内显示Python内置函数相关内容（Built-in Functions）。

1.数据结构相关：list()、tuple()、dict()、str()……

2.数字相关：abs()、min()、max()、len()……

3.其他：int()、float()……

好，不一一例举了，直接上图吧~~~

数据类型转换

Python内置的常用函数还包括数据类型转换函数，比如int()函数可以把其他数据类型转换为整数：

#Python之数据类型转换（int、float、str……） >>> int('123') 123 >>> int(12.34) 12 >>> float('12.34') 12.34 >>> str(1.23) '1.23' >>> str(100) '100' >>> bool(1) True >>> bool('') False

函数别名

了解Linux的读者可能知道别名（alias，unalias）这个指令。Python中也有“别名”之说，比如把函数名赋给变量：

#函数“别名” >>>abs(-8) 8 >>>a = abs >>>a(-9) 9 >>>a(0) 0 >>>a(9) 9

递归函数

讲述递归函数之前，我想起一个东西：阶乘（n!）。举个例子，我们来计算阶乘n! = 1 x 2 x 3 x … x n，用函数fact(n)表示，可以看出：

fact(n) = n! = 1 x 2 x 3 x ... x (n-1) x n = (n-1)! x n = fact(n-1) x n

因此，递归函数：在函数内部，一个函数在内部调用自身本身。

于是，fact(n)用递归的方式写出来就是：

''' 遇到问题没人解答？小编创建了一个Python学习交流QQ群：857662006 寻找有志同道合的小伙伴，互帮互助,群里还有不错的视频学习教程和PDF电子书！ ''' #递归函数 >>>def fact(n): ... if n == 1: ... return 1 ... else: ... return fact(n - 1) * n ... >>>fact(1) 1 >>>fact(5) 120 #递归函数之栈溢出 >>>fact(1000) Traceback (most recent call last):File "<stdin>", line 1, in <module>File "<stdin>", line 5, in xFile "<stdin>", line 5, in xFile "<stdin>", line 5, in x[Previous line repeated 994 more times]File "<stdin>", line 2, in x RecursionError: maximum recursion depth exceeded in comparison

如代码所示，使用递归函数的优点是逻辑简单清晰，缺点是过深的调用会导致栈溢出。

针对尾递归优化的语言可以通过尾递归防止栈溢出。尾递归事实上和循环是等价的，没有循环语句的编程语言只能通过尾递归实现循环。

Python标准的解释器没有针对尾递归做优化，任何递归函数都存在栈溢出的问题。

什么是尾递归？这个请读者自行查询呗，这里就不介绍啦，嘿嘿~~~

下面来个斐波拉契数列：

#斐波拉契数列 >>>def fibo(arg1,arg2): ... if arg1 == 0: ... print(arg1,arg2) ... arg3 = arg1 + arg2 ... print(arg3) ... fibo(arg2, arg3) ... >>>fibo(0,1)

上述代码展示的斐波拉契数列会一直计算，直至栈溢出：

#斐波拉契数列导致栈溢出 488272859468887457959087733119242564077850743657661180827326798539177758919828135114407499369796465649524266755391104990099120377 Traceback (most recent call last):File "<stdin>", line 1, in <module>File "<stdin>", line 6, in fiboFile "<stdin>", line 6, in fiboFile "<stdin>", line 6, in fibo[Previous line repeated 992 more times]File "<stdin>", line 5, in fibo RecursionError: maximum recursion depth exceeded while calling a Python object 16602747662452097049541800472897701834948051198384828062358553091918573717701170201065510185595898605104094736918879278462233015981029522997836311232618760539199036765399799926731433239718860373345088375054249

如何才能避免栈溢出呢？自己想呗，要不大脑会生锈的。

对于汉罗塔问题，利用递归来解决该问题也是相当的简单，且代码清晰：

#递归解决汉罗塔问题 >>>def hanrota(n,a,b,c): ... if n == 1: ... print(a,'-->',c) ... else: ... hanrota(n - 1,a,c,b) ... hanrota(1,a,b,c) ... hanrota(n - 1,b,a,c) ... >>>hanrota(3,'A','B','C') A --> C A --> B C --> B A --> C B --> A B --> C A --> C

匿名函数

定义函数真得不可多得，但有时候不需要显示地定义函数。因此，函数也需要灵活地运用。使用匿名函数可以更加方便。

匿名函数语法：

lambda x: x * x(关键字lambda表示匿名函数，冒号前面的x表示函数参数)

def f(x):return x * x

匿名函数的好处：因为函数没有名字，不必担心函数名冲突。

def is_odd(n):return n % 2==1L = list(filter(lambda n: n%2==1,range(1,20)))print(L)　　

1.匿名函数也是一个函数对象，也可以把匿名函数赋值给一个变量，再利用变量来调用该函数。

2.Python中，匿名函数可以作为返回值返回并输出结果。

总结

以上是生活随笔为你收集整理的Python编程核心内容 ---- Function（函数）的全部内容，希望文章能够帮你解决所遇到的问题。

如果觉得生活随笔网站内容还不错，欢迎将生活随笔推荐给好友。