Python函数详解：参数、返回值和文档字符串

函数介绍

函数简介（function）

函数是Python中的重要概念，它可以让我们将一个或一组语句封装起来，以便在其他地方反复调用。这样就可以提高代码的复用性和可维护性。下面是一些关于函数的基本知识：

• 函数是一个对象，也属于Python语言的标准类型之一。
• 创建函数时使用def语句，后跟函数名和参数列表，然后是冒号和函数体，函数体中是要执行的语句。
• 函数名必须符合标识符规范，可以包含字母、数字、下划线，但不能以数字开头。
• 定义函数不会立即执行函数体的语句，需要调用函数才会执行。
• 调用函数时，可以向函数传递实参。
• 函数也可以返回值，也可以没有返回值。

举个例子，我们可以定义一个简单的函数fn来输出一些信息：

def fn():
    print('这是我的第一个函数！')
    print('hello')
    print('今天天气真不错！')
1
2
3
4

函数定义好了之后，我们可以调用这个函数：

fn()
1

这样就会输出函数中的三行文本。

在函数中还可以指定形参，形参就是函数定义时用来接收实参的变量，例如：

def fn2(a, b):
    print(a, '+', b, '=', a + b)
1
2

我们可以调用该函数，并向它传递实参：

fn2(10, 20)
fn2(123, 456)
1
2

这样就会输出相应的结果。

函数的参数

在定义函数时，可以在函数名后的()中定义数量不等的形参，多个形参之间使用,隔开。形参（形式参数）定义形参就相当于在函数内部声明了变量，但是并不赋值。实参（实际参数）如果函数定义时，指定了形参，那么在调用函数时也必须传递实参，实参将会赋值给对应的形参，简单来说，有几个形参就得传几个实参。

练习1:

定义一个函数，可以用来求任意三个数的乘积

# 求任意三个数的乘积
def mul(a,b,c):
    print(a*b*c)
1
2
3

练习2：

定义一个函数，可以根据不同的用户名显示不同的欢迎信息

# 根据不同的用户名显示不同的欢迎信息   
def welcome(username):
    print('欢迎',username,'光临')
1
2
3

代码运行示例：

mul(1,2,3)   
welcome('孙悟空') 
1
2

定义一个函数，在定义形参时，可以为形参指定默认值。指定了默认值以后，如果用户传递了参数则默认值没有任何作用，如果用户没有传递，则默认值就会生效。

def fn(a = 5 , b = 10 , c = 20):
    print('a =',a)
    print('b =',b)
    print('c =',c)
1
2
3
4

代码运行示例：

fn(1 , 2 , 3)
fn(1 , 2)
fn()
1
2
3

实参的传递方式：

• 位置参数：位置参数就是将对应位置的实参复制给对应位置的形参。第一个实参赋值给第一个形参，第二个实参赋值给第二个形参…

fn(1 , 2 , 3)
1

• 关键字参数：关键字参数可以不按照形参定义的顺序去传递，而直接根据参数名去传递参数。

fn(b=1 , c=2 , a=3)
1

位置参数和关键字参数可以混合使用，混合使用关键字和位置参数时，必须将位置参数写到前面。

fn(1,c=30)
1

def fn2(a):
    print('a =',a)

# 函数在调用时，解析器不会检查实参的类型
# 实参可以传递任意类型的对象
b = 123
b = True
b = 'hello'
b = None
b = [1,2,3]

fn2(b)    
fn2(fn)
1
2
3
4
5
6
7
8
9
10
11
12
13

def fn3(a , b):
    print(a+b)

fn3(123,"456")
1
2
3
4

在函数中对形参进行重新赋值，不会影响其他的变量。但是如果形参执行的是一个对象，当我们通过形参去修改对象时，会影响到所有指向该对象的变量。

def fn4(a):
    # 在函数中对形参进行重新赋值，不会影响其他的变量
    # a = 20
    # a是一个列表，尝试修改列表中的元素
    # 如果形参执行的是一个对象，当我们通过形参去修改对象时
    #   会影响到所有指向该对象的变量
    a[0] = 30
    print('a =',a,id(a))

c = 10   
c = [1,2,3] 

