一篇不錯的Python入門教程_python

原文 http://www.hetland.org/python/instant-hacking.php

Instant Hacking[譯文]

譯者： 肯定來過

這是一篇簡短的關于python程序設計語言的入門教程，原文在這里，翻著詞典翻譯了來！

這是一份對編程藝術的簡短介紹，其中的例子是用python寫成的。(如果你已經知道了該如何編程，但是想簡單了解一下python，你可以查閱我的另一篇文章Instant Python。）這篇文章已經被翻譯為意大利、波蘭、日本、塞爾維亞以及巴西葡萄亞語等許多種語言，而且正在被翻譯為韓語。（譯者：當然，現在已經包括了中文版本，只是作者并不知道。）

這篇文章和如何闖入別人的計算機系統之類的東西無關。我不關注那類事情，所以請不要email問我那些東西。

注意：要使此文中的例子正確運行，你應該把它們寫在一個文本文件中，然后用解釋器運行；不要試圖直接在交互方式下運行它們－－不是所有的都可以這樣運行。（不要問我和此有關的具體細節。最好查閱python文檔或者email給help@python.org）。

1. 運行環境

要用python寫程序，你必須先安裝一個python的解釋器。它可以存在于大多數平臺（包括Macintosh、Unix和Windows）。更多與此有關的信息可以在python的網站上找到。你還應該有一個文本編輯器（象emacs、notepad或者類似的東西）。

2. 編程是什么？

為計算機寫程序其實就是給它一系列的指令告訴它去做什么。計算機程序在某些方面就象是菜譜，指導我們如何做菜的那種。例如［1］：

假日火腿沙拉

原料：

腌泡汁：
1/4杯酸橙汁
1/4杯低鈉大豆醬油
1/4杯水
1大湯匙植物油
3/4茶匙小茴香
1/2茶匙牛至
1/4茶匙熱胡椒粉
2片丁香、大蒜，搗碎

沙拉：
1份（12盎司）罐裝少鈉午餐肉火腿切成條狀
1個洋蔥，切片
胡椒粉，切好的生菜
12個櫻桃西紅柿，切半

方法：

把腌泡汁裝在有合適蓋子的廣口瓶里搖勻。用塑料袋裝上火腿，潑上腌泡汁，封住袋口。在電冰箱里腌制30分鐘。從塑料袋里取出火腿；準備2大湯匙腌泡汁，在煮鍋里煮一下。加上火腿、洋蔥、綠色的胡椒。燒3到4分鐘直到火腿熟了為止……

當然，沒有一臺計算機會懂這個……而且即便是懂，大多數計算機也不可能燒制出一份沙拉。那么，我們該如何讓這些變得對計算機來說更為友好一些呢？從根本上說依賴于兩點：首先，我們必須以計算機可以理解的方式與之交流；其次還要和它談論它能夠做到的事情。

第一點意味著我們必須使用一種語言－－一種已經為之準備好了解釋器的程序設計語言，第二點意味著我們不能期望計算機為我們做一份沙拉－－但是我們可以讓它做數字累加或者在屏幕上打印東西之類的事情。

3. Hello……

程序設計教程有一個傳統，通常以在屏幕上打印“Hello, world!”這樣的程序做為開始。對python來說，這非常簡單：

print "Hello, world!"

它從根本上說很象上面的菜譜（盡管要短得多！）。它告訴計算機做什么：打印“Hello, world!”。如果讓它打印更多的廢話該怎么做呢？很簡單：

print "Hello, world!"
print "Goodbye, world!"

不比上一個難，是不是？但是不怎么有趣……我們希望它可以處理更多的元素，就象沙拉菜譜那樣。那么，我們都有哪些元素呢？首先，有字符串，象“Hello, world!”，除此之外還有數字。假設我們打算讓計算機為我們計算矩形的面積。我們可以給它如下的菜譜：

# The Area of a Rectangle

# Ingredients:

width = 20
height = 30

# Instructions:

area = width * height
print area

你大概可以看出它同火腿沙拉菜譜的相似性（盡管有些細微的差別）。但它是如何工作的呢？首先，以#開始的行叫做注釋事實上會被計算機忽略。然而插入象這樣小段的注釋對于增強你程序的可讀性來說是很重要的。

接下來，看起來象 foo = bar 這樣的行叫做賦值。對于 width = 20 這樣的情況來說就是告訴計算機從這里開始width就代表20了。它還意味著一個名字為“width”的變量從此被創建了（如果它先前已經存在，那么會被重新覆蓋）。所以，我們以后使用這個變量的時候，計算機就知道了它的值。因此，

width * height

本質上同

20 * 30

一樣會計算出600這個結果，然后賦給名稱為“area”的變量。程序的最后一句在屏幕上打印出變量“area”的值，所以你看到這個程序運行的最終結果僅僅是

600

注意：在某些程序設計語言中，你必須在程序開始的時候告訴計算機你將會用到哪些變量（就象沙拉中的元素）－－而python足夠聰明，所以你可以根據需要隨時創建。

4. 反饋

現在，你可以執行一些簡單，或者再復雜一點的計算了。比方說，你或許打算寫一段程序來計算圓形的面積而不是矩形的：

radius = 30

print radius * radius * 3.14

然而，這事實上并不比計算矩形面積的那個程序更有意思。至少在我看來是這樣。它有些僵硬。如果我們看到半徑為31的圓該怎么辦？怎樣讓計算機知道？這有點象沙拉菜譜中的：“燒3到4分鐘直到火腿熟了為止。”要知道何時燒熟，我們必須檢查。我們需要反饋，或者提示。計算機如何知道我們圓形的半徑？同樣需要輸入資料……我們可以做的是告訴計算機半徑是多少：

radius = input("What is the radius?")
print radius * radius * 3.14

現在程序變得漂亮一些了……input是個被稱為函數的東西。（很快你將學習創建你自己的函數。而input是python內建的函數。）僅僅寫下

input

什么也不會做……你必須在它的后面放上一對括號。所以input()可以工作－－它會簡單的要求用戶輸入半徑的長度。而上面的那個版本對用戶來說也許更友好一些，因為它首先打印出了一個問題。當我們將諸如提問字符串“What is the radius?”之類的東西放在函數調用的括號中時，這個過程被稱為函數的參數傳遞。括號中的內容被稱為參數。在上個例子中我們傳遞了一個提問作為參數以便input知道在獲得答案前應該先打印什么。

但是獲得的答案如何到達radius變量呢？函數input，調用時，會返回一個值（象許多其它函數一樣）。你不一定非要使用這個值，但象我們這種情況，我們要使用它。這樣，下面這兩個表達式有著很大的差別：

foo = input
bar = input()

foo現在包含input函數本身（所以它事實上可以象foo("What is your age?")這樣使用；這被稱為動態函數調用）而bar包含用戶鍵入的值。

5. 流程

現在我們可以編寫程序執行簡單的任務（運算和打印）并且可以獲得用戶輸入了。這很有用，但仍然局限在按順序執行命令，也就是說－－它們必須按照事先安排好的順序執行。大多數火腿沙拉菜譜是象這樣順序或者線性敘述的。但是如果我們打算讓計算機檢查沙拉是否燒好該怎樣告訴它呢？如果燒好了，那么應該從烘箱里把它取出來－－否則的話，應該接著讓它燒更長一段時間什么的。我們如何表達這個？

我們想做的，其實是控制程序的流程。它可以從兩個方向執行－－要么拿開火腿，要不繼續讓它留在烘箱里。我們可以選擇，條件是它是否燒好。這被稱為條件執行。我們可以這樣寫：

temperature = input("What is the temperature of the spam?")

if temperature >; 50:
 print "The salad is properly cooked."
else:
 print "Cook the salad some more."

意思很明顯：如果溫度超過50（攝氏度），那么打印出信息告訴用戶燒好了，否則，告訴用戶再燒制一段時間。

注意：縮進在python中很重要。條件執行（還有循環執行以及函數定義－－見后面）中的語句塊必須被縮進（而且要縮進同等數量的空格；一個鍵相當于8個空格）以便解釋器可以知道它們從哪里開始到哪里結束。這同時也使程序變得更加可讀。

讓我們回到先前的面積計算問題。能看出來這段程序做什么嗎？

# Area calculation program

print "Welcome to the Area calculation program"
print "---------------------------------------"
print

# Print out the menu:
print "Please select a shape:"
print "1 Rectangle"
print "2 Circle"

#Get the user's choice:
shape = input(">; ")

#Calculate the area:
if shape == 1:
 height = input("Please enter the height: ")
 width = input("Please enter the width: ")
 area = height *width
 print "The area is ", area
else:
 radius = input("Please enter the radius: ")
 area = 3.14 * (radius**2)
 print "The area is ", area

這個例子中的新東西：
1. 只使用print本身將打印出一個空行
2. ==檢查兩個值是否相等，與=不同，后者把表達式右側的值賦給左側的變量。這是一個非常重要的差別！
3. **是python的冪運算符－－因此半徑的平方被寫成radius**2
4. print能夠打印出不止一個東西。只要用逗號把它們分開就可以了。（它們在輸出時會用單個空格分開。）

這個程序很簡單：它要一個數字，告訴它用戶打算讓它計算矩形或是圓形的面積。然后，使用一個if語句（條件執行）來決定應當執行哪個語句塊計算面積。這兩個語句塊同先前面積計算例子中使用的語句塊本質上是一樣的。留意注釋是如何使代碼變得更加可讀的。編程的第一條戒律就是：“你應當注釋！”無論如何－－它都是一個應該養成的好習慣。

練習1：

擴展上面的程序使它包括正方形面積的計算，用戶只要輸入它一條邊的長度就可以了。做這個練習之前你需要了解一件事：如果你有兩個以上的選擇，你可以象這樣寫：

if foo == 1:
 # Do something...
elif foo == 2:
 # Do something else...
elif foo == 3:
 # If all else fails...

這里的elif是意思為“else if”的神秘代碼:)。所以，如foo等于1，做某件事；否則，如果foo等于2，那么做另外的一些事，等等。你也可以在程序中加入其它的選項－－象三角形以及任意多邊形。隨你的便。

