六、函数：
函数是重用的程序段。它们允许你给一块语句一个名称，然后你可以在你的程序的任何地方使用这个名称任意多次地运行这个语句块。这被称为调用函数。我们已经使用了许多内建的函数，比如len和range。
函数通过def关键字定义。def关键字后跟一个函数的标识符名称，然后跟一对圆括号。圆括号之中可以包括一些变量名，该行以冒号结尾。接下来是一块语句，它们是函数体。
1、定义函数：
例如：
|
1
2
3
4
5
6
7
8
|
# Filename: function1.py
def
sayHello():
print
(
'Hello World!'
)
# block belonging to the function
# End of function
sayHello()
# call the function
sayHello()
# call the function again
|
输出：
C:\Users\Administrator>python D:\python\function1.py
Hello World!
Hello World!
工作原理：
我们使用上面解释的语法定义了一个称为sayHello的函数。这个函数不使用任何参数，因此在圆括号中没有声明任何变量。参数对于函数而言，只是给函数的输入，以便于我们可以传递不同的值给函数，然后得到相应的结果。我们在上程序中调用了两次相同的函数从而避免了对同一程序段写两次。
2、函数形参：
函数取得的参数是你提供给函数的值，这样函数就可以利用这些值做一些事情。这些参数就像变量一样，只不过它们的值是在我们调用函数的时候定义的，而非在函数本身内赋值。
参数在函数定义的圆括号对内指定，用逗号分割。当我们调用函数的时候，我们以同样的方式提供值。注意我们使用过的术语——函数中的参数名称为形参而你提供给函数调用的值称为实参。
使用函数形参：
例如：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
|
# Filename: func_param.py
def
printMax(a, b):
if
a > b:
print
(a,
'is maximum'
)
elif
a
=
=
b:
print
(a,
'is equal to'
, b)
else
:
print
(b,
'is maximum'
)
printMax(
3
,
4
)
# directly give literal values
x
=
5
y
=
7
printMax(x, y)
# give variables as arguments
|
输出：
C:\Users\Administrator>python D:\python\func_param.py
4 is maximum
7 is maximum
工作原理：
这里，我们定义了一个称为printMax的函数，这个函数需要两个形参，a和b。我们使用if..else语句找出两者之中较大的一个数，并且打印较大的那个数。
在第一个printMax使用中，我们直接把数，即实参，提供给函数。在第二个使用中，我们使用变量调用函数。printMax(x, y)使实参x的值赋给形参a，实参y的值赋给形参b。在两次调用中，printMax函数的工作完全相同。
3、局部变量：
当你在函数定义内声明变量的时候，它们与函数外具有相同名称的其他变量没有任何关系，即变量名称对于函数来说是 局部的。这称为变量的作用域 。所有变量的作用域是它们被定义的块，从它们的名称被定义的那点开始。
例如：
|
1
2
3
4
5
6
7
8
9
10
11
|
# Filename: func_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)
|
输出：
C:\Users\Administrator>python D:\python\func_local.py
x is 50
Changed local x to 2
x is still 50
工作原理：
在函数中，我们第一次使用x的 值 的时候，Python使用函数声明的形参的值。
接下来，我们把值2赋给x。x是函数的局部变量。所以，当我们在函数内改变x的值的时候，在主块中定义的x不受影响。
在最后一个print语句中，我们证明了主块中的x的值确实没有受到影响。
4、全局变量：
如果你想要为一个定义在函数外的变量赋值，那么你就得告诉Python这个变量名不是局部的，而是全局的。我们使用global语句完成这一功能。没有global语句，是不可能为定义在函数外的变量赋值的。
你可以使用定义在函数外的变量的值（假设在函数内没有同名的变量）。然而，并不推荐这样做，并且我们应该尽量避免这样做，因为这使得程序的读者会不清楚这个变量是在哪里定义的。使用global语句可以清楚地表明变量是在外面的块定义的。
我们可以这样使用：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
|
# Filename: func_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)
|
输出：
C:\Users\Administrator>python D:\python\func_global.py
x is 50
Changed global x to 2
Value of x is 2
工作原理：
global语句被用来声明x是全局的——因此，当我们在函数内把值赋给x的时候，这个变化也反映在我们在主块中使用x的值的时候。
你可以使用同一个global语句指定多个全局变量。例如global x, y, z。
5、外部变量：
上面我们已经知道如何使用局部变量和全局变量，还有一个外部变量是在以上两种变量之间的变量。当我们在函数内声明了外部变量则在函数中就可见了。
由于任何东西在python内都是可执行代码，所以你可以在任何位置定义函数，就如以下例子中的func_inner()定义在func_outer()内也是可以的。
以下例子说明如何使用外部变量：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
# Filename: func_nonlocal.py
def
func_outer():
x
=
2
print
(
'x is'
, x)
def
func_inner():
nonlocal x
x
=
5
func_inner()
print
(
'Changed local x to'
, x)
func_outer()
|
输出：
C:\Users\Administrator>python D:\python\func_nonlocal.py
x is 2
Changed local x to 5
工作原理：
当我们在func_inner()函数中的时候，在函数func_outer()内第一行定义的变量x既不是内部变量(它不在func_inner块内)也不是全局变量(它也不在主程序块内)，这时我们使用nonlocal x声明我们需要使用这个变量。
你可以尝试改变声明方式，然后观察这几种变量的区别。
6、默认参数值
对于一些函数，你可能希望它的一些参数是可选的，如果用户不想要为这些参数提供值的话，这些参数就使用默认值。这个功能借助于默认参数值完成。你可以在函数定义的形参名后加上赋值运算符（=）和默认值，从而给形参指定默认参数值。
注意，默认参数值应该是一个常数。更加准确的说，默认参数值应该是不可变的。
使用默认参数值：
例如：
|
1
2
3
4
5
6
7
|
# Filename: func_default.py
def
say(message, times
=
1
):
print
(message
*
times)
say(
'Hello'
)
say(
'World'
,
5
)
|
输出：
C:\Users\Administrator>python D:\python\func_default.py
Hello
WorldWorldWorldWorldWorld
工作原理：
名为say的函数用来打印一个字符串任意所需的次数。如果我们不提供一个值，那么默认地，字符串将只被打印一遍。我们通过给形参times指定默认参数值1来实现这一功能。
在第一次使用say的时候，我们只提供一个字符串，函数只打印一次字符串。在第二次使用say的时候，我们提供了字符串和参数5，表明我们想要打印这个字符串消息5遍。
注：
只有在形参表末尾的那些参数可以有默认参数值，即你不能在声明函数形参的时候，先声明有默认值的形参而后声明没有默认值的形参。
这是因为赋给形参的值是根据位置而赋值的。例如，def func(a, b=5)是有效的，但是def func(a=5, b)是无效的。
7、关键字（Keyword）参数：
如果你的某个函数有许多参数，而你只想指定其中的一部分，那么你可以通过命名来为这些参数赋值——这被称作关键字参数，我们使用名字（关键字）而不是位置（我们前面所一直使用的方法）来给函数指定实参。
这样做有两个优势：一，由于我们不必担心参数的顺序，使用函数变得更加简单了；二、假设其他参数都有默认值，我们可以只给我们想要的那些参数赋值。
使用关键参数：
|
1
2
3
4
5
6
7
8
|
# Filename: func_key.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
)
|
输出：
C:\Users\Administrator>python D:\python\func_key.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的值。
8、可变（VarArgs）参数：
有些时候你可能希望定义一个可以接受任意个数参数的函数，你可以使用星号来完成。
例如：
|
1
2
3
4
5
6
7
8
9
10
11
|
# Filename: total.py
def
total(initial
=
5
,
*
numbers,
*
*
keywords):
count
=
initial
for
number
in
numbers:
count
+
=
number
for
key
in
keywords:
count
+
=
keywords[key]
return
count
print
(total(
10
,
1
,
2
,
3
, vegetables
=
50
, fruits
=
100
))
|
输出：
C:\Users\Administrator>python D:\python\total.py
166
工作原理：
当我们以星号声明一个形参，如*param，从这个位置开始到结束的实参都将被收集在'param'元组内，类似的，当我们以双星号声明一个形参，例如**param，则从这个位置开始到结束的实参都将会被收集在一个叫'param'的字典中。
对于元组和字典，我们后面有详细讲解。
9、关键字限定（Keyword-only）参数：
如果我们希望某些关键形参只能通过关键字实参的到而不是通过位置得到，我们可以将其声明在星号参数后面。
例如：
|
1
2
3
4
5
6
7
8
9
10
11
12
|
# Filename: keyword_only.py
def
total(initial
=
5
,
*
numbers, extra_number):
count
=
initial
for
number
in
numbers:
count
+
=
number
count
+
=
extra_number
print
(count)
total(
10
,
1
,
2
,
3
, extra_number
=
50
)
total(
10
,
1
,
2
,
3
)
# Raises error because we have not supplied a default argument value for 'extra_number'
|
输出：
C:\Users\Administrator>python D:\python\keyword_only.py
66
Traceback (most recent call last):
File "D:\python\keyword_only.py", line 11, in
total(10, 1, 2, 3)
TypeError: total() needs keyword-only argument extra_number
工作原理：
在星号形参后声明的形成就成了关键字限定参数。如果没有为这些实参提供一个默认值，那么必须在调用函数时以关键字实参为其赋值，否则将引发错误，如上例所示。
注意这里用到的x+=y等同于x=x+y。如果你不需要星号形参只需要关键字限定形参则可以省略星号形参的参数名，如total(initial=5, *, extra_number)。
10、return语句
return语句用来从一个函数返回即跳出函数。我们也可选从函数返回一个值。
例如：
|
1
2
3
4
5
6
7
8
9
10
11
|
# Filename: func_return.py
def
maximum(x, y):
if
x > y:
return
x
elif
x
=
=
y:
return
'The numbers are equal'
else
:
return
y
print
(maximum(
2
,
3
))
|
输出：
C:\Users\Administrator>python D:\python\func_return.py
3
工作原理：
maximum函数返回参数中的最大值，在这里是提供给函数的数。它使用简单的if..else语句来找出较大的值，然后返回那个值。
注意，没有返回值的return语句等价于return None。None是Python中表示没有任何东西的特殊类型。例如，如果一个变量的值为None，可以表示它没有值。
除非你提供你自己的return语句，每个函数都在结尾暗含有return None语句。通过运行print someFunction()，你可以明白这一点，函数someFunction没有使用return语句，如同：
|
1
2
3
|
def
someFunction():
pass
print
(someFunction())
|
输出就是None。
提示：python已经包含了一个被称作max的内建函数，它的功能即是寻找最大值，你可以尽可能使用这个函数。
11、文档字符串（DocStrings）：
Python有一个很奇妙的特性，称为文档字符串，它通常被简称为docstrings。DocStrings是一个重要的工具，由于它帮助你的程序文档更加简单易懂。你甚至可以在程序运行的时候，从函数恢复文档字符串！
例如：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
|
# Filename: func_doc.py
def
printMax(x, y):
'''Prints the maximum of two numbers.
The two values must be integers.'''
x
=
int
(x)
# convert to integers, if possible
y
=
int
(y)
if
x > y:
print
(x,
'is maximum'
)
else
:
print
(y,
'is maximum'
)
printMax(
3
,
5
)
print
(printMax.__doc__)
|
输出：
C:\Users\Administrator>python D:\python\func_doc.py
5 is maximum
Prints the maximum of two numbers.The two values must be integers.
工作原理：
在函数的第一个逻辑行的字符串是这个函数的文档字符串。同时，DocStrings也适用于模块和类，我们会在后面相应的章节学习它们。
文档字符串的惯例是一个多行字符串，它的首行以大写字母开始，句号结尾。第二行是空行，从第三行开始是详细的描述。强烈建议在函数中使用文档字符串时遵循这个惯例。
你可以使用__doc__（注意双下划线）调用printMax函数的文档字符串属性（属于函数的名称）。Python把每一样东西都作为对象，包括这个函数。
如果你已经在Python中使用过help()，那么你已经看到过DocStings的使用了！它所做的只是抓取函数的__doc__属性，然后整洁地展示给你。你可以对上面这个函数尝试一下——只是在你的程序中包括help(printMax)。记住按q退出help。
自动化工具也可以以同样的方式从你的程序中提取文档。因此，我们强烈建议你对你所写的任何正式函数编写文档字符串。随你的Python发行版附带的pydoc命令，与help()类似地使用DocStrings。
63
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
