函数基础

除了可以直接使用的内置函数外，Python还支持自定义函数，即将一段有规律的、可重复使用的代码定义成函数，从而达到一次编写、多次调用的目的。

函数的本质就是一段有特定功能、可以重复使用的代码，这段代码已经被提前编写好了，并且为其起一个好听的名字。在后续编写程序过程中，如果需要同样的功能，直接通过起好的名字就可以调用这段代码。

函数的作用

  • 结构化编程对代码的最基本的封装，一般按照功能组织一段代码；
  • 封装的目的为了复用，减少冗余代码；
  • 代码更加简洁美观、可读易懂

函数的定义

Python函数：能完成一定的功能，由若干语句组成的语句块、函数名称、参数列表构成，它是组织代码的最小单元。

语法格式

1
2
3
4
def 函数名(参数1,参数2,参数3,...):
    '''注释'''
    函数体
    return 返回的值

需要注意的地方：

  • 函数名后面必须加冒号；
  • 函数名即标识符，命名规范：小写字母，多个单词用_间隔；
  • 如果函数体和def不在同一行，必须缩进，约定4个空格；
  • 若没有return，则隐式返回一个None值；
  • 如果函数体body语句只有一行，或者可以简写为一行，则可以写在def的同行。例如：
1
def myfunc(x,y,z): print(x+y+z)

函数的调用

如何调用

函数声明好之后，就可以执行函数，执行函数也称为调用函数，方式为func_name(args)，例如：

1
myfunc(1,2,3)

调用规则

函数的使用，必须遵循原则：先定义，后调用。

若在前面调用了，后面再定义，是否会报错呢？

测试一：

1
2
3
4
5
6
7
def bar():
    print('from bar')

def foo():
    print('from foo')
    bar()
foo() # 正常

测试二：

1
2
3
4
5
6
7
def foo():
    print('from foo')
    bar()
    
def bar():
    print('from bar')
foo() # 也正常

测试三：

1
2
3
4
5
6
7
8
9
10
def foo():
    print('from foo')
    bar()

foo()    
    
def bar():
    print('from bar')
# 报错
NameError: name 'bar' is not defined

函数的返回值

函数返回值：

  • 没有返回值：默认返回None
  • 返回一个值：函数结束了且返回一个值
  • 返回多个值：多个值之间用逗号隔开，接收的时候可以用一个变量接收(返回元组)，也可以用等量的多个变量接收

什么时候需要有返回值？

调用函数，经过一系列的操作，最后要拿到一个明确的结果，则必须要有返回值。

通常有参函数需要有返回值，输入参数，经过计算，得到一个最终的结果。

什么时候不需要有返回值？

调用函数，仅仅只是执行一系列的操作，最后不需要得到什么结果，则无需有返回值。

通常无参函数不需要有返回值。

多个返回值

Python的函数支持返回多个值。返回多个值时，默认以tuple的方式返回。例如，下面两个函数的定义是完全等价的。

1
2
3
4
5
def f():
    return 1,2

def f():
    return (1,2)

丢弃返回值

1
2
3
4
5
6
7
8
9
10
# 不进行任何赋值，将丢弃所有返回值
f()

# 可以通过索引取得某个或某几个返回值
a = f()[0]
b = f()[1]

# 使用双下划线__或更多下划线___________
# 丢弃第二个返回值
a, __ = f()

函数调用时的*和**

除了在def定义函数时，参数中可以使用*或**收集参数，在函数调用的时候也可以使用*或**分别解包元组(列表或其它对象)、字典。一定要注意区分函数定义和函数调用时的*、**，它们的用法是不通用的。

例如，解包元组：

1
2
3
4
5
6
7
8
def f(a,b,c,d):
    print(a)
    print(b)
    print(c)
    print(d)

T=(1,2,3,4)
f(*T)

*除了可以解包元组，还可以解包其它可迭代对象，例如列表。甚至是字典也能解包，只不过*解包的字典得到的是key组成的参数列表，和value无关：

1
2
3
4
5
6
7
8
D=dict(a=11,b=22,c=33,d=44)
f(*D)

# 输出：
a
b
c
d

而**解包的字典则是key=value组成的参数列表。以下是函数调用时使用**进行解包，字典D中的key名称必须和def中定义的参数名称相同：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
def f(a,b,c,d):
    print(a)
    print(b)
    print(c)
    print(d)