fn4(c)
fn4(c.copy())
fn4(c[:])

print('c =',c,id(c))
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

不定长的参数

在Python中，我们经常会遇到需要处理不定长度的参数的情况。不定长的参数指的是函数在定义时，无法确定实际调用时会传入多少个参数。那么，如何处理这种情况呢？接下来我们将介绍如何定义一个可以求任意个数字和的函数。

def sum(*nums):
    result = 0
    for n in nums:
        result += n
    print(result)
1
2
3
4
5

以上代码定义了一个名为sum的函数，它使用了一个带有星号（*）的形参nums，这样它就可以接收任意个参数，并将这些参数保存到一个元组中。然后，我们可以使用循环遍历这个元组，将其中的数进行累加，并打印结果。

现在，我们来测试一下这个函数：

sum(123, 456, 789, 10, 20, 30, 40)
1

运行后，输出结果为：1458。

带星号的形参

除了上述的不定长参数，我们还可以使用带星号（*）的形参来处理不定长度的参数。带星号的形参只能有一个，并且必须写在所有参数的最后。

def fn(*a):
    print("a =", a, type(a))
1
2

以上代码定义了一个名为fn的函数，它的形参是一个带星号的a。当我们调用这个函数时，它会将所有的位置实参统一保存到一个元组中，并打印出来。

让我们来测试一下：

fn(1, 2, 3, 4, 5)
1

运行后，输出结果为：a = (1, 2, 3, 4, 5) 。

带星号的形参可以和其他参数配合使用。例如，我们可以同时使用带星号的形参和普通的位置参数：

def fn2(a, *b, c):
    print('a =', a)
    print('b =', b)
    print('c =', c)
1
2
3
4

以上代码定义了一个名为fn2的函数，它的形参包括一个普通的位置参数a、一个带星号的形参b和一个关键字参数c。在调用这个函数时，第一个实参会赋值给a，剩下的位置实参会保存到b的元组中，并且c必须使用关键字参数来传递。

让我们来测试一下：

fn2(1, 2, 3, 4, c=5)
1

运行后，输出结果为：

a = 1
b = (2, 3, 4)
c = 5
1
2
3

特殊用法和注意事项

除了前面介绍的用法，带星号的形参还有一些特殊用法和需要注意的地方。

首先，如果在形参的开头直接写一个星号（*），则要求所有的参数必须以关键字参数的形式传递。例如：

def fn2(*, a, b, c):
    print('a =', a)
    print('b =', b)
    print('c =', c)
1
2
3
4

以上代码定义了一个名为fn2的函数，它没有位置参数，所有参数都必须使用关键字参数来传递。

让我们来测试一下：

fn2(a=3, b=4, c=5)
1

运行后，输出结果为：

a = 3
b = 4
c = 5
1
2
3

另外，带星号的形参只能接收位置参数，而不能接收关键字参数。下面的代码会产生错误：

def fn3(*a):
    print('a =', a)
1
2

在调用这个函数时，无论使用什么样的方式，都会导致错误：

fn3(1, 2, 3)           # 错误！不能使用位置参数
fn3(a=1, b=2, c=3)     # 错误！不能使用关键字参数
1
2

最后，我们还可以通过参数解包（拆包）的方式将序列或字典中的元素作为实参传递给函数。例如：

def fn4(a, b, c):
    print('a =', a)
    print('b =', b)
    print('c =', c)

t = (10, 20, 30)
fn4(*t)     # 参数解包，相当于 fn4(10, 20, 30)

d = {'a': 100, 'b': 200, 'c': 300}
fn4(**d)    # 参数解包，相当于 fn4(a=100, b=200, c=300)
1
2
3
4
5
6
7
8
9
10

以上代码分别使用了参数解包来传递元组和字典中的元素给函数fn4。

函数的返回值

函数的返回值指的是函数执行完成后所返回的结果。在 Python 中，可以使用 return 语句来指定函数的返回值。函数可以直接使用返回值，也可以通过变量来接收返回值。

返回值的使用

下面是一个计算多个数之和的函数示例：