6. 循環

順序執行和條件執行僅僅是程序設計三個基本語句塊架構方式中的兩個。第三個則是循環執行。在上個段落中我假設了一種情況，檢查火腿是否燒好，但很明顯它并不適用。如果下次檢查時火腿仍然沒燒好該怎么辦？我們怎么知道需要檢查多少次？事實上，我們不知道。而且我們也沒必要知道。我們可以要求計算機持續檢查直到燒好了為止。怎么表達這個？你猜到了－－我們使用循環，或者說是重復執行。

python有兩種循環類型：while循環和for循環。for循環大概是最簡單的。舉個例子：

for food in "spam", "eggs", "tomatoes":
 print "I love", food

它的意思是：對于列表"spam", "eggs", "tomatoes"中的每個元素，都打印出你喜歡它。循環中的語句塊為每個元素執行一次，而且每次執行，當前的元素都被賦給變量food（在這個例子中）。另外一個例子：

for number in range(1, 100):
 print "Hello, world!"
 print "Just", 100 - number, "more to go..."

print "Hello, world"
print "That was the last one... Phew!"

函數range返回給定范圍的數字列表（包括第一個數字，不包括最后一個……這個例子中是［1……99］）。所以，這樣解釋它：

循環體為1（包括）到100（不包括）之間的數字每個執行一次。（哪個是循環體以及隨后的表達式事實上做什么留下來做為練習。）

