函数-参数

函数参数1

函数可以获取参数，这个参数的值由你所提供，借此，函数便可以利用这些值来做一些事

情。这些参数与变量类似，这些变量的值在我们调用函数时已被定义，且在函数运行时均已

赋值完成。

函数中的参数通过将其放置在用以定义函数的一对圆括号中指定，并通过逗号予以分隔。当

我们调用函数时，我们以同样的形式提供需要的值。要注意在此使用的术语 —— 在定义函数

时给定的名称称作 “ 形参 ” （ Parameters ），在调用函数时你所提供给函数的值称作 “ 实 参 ”（ Arguments）。

# 案例（保存为 function_param.py ）：
def print_max(a, b):
if a > b:
print(a, 'is maximum')
elif a == b:
print(a, 'is equal to', b)
else:
print(b, 'is maximum')
# 直接传递字面值
print_max(3, 4)
x = 5
y = 7
# 以参数的形式传递变量
print_max(x, y)

输出：

$ python function_param.py

4 is maximum

7 is maximum

它是如何工作的

在这里，我们将函数命名为 print_max 并使用两个参数分别称作 a 和 b 。我们使用一个

简单的 if...else 语句来找出更大的那个数，并将它打印出来。

第一次调用函数 print_max 时，我们以实参的形式直接向函数提供这一数字。在第二次调用

时，我们将变量作为实参来调用函数。 print_max(x, y) 将使得实参 x 的值将被赋值给形参

a ，而实参 y 的值将被赋值给形参 b 。在两次调用中， print_max 都以相同的方式工作。

局部变量2

当你在一个函数的定义中声明变量时，它们不会以任何方式与身处函数之外但具有相同名称

的变量产生关系，也就是说，这些变量名只存在于函数这一局部（ Local ）。这被称为变量的

作用域（ Scope ）。所有变量的作用域是它们被定义的块，从定义它们的名字的定义点开始。

案例（保存为 function_local.py ）：

x = 50
def func(x):
print('x is', x)
x = 2
print('Changed local x to', x)
func(x)
print('x is still', x)
输出：
$ python function_local.py
x is 50
Changed local x to 2
x is still 50

它是如何工作的

当我们第一次打印出存在于函数块的第一行的名为 x 的值时， Python 使用的是在函数声明

之上的主代码块中声明的这一参数的值。

接着，我们将值 2 赋值给 x 。 x 是我们这一函数的局部变量。因此，当我们改变函数中

x 的值的时候，主代码块中的 x 则不会受到影响。

随着最后一句 print 语句，我们展示出主代码块中定义的 x 的值，由此确认它实际上不受

先前调用的函数中的局部变量的影响。

global 语句

如果你想给一个在程序顶层的变量赋值（也就是说它不存在于任何作用域中，无论是函数还

是类），那么你必须告诉 Python 这一变量并非局部的，而是全局（ Global ）的。我们需要通

过 global 语句来完成这件事。因为在不使用 global 语句的情况下，不可能为一个定义于

函数之外的变量赋值。

你可以使用定义于函数之外的变量的值（假设函数中没有具有相同名字的变量）。然而，这

种方式不会受到鼓励而且应该避免，因为它对于程序的读者来说是含糊不清的，无法弄清楚

变量的定义究竟在哪。而通过使用 global 语句便可清楚看出这一变量是在最外边的代码块

中定义的。

# 案例（保存为 function_global.py ）：
x = 50
def func():
global x
print('x is', x)
x = 2
print('Changed global x to', x)
func()
print('Value of x is', x)

输出：
$ python function_global.py
x is 50
Changed global x to 2
Value of x is 2

它是如何工作的：

global 语句用以声明 x 是一个全局变量 —— 因此，当我们在函数中为 x 进行赋值时，这

一改动将影响到我们在主代码块中使用的 x 的值。

你可以在同一句 global 语句中指定不止一个的全局变量，例如 global x, y, z 。

默认参数值

对于一些函数来说，你可能会 希望使一些参数可选并使用默认的值 ，以 避免用户不想为他们

