标签：void 存在 跟踪 zh-cn 应用 ber eric 接下来 intel
在程序设计中，函数是指用于进行某种计算的一系列语句的有名称的组合。定义一个函数时，需要指定函数的名称并写下一系列程序语句。之后，就可以使用名称来“调用”这个函数
一个函数调用的例子
>>> type(42)
<class ‘int‘>
这个函数的名称是type，括号中的表达式我们称之为函数的参数。这个函数调用的结果是求得参数的类型。
我们通常说函数“接收”参数，并“返回”结果。这个结果也称为返回值
Python有一个数学计算模块，提供了大多数常用的数学函数。模块是指包含一组相关的函数的文件。
要想使用模块中的函数，需要先使用import语句将它导入运行环境
>>> import math
这个语句将会创建一个名为math的模块对象。如果显示这个对象，可以看到它的一些信息：
>>> math
<module ‘math‘ (built-in)>
模块对象包含了该模块中定义的函数和变量。若要访问其中一个函数，需要同时指定模块名称和函数名称，用一个句点（.）分隔。这个格式称为句点表示法（dot notation）
>>> radians=0.7
>>> height=math.sin(radians)
>>> height
0.644217687237691
到现在为止，我们已经分别了解了程序的基本元素——变量、表达式和语句，但还没有接触如何将它们有机地组合起来。
程序设计语言最有用的特性之一就是可以将各种小的构建块（building block）组合起来。例如，函数的参数可以是任何类型的表达式，包括算术操作符：
>>> x = math.sin(degrees / 360.0 * 2 * math.pi)
甚至还包括函数调用：
>>> math.exp(math.log(x+1))
基本上在任何可以使用值的地方，都可以使用任意表达式，只有一个例外：赋值表达式的左边必须是变量名称，在左边放置任何其它的表达式都语法错误（后面还会看到这条规则的例外情况）
我们可以自己添加新的函数。函数定义指定新函数的名称，并提供一系列程序语句，当函数被调用时，这些语句会顺序运行。
下面是一个例子：
>>> 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.
将前面一节的代码片段整合起来，整个流程就像下面这个样子：
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
为了保证函数的定义先于其首次调用执行，需要知道程序中语句运行的顺序，即执行流程。
执行总是从程序的第一行开始。语句按照从下到下的顺序逐一运行。
函数定义并不会改变程序的执行流程，但应注意函数体中的语句并不立即运行，而是等到函数被调用时运行。
函数调用可以看作程序运行流程中的一个迂回路径。遇到函数调用时，并不会直接继续运行下一条语句，而是跳到被调用函数的函数体的第一行，继续运行完函数体的所有语句，再跳回到原来离开的地方。
这样看似简单，但马上你就会发现，函数体中可以调用其他函数。当程序流程运行到一个函数之中时，可能需要运行其他函数中的语句。而后，当运行那个函数中的语句时，又可能再需要调用运行另外一个函数语句！
幸好Python对于它运行到哪里有很好的记录，所以每个函数执行结束后，程序都能跳回到它离开的地方。直到执行到整个程序的结尾，才会结束程序。
总之，在阅读代码时，并不总应该按照代码书写顺序一行行阅读；有时候，按照程序执行的流程来阅读代码，理解的效果可能会更好。
在函数内部，实参会赋值给称为形参(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。
在函数体内新建一个变量时，这个变量是局部的(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这个变量。
要跟踪哪些变量在哪些地方使用，有时候画一个栈图(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
在我们使用过的函数中，有一部分函数，如数学函数，会返回结果。因为没有想到更好的名字，我称这类函数为有返回值函数(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‘>
到目前为止，我们自定义的函数都是无返回值函数。再过几章我们就会开始写有返回值的函数了。
为什么要花功夫将程序拆分成函数呢？也许刚开始编程的时候这其中的原因并不明晰。下面这些解释都可作为参考。
新建一个函数，可以让你有机会给一组语句命名，这样可以让代码更易读和更易调试。
函数可以通过减少重复代码使程序更短小。后面如果需要修改代码，也只要修改一个地方即可。
将一长段程序拆分成几个函数后，可以对每一个函数单独进行调试，再将它们组装起来成为完整的产品。
一个设计良好的函数，可以在很多程序中使用。书写一次，调试一次，复用无穷。
你将会掌握的一个最重要的技能就是调试。虽然调试可能时有烦恼，但它的确是编程活动中最耗脑力、最有挑战、最有趣的部分。
在某种程度上，调试和刑侦工作很像。你会面对一些线索，而且必须推导出事情发生的过程，以及导致现场结果的事件。
调试也像是一种实验科学。一旦猜出错误的可能原因，就可以修改程序，再运行一次。如果猜对了，那么程序的运行结果会符合预测，这样就离正确的程序更近了一步。如果猜错了，则需要重新思考。正如夏洛克.福尔摩丝所说的：“当你排除掉所有的可能性，那么剩下的，不管多么不可能，必定是真相。”
对某些人来说，编程和调试是同一件事。也就是说，编程正是不断调试修改直到程序达到设计目的的过程。这种想法的要旨是，应该从一个能做某些事的程序开始，然后做一点点修改，并调试改正，如此迭代，以确保总是有一个可以运行的程序。
例如，Linux是包含了数百万行代码的操作系统，但最开始只是Linus Torvalds编写的用来研究Intel 80386芯片的简单程序。据Larry Greenfield所说：“Linus最早的一个程序是交替打印AAAA 和 BBBB。后来这些程序演化成了Linux”
函数(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):当异常发生时，打印出正在执行的函数栈。
标签：void 存在 跟踪 zh-cn 应用 ber eric 接下来 intel
原文地址：https://www.cnblogs.com/kaerxifa/p/11372937.html