但這對我們的燒菜問題并沒有實質的幫助。如果我們打算檢查火腿一百次，那么這是個很好的解決方案；但是我們不知道這是否夠－－或者太多了。我們只是希望它在溫度達不到（或者，直到它足夠熱－－大致某個狀態）的時候持續檢查。所以，我們使用while:

# Spam-cooking program

# Fetch the function sleep
from time import sleep

print "Please start cooking the spam. (I'll be back in 3 minutes.)"

# Wait for 3 minutes (that is, 3*60 seconds)...
sleep(180)

print "I'm baaack :)"

# How hot is hot enough?
hot_enough = 50

temperature = input("How hot is the spam?")
while temperature < hot_enouth:
 print "Not hot enough... Cook it a bit more..."
 sleep(30)
 temperature = input("OK, How hot is it now?")

print "It's hot enough - You're done!"

這個例子中的新東西……

1. 有些有用的函數被存儲在模塊中而且可以被導入。此例中我們從python自帶的time模塊中導入了函數sleep（它休止給定的多少秒的時間）。（做你自己的模塊當然也是可能的……）

練習2：

寫一個程序，持續從用戶獲得數據然后相加，直到它們的和為100。再寫一個程序，從用戶那里獲得100個數據，打印出它們的和。

Bigger Programs - Abstraction

