函数部分主要有函数的调用、函数的定义、函数的参数(参数部分比较难，相对于java增加了好多新的概念，参数可以各种组合)、函数的递归。

函数的调用

为什么先强调函数的调用呢，因为Python有好多内置函数，可以为我们解决各种问题。举几个例子：

#!/usr/bin/env python3# -*- coding: utf-8 -*-//abs() 获取绝对值，我们可以直接调用x = abs(100)//abs 赋值给a, 相当于a指向了abs函数，这也体现python赋值的强大之处a = absy = a(-20)// int、str ...数据转化函数，可以对数据进行转换，前提是可以相互转换的数据z = int('123')s = str(True)print(x, y,z,s)//数学类函数print('max(1, 2, 3) =', max(1, 2, 3))print('min(1, 2, 3) =', min(1, 2, 3))print('sum([1, 2, 3]) =', sum([1, 2, 3]))

输出结果：


100 20 123 Truemax(1, 2, 3) = 3min(1, 2, 3) = 1sum([1, 2, 3]) = 6

python内置函数的调用中，如果参数不匹配会出现 TypeError 错误：

Traceback (most recent call last):  File "F:/python/HelloWord/call_func.py", line 4, in <module>    x = a(100,200)TypeError: abs() takes exactly one argument (2 given)

函数的定义

在Python中，定义一个函数要使用def语句，依次写出函数名、括号、括号中的参数和  冒号:，然后，在缩进块中编写 函数体，函数的返回值用return语句返回，注意python中没有大括号。

#!/usr/bin/env python3# -*- coding: utf-8 -*-import math//自定义一个取绝对值的函数def my_abs(x):     //自定义类型异常捕获机制，关键字 isinstance    if not isinstance(x, (int, float)):        raise TypeError('bad operand type')    if x >= 0:        return x    else:        return -xn = my_abs(-20)print(n)# TypeError: bad operand type:# my_abs('123')

输出结果：

20

• 在函数中，一旦执行到return时，函数就执行完毕，并将结果返回，如果没有return 函数执行完成后默认 return None , 函数中 return None 可以简写成 return。

• 自定义的函数，参数类型不会像内置函数抛出 TypeError 异常，可以自定义TypeError 异常，来保证函数的严谨性。

空函数

def no_fun():    passprint(no_fun())

输出结果：

None

空函数的定义: 可以通过关键字 pass 来做函数体 意思很明显，直接通过

函数返回值

python 中支持多参数返回，实质上是返回一个tuple！

def move(x, y, step, angle=0):    nx = x + step * math.cos(angle)    ny = y - step * math.sin(angle)    return nx, ny// 多参数接收x, y = move(100, 100, 60, math.pi / 6)// 单参数接收n =  move(100, 100, 60, math.pi / 6)print(x, y,n)

输出结果：

151.96152422706632 70.0 (151.96152422706632, 70.0)

函数参数

函数的参数定义非常的灵活，支持必选参数、位置参数、默认参数、可变参数、关键字参数等、并且这些参数可以组合使用。

必选参数

def myPower(x):    return x * xprint("myPower (2)= ",myPower(2))

输出结果：

myPower(2) =  4

参数x为必选参数，否则TypeError: myPower() missing 1 required positional argument: 'x'。

位置参数

def myPower(x,n):    s = 1    while n > 0:        n = n - 1        s = s * x    return sprint("myPower = ",myPower(2,5))

输出结果：

myPower =  32

myPower(x, n)函数有两个参数：x和n，这两个参数都是位置参数，调用函数时，传入的两个值按照位置顺序依次赋给参数x和n。

默认参数

默认参数相当于java的重载，一个函数传入不同个数的参数，没有传的参数，会有默认参数来代替

def myPower(x,n = 2):    s = 1    while n > 0:        n = n - 1        s = s * x    return sprint("myPower = ",myPower(2))

输出结果：

myPower =  4

• 注意定义函数时，必选参数在前，默认参数在后

• 变化大的的默认参数在前，变化小的默认参数在后，符合使用规则

• 默认参数代替了java 中因为参数个数引起的重载，减少了函数的定义

• 定义默认参数要牢记一点：默认参数必须指向不变对象！比如定义一个函数，传入一个默认参数list:

#!/usr/bin/env python3# -*- coding: utf-8 -*-def my_list(L=[]):    L.append('END')    return LN = my_list([1,2,3,4,5])print(N)# 第一次调用参数K = my_list()print(K)# 第二次调用参数R = my_list()print(R)print('--------------------')def my_list1(L = None):    if L is None:        L = []    L.append('END')    return L# 第一次调用参数K1 = my_list1()print(K1)# 第二次调用参数R1 = my_list1()print(R1)

输出结果：

[1, 2, 3, 4, 5, 'END']['END']['END', 'END']--------------------['END']['END']

