在程序设计中，函数是指用于进行某种计算的一系列语句的有名称的组合。定义一个函数时，需要指定函数的名称并写下一系列程序语句。之后，就可以使用名称来“调用”这个函数

3.1函数调用

一个函数调用的例子

>>> type(42)

<class 'int'>

这个函数的名称是type，括号中的表达式我们称之为函数的参数。这个函数调用的结果是求得参数的类型。

我们通常说函数“接收”参数，并“返回”结果。这个结果也称为返回值

3.2数学函数

Python有一个数学计算模块，提供了大多数常用的数学函数。模块是指包含一组相关的函数的文件。

要想使用模块中的函数，需要先使用import语句将它导入运行环境

>>> import math

这个语句将会创建一个名为math的模块对象。如果显示这个对象，可以看到它的一些信息：

>>> math

<module 'math' (built-in)>

 

模块对象包含了该模块中定义的函数和变量。若要访问其中一个函数，需要同时指定模块名称和函数名称，用一个句点（.）分隔。这个格式称为句点表示法（dot notation）

>>> radians=0.7

>>> height=math.sin(radians)

>>> height

0.644217687237691

 

 

 

3.3组合

到现在为止，我们已经分别了解了程序的基本元素——变量、表达式和语句，但还没有接触如何将它们有机地组合起来。

程序设计语言最有用的特性之一就是可以将各种小的构建块（building block）组合起来。例如，函数的参数可以是任何类型的表达式，包括算术操作符：

>>> x = math.sin(degrees / 360.0 * 2 * math.pi)

甚至还包括函数调用：

>>> math.exp(math.log(x+1))

基本上在任何可以使用值的地方，都可以使用任意表达式，只有一个例外：赋值表达式的左边必须是变量名称，在左边放置任何其它的表达式都语法错误（后面还会看到这条规则的例外情况）

3.4添加新函数

我们可以自己添加新的函数。函数定义指定新函数的名称，并提供一系列程序语句，当函数被调用时，这些语句会顺序运行。

下面是一个例子：

>>> def print_lyrics():

... print("I'm a lumberjack,and I'm okay")

... print("I sleep all night and I Work all day.")

def是一个关键字，表示接下来是一个函数定义。这个函数的名称是print_lyrics。函数名称的书写规则与变量名称一：字母、数字、下划线是合法的，但第一个字符不能是数字。关键字不能作为函数名，而且我们应用尽量避免函数和变量同名。函数名后的空括号表示它不接收任何参数。

有所思：如果函数名与变量名一样会发生什么情况呢？

假如有一个变量a=1，后面又定一个函数也叫a,执行1个print语句，这时候变量名a指向的是函数对象呢，还是int类型的1呢？我猜肯定指向的是函数a，因为python是按顺序执行的语句，如果同一个变量名被重复定义，则以最后一次定义的内容为准。

>>> a =1

>>> type(a)

<class 'int'>


>>> def a():

... print("函数a")

...

>>> type(a)

<class 'function'>

函数定义的第一行称为函数头(header)，其它部分称为函数体(body)。函数头应该以冒号结束，函数体则应当整体缩进一级。依照惯例，缩进总是使用4个空格，函数体的代码语句行数不限。

本例中的print语句里的字符串使用双引号括起来。单引号和双引号的作用相同。大部分情况下，人们都使用单引号，只在本例中这样的特殊情况下才使用双引号。本例中的字符串里本身就存在单引号(这里的单引号作为缩略符号用)。

代码中所有的引号（包括双引号和单引号）都必须是”直引号”，通常在键盘上Enter键附近。而”斜引号”，在Python中是非法的。

如果在交互模式里输入函数定义，则解释器会输出省略号（...）提示用户当前的定义还没有结束：

>>> def print_lyrics():

... print("I'm a lumberjack,and I'm okay")

... print("I sleep all night and I Work all day.")

... 

 

想要结束这个函数的定义，需要输入一个空行。

定义一个函数会创建一个函数对象，其类型是”function”。

>>> print(print_lyrics)

<function print_lyrics at 0x7f25f96a8e18>

>>> type(print_lyrics)

<class 'function'>

 

调用新创建的函数的方式，与调用内置函数是一样的：

>>> print_lyrics()

I'm a lumberjack,and I'm okay

I sleep all night and I Work all day.

定义好一个函数之后，就可以在其它函数中调用它。例如，若想重复上面的歌词，我们可以写一个repeat_lyrics函数：

>>> def repeat_lyrics():

... print_lyrics()

... print_lyrics()

 

然后调用 repeat_lyrics:

>>> repeat_lyrics()

I'm a lumberjack,and I'm okay

I sleep all night and I Work all day.

I'm a lumberjack,and I'm okay

I sleep all night and I Work all day.

 

3.5 定义和使用

将前面一节的代码片段整合起来，整个流程就像下面这个样子：

def print_lyrics():
    print("I'm a lumberjack,and I'm okay")
    print("I sleep all night and I Work all day.")

def repeat_lyrics():
    print_lyrics()
    print_lyrics()

repeat_lyrics()  

这个程序包含两个函数定义： print_lyrics和repeat_lyrics。函数定义的执行方式和其他语句一样，不同的是执行后会创建函数对象。函数体里面的语句并不会立即运行，而是等到函数被调用时才执行。函数定义不会产生任何输出。

你可能已经猜到，必须先创建一个函数，才能运行它。换言之，函数定义必须在函数被调用之前先运行。

练习1：

作为练习，将程序的最后一行移动到行首，于是函数调用会先于函数定义执行。运行程序并查看会有什么样的错误信息。

repeat_lyrics()

def print_lyrics():
    print("I'm a lumberjack,and I'm okay")
    print("I sleep all night and I Work all day.")

def repeat_lyrics():
    print_lyrics()
    print_lyrics()

运行程序报错如下：

NameError: name 'repeat_lyrics' is not defined

练习2：

现在将函数调用那一行放回到末尾，并将函数print_lyrics 的定义移到函数 repeat_lyrics 定义之后。这时候运行程序会发生什么？

def repeat_lyrics():
    print_lyrics()
    print_lyrics()
def print_lyrics():
    print("I'm a lumberjack,and I'm okay")
    print("I sleep all night and I Work all day.")
repeat_lyrics()

我以为会报错，提示 print_lyrics 函数没有定义，为什么没有报错呢？

打开程序的debug模式调试程序，发现程序的执行顺序是这样的

def repeat_lyrics(): #1
print_lyrics()#4
print_lyrics()#7
def print_lyrics():#2
print("I'm a lumberjack,and I'm okay")#5  #8
print("I sleep all night and I Work all day.")#6  #9
repeat_lyrics()#3

为什么练习1会报错，而练习2却能正常运行呢？

原因就是：函数定义必须在函数被调用之前先运行。 函数体里面的语句并不会立即运行，而是等到函数被调用时才执行

在练习2中，在repeat_lyrics函数的函数体中，调用 print_lyrics函数，而在执行repeat_lyrics函数前（#3）， print_lyrics已经被定义过了（#2），所以程序不会出错。

而在练习1中，程序自上而下运行，首先执行调用repeat_lyrics函数的语句，而在此条语句之前又没有执行定义repeat_lyrics函数的语句所以会出错。

举一反三，下面这样执行程序也会报错，因为 print_lyrics函数还没有被定义，就已经被调用。

def repeat_lyrics():
    print_lyrics()
    print_lyrics()

repeat_lyrics()

def print_lyrics():
    print("I'm a lumberjack,and I'm okay")
    print("I sleep all night and I Work all day.")

NameError: name 'print_lyrics' is not defined

3.6 执行流程

为了保证函数的定义先于其首次调用执行，需要知道程序中语句运行的顺序，即执行流程。

执行总是从程序的第一行开始。语句按照从下到下的顺序逐一运行。

函数定义并不会改变程序的执行流程，但应注意函数体中的语句并不立即运行，而是等到函数被调用时运行。

函数调用可以看作程序运行流程中的一个迂回路径。遇到函数调用时，并不会直接继续运行下一条语句，而是跳到被调用函数的函数体的第一行，继续运行完函数体的所有语句，再跳回到原来离开的地方。

这样看似简单，但马上你就会发现，函数体中可以调用其他函数。当程序流程运行到一个函数之中时，可能需要运行其他函数中的语句。而后，当运行那个函数中的语句时，又可能再需要调用运行另外一个函数语句！

幸好Python对于它运行到哪里有很好的记录，所以每个函数执行结束后，程序都能跳回到它离开的地方。直到执行到整个程序的结尾，才会结束程序。

总之，在阅读代码时，并不总应该按照代码书写顺序一行行阅读；有时候，按照程序执行的流程来阅读代码，理解的效果可能会更好。

3.7 形参和实参

在函数内部，实参会赋值给称为形参(parameter)的变量。下面的例子是一个函数的定义，接收一个实参

def print_twice(bruce):
    print(bruce)
    print(bruce)

这个函数在调用时会把实参的值赋到形参bruce上，并将其打印两次。这个函数对任何可以打印的值都可用。