如果想知道一本書的大致內容，你不會翻遍所有的頁－－你只是看看目錄，是不是？它會列出書的主要內容。現在－－想像寫一本菜譜。許多菜譜，像“奶油火腿通心面”和“瑞士火腿餡餅”很可能包含相同的東西，比如火腿，在這種情況下－－你肯定不會打算在每個菜譜里都重復敘述如何制作火腿。（好了……你事實上可能不做火腿……但是為了做例子，請忍受一下:)）。你會把制作火腿的菜譜單獨放在一個章節，而僅僅在其它章節里引用它。這樣－－代替在每個菜譜里都完整的描述，你只要引用章節的名稱就可以了。在計算機編程中這被稱為抽象化。

我們是不是已經象這樣運行了某些東西？是的。我們沒有詳細的告訴計算機如何從用戶那里獲得一個答案（好了－－我們沒有真的這樣做……同樣地……我們也沒有真正的在做火腿:)）而是簡單的使用了input－－一個函數來代替。我們事實上可以構造我們自己的函數，來應用于這種類型的抽象化中。

假設我們希望找到小于給定正數的最大整數。例如，給定2.7，這個數應當是2。這往往被稱為給定數的“底線（floor）”。（這事實上可以用python的內建函數int來處理，但是，請再次忍受我拿它作例子……）我們該怎樣做？一個簡單的解決辦法是從0開始試每一個可能的數：

number = input("What is the number?")

floor = 0
while floor <= number:
 floor = floor + 1
floor = floor - 1

print "The floor of ", number, "is ", floor

注意當floor不再小于（或者等于）給定數時循環結束了；我們加了太多1給它。因此我們必須為它減去1。如果我們希望把它應用于完整的數學運算該怎么辦呢？我們不得不為求每個數的基數（"floor"-ing)而寫一次完整的循環。這很不舒服……你可能猜到了我們代之以什么：把它放在我們自己的函數中，命名為“floor”：

def floor(number):
 result = 0
 while result <= number:
 result = result + 1
 result = result - 1
 return result

這個例子中的新東西……

1. 函數用關鍵字def定義，函數名緊隨其后并且要用括號把需要的參數括起來。
2. 如果要求函數返回一個值，要使用關鍵字return來處理（它同時也自動結束函數定義）。

定義了函數之后，我們可以象這樣使用它：

x = 2.7
y = floor(2.7)

執行后，y的值應該是2。定義擁有多個參數的函數也是可以的：

 
def sum(x, y):
 return x + y

練習3

寫一個函數，用歐幾里德方法尋找兩個數的一個共同因數。工作過程是這樣的：

1. 假設兩個數，a和b，a大于b
2. 重復以下步驟直到b變成0：
1. a變為b的值
2. b變成沒有改變值之前的a除以沒有改變值之前的b的余數
3. 返回a的最后一個值