提供值的情况 。默认参数值可以有效帮助解决这一情况。你可以通过在函数定义时附加一个

赋值运算符（ = ）来为参数指定默认参数值。

要注意到，默认参数值应该是常数。更确切地说，默认参数值应该是不可变的 —— 这将在后

面的章节中予以更详细的解释。就目前来说，只要记住就行了。

案例（保存为 function_default.py ）：

def say(message, times=1):
print(message * times)
say('Hello')
say('World', 5)

输出：

$ python function_default.py

Hello

WorldWorldWorldWorldWorld

它是如何工作的

名为 say 的函数用以按照给定的次数打印一串字符串。如果我们没有提供一个数值，则将按

照默认设置，只打印一次字符串。我们通过为参数 times 指定默认参数值 1 来实现这一

点。

在第一次使用 say 时，我们只提供字符串因而函数只会将这个字符串打印一次。在第二次使

用 say 时，我们既提供了字符串，同时也提供了一个参数 5 ，声明我们希望说（ Say ）这

个字符串五次。

注意

只有那些位于参数列表末尾的参数才能被赋予默认参数值，意即在函数的参数列表中拥

有默认参数值的参数不能位于没有默认参数值的参数之前。

这是因为值是按参数所处的位置依次分配的。举例来说， def func(a, b=5) 是有效的，

但 def func(a=5, b) 是无效的。

关键字参数3

如果你有一些具有许多参数的函数，而你又希望只对其中的一些进行指定，那么你可以通过

命名它们来给这些参数赋值 —— 这就是关键字参数（ Keyword Arguments ） —— 我们使用命

名（关键字）而非位置（一直以来我们所使用的方式）来指定函数中的参数。

这样做有两大优点 —— 其一，我们不再需要考虑参数的顺序，函数的使用将更加容易。其

二，我们可以只对那些我们希望赋予的参数以赋值，只要其它的参数都具有默认参数值。

案例（保存为 function_keyword.py ）：

 

def func(a, b=5, c=10):
print('a is', a, 'and b is', b, 'and c is', c)
func(3, 7)
func(25, c=24)
func(c=50, a=100)

输出：

$ python function_keyword.py

a is 3 and b is 7 and c is 10

a is 25 and b is 5 and c is 24

a is 100 and b is 5 and c is 50

它是如何工作的

名为 func 的函数有一个没有默认参数值的参数，后跟两个各自带有默认参数值的参数。

在第一次调用函数时， func(3, 7) ，参数 a 获得了值 3 ，参数 b 获得了值 7 ，而 c

获得了默认参数值 10 。

在第二次调用函数时， func(25, c=24) ，由于其所处的位置，变量 a 首先获得了值 25 。然

后，由于命名 —— 即关键字参数 —— 指定，变量 c 获得了值 24 。变量 b 获得默认参数值

5 。

在第三次调用函数时， func(c=50, a=100) ，我们全部使用关键字参数来指定值。在这里要注

意到，尽管 a 在 c 之前定义，但我们还是我们在变量 a 之前指定了变量 c 。

可变参数4

有时你可能想定义的函数里面能够有任意数量的变量，也就是 参数数量是可变 的，这 可以通

过使用星号来实现 （将下方案例保存为 function_varargs.py ）：

def total(a=5, *numbers, **phonebook):
print('a', a)
#遍历元组中的所有项目
for single_item in numbers:
print('single_item', single_item)
#遍历字典中的所有项目
for first_part, second_part in phonebook.items():
print(first_part,second_part)
print(total(10,1,2,3,Jack=1123,John=2231,Inge=1560))

输出：

$ python function_varargs.py

a 10

single_item 1

single_item 2

single_item 3

Inge 1560

John 2231

Jack 1123

None

它是如何工作的

当我们声明一个诸如 *param 的星号参数时，从此处开始直到结束的所有位置参数

（ Positional Arguments ）都将被收集并汇集成一个称为 “param” 的元组（ Tuple ）。

类似地，当我们声明一个诸如 **param 的双星号参数时，从此处开始直至结束的所有关键字

参数都将被收集并汇集成一个名为 param 的字典（ Dictionary ）。