 |
 |
 |
Python Tutorial |  |
 |
|
|
|
|
Python Tutorial | |
|
|
Besides the while statement just introduced, Python knows the usual control flow statements known from other languages, with some twists.
除了前面介紹的 while 語句，Python 還從別的語言中借鑒了一些流程控制功能，并有所改變。
Perhaps the most well-known statement type is the if statement. For example:
也許最有名的是 if 語句。例如：
>>> x = int(raw_input("Please enter an integer: "))
>>> if x < 0:
... x = 0
... print 'Negative changed to zero'
... elif x == 0:
... print 'Zero'
... elif x == 1:
... print 'Single'
... else:
... print 'More'
...
There can be zero or more elif parts, and the else part is optional. The keyword `elif' is short for `else if', and is useful to avoid excessive indentation. An if ... elif ... elif ... sequence is a substitute for the switch or case statements found in other languages.
可能會(huì)有零到多個(gè) elif 部分，else 是可選的。關(guān)鍵字“elif” 是“ else if ”的縮寫，這個(gè)可以有效避免過深的縮進(jìn)。if ... elif ... elif ... 序列用于替代其它語言中的 switch 或 case 語句。
The 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 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 中的略有不同。通常的循環(huán)可能會(huì)依據(jù)一個(gè)等差數(shù)值步進(jìn)過程（如Pascal）或由用戶來定義迭代步驟和中止條件（如 C ），Python 的 for 語句依據(jù)任意序列（鏈表或字符串）中的子項(xiàng)，按它們?cè)谛蛄兄械捻樞騺磉M(jìn)行迭代。例如（沒有暗指）：
>>> # 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:
在迭代過程中修改迭代序列不安全（只有在使用鏈表這樣的可變序列時(shí)才會(huì)有這樣的情況）。如果你想要修改你迭代的序列（例如，復(fù)制選擇項(xiàng)），你可以迭代它的復(fù)本。通常使用切片標(biāo)識(shí)就可以很方便的做到這一點(diǎn)：
>>> 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']
If you do need to iterate over a sequence of numbers, the built-in function range() comes in handy. It generates lists containing arithmetic progressions:
如果你需要一個(gè)數(shù)值序列，內(nèi)置函數(shù)range()可能會(huì)很有用，它生成一個(gè)等差級(jí)數(shù)鏈表。
>>> 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, exactly 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) 生成了一個(gè)包含10個(gè)值的鏈表，它準(zhǔn)確的用鏈表的索引值填充了這個(gè)長(zhǎng)度為10的列表，所生成的鏈表中不包括范圍中的結(jié)束值。也可以讓range操作從另一個(gè)數(shù)值開始，或者可以指定一個(gè)不同的步進(jìn)值（甚至是負(fù)數(shù)，有時(shí)這也被稱為“步長(zhǎng)”）：
>>> 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, combine range() and len() as follows:
需要迭代鏈表索引的話，如下所示結(jié)合使 用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
The break statement, like in C, breaks out of the smallest enclosing for or while loop.
break 語句和 C 中的類似，用于跳出最近的一級(jí) for 或 while 循環(huán)。
The continue statement, also borrowed from C, continues with the next iteration of the loop.
continue 語句是從 C 中借鑒來的，它表示循環(huán)繼續(xù)執(zhí)行下一次迭代。
Loop statements may have an else clause; it is executed when
the loop terminates through exhaustion of the list (with
for) or when the condition becomes false (with
while), but not when the loop is terminated by a
break statement. This is exemplified by the following loop,
which searches for prime numbers:
循環(huán)可以有一個(gè) else 子句;它在循環(huán)迭代完整個(gè)列表（對(duì)于 for ）或執(zhí)行條件為 false （對(duì)于 while ）時(shí)執(zhí)行，但循環(huán)被 break 中止的情況下不會(huì)執(zhí)行。以下搜索素?cái)?shù)的示例程序演示了這個(gè)子句：
>>> 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
The pass statement does nothing. It can be used when a statement is required syntactically but the program requires no action. For example:
pass 語句什么也不做。它用于那些語法上必須要有什么語句，但程序什么也不做的場(chǎng)合，例如：
>>> while True: ... pass # Busy-wait for keyboard interrupt ...
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 b < n: ... print b, ... a, b = b, a+b ... >>> # Now call the function we just defined: ... fib(2000) 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597
The 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. The first statement of the function body can optionally be a string literal; this string literal is the function's documentation string, or docstring.
關(guān)鍵字 def 引入了一個(gè)函數(shù)定義。在其后必須跟有函數(shù)名和包括形式參數(shù)的圓括號(hào)。函數(shù)體語句從下一行開始，必須是縮進(jìn)的。函數(shù)體的第一行可以是一個(gè)字符串值，這個(gè)字符串是該函數(shù)的 (文檔字符串（documentation string）)，也可稱作 docstring 。
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 try to make a habit of it.
有些文檔字符串工具可以在線處理或打印文檔，或讓用戶交互的瀏覽代碼;在代碼中加入文檔字符串是一個(gè)好的作法，應(yīng)該養(yǎng)成這個(gè)習(xí)慣。
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 global symbol table, and then in the table of built-in names. Thus, global variables cannot be directly assigned a value within a function (unless named in a global statement), although they may be referenced.
執(zhí)行函數(shù)時(shí)會(huì)為局部變量引入一個(gè)新的符號(hào)表。所有的局部變量都存儲(chǔ)在這個(gè)局部符號(hào)表中。引用參數(shù)時(shí)，會(huì)先從局部符號(hào)表中查找，然后是全局符號(hào)表，然后是內(nèi)置命名表。因此，全局參數(shù)雖然可以被引用，但它們不能在函數(shù)中直接賦值（除非它們用 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).4.1 When a function calls another function, a new local symbol table is created for that call.
函數(shù)引用的實(shí)際參數(shù)在函數(shù)調(diào)用時(shí)引入局部符號(hào)表，因此，實(shí)參總是傳值調(diào)用（這里的值總是一個(gè)對(duì)象引用，而不是該對(duì)象的值）。4.2 一個(gè)函數(shù)被另一個(gè)函數(shù)調(diào)用時(shí)，一個(gè)新的局部符號(hào)表在調(diào)用過程中被創(chuàng)建。
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:
函數(shù)定義在當(dāng)前符號(hào)表中引入函數(shù)名。作為用戶定義函數(shù)，函數(shù)名有一個(gè)為解釋器認(rèn)可的類型值。這個(gè)值可以賦給其它命名，使其能夠作為一個(gè)函數(shù)來使用。這就像一個(gè)重命名機(jī)制：
>>> fib <function fib at 10042ed0> >>> f = fib >>> f(100) 1 1 2 3 5 8 13 21 34 55 89
You might object that fib is not a function but a procedure. In
Python, like in C, procedures are just functions that don't return a
value. In fact, technically speaking, procedures 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:
你可能認(rèn)為fib不是一個(gè)函數(shù)（ function ），而是一個(gè)過程（ procedure ）。Python 和 C 一樣，過程只是一個(gè)沒有返回值的函數(shù)。實(shí)際上，從技術(shù)上講，過程也有一個(gè)返回值，雖然是一個(gè)不討人喜歡的。這個(gè)值被稱為 None （這是一個(gè)內(nèi)置命名）。如果一個(gè)值只是 None 的話，通常解釋器不會(huì)寫一個(gè) None 出來，如果你真想要查看它的話，可以這樣做：
>>> 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:
以下示例演示了如何從函數(shù)中返回一個(gè)包含菲波那契數(shù)列的數(shù)值鏈表，而不是打印它：
>>> 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 b < n: ... result.append(b) # see below ... a, b = b, a+b ... return result ... >>> f100 = fib2(100) # call it >>> f100 # write the result [1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]
This example, as usual, demonstrates some new Python features:
和以前一樣，這個(gè)例子演示了一些新的 Python 功能：
None.
Falling off the end of a procedure also returns None.
return 語句從函數(shù)中返回一個(gè)值，不帶表達(dá)式的 return 返回 None。過程結(jié)束后也會(huì)返回 None 。
result.append(b) 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, as discussed later
in this tutorial.)
The method 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 + [b]", but more
efficient.
語句 result.append(b) 稱為鏈表對(duì)象 result 的一個(gè)方法（ method ）。方法是一個(gè)“屬于”某個(gè)對(duì)象的函數(shù)，它被命名為 obj.methodename ，這里的 obj 是某個(gè)對(duì)象（可能是一個(gè)表達(dá)式），methodename 是某個(gè)在該對(duì)象類型定義中的方法的命名。不同的類型定義不同的方法。不同類型可能有同樣名字的方法，但不會(huì)混淆。（當(dāng)你定義自己的對(duì)象類型和方法時(shí)，可能會(huì)出現(xiàn)這種情況，本指南后面的章節(jié)會(huì)介紹如何使用類型）。示例中演示的 append()方法由鏈表對(duì)象定義，它向鏈表中加入一個(gè)新元素。在示例中它等同于""result = result + [b]""，不過效率更高。
It is also possible to define functions with a variable number of arguments. There are three forms, which can be combined.
有時(shí)需要定義參數(shù)個(gè)數(shù)可變的函數(shù)。有三個(gè)方法可以達(dá)到目的，我們可以組合使用它們。
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:
最有用的形式是給一個(gè)或多個(gè)參數(shù)指定默認(rèn)值。這樣創(chuàng)建的函數(shù)可以用較少的參數(shù)來調(diào)用。例如：
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 either like this:
ask_ok('Do you really want to quit?') or like this:
ask_ok('OK to overwrite the file?', 2).
這個(gè)函數(shù)還可以用以下的方式調(diào)用：ask_ok('Do you really want
to quit?')，或者像這樣：ask_ok('OK to overwrite the file?',
2)。
This example also introduces the in keyword. This tests whether or not a sequence contains a certain value.
這個(gè)示例還介紹了關(guān)鍵字 in 。它檢測(cè)一個(gè)序列中是否包含某個(gè)給定的值。
The default values are evaluated at the point of function definition in the defining scope, so that
默認(rèn)值在函數(shù)定義段被解析，如下所示：
i = 5
def f(arg=i):
print arg
i = 6
f()
will print 5.
以上代碼會(huì)打印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:
重要警告：默認(rèn)值只會(huì)解析一次。當(dāng)默認(rèn)值是一個(gè)可變對(duì)象，諸如鏈表、字典或大部分類實(shí)例時(shí)，會(huì)產(chǎn)生一些差異。例如，以下函數(shù)在后繼的調(diào)用中會(huì)累積它的參數(shù)值：
def f(a, L=[]):
L.append(a)
return L
print f(1)
print f(2)
print f(3)
This will print
這會(huì)打印出：
[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:
如果你不想在不同的函數(shù)調(diào)用之間共享參數(shù)默認(rèn)值，可以如下面的實(shí)例一樣編寫函數(shù)：
def f(a, L=None):
if L is None:
L = []
L.append(a)
return L
Functions can also be called using keyword arguments of the form "keyword = value". For instance, the following function:
函數(shù)可以通過關(guān)鍵字參數(shù)的形式來調(diào)用，形如"keyword = value"。例如，以下的函數(shù)：
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:
可以用以下的任一方法調(diào)用：
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:
不過以下幾種調(diào)用是無效的：
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:
通常，參數(shù)列表中的每一個(gè)關(guān)鍵字都必須來自于形式參數(shù)，每個(gè)參數(shù)都有對(duì)應(yīng)的關(guān)鍵字。形式參數(shù)有沒有默認(rèn)值并不重要。實(shí)際參數(shù)不能一次賦多個(gè)值——形式參數(shù)不能在同一次調(diào)用中同時(shí)使用位置和關(guān)鍵字綁定值。這里有一個(gè)例子演示了在這種約束下所出現(xiàn)的失敗情況：
>>> 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 containing all keyword arguments
whose keyword doesn't correspond 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:
引入一個(gè)形如 **name 的參數(shù)時(shí)，它接收一個(gè) 字典 ，該字典包含了所有未出現(xiàn)在形式參數(shù)列表中的關(guān)鍵字參數(shù)。這里可能還會(huì)組合使用一個(gè)形如 *name 的形式參數(shù)，它接收一個(gè)元組（下一節(jié)中會(huì)詳細(xì)介紹），包含了所有沒有出現(xiàn)在形式參數(shù)列表中的參數(shù)值。（*name 必須在 **name 之前出現(xiàn)） 例如，我們這樣定義一個(gè)函數(shù)：
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:
它可以像這樣調(diào)用：
cheeseshop('Limburger', "It's very runny, sir.",
"It's really very, VERY runny, sir.",
client='John Cleese',
shopkeeper='Michael Palin',
sketch='Cheese Shop Sketch')
and of course it would print:
當(dāng)然它會(huì)按如下內(nèi)容打印：
-- 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 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.
注意sort()方法在關(guān)鍵字字典內(nèi)容打印前被調(diào)用，否則的話，打印參數(shù)時(shí)的順序是未定義的。
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. Before the variable number of arguments, zero or more normal arguments may occur.
最后，一個(gè)最不常用的選擇是可以讓函數(shù)調(diào)用可變個(gè)數(shù)的參數(shù)。這些參數(shù)被包裝進(jìn)一個(gè)元組。在這些可變個(gè)數(shù)的參數(shù)之前，可以有零到多個(gè)普通的參數(shù)：
def fprintf(file, format, *args):
file.write(format % args)
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 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:
另有一種相反的情況: 當(dāng)你要傳遞的參數(shù)已經(jīng)是一個(gè)列表但要調(diào)用的函數(shù)卻接受分開一個(gè)個(gè)的參數(shù)值. 這時(shí)候你要把已有的列表拆開來. 例如內(nèi)建函數(shù) range() 需要要獨(dú)立的 start, stop 參數(shù). 你可以在調(diào)用函數(shù)時(shí)加一個(gè) * 操作符來自動(dòng)把參數(shù)列表拆開:
>>> 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]
By popular demand, a few features commonly found in functional programming languages and Lisp have been added to Python. With the 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:
出于實(shí)際需要，有幾種通常在功能性語言和 Lisp 中出現(xiàn)的功能加入到了 Python 。通過 lambda 關(guān)鍵字，可以創(chuàng)建短小的匿名函數(shù)。這里有一個(gè)函數(shù)返回它的兩個(gè)參數(shù)的和："lambda a, b: a+b"。 Lambda 形式可以用于任何需要的函數(shù)對(duì)象。出于語法限制，它們只能有一個(gè)單獨(dú)的表達(dá)式。語義上講，它們只是普通函數(shù)定義中的一個(gè)語法技巧。類似于嵌套函數(shù)定義，lambda 形式可以從包含范圍內(nèi)引用變量：
>>> def make_incrementor(n): ... return lambda x: x + n ... >>> f = make_incrementor(42) >>> f(0) 42 >>> f(1) 43
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.
第一行應(yīng)該是關(guān)于對(duì)象用途的簡(jiǎn)介。簡(jiǎn)短起見，不用明確的陳述對(duì)象名或類型，因?yàn)樗鼈兛梢詮膭e的途徑了解到（除非這個(gè)名字碰巧就是描述這個(gè)函數(shù)操作的動(dòng)詞）。這一行應(yīng)該以大寫字母開頭，以句號(hào)結(jié)尾。
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.
如果文檔字符串有多行，第二行應(yīng)該空出來，與接下來的詳細(xì)描述明確分隔。接下來的文檔應(yīng)該有一或多段描述對(duì)象的調(diào)用約定、邊界效應(yīng)等。
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的解釋器不會(huì)從多行的文檔字符串中去除縮進(jìn)，所以必要的時(shí)候應(yīng)當(dāng)自己清除縮進(jìn)。這符合通常的習(xí)慣。第一行之后的第一個(gè)非空行決定了整個(gè)文檔的縮進(jìn)格式。（我們不用第一行是因?yàn)樗ǔ＞o靠著起始的引號(hào)，縮進(jìn)格式顯示的不清楚。）留白“相當(dāng)于”是字符串的起始縮進(jìn)。每一行都不應(yīng)該有縮進(jìn)，如果有縮進(jìn)的話，所有的留白都應(yīng)該清除掉。留白的長(zhǎng)度應(yīng)當(dāng)?shù)扔跀U(kuò)展制表符的寬度（通常是8個(gè)空格）。
Here is an example of a multi-line docstring:
以下是一個(gè)多行文檔字符串的示例：
>>> 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 Tutorial | |
|
|