def sum(*nums):
    # 定义一个变量，来保存结果
    result = 0
    # 遍历元组，并将元组中的数进行累加
    for n in nums :
        result += n
    return result

r = sum(123, 456, 789)
1
2
3
4
5
6
7
8
9

在上述代码中，sum 函数接受多个参数，并将它们相加得到总和，然后通过 return 语句返回这个结果。调用函数时，可以直接使用函数的返回值，比如将其打印出来。

print(r)  # 输出结果为 1368
1

同时，还可以对返回值进行其他的操作，比如与其他数字相加。

print(r + 778)  # 输出结果为 2146
1

需要注意的是，函数只能有一个返回值，但这个返回值可以是任意对象，甚至可以是一个函数本身。

空的返回值

如果函数中仅写了一个 return，或者没有写 return，则相当于隐式地返回了 None。

def fn2():
    a = 10
    return

r = fn2()
print(r)  # 输出结果为 None
1
2
3
4
5
6

在上述代码中，函数 fn2 中没有指定返回值，而是直接使用了一个 return 语句。由于 return 后面没有跟任何值，因此相当于隐式地返回了 None。

函数的执行与返回

当函数执行到 return 语句时，函数将会立即结束，并将 return 后面的值作为返回结果返回给调用者。同时，函数中 return 后面的代码将不会再执行。

def fn3():
    print('hello')
    return
    print('abc')

r = fn3()
print(r)  # 输出结果为 hello 和 None
1
2
3
4
5
6
7

在上述代码中，函数 fn3 中的 print('abc') 并没有被执行，因为 return 语句已经结束了函数的执行。函数 fn3 的返回值是 None，因为 return 后面没有跟任何值。

提前结束函数执行

在函数中，可以使用 return 语句来提前结束函数的执行。当遇到 return 语句时，函数将立即结束执行并返回指定的值。

def fn4():
    for i in range(5):
        if i == 3:
            return  # 遇到 i 等于 3 的时候提前结束函数执行
        print(i)
    print('循环执行完毕！')

fn4()
1
2
3
4
5
6
7
8

在上述代码中，函数 fn4 使用了一个循环来打印出 0 到 4 的数字。当 i 等于 3 时，执行了 return 语句，函数 fn4 立即结束了执行。因此，循环中后续的代码和最后一行的打印语句都不会执行。

文档字符串（doc str）

在Python中，我们可以通过编写文档字符串来为函数添加说明。文档字符串是函数定义中的一个字符串，用于描述函数的作用、参数和返回值等信息。有了文档字符串，我们可以使用help()函数来查看函数的说明。

下面是一个函数示例：

def fn(a:int,b:bool,c:str='hello') -> int:
    '''
    这是一个文档字符串的示例

    函数的作用：。。。。。
    函数的参数：
        a，作用，类型，默认值。。。。
        b，作用，类型，默认值。。。。
        c，作用，类型，默认值。。。。
    '''
    return 10
1
2
3
4
5
6
7
8
9
10
11

上面的代码中，函数fn有三个参数a、b和c，分别是整数型、布尔型和字符串型。其中，参数c有一个默认值'hello'。函数的返回值是整数型。

我们可以使用help()函数来查看函数fn的说明：

help(fn)
1

运行上述代码，将会输出函数fn的说明文档。

函数的说明文档

函数fn的说明文档如下：

fn(a:int,b:bool,c:str='hello') -> int
    这是一个文档字符串的示例

    函数的作用：。。。。。
    函数的参数：
        a，作用，类型，默认值。。。。
        b，作用，类型，默认值。。。。
        c，作用，类型，默认值。。。。
1
2
3
4
5
6
7
8

说明文档使用了标准的格式，可以清晰地描述函数的作用、参数和返回值。在函数的第一行直接编写一个字符串，就可以作为文档字符串。

有了文档字符串，我们可以通过help()函数来查看函数的说明。比如，我们可以使用以下代码来查看函数fn的说明：

help(fn)
1

运行上述代码，将会输出函数fn的说明文档。

通过文档字符串，我们可以更好地理解函数的功能和使用方法，帮助我们编写更好的代码。所以，在编写函数时，不妨考虑添加文档字符串，让代码更加友好和易于理解。