爲非程序員準備的簡潔Python語言教材

感謝匿名人士的投遞
爲非程序員準備的簡潔Python語言教材，歡迎提問。
Python 的中文意思是巨蟒，大蟒蛇。

計算機編程主要概念¶

計算機語言編程的主要內容就這些：數字，文字，循環，公式，變量

• 數 字: 1, 2, 3, 5.6, 120, 32.4, 3.1415926, -3, -0.123

• 文字: 你好，我好，你太牛了，很黃很暴力，這類的文字。一般用雙引號(")或者單引號(')括起來。術語叫字符串 ，就是一堆字符，串起來。

• 循環: 循環(loop)就是重複的做一件事。計算機是一個很笨的機器，基本上只會做加，減，乘，除，大於，小於，等於和循環這種簡單的工作。編程就是把複雜的問 題，拆成簡單的單元讓它重複。

幸虧有下面講到的公式，所以很多較複雜的問題已經有了解決方法，我們只是重 復的套用別人的解決公式就可以了，不用拆得太細。

Python 語言最大的優勢，就是這個語言中包含了大量解決常見問題的公式，你想幹的事，基本上都有人幫你幹了，你只是需要把他們組織，捆綁起來就可以了。比如下載文 件的公式，分析網頁內容的公式，壓縮文件的公式，處理電子郵件的公式等等。

• 公式: 就像數學公式 (a+b)²= a² + 2ab + b² 這種。算的時候帶入具體數值，比如：(3+4)² = 3² + 2*3*4 + 4² = 9+24+16 = 49 。前面的 (a+b)² 就是我們的公式名（當然編程時，我們會用一些比較容易明白的詞組做爲公式名，比如“和的平方”這種，英語或者拼音都可以），他需要兩個參數a，b；後面的 a² + 2ab + b² 是具體怎麼算出來的步驟，這就是我們的公式內容。

在 計算機裏，公式的術語叫“函數”或者“方法”。我們定義一個函數，就是定義一條公式，用的時候，拿來參數a,b什麼 的，套一下公式就行了。

爲了程序的結構清晰，我們往往會定義很多函數。把複雜的問題分成很多小問題，每個小問題放到一個函數 裏，然後在解決複雜問題的函數裏，使用這些小問題函數解決大問題。更重要的是我們可以大量的使用別人寫好的函數來解決自己的問題。

 

函數的作用是讓程序結構清晰，而且可以在不同的地方重複套用。

• 變量: 就是上面的a，b這種可以代表任何值，可以放進不定值的單詞。我們用變量來存儲我們程序中用到的各種數字，文字，公式。所謂參數，就是定義公式時候用到的 變量，就叫參數，換個馬甲而已。

換成術語，我們有：

數字 (number)	=>	數字
字符串 (string)	=>	文字
循環 (loop)	=>	循環
函數／方法 (function/method)	=>	公式
變量 (variable)	=>	變量

到這裏，基本上編程就沒什麼可學得了。剩下的就是掌握各種編程語言特定的函數和循環的書寫格式，再掌握了別人已 經寫好的函數的用法，組合起來就得了。

基本編程¶

最基本的python程序：

print ("世界，你好！")

存 到文件 hello.py 裏，然後命令行下輸入 python hello.py 就可以看到結果了。

這裏就用到了 函數和字符串，在屏幕上輸出一行：世界，你好！

Python 裏函數的用法是：函數名(參數1, 參數2)

這 裏 print 是函數；在屏幕上打印內容，"世界，你好！"是參數。

學會怎麼用函數了，再學會定義函數的格式，就差不多了。

定義函數¶

def a_b_pingfang(a, b):
    c = a**2 + 2*a*b + b**2
    return c

我 們定義一個(a+b)²的函數，def 是英語 define 的縮寫，意思是定義函數，定義公式。

第 1 行就是說我們要定義一個函數名叫 a_b_pingfang 的函數，用它的時候，需要兩個參 數a 和 b。尾巴上有個冒號，冒號的意思是說：“下面的一段就是公式定義了，要注意了”。

計算機編程裏，* 代表乘法，/代表除法，** 代表乘方， b**2 就是 b 的二次方。

注意： Python 是用 縮進空格 來表示段落的，冒號(:)來表示段落開始。

第 2 行先縮進4個空格，說明下面縮進4格的，都是同一段落。用來具體計算上面的定義的公式的。把 a2+2*a*b+b2 的計算結果，放到c裏。

c類似於a，b，都是表示一個變量，它可以用來存放數字，文字，甚至函數。這裏它存放的是用a，b計算後得到的 結果。因爲不是在函數名裏，所以術語叫做“變量”，在函數名裏，就叫參數了。

“變量”就是用一個單詞來代表一個可以變化的量的。單詞裏可 以有字母，數字和下加線(_)，數字不能打頭。

第 3 行，把存在c裏的結果，傳回給函數的使用者。

return 命令的意思，就是立即結束函數的執行，把return後面的值傳給調用者，可以傳回多個值。

現在可以使用這個公式了，我們叫調 用函數 ：

ping2 = a_b_pingfang(2, 3)

ping2 裏存放了 a_b_pingfang(2, 3)得到的結果，也就是上面 return c 這句，把 c 的內容，傳給了外面的ping2。

把結果打印出來：

print(ping2)

全 部程序是：

def a_b_pingfang(a, b):
    c = a**2 + 2*a*b + b**2
    return c
ping2 = a_b_pingfang(2, 3)
print(ping2)

存 到 test2.py ，跑 python test2.py 就可以看到輸出 25。

循環 (loop)¶

當然還有循環，怎麼讓程序重複的做事？我們有 while(當...), for(對於...) 命令來進行循環控制。

a = 0
while a < 100:
   a = a + 1

這 個循環說，當 a < 100 的時候，把 a 增加 1，然後重複。當 a 等於100了，就結束了。

我們有 <, >, ==, <=, >=, != 來判斷大於，小於，等於，小於等於，大於等於，不等於。

還有 and, or, not 來進行邏輯運算，所謂邏輯運算，就是測試已有判斷之間的關係的：

a == 1 and b != 2 來測試這兩個判斷是否同時成立。 a == 1 or b != 2 來測試這兩個判斷裏是否有至少一個成立。 not a == 1 來測試這個判斷是否是錯的。錯的就是對的，對的就是錯的，顛倒黑白。

我們還有 break(中斷) 來打斷循環，和 continue(繼續) 來立刻回到循環開始，也可以用 if(是否) 命令來進行判斷：

a = 0
while True:
    a = a + 1
    if a >= 100:
        break

這 裏 True 表示總是正確，相對的是 False 表示錯誤。這一段是說一直執行，因爲 while 總是正確。下面在 if 處判斷a是否大於等於100，如果是，那麼執行 if 下的段落，這裏我們打斷了循環。

for 循環是利用下面介紹的的列表數據結構對列表進行循環。

Python 數據概念¶

下面具體到python特殊的規定，它有幾個特殊的存儲數據的格式。

• 列 表: list
• 元組: tuple
• 字典: dict (dictionary)

列表 (list)¶

列表：把很多變量存進一個列表裏，叫列的意思，就因爲他像列車一樣，一節一 節車廂，每廂放一個變量。格式爲 b, c, 1, 3, 5, '葡萄', '葡萄皮兒'，可以看到，方括號裏，可以放具體的數字，文字，也可以放變量，用逗號分隔。

這些內容是在固定位置上，可以通過他們的位置， 來提取：

alist = [1, 3, 5, '很傻', '葡萄', '葡萄皮兒', a, var1]
print (alist[0]) # 打印 "1"

在 python裏，數數是從0開始數的，開始是0，然後是1，2，3，4，5，所以上面的列表 alist的第一個內容，可以用alist[0]來 提取，第二個用alist[2]來提取。

print (alist[4]) # 打印 '葡萄'

這裏，我們可以介紹用 for 循環來訪問這個列表裏的所有內容：

for me in alist:
    print (me)

上 面這一段，打印所有alist裏的內容。

這個循環是，對於列表 alist ，從 0 開始，訪問它的每一個位置，把這個位置上的值， 放到me裏，然後針對不同的me值，重複執行下面段落的內容。

in 表示me在alist裏，也可以用來判斷：

  if "葡萄" in alist:
     print "葡萄在alist裏！"

這 個列表的內容是可以改變的，我們可以把第4個位置設爲"很天真":

alist[3] = alist[3] + ' 很天真'
print (alist[3]) # 打印 '很傻 很天真'

元組 (tuple)¶

元組：元組就是列表，但是他的內容是不能改變的。 他的內容只能一開始就設定。但是，元組和列表之間是可以用函數互相轉變的，轉成列表就可以改變內容，轉回元組就不能改了。

元組是用圓括號 來表示，所以叫元組嘛。

atuple = (2, 3, "老子")
alist = list(atuple) # 變成 [2, 3, "老子"]
alist[0] = 0
tuple2 = tuple(alist) # 變回 (0, 3, "老子")

在 python 裏，字符串也是一種特殊的元組，也就是內容不可變的字符列表。

txt = 'abcdefg'
print(txt[1]) # 'b'

字典 (dict)¶

字典：字典就像一般的字典，一個字，一個解釋，再一個字，再一個解釋。用大 括號表示：

adict = {1: "我是解釋",
  2: "我是解釋2", 
  "我是3": 3, 
  "我是4": 4}

前 面的字叫鑰匙(key)或者索引，後面的解釋，叫"值"。索引不能重複，必須是唯一的。

我們可以看到，前面的字，和後面的解釋可以是數 字，文字，還可以是函數或者元組。但是前面的字，不能是列表，因爲列表內容是可變的，可變的東西都不能做索引。

我們用索引來提取值，而不 是用位置：

adict[1] # "我是解釋"
adict["我是3"] # 3

模塊 (module)¶

Python 裏包涵了很多別人寫好的函數、方法讓我們直接利用。譬如寫網絡程序的函數，數 學計算的函數，分析電郵文件的函數，加密的函數。

這些函數 分門別類的放到叫“模塊”的東西里。一個模塊裏，包括很多功能相類的函數。而具體實現上，一個模塊，就是一個python的程序文件。

如 果模塊還還需要細分更多層，那麼每層就是一個文件目錄。裏面有很多做爲模塊的python文件。

要使用模塊，我們用“進口”這個命令: import

import time
now = time.clock()
print (now)

這 裏，我們先進口 time 模塊，然後使用 time 模塊裏的函數 clock() ，得到當前時間，打印出來。

用個句點表示模塊 time裏的clock函數: 模塊名.函數名

在 python 裏，我們會用到很多別人寫的模塊，能自己少寫點兒源碼，儘量少寫，懶不是？

類 (class)¶

其實編程來說，類並不是必須的，但是因爲很多python提供的模塊，裏面 的函數都是包在類裏面的，所以我們需要介紹一下類。

面向對象編程，是現在比較流行的編程模式，是個人都得用“面像對象”的思路來編程。基 本上就是把同類的函數，打包放到一個叫“類”的東西里。

這個“類”一般上是以具體的東西爲模子，譬如物種：人類，貓類；物品：傢俱類，電 器類。他裏面打包的函數，基本上是針對這個類進行操作的，譬如人說話，人喫飯，貓逮耗子，家居磨損。

使用類的時候，我們先具體化他，把類 變成個體。人類變成某人，貓類變成某貓，傢俱變 成某傢俱語法上比較怪，只好變成一件傢俱。這個具體化的類，就是所謂的“對象(object) ”。然後我們就可以使用這個具體人，貓，家居的函數，針對具體的人，物進行操作了。

定義類¶

class RenLei:
    def __init__(self, mingzi):  # self 是一個固定參數，代表這個對象自己。
        self.mingzi = mingzi     # 把名字存到對象自己的 mingzi 變量上。
    def shui2(self):
        return self.mingzi

在 類的定義裏，每一個函數，他的第一個參數，都是規定死的，必須是self。self代表這個對象自己。這個對像本身的變量，函數，都是通過這個自己來存取 的。

你可以管他叫wo3, you, me，用什麼名字隨便，但是第一位置的，就是代表對象自己。

    def __init__(wo3, mingzi):
       wo3.mingzi = mingzi

也 可以。

在調用類裏的函數時，不用提供 self 這個參數，程序自動加入 self。我們只要提供其他參數即可。

__init__() 這個函數是特殊函數，他代表建立函數的時候，需要的使用的參數。通過類建立函數的時候，程序會自動調用 __init__()函數。

具體化類，建立對象¶

# 建立對象，提供的函數對應__init__() 函數，self 參數程序自動提供，不用我們提供。
xiaozhang1 = RenLei("小張")  
mingzi = xiaozhang1.shui2()  # 使用“對象名.函數名()”的格式來調用類裏的函數。
print mingzi <-- "小張"

字符串的對象性質¶

Python 裏的字符串，列表，元組，字典，都是面對對象的類，所以他們本身帶有很多函數可以對自己進行操作，譬如：

a = "握手 不一定 就是 友誼".split()

split 是字符串的函數，他可以把字符串在給定位置分段，當我們不給他參數的時候，會在所有空白位置分割，然後返回一個列表，裏面是被割裂的字符串。

結 果，a 的內容是 ["握手", "不一定", "就是", "友誼"]，這是一個有4個元素的列表。

對於字符串，列 表，字典之類的操作，請熟讀說明手冊他們的說明，python編程，主要就靠字符串，列表和字典了。

Python 程序書編程習慣¶

寫一個 Python 程序，我們一般步驟是：

1. 進 口所有會用到到模塊 import
2. 定義我們自己的類和函數。每個函數裏要用到的函數，被調用的函數一般放在調用函數的前面定義。這樣 我們讀程序的時候，就知道調用的函數，在前面是怎麼定義的，有什麼功能，需要什麼參數，返回什麼值。
3. 在文件的最下面，調用上面定義的 函數和類，開始工作。
4. 儘量使用python提供的內建函數和模塊裏的函數，所以我們對Python的模塊說明手冊要很熟悉。

Python 運行，是從文件的上面往下走的，看到命令執行命令，一直到最後一行。當我們定義函數和類的時候，他們只是定義，而沒有執行，所以Python 看到他們，先存起來，直到看到定義外的具體命令，才真正的執行。如果這個命令調用上面的函數，那麼就把存起來的函數執行一下。

Python 裏註釋符號是"#"。就是說，在 # 符號後的那一行文字，都當做解釋，不做爲程序的命令。

print ("打醬油！") # print ("關我屁事")

只 打印出 “打醬油”，剩下的，因爲是在 # 後面，所以程序把他們當做註釋語言自動忽略了。

完整例子： 把一個兩列的文件input.txt，分割成兩個文件col1.txt, col2.txt，一個文件一列。 input.txt 內容:

a1 啊阿
ai1 挨埃哀
ao2 熬鰲翱獒

程 序內容：

def split_file(filename): # 把文件分成兩列
    col1 = [] # 存儲第一列
    col2 = []
    fd = open(filename) # open 函數用來打開文件，返回一個文件對象
    text = fd.read() # fd.read 讀入文件fd 的內容。
    lines = text.splitlines() # 把讀入的內容分行
    for line in lines: # 循環每一行
        part = line.split(None, 1) # 分割一行。
        col1.append(part[0]) # 把分割的第一部分放到col1後面。
        col2.append(part[1])

    return col1, col2 # 返回 col1, col2

def write_list(filename, alist): # 把文字列表內容寫入文件
    fd = open(filename, 'w') # 打開輸出文件col1.txt，'w'指定使用寫入模式。
    for line in alist:
         fd.write(line + '/n')

def main(): # 主函數，程序進入點，習慣性叫他 main()
    filename = 'input.txt'            # 把輸入文件名 input.txt 放進一個變量
    col1, col2 = split_file(filename) # 調用分割函數，結果存入 col1, col2
    write_list('col1.txt', col1)      # 調用寫入函數
    write_list('col2.txt', col2)

main() # 唯一的函數外命令，程序開始執行，調用上面的 main() 函數數。

這 裏，輸入的文件名是寫死的 input.txt ，我們可以使用模塊 optparse 來通過命令行讀取用戶提供的文件，會更靈活些。

參考資料¶

更多的功能，函數，請參考python的官方教學和手冊。

先熟悉:

• 內建函數
• 內建數據類 型 (字符串，數字，列表，字典，文件對象)
• sys 模塊
• re 模塊
• os 模塊
• optparse 模塊

熟悉這些，基本上編程沒問題了。

深入 Python是一本經典的參考書，雖然沒有涵蓋所有python模塊的內容，但是對初學者基本夠用。而且它 是一個自由文件，說俗了就是合法免費的，又有中文翻譯版，難得。

也可以參考 Python 絕對簡明手冊這個中文說明。

如果需要網絡編程，還要熟悉網絡相關的模塊。如果想 要圖形界面，建議使用pygtk或者pyqt圖形界面函數庫，這時候，也需要熟悉面對對象編程的概念。

對於英文不好的人，建議買一本有Python函數模塊介紹的中文書，作爲參考書，在編程的時候，邊編邊翻書。

Python 的中文意思是巨蟒，大蟒蛇。但是這個語言的具體出處是一個叫Monty Python的英 國電視劇。

查看:快速 Python 語言入門教學，課程，課件，教材，自學，概念