原文地址：http://hetland.org/writing/instant-hacking.html
http://www.jb51.net/article/6820.htm
譯者： 肯定來過
這是一篇簡短的關於python程序設計語言的入門教程，原文在這裏，翻着詞典翻譯了來！
這是一份對編程藝術的簡短介紹，其中的例子是用python寫成的。(如果你已經知道了該如何編程，但是想簡單瞭解一下python，你可以查閱我的另一篇文章Instant Python。）這篇文章已經被翻譯爲意大利、波蘭、日本、塞爾維亞以及巴西葡萄亞語等許多種語言，而且正在被翻譯爲韓語。（譯者：當然，現在已經包括了中文版本，只是作者並不知道。）
這篇文章和如何闖入別人的計算機系統之類的東西無關。我不關注那類事情，所以請不要email問我那些東西。
注意：要使此文中的例子正確運行，你應該把它們寫在一個文本文件中，然後用解釋器運行；不要試圖直接在交互方式下運行它們－－不是所有的都可以這樣運行。（不要問我和此有關的具體細節。最好查閱python文檔或者email給[email protected]）。
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!"print "Hello, world!"
print "Goodbye, 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.14radius = input("What is the radius?")
print radius * radius * 3.14input
什麼也不會做……你必須在它的後面放上一對括號。所以input()可以工作－－它會簡單的要求用戶輸入半徑的長度。而上面的那個版本對用戶來說也許更友好一些，因爲它首先打印出了一個問題。當我們將諸如提問字符串“What is the radius?”之類的東西放在函數調用的括號中時，這個過程被稱爲函數的參數傳遞。括號中的內容被稱爲參數。在上個例子中我們傳遞了一個提問作爲參數以便input知道在獲得答案前應該先打印什麼。
但是獲得的答案如何到達radius變量呢？函數input，調用時，會返回一個值（象許多其它函數一樣）。你不一定非要使用這個值，但象我們這種情況，我們要使用它。這樣，下面這兩個表達式有着很大的差別：
foo = input
bar = input()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."注意：縮進在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 ", area1. 只使用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...6. 循環
順序執行和條件執行僅僅是程序設計三個基本語句塊架構方式中的兩個。第三個則是循環執行。在上個段落中我假設了一種情況，檢查火腿是否燒好，但很明顯它並不適用。如果下次檢查時火腿仍然沒燒好該怎麼辦？我們怎麼知道需要檢查多少次？事實上，我們不知道。而且我們也沒必要知道。我們可以要求計算機持續檢查直到燒好了爲止。怎麼表達這個？你猜到了－－我們使用循環，或者說是重複執行。
python有兩種循環類型：while循環和for循環。for循環大概是最簡單的。舉個例子：
for food in "spam", "eggs", "tomatoes":
print "I love", foodfor 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!"循環體爲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 ", floordef floor(number):
result = 0
while result <= number:
result = result + 1
result = result - 1
return result1. 函數用關鍵字def定義，函數名緊隨其後並且要用括號把需要的參數括起來。
2. 如果要求函數返回一個值，要使用關鍵字return來處理（它同時也自動結束函數定義）。
定義了函數之後，我們可以象這樣使用它：
x = 2.7
y = floor(2.7)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"注意：全局變量在python中不常用。它們容易引起不好的代碼組織結構，被稱爲意大利麪代碼。我這裏使用它們是爲了引出更復雜一點的技術問題－－如果你可以請儘量避免使用它們。
通過告訴解釋器一個變量是全局的（用象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"性和setAge方法的對象。在數據結構那段，你也將會發現一些函數改變它的環境的更好的
例子。
好了－－那麼真正的函數是什麼樣？什麼是函數呢，事實上？數學函數象一種“機
器”，獲得輸入然後計算結果。它會每次返回同樣的結果，如果每次提供它同樣的輸入。
例如：
def square(x):
return 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()一個Spam類，那麼我們可象這樣做：
mySpam = Spam()
myOven.insertSpam(mySpam)時，第一個參數，通常稱爲self，總是包含對象本身。（巧妙，哈！）這樣，self.spam =spam這一行設置當前Oven對象的spam屬性的值爲參數spam。注意它們是兩個不同的事物，儘管在這個例子中它們都被稱爲spam。
11. 練習3答案
這是這個運算法則的一個非常簡潔的版本：
def euclid(a, b):
while b:
a, b = b, a%b
return a