print_twice('span'*4)
span span span span 
span span span span 

print_twice(42)
42
42

print_twice(math.pi)

3.141592653589793

3.141592653589793

 

内置函数的组合规则，在用户自定义函数上同样可用，所以我们可以对print_twice 使用任何表达式作为实参：

>>> print_twice('span '*4)

span span span span

span span span span

>>> print_twice(math.cos(math.pi))

-1.0

-1.0

作为实参的表达式会在函数调用之前先执行。所以在这个例子中，表达式'span '*4和math.cos(math.pi)都只执行一次。

也可以使用变量作为实参：

>>> michael = 'Eric,the half a bee'

>>> print_twice(michael)

Eric,the half a bee

Eric,the half a bee

 

作为实参传入到函数的变量的名称(michael)和函数定义里形参的名称(bruce)没有关系。函数内部只关心形参的值，而不用关心它在调用前叫什么名字；在 print_twice函数内部，大家都叫bruce。

3.8 变量和形参是局部的

在函数体内新建一个变量时，这个变量是局部的(local)，即它只存在于这个函数之内。例如：

def print_twice(bruce):
    print(bruce)
    print(bruce)

def cat_twice(part1,part2):
    cat = part1+part2
    print_twice(cat)
这个函数接收两个实参，将它们拼接起来，并将结果打印两遍。下面是一个使用这一函数的例子：
line1 = 'Bing tiddle '
line2 = 'tiddle bang. '

>>> cat_twice(line1,line2)

Bing tiddle tiddle bang.

Bing tiddle tiddle bang.

 

当 cat_twice 结束时，变量cat会被销毁。这时再尝试打印它的话，会得到一个异常：

>>> print(cat)

NameError: name 'cat' is not defined

 

形参也是局部的。例如，在 print_twice函数之外，不存在 bruce这个变量。

3.9 栈图

要跟踪哪些变量在哪些地方使用，有时候画一个栈图(stack diagram)会很方便。和状态图一样，栈图可以展示每个变量的值，不同的是它会展示每个变量所属的函数。

每个函数使用一个帧包含，帧在栈图中就是一个带着函数名称的盒子，里面有函数的参数和变量。前面的函数示例的栈图如图3－1所示。

图中各个帧从上到下安排成一个栈，能够展示出哪个函数被哪个函数调用了。在这个例子里，print_twice被cat_twice调用，而cat_twice被__main__调用。__main__是用于表示整个栈图的图框的特别名称。在所有函数之外新建变量时，它就是属于__main__的。

每个形参都指向与其对应的实参相同的值，所以part1和line1的值相同，part2和line2的值相同，而bruce和cat的值相同。

如果调用函数的过程中发生了错误，Python会打出函数名、调用它的函数的名称，以及调用这个调用者的函数名，依此类推，一直到__main__。

例如，如果在print_twice中访问cat变量，则会得到一个NameError：

Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<stdin>", line 3, in cat_twice
  File "<stdin>", line 4, in print_twice
NameError: name 'cat' is not defined

上面这个函数列表被称为回溯（traceback）。它告诉你错误出现在哪个程序文件，哪一行，以及哪些函数正在运行。它也会显示导致错误的那一行代码。

回溯中函数的顺序和栈图中图框的顺序一致。当前正在执行的函数在最底部。

这里插个题外话，说到形参与实参的值相同，突然想到一个点，如果a与b的值相同，a 与 b可以视作是同个对象吗？神奇的是如果a与b都指同一个整数（指向同一个对象地址），python会认为它们是同一个对象，而如果a与b是浮点型，则python不认为它们是同一个对象(指向不同的对象地址)

>>> a=2

>>> b=2

>>> a is b

True

>>> id(a)

10943040

>>> id(b)

10943040

>>> a=2.3

>>> b=2.3

>>> a is b

False

>>> id(a)

139801075219456

>>> id(b)

139801075219648

3.10 有返回值函数和无返回值函数

在我们使用过的函数中，有一部分函数，如数学函数，会返回结果。因为没有想到更好的名字，我称这类函数为有返回值函数(fruitful function)。 另一些函数，如print_twice，会执行一个动作，但不返回任何值。我们称这类函数为无返回值函数(void function)。

当调用一个有返回值的函数时，大部分情况下你都想要对结果做某种操作。例如，你可能会想把它赋值给一个变量，或者在一个表达式中：

x = math.cos(radians)

golden = (math.sqrt(5)+1)/2

在交互模式中调用函数时，Python会直接显示结果：

>>> math.sqrt(5)