D=dict(a=11,b=22,c=33,d=44)
f(**D)

# 输出：
11
22
33
44

在函数调用时，可以混合位置参数、关键字参数、*解包参数、**解包参数。用法非常的灵活：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
def f(a,b,c,d):
    print(a)
    print(b)
    print(c)
    print(d)

f(*(1,2),**{'d':4,'c':3})

f(1,*(2,3),**{'d':4})

f(1,c=3,*(2,),**{'d':4})

f(1,*(2,3),d=4)

f(1,*(2,),c=3,**{'d':4})

# 结果如下
1
2
3
4
1
2
3
4
1
2
3
4
1
2
3
4
1
2
3
4

上面调用函数时的效果都等同于f(1,2,3,4)。

函数的参数

函数的参数其实也是变量，只不过这些变量是独属于函数的本地变量，函数外部无法访问。在函数调用的时候，会将给定的值传递给函数的参数，这实际上是变量赋值的过程。例如：

1
2
3
4
def myfunc(x,y,z):
    print(x,y,z)

myfunc(1,2,3)

形参和实参

形参即变量名，实参即变量值，函数调用时，将值绑定到变量名上，函数调用结束，解除绑定。

形参：定义函数时，小括号中的参数，是用来接收参数用的，在函数内部作为变量使用。

实参：调用函数时，小括号中的参数，是用来把数据传递到函数内部用的。

参数的传递

参数的传递可以分为按指针传参、按位置传参、按关键字key=value方式传参。

按指针传参

Python中变量赋值、参数传递都是通过指针拷贝的方式进行的。都只是拷贝了源数据的一个地址，而不会拷贝内存中完整的数据对象副本。所以，如果在函数内部修改变量指向的数据对象，会影响函数外部的数据。

例如：

1
2
3
4
5
6
7
8
9
def f(x):
    print(x+3)


a = 4
f(a)

# 输出结果
7

按位置传参

如果是多个参数，则按从左到右的顺序进行参数变量的赋值：

1
2
3
4
5
6
7
8
9
10
11
12
def f(x, y, z):
    print(x)
    print(y)
    print(z)


f(2, 3, 4)

# 输出结果
2
3
4

调用f(2,3,4)的时候，会按照从左向右的位置方式对本地变量x、y、z赋值：x=2,y=3,z=4。

按关键字key=value方式传参

Python还支持key=value的方式设置函数调用时的参数，使用key=value的方式赋值时，顺序不重要。这种函数调用时的传值方式称为关键字传值。

例如：

1
2
3
4
5
6
7
8
9
10
11
12
def f(x, y, z):
    print(x)
    print(y)
    print(z)


f(x=3, y="haha", z=4)

# 输出
3
haha
4

也可以打乱顺序，输出结果不变：

1
f(x=3, z=4, y="haha")

还可以将key=value和位置传参的方式进行混合：

1
f(3, "haha", z=4)

但混合按位置传参方式的时候，位置参数必须在其它传参方式的前面，不仅此处结合key=value时如此，后文中位置参数结合其它方式传参也都如此：位置参数必须在最前面。例如，下面的传参方式是错的：

1
f(z=4, 3, "haha")

参数默认值

在def或lambda声明函数的时候，可以通过var=default的方式指定参数的默认值。

例如：

1
2
3
4
5
6
7
8
9
10
11
12
def f(x=3):
    print(x)


f(4)
f("haha")
f()

# 输出结果
4
haha
3

上面的f(4)和f("haha")都对函数f()的本地变量x进行了赋值。但是最后一个调用语句f()未赋值，而是使用参数的默认值3。

设置参数默认值时，如果函数有多个参数，则带默认值参数后面必须放在最后面。例如：

1
2
3
4
5
6
# 正确
def f(x, y, z=4)
def f(x, y=1, z=4)

# 错误
def f(x, y=4, z)

只要为参数设置了默认值，那么调用函数的时候，这个参数就是可选的，可有可无的，如果没有，则采用默认值。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
def f(x, y=2, z=4):
    print(x)
    print(y)
    print(z)


# 不采用任何默认值
f(2, 3, 4)

# 采用z的默认值
f(2, 3)