提示：

* 使用a和b作為函數的參數
* 簡單的設定a大于b
* x除以z的余數用表達式 x % z 來計算
* 兩個變量可以象這樣一起賦值：x, y = y, y+1。這里x被賦以值y（這意味著，y的值此前已經指定）而且y被遞增了1。

7. 深入函數

上面的練習怎么做？難嗎？還不太清楚函數？別擔心－－我還沒完成我的話題呢。

我們構建函數時使用的萃取方法稱為過程抽象，許多編程語言把關鍵字過程同函數一樣使用。事實上，這兩個概念是不一樣的，但是在python中它們都被稱為函數（因為它們或多或少以同樣的方式定義和使用）。

函數和過程（在其它語言中）的區別在哪里呢？嗯－－就像你在前面的段落里看到的那樣，函數可以返回一個值。區別就是過程并不返回這樣的值。許多時候，用這種方法把函數劃分為兩種類型－－返回值的和不返回值的－－是很有用的。

不返回值的函數（過程）可以用作子程序或例行程序。我們調用這些函數，它們制造某些原料，就象泡沫鮮奶之類的。我們可以在很多地方使用這個函數而不需要重寫它的代碼（這被稱為代碼再利用－－以后你還會知道，它意義不僅僅在這里）。

這樣的函數（或過程）的另一個有用性體現在－－它改變了環境（例如，把糖和奶油混在一起攪拌，它們的整個外部狀態就變化了）讓我們看個例子：

def hello(who):
 print "Hello, ", who

hello("world")
# Prints out "Hello, world"

打印出內容是它一方面的作用，因為這是這個函數唯一需要做的事，它其實是一個典型的所謂過程。但是……它事實上沒有改變它的運行環境，是不是？它怎樣才能改變呢？讓我們試一下：

# The *wrong* way of doing it
age = 0

def setAge(a):
 age = a

setAge(100)
print age
# Prints "0"

錯在哪兒？錯在函數setAge創建了它自己的也被命名為age的局部變量，它只在setAge函數內部可用。那如何才可以避免出現這個問題呢？我們可以使用全局變量。

注意：全局變量在python中不常用。它們容易引起不好的代碼組織結構，被稱為意大利面代碼。我這里使用它們是為了引出更復雜一點的技術問題－－如果你可以請盡量避免使用它們。