2.23606797749979

但是在脚本中，如果只是直接调用这类函数，那么它的返回值就会永远选择掉！

 

math.sqrt(5)

 

这个脚本计算5的平方根，但由于并没有把计算结果存储到某个变量中，或显示出来，所以其实没什么实际作用。

无返回值函数可能在屏幕上显示某些东西，或者有其他的效果，但是它们没有返回值。如果把该结果赋值给某个变量，则会得到一个特殊的值None。

>>> result = print_twice('Bing')

Bing

Bing

>>> print(result)

None

值None和字符串’None’并不一样。它是一个特殊的值，有自己独特的类型：

>>> type(None)

<class 'NoneType'>

到目前为止，我们自定义的函数都是无返回值函数。再过几章我们就会开始写有返回值的函数了。

 

3.11 为什么要有函数

为什么要花功夫将程序拆分成函数呢？也许刚开始编程的时候这其中的原因并不明晰。下面这些解释都可作为参考。

新建一个函数，可以让你有机会给一组语句命名，这样可以让代码更易读和更易调试。

函数可以通过减少重复代码使程序更短小。后面如果需要修改代码，也只要修改一个地方即可。

将一长段程序拆分成几个函数后，可以对每一个函数单独进行调试，再将它们组装起来成为完整的产品。

一个设计良好的函数，可以在很多程序中使用。书写一次，调试一次，复用无穷。

3.12调试

你将会掌握的一个最重要的技能就是调试。虽然调试可能时有烦恼，但它的确是编程活动中最耗脑力、最有挑战、最有趣的部分。

在某种程度上，调试和刑侦工作很像。你会面对一些线索，而且必须推导出事情发生的过程，以及导致现场结果的事件。

调试也像是一种实验科学。一旦猜出错误的可能原因，就可以修改程序，再运行一次。如果猜对了，那么程序的运行结果会符合预测，这样就离正确的程序更近了一步。如果猜错了，则需要重新思考。正如夏洛克.福尔摩丝所说的：“当你排除掉所有的可能性，那么剩下的，不管多么不可能，必定是真相。”

对某些人来说，编程和调试是同一件事。也就是说，编程正是不断调试修改直到程序达到设计目的的过程。这种想法的要旨是，应该从一个能做某些事的程序开始，然后做一点点修改，并调试改正，如此迭代，以确保总是有一个可以运行的程序。

例如，Linux是包含了数百万行代码的操作系统，但最开始只是Linus Torvalds编写的用来研究Intel 80386芯片的简单程序。据Larry Greenfield所说：“Linus最早的一个程序是交替打印AAAA 和 BBBB。后来这些程序演化成了Linux”

3.13术语表

函数(function):一个有名称的语句序列，可以进行某种有用的操作。函数可以接收或者不接收参数，可以返回或不返回结果。

 

函数定义(function definition):一个用来创建新函数的语句，指定函数的名称、参数以及它包含的语句序列。

 

函数对象(function object):函数定义所创建的值。函数名可以用作变量来引用一个函数对象。

 

函数头(header):函数定义的第一行。

 

函数体(body):函数定义内的语句序列。

 

形参(parameter):函数内使用的用来引用作为实参传入的值的名称。

 

函数调用(function call ):运行一个函数的语句。它由函数名称和括号中的参数列表组成。

 

实参(argument):当函数调用时，提供给它的值。这个值会被赋值给对应的形参。

 

局部变量(local variable):函数内定义的变量。局部变量只能在函数体内使用。

 

返回值(return value):函数的结果。如果函数被当作表达式调用，返回值就是表达式的值。

 

有返回值函数(fruitful function):返回一个值的函数

 

无返回值函数(void function):总是返回None的函数

 

None:由无返回值函数返回的一个特殊值。

 

模块(module):一个包含相关函数以及其他定义的集合的文件

 

import语句(import statement):读入一个模块文件，并创建一个模块对象的语句。

 

模块对象(module object):使用import语句时创建的对象，提供对模块中定义的值的访问。

 

句点表示法(dot notation):调用另一个模块中的函数的语法，使用模块名加上一个句点符号，再加上函数名。

 

组合(composition):使用一个表达式作为一个更大的表达式的一部分，或者使用语句作为更大的语句的一部分。

 

栈图(stack diagram):函数栈的图形表达形式，也展示它们的变量，以及这些变量引用的值。

 

图框(frame):栈图中的一个图框，表达一个函数调用。它包含了局部变量以及函数的参数。

 

回溯(traceback):当异常发生时，打印出正在执行的函数栈。

<style></style>