# 采用y的默认值
# 此时z必须按key=value的方式传值
f(2, z=5)

# y、z都采用默认值
f(2)

# 输出结果
2
3
4
2
3
4
2
2
5
2
2
4

位置可变参数*

对于任意长度的参数，可以在def声明的函数中使用*将各位置参数收集到一个元组中。

1
2
3
4
5
6
7
def f(*args):
    print(args)


f(1, 2, 3, 4)

# 结果输出：(1, 2, 3, 4)

上面调用f(1, 2, 3, 4)的时候，将所有参数都收集到了一个名为args的元组中。

既然是元组，就可以对参数进行迭代遍历：

1
2
3
4
5
6
7
8
9
10
11
def f(*args):
    for arg in args:
        print(arg)

f(1,2,3,4)

# 输出结果
1
2
3
4

必须注意，*是按位置收集参数的。

1
2
3
4
5
6
7
8
def f(x, y, *args):
    print(x)
    print(y)
    for arg in args:
        print(arg)


f(1, 2, 3, 4)

按照从左向右的传参规则，首先将1赋值给x，将2赋值给y，然后将剩余所有的位置参数收集到args元组中，所以args=(3,4)。

如果*后面还有参数，则调用函数的时候，后面的参数必须使用key=value的方式传递，否则会收集到元组中，从而导致参数缺少的问题：

1
2
3
4
5
6
7
8
9
10
11
12
def f(x, *args, y):
    print(x)
    print(y)
    for arg in args:
        print(arg)


# 正确
f(1, 3, 4, y=2)

# 错误
f(1, 2, 3, 4)

上面调用f(1, 3, 4, y=2)的时候，会按照位置参数对x赋值为1，然后将所有位置参数收集到元组args中，因为y=2是非位置参数传值方式，所以args=(3, 4)。

如果为上面的y设置默认值：

1
def f(x, *args, y=2)

那么f(1, 2, 3, 4)会将(2, 3, 4)都收集到元组args中，然后y采用默认值2。

关键字可变参数**

除了可以使用*将位置参数收集到元组中，还可以使用**将key=value格式的参数收集到字典中。

例如：

1
2
3
4
5
6
def f(x, **args):
    print(x)
    print(args)


f(1, a=11, b=22, c=33, d=44)

既然是将参数收集到字典中，就可以使用字典类的工具操作这个字典。例如，遍历字典。

在**的后面不能出现任何其它类型的参数。例如，下面的都是错误的def定义方式：

1
2
3
def f(x, **args, y)
def f(x, **args, y=3)
def f(x, **args, *t)

只能将位置参数或者*的收集放在**的前面。

1
2
def f(x, y, **args)
def f(x, *args1, **args2)

keyword-only参数形式

keyword-only的参数传值方式表示def中如果使用了*，那么在调用函数时，它后面的参数必须只能使用关键字传值。其实在前面的内容中已经出现过几次与之相关的说明。

另外注意，*才是keyword-only开关，**不是，虽然**也有自己的一些语法限制：任意类型的参数定义都必须在**之前，包括keyword-only类型的参数。例如：

1
2
def f(a, *b, c):
    print(a, b, c)

按照keyword-only的规则，被*b收集的位置参数不包括c，这个c必须只能使用关键字的方式传值，否则就被当作位置参数被收集到元组b中。

1
2
3
4
5
6
7
8
# 正确
f(1, 2, 3, c=4)

# 错误
f(1, 2, 3, 4)

# 错误
f(1, c=4, 2, 3)

其中最后一个错误和如何def的定义无关，而是函数调用时的语法错误，前面已经解释过：位置参数必须放在最前面。

还可以直接使用*而非*args的方式，这表示不收集任何参数，但却要求它后面的参数必须按照关键字传值的方式。

1
2
def f(a, *, b, c):
    print(a, b, c)

以下是正确和错误的调用方式示例：

1
2
3
4
5
6
7
8
9
# 正确
f(1, b=2, c=3)
f(1, c=3, b=2)
f(b=2, c=3, a=1)

# 错误
f(1, 2, 3)
f(1, 2, c=3)
f(1, b=2, 3)

不过，keyword-only后面的参数可以使用参数默认值。

1
def f(a, *, b, c=3)

那么c是可选的，但如果给定，则必须按关键字方式传值。