[color=#FF0000]未譯完。。[/color]

rockety 回復于：2005-06-06 09:27:59

[color=red]譯完了的，只是不小心，沒在我的blog上貼全，而且也沒有給出縮進。:oops: 今天一并更正了。感謝wolfg轉貼，并給出了正確的縮進。以下是其余部分：[/color]

通過告訴解釋器一個變量是全局的（用象global age這樣的表達式做），我們事實上
告訴了它在函數之外使用這個變量，而不是重新創建一個新的局部變量。（所以，和局部
相反它是全局的。）因此上面的程序可以象這樣重寫：

# The correct, but not-so-good way of doing it
age=0

def setAge(a):
 global age

setAge(100)
print age

# Prints "100"

了解對象（隨后談到）后，你會發現更好的解決這個問題的辦法是使用一個有age屬
性和setAge方法的對象。在數據結構那段，你也將會發現一些函數改變它的環境的更好的
例子。
好了－－那么真正的函數是什么樣？什么是函數呢，事實上？數學函數象一種“機
器”，獲得輸入然后計算結果。它會每次返回同樣的結果，如果每次提供它同樣的輸入。
例如：

def square(x):
return x*x

這和數學上的函數f(x)=x*x 一樣。它的行為象一個精確的函數，僅僅依賴于它的輸
入，在任何情況下都不改變它的環境。

所以－－我這里描繪了兩種構造函數的方法：一種類型更象是過程，不返回任何結
果；另一種更象是數學上的函數，（幾乎）什么也不做就是為了返回一個結果。當然，在
這兩種極端事物之間做某些事情是可能的，盡管當函數改變事物的時候，它應該清楚它改
變了。你可以通過標記它們的名字區分它們，例如為“純粹”的函數使用象square這樣的
名詞而對類似過程那樣的函數使用象setAge這樣命令式的名字。

9. 更多類型－數據結構

現在－－你已經知道了不少：怎樣輸入輸出，怎樣設計復雜的運算法則（程序）來執
行數學運算，但是好戲還在后頭呢。

截止目前我們都在程序中使用了哪些成份呢？數字和字符串，對不對？沒意思的種
類……現在讓我們引入兩三個其它的成份來讓事情變得更有意思些。

數據結構是種組織數據的成份。（驚奇，吃驚……）單個的數據沒有什么真正的數據
結構，是不是？但是假設我們需要很多數放在一起做為一個成份－－那就需要某種結構。
例如，我們可能想要一個數據列表。那很容易：

[3, 6, 78, 93]

在循環那段我提到了列表，但沒真正描述它。好－－這里說的就是你如何創建它。只
需要列出元素，用逗號分開，再加上方括號就行了。

來看一個計算素數（只能被1和它本身整除的數）的例子：

# Calculate all the primes below 1000
# (Not the best way to do it, but...)

result = [1]
candidates = range(3, 1000)
base = 2
product = base

while candidates:
 while product < 1000:
 if product in candidates:
 candidates.remove(product)
 product = product+base
 result.append(base)
 base = candidates[0]
 product = base
 del candidates[0]
 result.append(base)
 print result

這個例子中的新東西……

內建函數range事實上返回一個列表，可以象所有其它列表那樣使用。（它包括第
一個數，但是不包括最后一個數。）

列表可以當作邏輯變量使用。如果它非空，則為true，否則為false。因此，while
candidates意思是“while名稱為candidates的列表非空時”或者簡單的說“while存
在candidates時”。

你可以用if someElement in somelist來檢查一個元素是否在列表中。

你可以用someList.remove(someElement)來刪除someList中的someElement。

你可以用someList.append(something)為一個列表添加元素。事實上，你也可以使
用“＋”（象someList = someList+[something])。但是效率不是太高。

你可以通過在列表名之后加上用括號括起來的表示某元素位置的數字（很奇怪，列
表的第1個元素，位置是0）來獲得列表的某個元素。因此someList[3]是someList
列表的第四個元素（依次類推）。

你可以使用關鍵字del刪除變量。它也可以用來刪除列表中的元素（就象這里）。
因此del someList[0]刪除someList 列表中的第一個元素。如果刪除前列表是[1, 2,
3]，刪除后就變成了[2, 3]。

在繼續敘述索引列表中的元素之前，我簡單解釋一下上面的例子。

這是古老算術的一個版本，稱為“The Sieve of Erastothenes”（類似這樣）。它考量一
系列給定數字（在本例中是一個列表），然后有組織的刪除已知不是素數的數字。如何知
道？只要看看它們是不是可以被分解為其它兩個數就可以了。

我們從一個包含數字[2...999]的候選列表開始－－我們知道1是素數（事實上，它可能
是也可能不是，看你問誰了），我們想得到小于1000的所有素數。（事實上，我們的候
選列表是[3...999]，但是2也是候選數字，因為它是我們的第一個base）。我們還有個叫result的列表，它任何時間都包含著最新的結果。最初的時候，它只包含1。我們還有個叫base的變量。每次循環，我們刪除是它的倍數的數字（它總是候選列表中最小的數）。每次循環之后，我們知道剩下的最小的數是素數（因為所有可以分解的數我們都刪除了）。

因此，我們把它加入result，并把它設為新的base，然后從列表里移除它（這樣就不會對
它重復計算了）。當候選列表為空時，result列表將包含所有的素數。精巧吧，哈!
思考一下：第一次循環有什么特別嗎？那時base 是2，但它一樣經過了篩選。為什
么？為什么這不發生在其它的base值身上？我們打算移除product時能否確定它在候選列
表中呢？為什么？

