除了前面介绍的 while语句，Python 也有其它语言常见的流程控制语句，但是稍有不同。
也许最知名的语句类型是if语句。例如：
>>> x = int(input("Please enter an integer: "))Please enter an integer: 42>>> if x < 0:... x = 0... print('Negative changed to zero')... elif x == 0:... print('Zero')... elif x == 1:... print('Single')... else:... print('More')...More可以有零个或多个 elif 部分，else 部分是可选的。关键字 'elif' 是 'else if' 的简写，可以有效避免过深的缩进。if... elif ... elif ... 序列用于替代其它语言中 switch 或case 语句。
Python 中的for语句和你可能熟悉的 C 或 Pascal 中的有点不同。和常见的依据一个等差数列迭代（如 Pascal），或让用户能够自定义迭代步骤和停止条件（如 C）不一样，Python 的 for 语句按照元素出现的顺序迭代任何序列（列表或字符串）。例如（没有双关意）：
>>> # Measure some strings:... words = ['cat', 'window', 'defenestrate']>>> for w in words:... print(w, len(w))...cat 3window 6defenestrate 12
如果要在循环内修改正在迭代的序列（例如，复制所选的项目），建议首先制作副本。迭代序列不会隐式地创建副本。 使用切片就可以很容易地做到：
>>> for w in words[:]: # Loop over a slice copy of the entire list.... if len(w) > 6:... words.insert(0, w)...>>> words['defenestrate', 'cat', 'window', 'defenestrate']
如果你确实需要遍历一个数字序列，内置函数range()很方便。它会生成等差序列：
>>> for i in range(5):... print(i)...01234
给定的终点永远不会在生成的序列中；若要依据索引迭代序列，你可以结合使用range()和len() ，如下所示：也可以让 range 函数从另一个数值开始，或者可以指定一个不同的步进值（甚至是负数，有时这也被称为‘步长’）：
range(5, 10) 5 through 9range(0, 10, 3) 0, 3, 6, 9range(-10, -100, -30) -10, -40, -70
若要依据索引迭代序列，你可以结合使用range () 和len() ，如下所示：
>>> a = ['Mary', 'had', 'a', 'little', 'lamb']>>> for i in range(len(a)):... print(i, a[i])...0 Mary1 had2 a3 little4 lamb
然而，在这种情况下，大部分时候使用enumerate()函数会更加方便，请参见Looping Techniques。
如果你只打印range，会出现奇怪的结果：
>>> print(range(10))range(0, 10)
range()返回的对象的行为在很多方面很像一个列表，但实际上它并不是列表。当你迭代它的时候它会依次返回期望序列的元素，但是它不会真正产生一个列表，因此可以节省空间。
我们把这样的对象称为可迭代的，也就是说它们适合期望连续获得元素的函数和构造器,直到穷尽。我们已经看到for语句是这样的一个迭代器。list()函数是另外一个；它从可迭代对象创建列表。
>>> list(range(5))[0, 1, 2, 3, 4]
后面我们会看到更多返回可迭代对象和以可迭代对象作为参数的函数。
Break 语句和 C 中的类似，用于跳出最近的for 或 while 循环。
循环语句可以有一个 else 子句；当 (for) 循环迭代完整个列表或（while）循环条件变为 false，而非由break 语句终止时，它会执行。下面循环搜索质数的代码例示了这一点：
>>> for n in range(2, 10):... for x in range(2, n):... if n % x == 0:... print(n, 'equals', x, '*', n//x)... break... else:... # loop fell through without finding a factor... print(n, 'is a prime number')...2 is a prime number3 is a prime number4 equals 2 * 25 is a prime number6 equals 2 * 37 is a prime number8 equals 2 * 49 equals 3 * 3
（是的，这是正确的代码。看仔细：else子句属于for 循环，不属于 if 语句。)
当使用一个循环， else子句已更像的else子句的try语句而不是，if语句： try语句的else子句时未发生任何异常，和一个循环else子句运行不会中断发生时运行。更多关于try语句和异常的内容，请参见处理异常。
continue 语句，也是从 C 语言借来的，表示继续下一次迭代：
>>> for num in range(2, 10):... if num % 2 == 0:... print("Found an even number", num)... continue... print("Found a number", num)Found an even number 2Found a number 3Found an even number 4Found a number 5Found an even number 6Found a number 7Found an even number 8Found a number 9pass语句什么也不做。它用于语法上必须要有一条语句，但程序什么也不需要做的场合。例如：
>>> while True:... pass # Busy-wait for keyboard interrupt (Ctrl+C)...
它通常用于创建最小的类：
>>> class MyEmptyClass:... pass...
另一个使用 pass 的地方是编写新代码时作为函数体或控制体的占位符 ，这让你在更抽象层次上思考。pass 语句将被默默地忽略：
>>> def initlog(*args):... pass # Remember to implement this!...
我们可以创建一个生成任意上界菲波那契数列的函数：
>>> def fib(n): # write Fibonacci series up to n... """Print a Fibonacci series up to n."""... a, b = 0, 1... while a < n:... print(a, end=' ')... a, b = b, a+b... print()...>>> # Now call the function we just defined:... fib(2000)0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597
关键字 def 引入函数的 定义。其后必须跟有函数名和以括号标明的形式参数列表。组成函数体的语句从下一行开始，且必须缩进。
函数体的第一行可以是一个可选的字符串文本；此字符串是该函数的文档字符串，或称为docstring。（更多关于 docstrings 的内容可以在 文档字符串一节中找到。）有工具使用 docstrings 自动生成在线的或可打印的文档，或者让用户在代码中交互浏览；在您编写的代码中包含 docstrings 是很好的做法，所以让它成为习惯吧。
函数的 执行 会引入一个新的符号表，用于函数的局部变量。更确切地说，函数中的所有的赋值都是将值存储在局部符号表；而变量引用首先查找局部符号表，然后是上层函数的局部符号表，然后是全局符号表，最后是内置名字表。因此，在函数内部全局变量不能直接赋值 （除非用 global 语句命名），虽然可以引用它们。
函数调用的实际参数在函数被调用时引入被调函数的局部符号表；因此，参数的传递使用传值调用（这里的 值 始终是对象的 引用，不是对象的值）。[1]一个函数调用另一个函数时，会为该调用创建一个新的局部符号表。
函数定义会在当前符号表内引入函数名。函数名对应值的类型是解释器可识别的用户自定义函数。此值可以分配给另一个名称，然后也可作为函数。这是通用的重命名机制：
>>> fib<function fib at 10042ed0>>>> f = fib>>> f(100)0 1 1 2 3 5 8 13 21 34 55 89
如果你使用过其他语言，你可能会反对说： fib 不是一个函数，而是一个方法，因为它并不返回任何值。事实上，没有return语句的函数也返回一个值，尽管是一个很无聊的值。此值被称为None（它是一个内置的名称）。如果None是唯一的输出，解释器通常不会打印出来。如果你真的想看到这个值，可以使用print()：
>>> fib(0)>>> print(fib(0))None
写一个函数返回菲波那契数列的列表，而不是打印出来，非常简单：
>>> def fib2(n): # return Fibonacci series up to n... """Return a list containing the Fibonacci series up to n."""... result = []... a, b = 0, 1... while a < n:... result.append(a) # see below... a, b = b, a+b... return result...>>> f100 = fib2(100) # call it>>> f100 # write the result[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]
此示例中，像往常一样，演示了一些新的 Python 功能：
可以定义具有可变数目的参数的函数。有三种函数形式，可以结合使用。
最有用的形式是指定一个或多个参数的默认值。这种方法创建的函数被调用时，可以带有比定义的要少的参数。例如：
def ask_ok(prompt, retries=4, complaint='Yes or no, please!'): while True: ok = input(prompt) if ok in ('y', 'ye', 'yes'): return True if ok in ('n', 'no', 'nop', 'nope'): return False retries = retries - 1 if retries < 0: raise OSError('uncooperative user') print(complaint)这个函数可以通过几种方式调用：
此示例还引入了in关键字。它测试一个序列是否包含特定的值。
默认值的计算在定义域中的函数定义的时候，例如：
i = 5def f(arg=i): print(arg)i = 6f()
将打印5。
重要的警告：默认值只计算一次。这使得默认值是列表、字典或大部分类的实例时会有所不同。例如，下面的函数在后续调用过程中会累积传给它的参数：
def f(a, L=[]): L.append(a) return Lprint(f(1))print(f(2))print(f(3))
这将会打印
[1][1, 2][1, 2, 3]
如果你不想默认值在随后的调用中共享，可以像这样编写函数：
def f(a, L=None): if L is None: L = [] L.append(a) return L
函数也可以通过 kwarg = value 形式的 关键字参数 调用。例如，下面的函数：
def parrot(voltage, state='a stiff', action='voom', type='Norwegian Blue'): print("-- This parrot wouldn't", action, end=' ') print("if you put", voltage, "volts through it.") print("-- Lovely plumage, the", type) print("-- It's", state, "!")接受一个必选参数 （voltage） 和三个可选参数 （state, action 和 type）。可以用下列任意一种方式调用这个函数：
parrot(1000) # 1 positional argumentparrot(voltage=1000) # 1 keyword argumentparrot(voltage=1000000, action='VOOOOOM') # 2 keyword argumentsparrot(action='VOOOOOM', voltage=1000000) # 2 keyword argumentsparrot('a million', 'bereft of life', 'jump') # 3 positional argumentsparrot('a thousand', state='pushing up the daisies') # 1 positional, 1 keyword但下面的所有调用将无效：
parrot() # required argument missingparrot(voltage=5.0, 'dead') # non-keyword argument after a keyword argumentparrot(110, voltage=220) # duplicate value for the same argumentparrot(actor='John Cleese') # unknown keyword argument
在函数调用中，关键字的参数必须跟随在位置参数的后面。传递的所有关键字参数必须与函数接受的某个参数相匹配 （例如actor 不是 parrot 函数的有效参数），它们的顺序并不重要。这也包括非可选参数（例如 parrot(voltage=1000) 也是有效的）。任何参数都不可以多次赋值。下面的示例由于这种限制将失败：
>>> def function(a):... pass...>>> function(0, a=0)Traceback (most recent call last): File "<stdin>", line 1, in ?TypeError: function() got multiple values for keyword argument 'a'
当最后一个形参以 **name 形式出现，它接收一个字典 (见映射类型 —— 字典) ，该字典包含了所有未出现在形式参数列表中的关键字参数。它还可能与 *name 形式的参数（在下一小节中所述）组合使用，*name 接收一个包含所有没有出现在形式参数列表中的位置参数元组。(*name 必须出现在 ** name 之前。)例如，如果我们定义这样的函数：
def cheeseshop(kind, *arguments, **keywords): print("-- Do you have any", kind, "?") print("-- I'm sorry, we're all out of", kind) for arg in arguments: print(arg) print("-" * 40) keys = sorted(keywords.keys()) for kw in keys: print(kw, ":", keywords[kw])它可以这样调用：
cheeseshop("Limburger", "It's very runny, sir.", "It's really very, VERY runny, sir.", shopkeeper="Michael Palin", client="John Cleese", sketch="Cheese Shop Sketch")当然它会打印：
-- Do you have any Limburger ?-- I'm sorry, we're all out of LimburgerIt's very runny, sir.It's really very, VERY runny, sir.----------------------------------------client : John Cleeseshopkeeper : Michael Palinsketch : Cheese Shop Sketch
注意在打印关键字参数之前，通过对关键字字典 keys() 方法的结果进行排序，生成了关键字参数名的列表；如果不这样做，打印出来的参数的顺序是未定义的。
最后，一个最不常用的场景是让函数可以被可变个数的参数调用。这些参数被放在一个元组（见元组和序列）中。在可变个数的参数之前，可以有零到多个普通的参数。
def write_multiple_items(file, separator, *args): file.write(separator.join(args))
通常情况下，这些可变参数位于形式参数列表的最后，因为它们会搜集传递给函数的所有剩余输入参数。出现在*args参数后面的任何形式参数都是‘keyword-only’参数，意味着它们只能作为关键字参数而不能作为位置参数。
>>> def concat(*args, sep="/"):... return sep.join(args)...>>> concat("earth", "mars", "venus")'earth/mars/venus'>>> concat("earth", "mars", "venus", sep=".")'earth.mars.venus'当传递的参数已经是一个列表或元组时，情况与之前相反，你要分拆这些参数，因为函数调用要求独立的位置参数。例如，内置的 range() 函数期望单独的 start 和 stop 参数。如果它们不是独立的，函数调用时使用 *-操作符将参数从列表或元组中分拆开来：
>>> list(range(3, 6)) # normal call with separate arguments[3, 4, 5]>>> args = [3, 6]>>> list(range(*args)) # call with arguments unpacked from a list[3, 4, 5]
以同样的方式，可以用**-操作符让字典传递关键字参数：
>>> def parrot(voltage, state='a stiff', action='voom'):... print("-- This parrot wouldn't", action, end=' ')... print("if you put", voltage, "volts through it.", end=' ')... print("E's", state, "!")...>>> d = {"voltage": "four million", "state": "bleedin' demised", "action": "VOOM"}>>> parrot(**d)-- This parrot wouldn't VOOM if you put four million volts through it. E's bleedin' demised !可以使用lambda关键字创建小的匿名函数。此函数返回其两个参数的总和： lambda a, b: a + b。Lambda 函数可以用于任何需要的函数对象的地方。在语法上，它们被局限于只能有一个单独的表达式。在语义上，他们只是普通函数定义的语法糖。像嵌套的函数定义，lambda 函数可以从包含范围引用变量：
>>> def make_incrementor(n):... return lambda x: x + n...>>> f = make_incrementor(42)>>> f(0)42>>> f(1)43
上面的示例使用 lambda 表达式返回一个函数。另一个用途是将一个小函数作为参数传递：
>>> pairs = [(1, 'one'), (2, 'two'), (3, 'three'), (4, 'four')]>>> pairs.sort(key=lambda pair: pair[1])>>> pairs[(4, 'four'), (1, 'one'), (3, 'three'), (2, 'two')]
下面是一些关于文档字符串内容和格式的惯例。
第一行永远应该是对象用途的简短、精确的总述。为了简单起见，不应该明确的陈述对象的名字或类型，因为这些信息可以从别的途径了解到（除非这个名字碰巧就是描述这个函数操作的动词）。这一行应该以大写字母开头，并以句号结尾。
如果在文档字符串中有更多的行，第二行应该是空白，在视觉上把摘要与剩余的描述分离开来。以下各行应该是一段或多段描述对象的调用约定、 其副作用等。
Python 解释器不会从多行的文档字符串中去除缩进，所以必要的时候处理文档字符串的工具应当自己清除缩进。这通过使用以下约定可以达到。第一行 之后 的第一个非空行字符串确定整个文档字符串的缩进的量。（我们不用第一行是因为它通常紧靠着字符串起始的引号，其缩进格式不明晰。）所有行起始的等于缩进量的空格都将被过滤掉。不应该发生缩进较少的行，但如果他们发生，应去除所有其前导空白。留白的长度应当等于扩展制表符的宽度（正常是 8 个空格）。
这里是一个多行文档字符串的示例：
>>> def my_function():... """Do nothing, but document it....... No, really, it doesn't do anything.... """... pass...>>> print(my_function.__doc__)Do nothing, but document it. No, really, it doesn't do anything.
函数注释是对用户定义函数的完全可选、任意元信息。Python 自己以及标准库都没有使用任何形式的函数注释；这一节只是展示它的语法。第三方项目可以自由使用函数注释作为文档，类型检查和其它用途。
注释以字典的形式存储在函数的__annotations__属性中，对函数的其它任何部分都没有影响。Parameter annotations are defined by a colon after the parameter name, followed by an expression evaluating to the value of the annotation.Return annotations are defined by a literal ->, followed by an expression, between the parameter list and the colon denoting the end of the def statement.下面的示例包含一个位置参数，一个关键字参数，和没有意义的返回值注释。
>>> def f(ham: 42, eggs: int = 'spam') -> "Nothing to see here":... print("Annotations:", f.__annotations__)... print("Arguments:", ham, eggs)...>>> f('wonderful')Annotations: {'eggs': <class 'int'>, 'return': 'Nothing to see here', 'ham': 42}Arguments: wonderful spam既然你将要编写更长更复杂的 Python 片段，这是谈一谈 编码风格 的好时机。大多数语言可以编写成（或者更准确地讲，格式化成）不同的风格；其中有一些会比其他风格更具可读性。让你的代码对别人更易读永远是个好想法，养成良好的编码风格对此有很大的帮助。
对于 Python 而言， PEP 8 已成为大多数项目遵循的风格指南；它给出了一个高度可读，视觉友好的编码风格。每个 Python 开发者应该阅读一下；这里是为你提取出来的最重要的要点：
使用 4 个空格的缩进，不要使用制表符。
4 个空格是小缩进（允许更深的嵌套）和大缩进（易于阅读）之间很好的折衷。制表符会引起混乱，最好弃用。
折行以确保其不会超过 79 个字符。
这有助于小显示器用户阅读，也可以让大显示器能并排显示几个代码文件。
使用空行分隔函数和类，以及函数内的大块代码。
如果可能，注释独占一行。
使用 docstrings。
运算符周围和逗号后面使用空格，但是括号里侧不加空格： a = f （1， 2） + g (3， 4)。
一致地命名您的类和函数；常见的做法是命名类的时候使用驼峰法，命名函数和方法的时候使用小写字母+下划线法。始终使用self作为方法的第一个参数的名称 （请参见类第一次看更多的关于的类和方法）。
如果希望你的代码在国际化环境中使用，不要使用奇特的编码。Python默认的UTF-8，或者纯 ASCII 在任何情况下永远工作得最好。
同样地，如果讲其它语言的人很少有机会阅读或维护你的代码，不要使用非ASCII字符作为标识符。
脚注
| [1] | Actually, call by object reference would be a better description,since if a mutable object is passed, the caller will see any changes thecallee makes to it (items inserted into a list). |
联系客服
