Python 2.7 Tutorial —— 流程控制
2010-10-01 01:03
387 查看
.. _tut-morecontrol:
******************************************
More Control Flow Tools 深入流程控制
******************************************
Besides the :keyword:`while` statement just introduced, Python knows the usual
control flow statements known from other languages, with some twists.
除了前面介绍的 :keyword:`while` 语句，Python 还从其它语言借鉴了一些流
程控制功能，并有所改变。
.. _tut-if:
:keyword:`if` Statements :keyword:`if` 語句
=========================================================
Perhaps the most well-known statement type is the :keyword:`if` statement. For
example::
也许最有名的是 if 语句。例如：
>>> x = int(raw_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
There can be zero or more :keyword:`elif` parts, and the :keyword:`else` part is
optional. The keyword ':keyword:`elif`' is short for 'else if', and is useful
to avoid excessive indentation. An :keyword:`if` ... :keyword:`elif` ...
:keyword:`elif` ... sequence is a substitute for the ``switch`` or
``case`` statements found in other languages.
可能会有零到多个 elif 部分，else 是可选的。关键字“elif” 是“ else if
”的缩写，这个可以有效避免过深的缩进。if ... elif ... elif ... 序列用
于替代其它语言中的 switch 或 case 语句。
.. _tut-for:
:keyword:`for` Statements :keyword:`for` 语句
=================================================
.. index::
statement: for
statement: for
The :keyword:`for` statement in Python differs a bit from what you may be used
to in C or Pascal. Rather than always iterating over an arithmetic progression
of numbers (like in Pascal), or giving the user the ability to define both the
iteration step and halting condition (as C), Python's :keyword:`for` statement
iterates over the items of any sequence (a list or a string), in the order that
they appear in the sequence. For example (no pun intended):
Python 中的 for 语句和 C 或 Pascal 中的略有不同。通常的循环可能会依据
一个等差数值步进过程（如Pascal），或由用户来定义迭代步骤和中止条件（如 C
），Python 的 for 语句依据任意序列（链表或字符串）中的子项，按它们在序
列中的顺序来进行迭代。例如（没有暗指）：
.. One suggestion was to give a real C example here, but that may only serve to
confuse non-C programmers. 有建议说在这里给出一个真正的 C 示例，不
过这样大概只会给非 C 程序员带来更多的困扰吧。
::
>>> # Measure some strings:
... a = ['cat', 'window', 'defenestrate']
>>> for x in a:
... print x, len(x)
...
cat 3
window 6
defenestrate 12
It is not safe to modify the sequence being iterated over in the loop (this can
only happen for mutable sequence types, such as lists). If you need to modify
the list you are iterating over (for example, to duplicate selected items) you
must iterate over a copy. The slice notation makes this particularly
convenient::
在迭代过程中修改迭代序列不安全（只有在使用链表这样的可变序列时才会有这
样的情况）。如果你想要修改你迭代的序列（例如，复制选择项），你可以迭代
它的复本。使用切割标识就可以很方便的做到这一点 ::
>>> for x in a[:]: # make a slice copy of the entire list
... if len(x) > 6: a.insert(0, x)
...
>>> a
['defenestrate', 'cat', 'window', 'defenestrate']
.. _tut-range:
The :func:`range` Function :func:`range` 函数
======================================================
If you do need to iterate over a sequence of numbers, the built-in function
:func:`range` comes in handy. It generates lists containing arithmetic
progressions::
如果你需要一个数值序列，内置函数range()会很方便，它生成一个等差级
数链表 ::
>>> range(10)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
The given end point is never part of the generated list; ``range(10)`` generates
a list of 10 values, the legal indices for items of a sequence of length 10. It
is possible to let the range start at another number, or to specify a different
increment (even negative; sometimes this is called the 'step')::
range(10) 生成了一个包含10个值的链表，它用链表的索引值填充了这个长度为
10的列表，所生成的链表中不包括范围中的结束值。也可以让range操作从另一
个数值开始，或者可以指定一个不同的步进值（甚至是负数，有时这也被称为
“步长”） ::
>>> range(5, 10)
[5, 6, 7, 8, 9]
>>> range(0, 10, 3)
[0, 3, 6, 9]
>>> range(-10, -100, -30)
[-10, -40, -70]
To iterate over the indices of a sequence, you can combine :func:`range` and
:func:`len` as follows::
需要迭代链表索引的话，如下所示结合使 用range() 和 len() ::
>>> a = ['Mary', 'had', 'a', 'little', 'lamb']
>>> for i in range(len(a)):
... print i, a[i]
...
0 Mary
1 had
2 a
3 little
4 lamb
In most such cases, however, it is convenient to use the :func:`enumerate`
function, see :ref:`tut-loopidioms`.
不过，这种场合可以方便的使用 :func:`enumerate` ，请参见
:ref:`tut-loopidioms` 。
.. _tut-break:
:keyword:`break` and :keyword:`continue` Statements, and :keyword:`else` Clauses on Loops break 和 continue 语句, 以及 循环中的 else 子句
==============================================================================================================================================
The :keyword:`break` statement, like in C, breaks out of the smallest enclosing
:keyword:`for` or :keyword:`while` loop.
break 语句和 C 中的类似，用于跳出最近的一级 for 或 while 循环。
The :keyword:`continue` statement, also borrowed from C, continues with the next
iteration of the loop.
:keyword:`continue` 语句是从 C 中借鉴来的，它表示循环继续执行下一次迭代。
Loop statements may have an ``else`` clause; it is executed when the loop
terminates through exhaustion of the list (with :keyword:`for`) or when the
condition becomes false (with :keyword:`while`), but not when the loop is
terminated by a :keyword:`break` statement. This is exemplified by the
following loop, which searches for prime numbers::
循环可以有一个 ``else`` 子句;它在循环迭代完整个列表（对于 :keyword:`for` ）或执行条件
为 false （对于 :keyword:`while` ）时执行，但循环被 :keyword:`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 number
3 is a prime number
4 equals 2 * 2
5 is a prime number
6 equals 2 * 3
7 is a prime number
8 equals 2 * 4
9 equals 3 * 3
.. _tut-pass:
:keyword:`pass` Statements :keyword:`pass` 语句
=====================================================
The :keyword:`pass` statement does nothing. It can be used when a statement is
required syntactically but the program requires no action. For example::
pass 语句什么也不做。它用于那些语法上必须要有什么语句，但程序什么也不
做的场合，例如 ::
>>> while True:
... pass # Busy-wait for keyboard interrupt (Ctrl+C)
...
This is commonly used for creating minimal classes::
这通常用于创建最小结构的类 ::
>>> class MyEmptyClass:
... pass
...
Another place :keyword:`pass` can be used is as a place-holder for a function or
conditional body when you are working on new code, allowing you to keep thinking
at a more abstract level. The :keyword:`pass` is silently ignored::
另一方面， :keyword:`pass` 可以在创建新代码时用来做函数或控制体的占位
符。可以让你在更抽象的级别上思考。 :keyword:`pass` 可以默默的被忽视 ::
>>> def initlog(*args):
... pass # Remember to implement this!
...
.. _tut-functions:
Defining Functions 定义函数
==============================
We can create a function that writes the Fibonacci series to an arbitrary
boundary::
我们可以定义一个函数以生成任意上界的菲波那契数列 ::
>>> 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,
... a, b = b, a+b
...
>>> # 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
.. index::
single: documentation strings
single: docstrings
single: strings, documentation
The keyword :keyword:`def` introduces a function *definition*. It must be
followed by the function name and the parenthesized list of formal parameters.
The statements that form the body of the function start at the next line, and
must be indented.
关键字 :keyword:`def` 引入了一个函数 *定义* 。在其后必须跟有函数名和包
括形式参数的圆括号。函数体语句从下一行开始，必须是缩进的。
The first statement of the function body can optionally be a string literal;
this string literal is the function's documentation string, or :dfn:`docstring`.
(More about docstrings can be found in the section :ref:`tut-docstrings`.)
There are tools which use docstrings to automatically produce online or printed
documentation, or to let the user interactively browse through code; it's good
practice to include docstrings in code that you write, so make a habit of it.
函数体的第一行可以是一个字符串值，这个字符串是该函数的文档字符串
，或称 :dfn:`docstring` 。（更进一步的文
档字符串介绍可以在这一节找到 :ref:`tut-docstrings` 。）有些工具使用文
档字符串在线的生成及打印文档，或者允许用户在代码中交互式的浏览；编写代
码进加入文档字符串是个好的风格，应该养成习惯。
The *execution* of a function introduces a new symbol table used for the local
variables of the function. More precisely, all variable assignments in a
function store the value in the local symbol table; whereas variable references
first look in the local symbol table, then in the local symbol tables of
enclosing functions, then in the global symbol table, and finally in the table
of built-in names. Thus, global variables cannot be directly assigned a value
within a function (unless named in a :keyword:`global` statement), although they
may be referenced.
*执行* 函数时会为局部变量引入一个新的符号表。所有的局部变量都存储在这
个局部符号表中。引用参数时，会先从局部符号表中查找，然后是全局符号表，然
后是内置命名表。因此，全局参数虽然可以被引用，但它们不能在函数中直接
赋值（除非它们用 :keyword:`global` 语句命名）。
The actual parameters (arguments) to a function call are introduced in the local
symbol table of the called function when it is called; thus, arguments are
passed using *call by value* (where the *value* is always an object *reference*,
not the value of the object). [#]_ When a function calls another function, a new
local symbol table is created for that call.
函数引用的实际参数在函数调用时引入局部符号表，因此，实参总是 *传值调用*
（这里的 *值* 总是一个对象 *引用* ，而不是该对象的值）。 [#]_ 一个函数被另一个函
数调用时，一个新的局部符号表在调用过程中被创建。
A function definition introduces the function name in the current symbol table.
The value of the function name has a type that is recognized by the interpreter
as a user-defined function. This value can be assigned to another name which
can then also be used as a function. This serves as a general renaming
mechanism::
函数定义在当前符号表中引入函数名。作为用户定义函数，函数名有一个为解释
器认可的类型值。这个值可以赋给其它命名，使其能够作为一个函数来使用。这
就像一个重命名机制 ::
>>> fib
<function fib at 10042ed0>
>>> f = fib
>>> f(100)
0 1 1 2 3 5 8 13 21 34 55 89
Coming from other languages, you might object that ``fib`` is not a function but
a procedure since it doesn't return a value. In fact, even functions without a
:keyword:`return` statement do return a value, albeit a rather boring one. This
value is called ``None`` (it's a built-in name). Writing the value ``None`` is
normally suppressed by the interpreter if it would be the only value written.
You can see it if you really want to using :keyword:`print`::
你可能认为 ``fib`` 没有返回值，它不是一个函数（ function ），而是一个
过程（ procedure ）。实际上，即使函数没有 :keyword:`return` 语句，它也
有返回值，虽然是一个不讨人喜欢的。这个值被称为 ``None`` （这是一个内置命
名）。如果一个值只是 None 的话，通常解释器不会写出来，如果你真想要查看
它的话，可以这样做 ::
>>> fib(0)
>>> print fib(0)
None
It is simple to write a function that returns a list of the numbers of the
Fibonacci series, instead of printing it::
以下示例演示了如何从函数中返回一个包含菲波那契数列的数值链表，而不是打
印它 ::
>>> 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]
This example, as usual, demonstrates some new Python features:
和以前一样，这个例子演示了一些新的 Python 功能：
* The :keyword:`return` statement returns with a value from a function.
:keyword:`return` without an expression argument returns ``None``. Falling off
the end of a function also returns ``None``.
:keyword:`return` 语句从函数中返回一个值，不带表达式的
:keyword:`return` 返回 ``None`` 。过程结束后也会返回 ``None`` 。
* The statement ``result.append(a)`` calls a *method* of the list object
``result``. A method is a function that 'belongs' to an object and is named
``obj.methodname``, where ``obj`` is some object (this may be an expression),
and ``methodname`` is the name of a method that is defined by the object's type.
Different types define different methods. Methods of different types may have
the same name without causing ambiguity. (It is possible to define your own
object types and methods, using *classes*, see :ref:`tut-classes`)
The method :meth:`append` shown in the example is defined for list objects; it
adds a new element at the end of the list. In this example it is equivalent to
``result = result + [a]``, but more efficient.
语句 ``result.append(b)`` 称为链表对象 ``result`` 的一个 *方法* （ method ）。方
法是一个“属于”某个对象的函数，它被命名为 ``obj.methodename`` ，这里的
``obj`` 是某个对象（可能是一个表达式）， ``methodename`` 是某个在该对象类型定
义中的方法的命名。不同的类型定义不同的方法。不同类型可能有同样名字的
方法，但不会混淆。（当你定义自己的对象类型和方法时，可能会出现这种情
况， *class* 的定义方法详见 :ref:`tut-classes` ）。示例中演示的
:meth:`append` 方法
由链表对象定义，它向链表中加入一个新元素。在示例中它等同于
``result = result + [b]`` ，不过效率更高。
.. _tut-defining:
More on Defining Functions 深入函数定义
====================================================
It is also possible to define functions with a variable number of arguments.
There are three forms, which can be combined.
有时需要定义参数个数可变的函数。有三种形式，我们可以组合使用它们。
.. _tut-defaultargs:
Default Argument Values 参数默认值
----------------------------------------------------
The most useful form is to specify a default value for one or more arguments.
This creates a function that can be called with fewer arguments than it is
defined to allow. For example::
最有用的形式是给一个或多个参数指定默认值。这样创建的函数可以用较少的参
数来调用。例如 ::
def ask_ok(prompt, retries=4, complaint='Yes or no, please!'):
while True:
ok = raw_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 IOError('refusenik user')
print complaint
This function can be called in several ways:
这个函数可以通过几种不同的方式调用：
* giving only the mandatory argument:
只给出必要的参数：
``ask_ok('Do you really want to quit?')``
* giving one of the optional arguments:
给出一个可选的参数：
``ask_ok('OK to overwrite the file?', 2)``
* or even giving all arguments:
或者给出所有的参数：
``ask_ok('OK to overwrite the file?', 2, 'Come on, only yes or no!')``
This example also introduces the :keyword:`in` keyword. This tests whether or
not a sequence contains a certain value.
这个例子还介绍了 :keyword:`in` 关键字。它测定序列中是否包含某个确定的
值。
The default values are evaluated at the point of function definition in the
*defining* scope, so that ::
默认值在函数 *定义* 作用域被解析，如下所示 ::
i = 5
def f(arg=i):
print arg
i = 6
f()
will print ``5``.
**Important warning:** The default value is evaluated only once. This makes a
difference when the default is a mutable object such as a list, dictionary, or
instances of most classes. For example, the following function accumulates the
arguments passed to it on subsequent calls :
**重要警告** 默认值只解析一次。这造成字典、列表或大部分类实例等可变对象的行为会与期待的不太一样。例如，下例的函数在每次调用时都造成参数的累加 ::
def f(a, L=[]):
L.append(a)
return L
print f(1)
print f(2)
print f(3)
This will print ::
这样会打印出 ::
[1]
[1, 2]
[1, 2, 3]
If you don't want the default to be shared between subsequent calls, you can
write the function like this instead::
如果你不想在随后的调用中共享默认值，可以像这样写函数 ::
def f(a, L=None):
if L is None:
L = []
L.append(a)
return L
.. _tut-keywordargs:
Keyword Arguments 关键字参数
-------------------------------------
Functions can also be called using keyword arguments of the form ``keyword =
value``. For instance, the following function::
函数可以通过关键字参数的形式来调用，形如 ``keyword = value`` 。例如，
以下的函数 ::
def parrot(voltage, state='a stiff', action='voom', type='Norwegian Blue'):
print "-- This parrot wouldn't", action,
print "if you put", voltage, "volts through it."
print "-- Lovely plumage, the", type
print "-- It's", state, "!"
could be called in any of the following ways::
可以用以下的任一方法调用 ::
parrot(1000)
parrot(action = 'VOOOOOM', voltage = 1000000)
parrot('a thousand', state = 'pushing up the daisies')
parrot('a million', 'bereft of life', 'jump')
but the following calls would all be invalid::
不过以下几种调用是无效的 ::
parrot() # required argument missing
parrot(voltage=5.0, 'dead') # non-keyword argument following keyword
parrot(110, voltage=220) # duplicate value for argument
parrot(actor='John Cleese') # unknown keyword
In general, an argument list must have any positional arguments followed by any
keyword arguments, where the keywords must be chosen from the formal parameter
names. It's not important whether a formal parameter has a default value or
not. No argument may receive a value more than once --- formal parameter names
corresponding to positional arguments cannot be used as keywords in the same
calls. Here's an example that fails due to this restriction::
通常，参数列表中的每一个关键字都必须来自于形式参数，每个参数都有对应的
关键字。形式参数有没有默认值并不重要。实际参数不能一次赋多个值——形式参
数不能在同一次调用中同时使用位置和关键字绑定值。这里有一个例子演示了在
这种约束下所出现的失败情况 ::
>>> 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'
When a final formal parameter of the form ``**name`` is present, it receives a
dictionary (see :ref:`typesmapping`) containing all keyword arguments except for
those corresponding to a formal parameter. This may be combined with a formal
parameter of the form ``*name`` (described in the next subsection) which
receives a tuple containing the positional arguments beyond the formal parameter
list. (``*name`` must occur before ``**name``.) For example, if we define a
function like this::
引入一个形如 ``**name`` 的参数时，它接收一个字典（参见
:ref:`typesmapping` ） ，该字典包含了所有未出现
在形式参数列表中的关键字参数。这里可能还会组合使用一个形如 ``*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 = keywords.keys()
keys.sort()
for kw in keys: print kw, ":", keywords[kw]
It could be called like this::
它可以像这样调用 ::
cheeseshop("Limburger", "It's very runny, sir.",
"It's really very, VERY runny, sir.",
shopkeeper='Michael Palin',
client="John Cleese",
sketch="Cheese Shop Sketch")
and of course it would print::
当然它会按如下内容打印 ::
-- Do you have any Limburger ?
-- I'm sorry, we're all out of Limburger
It's very runny, sir.
It's really very, VERY runny, sir.
----------------------------------------
client : John Cleese
shopkeeper : Michael Palin
sketch : Cheese Shop Sketch
Note that the :meth:`sort` method of the list of keyword argument names is
called before printing the contents of the ``keywords`` dictionary; if this is
not done, the order in which the arguments are printed is undefined.
注意在打印 ``关系字`` 参数字典的内容前先调用 :meth:`sort` 方法。否则的话，打印参数时的顺序是未定义的。
.. _tut-arbitraryargs:
Arbitrary Argument Lists 可变参数列表
---------------------------------------------
.. index::
statement: *
Finally, the least frequently used option is to specify that a function can be
called with an arbitrary number of arguments. These arguments will be wrapped
up in a tuple (see :ref:`tut-tuples`). Before the variable number of arguments,
zero or more normal arguments may occur. ::
最后，一个最不常用的选择是可以让函数调用可变个数的参数。这些参数被包装
进一个元组（参见 :ref:`tut-tuples` ）。在这些可变个数的参数之前，可以有零到多个普通的参数 ::
def write_multiple_items(file, separator, *args):
file.write(separator.join(args))
.. _tut-unpacking-arguments:
Unpacking Argument Lists 参数列表的分拆
--------------------------------------------
The reverse situation occurs when the arguments are already in a list or tuple
but need to be unpacked for a function call requiring separate positional
arguments. For instance, the built-in :func:`range` function expects separate
*start* and *stop* arguments. If they are not available separately, write the
function call with the ``*``/ -operator to unpack the arguments out of a list
or tuple::
另有一种相反的情况: 当你要传递的参数已经是一个列表，但要调用的函数却接受
分开一个个的参数值. 这时候你要把已有的列表拆开来. 例如内建函数 :func:`range`
需要要独立的 *start*, *stop* 参数. 你可以在调用函数时加一个 ``*`` 操作符来自动
把参数列表拆开 ::
>>> range(3, 6) # normal call with separate arguments
[3, 4, 5]
>>> args = [3, 6]
>>> range(*args) # call with arguments unpacked from a list
[3, 4, 5]
.. index::
statement: **
In the same fashion, dictionaries can deliver keyword arguments with the ``**``/
-operator::
以同样的方式，可以使用 ``**`` 操作符分拆关键字参数为字典：
>>> def parrot(voltage, state='a stiff', action='voom'):
... print "-- This parrot wouldn't", action,
... print "if you put", voltage, "volts through it.",
... 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 !
.. _tut-lambda:
Lambda Forms Lambda 形式
------------------------------
By popular demand, a few features commonly found in functional programming
languages like Lisp have been added to Python. With the :keyword:`lambda`
keyword, small anonymous functions can be created. Here's a function that
returns the sum of its two arguments: ``lambda a, b: a+b``. Lambda forms can be
used wherever function objects are required. They are syntactically restricted
to a single expression. Semantically, they are just syntactic sugar for a
normal function definition. Like nested function definitions, lambda forms can
reference variables from the containing scope::
出于实际需要，有几种通常在函数式编程语言例如 Lisp 中出现的功能加入到了
Python 。通过 :keyword:`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
.. _tut-docstrings:
Documentation Strings 文档字符串
----------------------------------------
.. index::
single: docstrings
single: documentation strings
single: strings, documentation
There are emerging conventions about the content and formatting of documentation
strings.
这里介绍的文档字符串的概念和格式。
The first line should always be a short, concise summary of the object's
purpose. For brevity, it should not explicitly state the object's name or type,
since these are available by other means (except if the name happens to be a
verb describing a function's operation). This line should begin with a capital
letter and end with a period.
第一行应该是关于对象用途的简介。简短起见，不用明确的陈述对象名或类型，
因为它们可以从别的途径了解到（除非这个名字碰巧就是描述这个函数操作的动
词）。这一行应该以大写字母开头，以句号结尾。
If there are more lines in the documentation string, the second line should be
blank, visually separating the summary from the rest of the description. The
following lines should be one or more paragraphs describing the object's calling
conventions, its side effects, etc.
如果文档字符串有多行，第二行应该空出来，与接下来的详细描述明确分隔。接
下来的文档应该有一或多段描述对象的调用约定、边界效应等。
The Python parser does not strip indentation from multi-line string literals in
Python, so tools that process documentation have to strip indentation if
desired. This is done using the following convention. The first non-blank line
*after* the first line of the string determines the amount of indentation for
the entire documentation string. (We can't use the first line since it is
generally adjacent to the string's opening quotes so its indentation is not
apparent in the string literal.) Whitespace "equivalent" to this indentation is
then stripped from the start of all lines of the string. Lines that are
indented less should not occur, but if they occur all their leading whitespace
should be stripped. Equivalence of whitespace should be tested after expansion
of tabs (to 8 spaces, normally).
Python的解释器不会从多行的文档字符串中去除缩进，所以必要的时候应当自己
清除缩进。这符合通常的习惯。第一行之后的第一个非空行决定了整个文档的缩
进格式。（我们不用第一行是因为它通常紧靠着起始的引号，缩进格式显示的不
清楚。）留白“相当于”是字符串的起始缩进。每一行都不应该有缩进，如果有
缩进的话，所有的留白都应该清除掉。留白的长度应当等于扩展制表符的宽度
（通常是8个空格）。
Here is an example of a multi-line docstring::
以下是一个多行文档字符串的示例 ::
>>> 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.
.. _tut-codingstyle:
Intermezzo: Coding Style 插曲：编码风格
==============================================
.. sectionauthor:: Georg Brandl <georg@python.org>
.. index:: pair: coding; style
Now that you are about to write longer, more complex pieces of Python, it is a
good time to talk about *coding style*. Most languages can be written (or more
concise, *formatted*) in different styles; some are more readable than others.
Making it easy for others to read your code is always a good idea, and adopting
a nice coding style helps tremendously for that.
此时你已经可以写一此更长更复杂的 Python 程序，是时候讨论一下
*编码风格* 了。大多数语言可以写（或者更明白的说， *格式化* ）作几种不
同的风格。有些比其它的更好读。让你的代码对别人更易读是个好想法，养成良
好的编码风格对此很有帮助。
For Python, :pep:`8` has emerged as the style guide that most projects adhere to;
it promotes a very readable and eye-pleasing coding style. Every Python
developer should read it at some point; here are the most important points
extracted for you:
对于 Python， :pep:`8` 引入了大多数项目遵循的风格指导。它给出了一个高
度可读，视觉友好的编码风格。每个 Python 开发者都应该读一下，大多数要点
都会对你有帮助：
* Use 4-space indentation, and no tabs.
使用 4 空格缩进，而非 TAB。
4 spaces are a good compromise between small indentation (allows greater
nesting depth) and large indentation (easier to read). Tabs introduce
confusion, and are best left out.
在小缩进（可以嵌套更深）和大缩进（更易读）之间，4空格是一个很好的折
中。TAB 引发了一些混乱，最好弃用。
* Wrap lines so that they don't exceed 79 characters.
折行以确保其不会超过 79 个字符。
This helps users with small displays and makes it possible to have several
code files side-by-side on larger displays.
这有助于小显示器用户阅读，也可以让大显示器能并排显示几个代码文件。
* Use blank lines to separate functions and classes, and larger blocks of
code inside functions.
使用空行分隔函数和类，以及函数中的大块代码。
* When possible, put comments on a line of their own.
可能的话，注释独占一行
* Use docstrings.
使用文档字符串
* Use spaces around operators and after commas, but not directly inside
bracketing constructs: ``a = f(1, 2) + g(3, 4)``.
把空格放到操作符两边，以及逗号后面，但是括号里侧不加空格： ``a =
f(1, 2) + g(3, 4)`` 。
* Name your classes and functions consistently; the convention is to use
``CamelCase`` for classes and ``lower_case_with_underscores`` for functions
and methods. Always use ``self`` as the name for the first method argument
(see :ref:`tut-firstclasses` for more on classes and methods).
统一函数和类命名。推荐类名用 ``驼峰命名``， 函数和方法名用
``小写_和_下划线`` 。 总是用 ``self`` 作为方法的第一个参数（关于类和
方法的知识详见 :ref:`tut-firstclasses` ）。
* Don't use fancy encodings if your code is meant to be used in international
environments. Plain ASCII works best in any case.
在国际化环境中不要随意使用自己喜欢的编码， 纯 ASCII 文本总是工作的最好。
（作为东方人，我有不同的见解，个人推荐首选 utf-8——译者）
.. rubric:: Footnotes
.. [#] Actually, *call by object reference* would be a better description,
since if a mutable object is passed, the caller will see any changes the
callee makes to it (items inserted into a list).
实际上， *引用对象调用* 描述的更为准确。如果传入一个可变对像，调用
者会看到调用操作带来的任何变化（如子项插入到列表中）。
******************************************
More Control Flow Tools 深入流程控制
******************************************
Besides the :keyword:`while` statement just introduced, Python knows the usual
control flow statements known from other languages, with some twists.
除了前面介绍的 :keyword:`while` 语句，Python 还从其它语言借鉴了一些流
程控制功能，并有所改变。
.. _tut-if:
:keyword:`if` Statements :keyword:`if` 語句
=========================================================
Perhaps the most well-known statement type is the :keyword:`if` statement. For
example::
也许最有名的是 if 语句。例如：
>>> x = int(raw_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
There can be zero or more :keyword:`elif` parts, and the :keyword:`else` part is
optional. The keyword ':keyword:`elif`' is short for 'else if', and is useful
to avoid excessive indentation. An :keyword:`if` ... :keyword:`elif` ...
:keyword:`elif` ... sequence is a substitute for the ``switch`` or
``case`` statements found in other languages.
可能会有零到多个 elif 部分，else 是可选的。关键字“elif” 是“ else if
”的缩写，这个可以有效避免过深的缩进。if ... elif ... elif ... 序列用
于替代其它语言中的 switch 或 case 语句。
.. _tut-for:
:keyword:`for` Statements :keyword:`for` 语句
=================================================
.. index::
statement: for
statement: for
The :keyword:`for` statement in Python differs a bit from what you may be used
to in C or Pascal. Rather than always iterating over an arithmetic progression
of numbers (like in Pascal), or giving the user the ability to define both the
iteration step and halting condition (as C), Python's :keyword:`for` statement
iterates over the items of any sequence (a list or a string), in the order that
they appear in the sequence. For example (no pun intended):
Python 中的 for 语句和 C 或 Pascal 中的略有不同。通常的循环可能会依据
一个等差数值步进过程（如Pascal），或由用户来定义迭代步骤和中止条件（如 C
），Python 的 for 语句依据任意序列（链表或字符串）中的子项，按它们在序
列中的顺序来进行迭代。例如（没有暗指）：
.. One suggestion was to give a real C example here, but that may only serve to
confuse non-C programmers. 有建议说在这里给出一个真正的 C 示例，不
过这样大概只会给非 C 程序员带来更多的困扰吧。
::
>>> # Measure some strings:
... a = ['cat', 'window', 'defenestrate']
>>> for x in a:
... print x, len(x)
...
cat 3
window 6
defenestrate 12
It is not safe to modify the sequence being iterated over in the loop (this can
only happen for mutable sequence types, such as lists). If you need to modify
the list you are iterating over (for example, to duplicate selected items) you
must iterate over a copy. The slice notation makes this particularly
convenient::
在迭代过程中修改迭代序列不安全（只有在使用链表这样的可变序列时才会有这
样的情况）。如果你想要修改你迭代的序列（例如，复制选择项），你可以迭代
它的复本。使用切割标识就可以很方便的做到这一点 ::
>>> for x in a[:]: # make a slice copy of the entire list
... if len(x) > 6: a.insert(0, x)
...
>>> a
['defenestrate', 'cat', 'window', 'defenestrate']
.. _tut-range:
The :func:`range` Function :func:`range` 函数
======================================================
If you do need to iterate over a sequence of numbers, the built-in function
:func:`range` comes in handy. It generates lists containing arithmetic
progressions::
如果你需要一个数值序列，内置函数range()会很方便，它生成一个等差级
数链表 ::
>>> range(10)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
The given end point is never part of the generated list; ``range(10)`` generates
a list of 10 values, the legal indices for items of a sequence of length 10. It
is possible to let the range start at another number, or to specify a different
increment (even negative; sometimes this is called the 'step')::
range(10) 生成了一个包含10个值的链表，它用链表的索引值填充了这个长度为
10的列表，所生成的链表中不包括范围中的结束值。也可以让range操作从另一
个数值开始，或者可以指定一个不同的步进值（甚至是负数，有时这也被称为
“步长”） ::
>>> range(5, 10)
[5, 6, 7, 8, 9]
>>> range(0, 10, 3)
[0, 3, 6, 9]
>>> range(-10, -100, -30)
[-10, -40, -70]
To iterate over the indices of a sequence, you can combine :func:`range` and
:func:`len` as follows::
需要迭代链表索引的话，如下所示结合使 用range() 和 len() ::
>>> a = ['Mary', 'had', 'a', 'little', 'lamb']
>>> for i in range(len(a)):
... print i, a[i]
...
0 Mary
1 had
2 a
3 little
4 lamb
In most such cases, however, it is convenient to use the :func:`enumerate`
function, see :ref:`tut-loopidioms`.
不过，这种场合可以方便的使用 :func:`enumerate` ，请参见
:ref:`tut-loopidioms` 。
.. _tut-break:
:keyword:`break` and :keyword:`continue` Statements, and :keyword:`else` Clauses on Loops break 和 continue 语句, 以及 循环中的 else 子句
==============================================================================================================================================
The :keyword:`break` statement, like in C, breaks out of the smallest enclosing
:keyword:`for` or :keyword:`while` loop.
break 语句和 C 中的类似，用于跳出最近的一级 for 或 while 循环。
The :keyword:`continue` statement, also borrowed from C, continues with the next
iteration of the loop.
:keyword:`continue` 语句是从 C 中借鉴来的，它表示循环继续执行下一次迭代。
Loop statements may have an ``else`` clause; it is executed when the loop
terminates through exhaustion of the list (with :keyword:`for`) or when the
condition becomes false (with :keyword:`while`), but not when the loop is
terminated by a :keyword:`break` statement. This is exemplified by the
following loop, which searches for prime numbers::
循环可以有一个 ``else`` 子句;它在循环迭代完整个列表（对于 :keyword:`for` ）或执行条件
为 false （对于 :keyword:`while` ）时执行，但循环被 :keyword:`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 number
3 is a prime number
4 equals 2 * 2
5 is a prime number
6 equals 2 * 3
7 is a prime number
8 equals 2 * 4
9 equals 3 * 3
.. _tut-pass:
:keyword:`pass` Statements :keyword:`pass` 语句
=====================================================
The :keyword:`pass` statement does nothing. It can be used when a statement is
required syntactically but the program requires no action. For example::
pass 语句什么也不做。它用于那些语法上必须要有什么语句，但程序什么也不
做的场合，例如 ::
>>> while True:
... pass # Busy-wait for keyboard interrupt (Ctrl+C)
...
This is commonly used for creating minimal classes::
这通常用于创建最小结构的类 ::
>>> class MyEmptyClass:
... pass
...
Another place :keyword:`pass` can be used is as a place-holder for a function or
conditional body when you are working on new code, allowing you to keep thinking
at a more abstract level. The :keyword:`pass` is silently ignored::
另一方面， :keyword:`pass` 可以在创建新代码时用来做函数或控制体的占位
符。可以让你在更抽象的级别上思考。 :keyword:`pass` 可以默默的被忽视 ::
>>> def initlog(*args):
... pass # Remember to implement this!
...
.. _tut-functions:
Defining Functions 定义函数
==============================
We can create a function that writes the Fibonacci series to an arbitrary
boundary::
我们可以定义一个函数以生成任意上界的菲波那契数列 ::
>>> 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,
... a, b = b, a+b
...
>>> # 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
.. index::
single: documentation strings
single: docstrings
single: strings, documentation
The keyword :keyword:`def` introduces a function *definition*. It must be
followed by the function name and the parenthesized list of formal parameters.
The statements that form the body of the function start at the next line, and
must be indented.
关键字 :keyword:`def` 引入了一个函数 *定义* 。在其后必须跟有函数名和包
括形式参数的圆括号。函数体语句从下一行开始，必须是缩进的。
The first statement of the function body can optionally be a string literal;
this string literal is the function's documentation string, or :dfn:`docstring`.
(More about docstrings can be found in the section :ref:`tut-docstrings`.)
There are tools which use docstrings to automatically produce online or printed
documentation, or to let the user interactively browse through code; it's good
practice to include docstrings in code that you write, so make a habit of it.
函数体的第一行可以是一个字符串值，这个字符串是该函数的文档字符串
，或称 :dfn:`docstring` 。（更进一步的文
档字符串介绍可以在这一节找到 :ref:`tut-docstrings` 。）有些工具使用文
档字符串在线的生成及打印文档，或者允许用户在代码中交互式的浏览；编写代
码进加入文档字符串是个好的风格，应该养成习惯。
The *execution* of a function introduces a new symbol table used for the local
variables of the function. More precisely, all variable assignments in a
function store the value in the local symbol table; whereas variable references
first look in the local symbol table, then in the local symbol tables of
enclosing functions, then in the global symbol table, and finally in the table
of built-in names. Thus, global variables cannot be directly assigned a value
within a function (unless named in a :keyword:`global` statement), although they
may be referenced.
*执行* 函数时会为局部变量引入一个新的符号表。所有的局部变量都存储在这
个局部符号表中。引用参数时，会先从局部符号表中查找，然后是全局符号表，然
后是内置命名表。因此，全局参数虽然可以被引用，但它们不能在函数中直接
赋值（除非它们用 :keyword:`global` 语句命名）。
The actual parameters (arguments) to a function call are introduced in the local
symbol table of the called function when it is called; thus, arguments are
passed using *call by value* (where the *value* is always an object *reference*,
not the value of the object). [#]_ When a function calls another function, a new
local symbol table is created for that call.
函数引用的实际参数在函数调用时引入局部符号表，因此，实参总是 *传值调用*
（这里的 *值* 总是一个对象 *引用* ，而不是该对象的值）。 [#]_ 一个函数被另一个函
数调用时，一个新的局部符号表在调用过程中被创建。
A function definition introduces the function name in the current symbol table.
The value of the function name has a type that is recognized by the interpreter
as a user-defined function. This value can be assigned to another name which
can then also be used as a function. This serves as a general renaming
mechanism::
函数定义在当前符号表中引入函数名。作为用户定义函数，函数名有一个为解释
器认可的类型值。这个值可以赋给其它命名，使其能够作为一个函数来使用。这
就像一个重命名机制 ::
>>> fib
<function fib at 10042ed0>
>>> f = fib
>>> f(100)
0 1 1 2 3 5 8 13 21 34 55 89
Coming from other languages, you might object that ``fib`` is not a function but
a procedure since it doesn't return a value. In fact, even functions without a
:keyword:`return` statement do return a value, albeit a rather boring one. This
value is called ``None`` (it's a built-in name). Writing the value ``None`` is
normally suppressed by the interpreter if it would be the only value written.
You can see it if you really want to using :keyword:`print`::
你可能认为 ``fib`` 没有返回值，它不是一个函数（ function ），而是一个
过程（ procedure ）。实际上，即使函数没有 :keyword:`return` 语句，它也
有返回值，虽然是一个不讨人喜欢的。这个值被称为 ``None`` （这是一个内置命
名）。如果一个值只是 None 的话，通常解释器不会写出来，如果你真想要查看
它的话，可以这样做 ::
>>> fib(0)
>>> print fib(0)
None
It is simple to write a function that returns a list of the numbers of the
Fibonacci series, instead of printing it::
以下示例演示了如何从函数中返回一个包含菲波那契数列的数值链表，而不是打
印它 ::
>>> 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]
This example, as usual, demonstrates some new Python features:
和以前一样，这个例子演示了一些新的 Python 功能：
* The :keyword:`return` statement returns with a value from a function.
:keyword:`return` without an expression argument returns ``None``. Falling off
the end of a function also returns ``None``.
:keyword:`return` 语句从函数中返回一个值，不带表达式的
:keyword:`return` 返回 ``None`` 。过程结束后也会返回 ``None`` 。
* The statement ``result.append(a)`` calls a *method* of the list object
``result``. A method is a function that 'belongs' to an object and is named
``obj.methodname``, where ``obj`` is some object (this may be an expression),
and ``methodname`` is the name of a method that is defined by the object's type.
Different types define different methods. Methods of different types may have
the same name without causing ambiguity. (It is possible to define your own
object types and methods, using *classes*, see :ref:`tut-classes`)
The method :meth:`append` shown in the example is defined for list objects; it
adds a new element at the end of the list. In this example it is equivalent to
``result = result + [a]``, but more efficient.
语句 ``result.append(b)`` 称为链表对象 ``result`` 的一个 *方法* （ method ）。方
法是一个“属于”某个对象的函数，它被命名为 ``obj.methodename`` ，这里的
``obj`` 是某个对象（可能是一个表达式）， ``methodename`` 是某个在该对象类型定
义中的方法的命名。不同的类型定义不同的方法。不同类型可能有同样名字的
方法，但不会混淆。（当你定义自己的对象类型和方法时，可能会出现这种情
况， *class* 的定义方法详见 :ref:`tut-classes` ）。示例中演示的
:meth:`append` 方法
由链表对象定义，它向链表中加入一个新元素。在示例中它等同于
``result = result + [b]`` ，不过效率更高。
.. _tut-defining:
More on Defining Functions 深入函数定义
====================================================
It is also possible to define functions with a variable number of arguments.
There are three forms, which can be combined.
有时需要定义参数个数可变的函数。有三种形式，我们可以组合使用它们。
.. _tut-defaultargs:
Default Argument Values 参数默认值
----------------------------------------------------
The most useful form is to specify a default value for one or more arguments.
This creates a function that can be called with fewer arguments than it is
defined to allow. For example::
最有用的形式是给一个或多个参数指定默认值。这样创建的函数可以用较少的参
数来调用。例如 ::
def ask_ok(prompt, retries=4, complaint='Yes or no, please!'):
while True:
ok = raw_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 IOError('refusenik user')
print complaint
This function can be called in several ways:
这个函数可以通过几种不同的方式调用：
* giving only the mandatory argument:
只给出必要的参数：
``ask_ok('Do you really want to quit?')``
* giving one of the optional arguments:
给出一个可选的参数：
``ask_ok('OK to overwrite the file?', 2)``
* or even giving all arguments:
或者给出所有的参数：
``ask_ok('OK to overwrite the file?', 2, 'Come on, only yes or no!')``
This example also introduces the :keyword:`in` keyword. This tests whether or
not a sequence contains a certain value.
这个例子还介绍了 :keyword:`in` 关键字。它测定序列中是否包含某个确定的
值。
The default values are evaluated at the point of function definition in the
*defining* scope, so that ::
默认值在函数 *定义* 作用域被解析，如下所示 ::
i = 5
def f(arg=i):
print arg
i = 6
f()
will print ``5``.
**Important warning:** The default value is evaluated only once. This makes a
difference when the default is a mutable object such as a list, dictionary, or
instances of most classes. For example, the following function accumulates the
arguments passed to it on subsequent calls :
**重要警告** 默认值只解析一次。这造成字典、列表或大部分类实例等可变对象的行为会与期待的不太一样。例如，下例的函数在每次调用时都造成参数的累加 ::
def f(a, L=[]):
L.append(a)
return L
print f(1)
print f(2)
print f(3)
This will print ::
这样会打印出 ::
[1]
[1, 2]
[1, 2, 3]
If you don't want the default to be shared between subsequent calls, you can
write the function like this instead::
如果你不想在随后的调用中共享默认值，可以像这样写函数 ::
def f(a, L=None):
if L is None:
L = []
L.append(a)
return L
.. _tut-keywordargs:
Keyword Arguments 关键字参数
-------------------------------------
Functions can also be called using keyword arguments of the form ``keyword =
value``. For instance, the following function::
函数可以通过关键字参数的形式来调用，形如 ``keyword = value`` 。例如，
以下的函数 ::
def parrot(voltage, state='a stiff', action='voom', type='Norwegian Blue'):
print "-- This parrot wouldn't", action,
print "if you put", voltage, "volts through it."
print "-- Lovely plumage, the", type
print "-- It's", state, "!"
could be called in any of the following ways::
可以用以下的任一方法调用 ::
parrot(1000)
parrot(action = 'VOOOOOM', voltage = 1000000)
parrot('a thousand', state = 'pushing up the daisies')
parrot('a million', 'bereft of life', 'jump')
but the following calls would all be invalid::
不过以下几种调用是无效的 ::
parrot() # required argument missing
parrot(voltage=5.0, 'dead') # non-keyword argument following keyword
parrot(110, voltage=220) # duplicate value for argument
parrot(actor='John Cleese') # unknown keyword
In general, an argument list must have any positional arguments followed by any
keyword arguments, where the keywords must be chosen from the formal parameter
names. It's not important whether a formal parameter has a default value or
not. No argument may receive a value more than once --- formal parameter names
corresponding to positional arguments cannot be used as keywords in the same
calls. Here's an example that fails due to this restriction::
通常，参数列表中的每一个关键字都必须来自于形式参数，每个参数都有对应的
关键字。形式参数有没有默认值并不重要。实际参数不能一次赋多个值——形式参
数不能在同一次调用中同时使用位置和关键字绑定值。这里有一个例子演示了在
这种约束下所出现的失败情况 ::
>>> 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'
When a final formal parameter of the form ``**name`` is present, it receives a
dictionary (see :ref:`typesmapping`) containing all keyword arguments except for
those corresponding to a formal parameter. This may be combined with a formal
parameter of the form ``*name`` (described in the next subsection) which
receives a tuple containing the positional arguments beyond the formal parameter
list. (``*name`` must occur before ``**name``.) For example, if we define a
function like this::
引入一个形如 ``**name`` 的参数时，它接收一个字典（参见
:ref:`typesmapping` ） ，该字典包含了所有未出现
在形式参数列表中的关键字参数。这里可能还会组合使用一个形如 ``*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 = keywords.keys()
keys.sort()
for kw in keys: print kw, ":", keywords[kw]
It could be called like this::
它可以像这样调用 ::
cheeseshop("Limburger", "It's very runny, sir.",
"It's really very, VERY runny, sir.",
shopkeeper='Michael Palin',
client="John Cleese",
sketch="Cheese Shop Sketch")
and of course it would print::
当然它会按如下内容打印 ::
-- Do you have any Limburger ?
-- I'm sorry, we're all out of Limburger
It's very runny, sir.
It's really very, VERY runny, sir.
----------------------------------------
client : John Cleese
shopkeeper : Michael Palin
sketch : Cheese Shop Sketch
Note that the :meth:`sort` method of the list of keyword argument names is
called before printing the contents of the ``keywords`` dictionary; if this is
not done, the order in which the arguments are printed is undefined.
注意在打印 ``关系字`` 参数字典的内容前先调用 :meth:`sort` 方法。否则的话，打印参数时的顺序是未定义的。
.. _tut-arbitraryargs:
Arbitrary Argument Lists 可变参数列表
---------------------------------------------
.. index::
statement: *
Finally, the least frequently used option is to specify that a function can be
called with an arbitrary number of arguments. These arguments will be wrapped
up in a tuple (see :ref:`tut-tuples`). Before the variable number of arguments,
zero or more normal arguments may occur. ::
最后，一个最不常用的选择是可以让函数调用可变个数的参数。这些参数被包装
进一个元组（参见 :ref:`tut-tuples` ）。在这些可变个数的参数之前，可以有零到多个普通的参数 ::
def write_multiple_items(file, separator, *args):
file.write(separator.join(args))
.. _tut-unpacking-arguments:
Unpacking Argument Lists 参数列表的分拆
--------------------------------------------
The reverse situation occurs when the arguments are already in a list or tuple
but need to be unpacked for a function call requiring separate positional
arguments. For instance, the built-in :func:`range` function expects separate
*start* and *stop* arguments. If they are not available separately, write the
function call with the ``*``/ -operator to unpack the arguments out of a list
or tuple::
另有一种相反的情况: 当你要传递的参数已经是一个列表，但要调用的函数却接受
分开一个个的参数值. 这时候你要把已有的列表拆开来. 例如内建函数 :func:`range`
需要要独立的 *start*, *stop* 参数. 你可以在调用函数时加一个 ``*`` 操作符来自动
把参数列表拆开 ::
>>> range(3, 6) # normal call with separate arguments
[3, 4, 5]
>>> args = [3, 6]
>>> range(*args) # call with arguments unpacked from a list
[3, 4, 5]
.. index::
statement: **
In the same fashion, dictionaries can deliver keyword arguments with the ``**``/
-operator::
以同样的方式，可以使用 ``**`` 操作符分拆关键字参数为字典：
>>> def parrot(voltage, state='a stiff', action='voom'):
... print "-- This parrot wouldn't", action,
... print "if you put", voltage, "volts through it.",
... 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 !
.. _tut-lambda:
Lambda Forms Lambda 形式
------------------------------
By popular demand, a few features commonly found in functional programming
languages like Lisp have been added to Python. With the :keyword:`lambda`
keyword, small anonymous functions can be created. Here's a function that
returns the sum of its two arguments: ``lambda a, b: a+b``. Lambda forms can be
used wherever function objects are required. They are syntactically restricted
to a single expression. Semantically, they are just syntactic sugar for a
normal function definition. Like nested function definitions, lambda forms can
reference variables from the containing scope::
出于实际需要，有几种通常在函数式编程语言例如 Lisp 中出现的功能加入到了
Python 。通过 :keyword:`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
.. _tut-docstrings:
Documentation Strings 文档字符串
----------------------------------------
.. index::
single: docstrings
single: documentation strings
single: strings, documentation
There are emerging conventions about the content and formatting of documentation
strings.
这里介绍的文档字符串的概念和格式。
The first line should always be a short, concise summary of the object's
purpose. For brevity, it should not explicitly state the object's name or type,
since these are available by other means (except if the name happens to be a
verb describing a function's operation). This line should begin with a capital
letter and end with a period.
第一行应该是关于对象用途的简介。简短起见，不用明确的陈述对象名或类型，
因为它们可以从别的途径了解到（除非这个名字碰巧就是描述这个函数操作的动
词）。这一行应该以大写字母开头，以句号结尾。
If there are more lines in the documentation string, the second line should be
blank, visually separating the summary from the rest of the description. The
following lines should be one or more paragraphs describing the object's calling
conventions, its side effects, etc.
如果文档字符串有多行，第二行应该空出来，与接下来的详细描述明确分隔。接
下来的文档应该有一或多段描述对象的调用约定、边界效应等。
The Python parser does not strip indentation from multi-line string literals in
Python, so tools that process documentation have to strip indentation if
desired. This is done using the following convention. The first non-blank line
*after* the first line of the string determines the amount of indentation for
the entire documentation string. (We can't use the first line since it is
generally adjacent to the string's opening quotes so its indentation is not
apparent in the string literal.) Whitespace "equivalent" to this indentation is
then stripped from the start of all lines of the string. Lines that are
indented less should not occur, but if they occur all their leading whitespace
should be stripped. Equivalence of whitespace should be tested after expansion
of tabs (to 8 spaces, normally).
Python的解释器不会从多行的文档字符串中去除缩进，所以必要的时候应当自己
清除缩进。这符合通常的习惯。第一行之后的第一个非空行决定了整个文档的缩
进格式。（我们不用第一行是因为它通常紧靠着起始的引号，缩进格式显示的不
清楚。）留白“相当于”是字符串的起始缩进。每一行都不应该有缩进，如果有
缩进的话，所有的留白都应该清除掉。留白的长度应当等于扩展制表符的宽度
（通常是8个空格）。
Here is an example of a multi-line docstring::
以下是一个多行文档字符串的示例 ::
>>> 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.
.. _tut-codingstyle:
Intermezzo: Coding Style 插曲：编码风格
==============================================
.. sectionauthor:: Georg Brandl <georg@python.org>
.. index:: pair: coding; style
Now that you are about to write longer, more complex pieces of Python, it is a
good time to talk about *coding style*. Most languages can be written (or more
concise, *formatted*) in different styles; some are more readable than others.
Making it easy for others to read your code is always a good idea, and adopting
a nice coding style helps tremendously for that.
此时你已经可以写一此更长更复杂的 Python 程序，是时候讨论一下
*编码风格* 了。大多数语言可以写（或者更明白的说， *格式化* ）作几种不
同的风格。有些比其它的更好读。让你的代码对别人更易读是个好想法，养成良
好的编码风格对此很有帮助。
For Python, :pep:`8` has emerged as the style guide that most projects adhere to;
it promotes a very readable and eye-pleasing coding style. Every Python
developer should read it at some point; here are the most important points
extracted for you:
对于 Python， :pep:`8` 引入了大多数项目遵循的风格指导。它给出了一个高
度可读，视觉友好的编码风格。每个 Python 开发者都应该读一下，大多数要点
都会对你有帮助：
* Use 4-space indentation, and no tabs.
使用 4 空格缩进，而非 TAB。
4 spaces are a good compromise between small indentation (allows greater
nesting depth) and large indentation (easier to read). Tabs introduce
confusion, and are best left out.
在小缩进（可以嵌套更深）和大缩进（更易读）之间，4空格是一个很好的折
中。TAB 引发了一些混乱，最好弃用。
* Wrap lines so that they don't exceed 79 characters.
折行以确保其不会超过 79 个字符。
This helps users with small displays and makes it possible to have several
code files side-by-side on larger displays.
这有助于小显示器用户阅读，也可以让大显示器能并排显示几个代码文件。
* Use blank lines to separate functions and classes, and larger blocks of
code inside functions.
使用空行分隔函数和类，以及函数中的大块代码。
* When possible, put comments on a line of their own.
可能的话，注释独占一行
* Use docstrings.
使用文档字符串
* Use spaces around operators and after commas, but not directly inside
bracketing constructs: ``a = f(1, 2) + g(3, 4)``.
把空格放到操作符两边，以及逗号后面，但是括号里侧不加空格： ``a =
f(1, 2) + g(3, 4)`` 。
* Name your classes and functions consistently; the convention is to use
``CamelCase`` for classes and ``lower_case_with_underscores`` for functions
and methods. Always use ``self`` as the name for the first method argument
(see :ref:`tut-firstclasses` for more on classes and methods).
统一函数和类命名。推荐类名用 ``驼峰命名``， 函数和方法名用
``小写_和_下划线`` 。 总是用 ``self`` 作为方法的第一个参数（关于类和
方法的知识详见 :ref:`tut-firstclasses` ）。
* Don't use fancy encodings if your code is meant to be used in international
environments. Plain ASCII works best in any case.
在国际化环境中不要随意使用自己喜欢的编码， 纯 ASCII 文本总是工作的最好。
（作为东方人，我有不同的见解，个人推荐首选 utf-8——译者）
.. rubric:: Footnotes
.. [#] Actually, *call by object reference* would be a better description,
since if a mutable object is passed, the caller will see any changes the
callee makes to it (items inserted into a list).
实际上， *引用对象调用* 描述的更为准确。如果传入一个可变对像，调用
者会看到调用操作带来的任何变化（如子项插入到列表中）。
内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理 
相关文章推荐
- Python 2.7 Tutorial —— 流程控制
- Python3.6.4文档(tutorial)总结——流程控制
- Python2.7自学笔记3――流程控制语句
- Python 流程控制之while
- python 运算与流程控制
- python练习----基本流程控制
- Python流程控制
- Python中的流程控制
- Python指南－－深入流程控制
- Python的流程控制 - for序列
- python基础---流程控制
- Python流程控制语句
- python学习 流程控制语句
- Python 2.7 Tutorial —— 索引和前言
- Python 2.7 Tutorial —— 简介
- Python 2.7 Tutorial —— 模块
- Python 2.7 Tutorial —— 浮点数
- Python教程之三-----深入流程控制
- python 学习笔记-山寨携程(列表，字符串,字典和流程控制总结)
- python学习-Day8-python流程控制之if、for、which、