接下來是什么呢？哦，是的……索引。還有切片。它們是從python列表中獲得單個
元素的方法。你已經見到了普通的索引行為。它相當簡單。事實上，我已經告訴了你所有
你需要知道的關于它的東西，除了一件事：負數索引從列表的末尾向前計算。所以，
someList[-1]是someList的最后一個元素，someList[-2]是它之前的一個元素，依次類
推。

切片，仍然，對你來說是陌生的。它和索引相似，除了切片可以獲得列表中的所有的
元素，而不僅僅是單個的元素。這如何做呢？象這樣：

food = [“spam”, “spam”, “eggs”, “sausages”, “spam”]
print food[2:4]

# Prints “['eggs', 'sausages']”

10. 繼續抽象－對象和面向對象編程

現在有個比較熱門的詞叫做“面向對象編程”。

就象本段標題暗示的那樣，面向對象編程僅僅是另外一種抽象細節的方式。程序通過
命名將簡單的描述抽象為復雜的操作。在面向對象編程時，我們不僅可以這樣對待程序，
還可以把它們做為對象。（現在，這肯定會讓你吃驚，哈！）例如，如果編寫燒火腿程
序，我們不用編寫很多過程來處理溫度、時間、成份等等，我們可以把它們結合為一個火
腿對象。或者，也許我們可以再有爐子對象和時鐘對象……那么，象溫度這類事物就變成
了火腿對象的一個屬性，而時間可以從時鐘對象讀取。要使用我們的程序做某些事，我們
可以教給我們的對象某些方法；比如，爐子應當知道如何烹制火腿等。

那么－－在python中我們如何做呢？我們不能直接制造一個對象。不能直接制造一個
爐子，而是做一個菜譜來描述爐子應該是什么樣。這份菜譜因此就描述了一個被我們稱為
爐子的一類對象。一個非常簡單的爐子類可能是這樣：

class Oven:

 def insertSpam(self, spam):
 self.spam = spam

 def getSpam(self):
 return self.spam

這看起來很難理解，還是怎樣呢？

這個例子中的新東西……

對象的類用關鍵字class定義。

類的名稱通常以大寫字母開始，而函數和變量（還有屬性和方法）的名稱以小寫字
母開始。

方法（也就是讓對象知道如何去做的函數和操作）的定義沒有特別，但是要在類的
定義里面。

所有對象的方法應當有的第一個參數叫做self（或者類似的……）原因很快就清楚
了。

對象的屬性和方法可以這樣來訪問：mySpam.temperature = 2 或者dilbert.be_nice
()。

我能猜到上面例子中的某些東西你仍然不清楚。例如，什么是self？還有，現在我們
有了對象菜譜（也就是類），我們怎樣事實上構造一個對象呢？

我們先顛倒一下順序。對象通過象引用函數那樣引用類名來創建：

myOven = Oven()

myOven包含了一個Oven對象，通常叫做Oven類的一個實例。假設我們也構造好了
一個Spam類，那么我們可象這樣做：

mySpam = Spam()
myOven.insertSpam(mySpam)

myOven.spam現在將包含mySpam。怎么回事？因為，我們調用一個對象的某個方法
時，第一個參數，通常稱為self，總是包含對象本身。（巧妙，哈！）這樣，self.spam =spam這一行設置當前Oven對象的spam屬性的值為參數spam。注意它們是兩個不同的事物，盡管在這個例子中它們都被稱為spam。

11. 練習3答案

這是這個運算法則的一個非常簡潔的版本：

def euclid(a, b):
 while b:
 a, b = b, a%b
 return a

12. 參考
［1］假日火腿沙拉菜譜摘自獺ormel Foods壞繾影娌似住?
Copyright ?nbsp;Magnus Lie Hetland 肯定來過［譯］

聲明：本網頁內容旨在傳播知識，若有侵權等問題請及時與本網聯系，我們將在第一時間刪除處理。TEL:177 7030 7066 E-MAIL:11247931@qq.com