以上就可以看到，如果定义函数时，参数为list：L = [ ] 在多次使用默认参数时 就会出现 重复添加的情况，原因也很简单，我们定义了一个默认参数的值就会创建一个数据对象，函数执行完返回的值会存储在数据对象中，所以再次调用会呈现累加的情况，我们可以给参数定义一个None L = None 特殊的一个空对象(这个对象是不变的)，这样就不会造成累加的情况了。

可变参数

可变参数指传入的参数是可变的，不同于默认参数，可变参数可以理解为传入一个list或tuple，具体的使用有两种方式

#!/usr/bin/env python3# -*- coding: utf-8 -*-# 第一种def my_calc(numbers):    sum = 0    for n in numbers:        sum = sum + n * n    return sum#传入一个listm = [1,2,3,4,5,6]print(my_calc(m))# 第二种def my_calc1(*numbers):    sum = 0    for n in numbers:        sum = sum + n * n    return sum# 直接将参数用逗号隔开，传进去print(my_calc1(1,3,5,7,9))# 接收一个list的写法n = [2,4,6,8,10]print(my_calc1(*n))

输出结果：

91165220

可以看出可变参数的写法有两种，一种是直接传入一个list，第二种是用*numbers 直接将参数传入，list 传入时用 *n传入。

关键字参数

关键字参数允许你传入0个或任意个含参数名的参数，这些关键字参数在函数内部自动组装为一个dict。与java中传入一个map 集合类似，如下：

#!/usr/bin/env python3# -*- coding: utf-8 -*-def person(name, age, **kw):    print('name:', name, 'age:', age, 'other:', kw)    return# 通过name = value 形式传入person('张三', 35, weight=55,height = 175)##直接传入一个dictothers = {'weight': 65,'height': 185}person ('李四',45,**others)

输出结果：

name: 张三 age: 35 other: {'weight': 55, 'height': 175}name: 李四 age: 45 other: {'weight': 65, 'height': 185}

最后**others传入的是others 的复制版本，others 的变化不会引起函数的变化。

命名关键字参数

命名关键字是与位置参数比较的，位置可以灵活，写法在位置参数前加一个可变参数*args 或者*,命名关键字参数也可以有默认参数，如下：

#!/usr/bin/env python3# -*- coding: utf-8 -*-def person(name, age, *,  weight,heigth):    print('name=',name, 'age=',age,'weight=', weight,'heigth=', heigth)person('张三', 24, weight=55, heigth=175)def person(name, age, *args,  weight,heigth):    print('name=',name, 'age=',age,'weight=', weight,'heigth=', heigth,args)person('张三', 24,weight=55, heigth=175,*(1,2,3,4))

输出结果：

name= 张三 age= 24 weight= 55 heigth= 175name= 张三 age= 24 weight= 55 heigth= 175 (1, 2, 3)

组合参数

在Python中定义函数，可以用必选参数、默认参数、可变参数、关键字参数和命名关键字参数，这5种参数都可以组合使用。但是他们是有顺序的跟运算符的级别一样。顺序如下：

• 必选参数

• 默认参数

• 可变参数

• 命名关键字参数

• 关键字参数

要注意的是不要同时使用太多的组合，否则函数接口的可理解性很差。

#!/usr/bin/env python3# -*- coding: utf-8 -*-def f1(a, b, c=0, *args, **kw):    print('a =', a, 'b =', b, 'c =', c, 'args =', args, 'kw =', kw)args = (1, 2, 3, 4,5)kw = {'d': 99, 'x': '#'}f1(*args, **kw)

输出结果：

a = 1 b = 2 c = 3 args = (4, 5) kw = {'d': 99, 'x': '#'}

不可思议吧，看到这个结果，对照组合参数的级别不难理解。参数到这就介绍完了，只有多实践才能深入理解。

递归函数

递归函数在各种语言中都有，python的递归有啥特点呢？廖雪峰大神专门一节讲解，我们就来看看吧。

递归函数的优点是定义简单，逻辑清晰。理论上，所有的递归函数都可以写成循环的方式，但循环的逻辑不如递归清晰。递归函数的缺点是递归太深的话，因为python没有尾递归优化会导致栈溢出。

#!/usr/bin/env python3# -*- coding: utf-8 -*-#n! n的阶乘def fact(n):    if n==1:        return 1    return n * fact(n - 1)print(fact(10))print(fact(20))

输出结果：

36288002432902008176640000

参考

https://www.python.org
http://www.runoob.com/python3/python3-tutorial.html
https://www.liaoxuefeng.com

作者：猿来如痴链接：https://www.jianshu.com/p/433fabbf2ba7来源：简书简书著作权归作者所有，任何形式的转载都请联系作者获得授权并注明出处。