當前位置：首頁 > 编程语言 > python >内容正文

python

Python 2.7 Tutorial —— 流程控制

發布時間：2023/12/9 python 26 豆豆

生活随笔收集整理的這篇文章主要介紹了 Python 2.7 Tutorial —— 流程控制小編覺得挺不錯的,現在分享給大家,幫大家做個參考.

.. _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

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).

?? 實際上， *引用對象調用* 描述的更為準確。如果傳入一個可變對像，調用

?? 者會看到調用操作帶來的任何變化（如子項插入到列表中）。

轉載于:https://www.cnblogs.com/it20120227/archive/2010/10/01/2370779.html

總結

以上是生活随笔為你收集整理的Python 2.7 Tutorial —— 流程控制的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。

上一篇：职场新人如何高效办公？这10款软件帮到你
下一篇： python 矩阵乘法跳过nan_py