Python中什麼是set dict的作用是建立一組 key 和一組 value 的對映關係，dict的key是不能重複的。 有的時候，我們只想要 dict 的 key，不關心 key 對應的 value，目的就是保證這個集合的元素不會重複，這時，set就派上用場了。 set 持有一系列元素，這一點和 list 很像，但是set的元素沒有重複，而且是無序的，這點和 dict 的 key很像。 建立 set 的方式是呼叫 set() 並傳入一個 list，list的元素將作為set的元素： >>> s = set(['A', 'B', 'C']) 可以檢視 set 的內容： >>> print s
set(['A', 'C', 'B']) 注意：上述列印的形式類似 list， 但它不是 list，仔細看還可以發現，列印的順序和原始 list 的順序有可能是不同的，因為set內部儲存的元素也是無序的。 當傳入相同的元素時，set會自動去除掉重複的元素 Python之 訪問set 由於set儲存的是無序集合，所以我們沒法通過索引來訪問。 訪問 set中的某個元素實際上就是判斷一個元素是否在set中。 例如，儲存了班裡同學名字的set： >>> s = set(['Adam', 'Lisa', 'Bart', 'Paul']) 我們可以用 in 操作符判斷： Bart是該班的同學嗎？ >>> 'Bart' in s
True Bill是該班的同學嗎？ >>> 'Bill' in s
False bart是該班的同學嗎？ >>> 'bart' in s
False 注意：元素區分大小寫，大小寫不同會被認為是不同的元素 Python之 set的特點 ①set的內部結構和dict很像，唯一區別是不儲存value，因此，判斷一個元素是否在set中速度很快。 ②set儲存的元素和dict的key類似，必須是不變物件，因此，任何可變物件是不能放入set中的。 ③set儲存的元素也是沒有順序的。 Python之 遍歷set 由於 set 也是一個集合，所以，遍歷 set 和遍歷 list 類似，都可以通過 for 迴圈實現。 直接使用 for 迴圈可以遍歷 set 的元素： >>> s = set(['Adam', 'Lisa', 'Bart'])
>>> for name in s:
...     print name
...
Lisa
Adam
Bart 注意: 觀察 for 迴圈在遍歷set時，元素的順序和list的順序很可能是不同的，而且不同的機器上執行的結果也可能不同。 Python之 更新set 由於set儲存的是一組不重複的無序元素，因此，更新set主要做兩件事： 一是把新的元素新增到set中，二是把已有元素從set中刪除。 新增元素時，用set的add()方法： >>> s = set([1, 2, 3])
>>> s.add(4)
>>> print s
set([1, 2, 3, 4]) 如果新增的元素已經存在於set中，add()不會報錯，但是不會加進去了： >>> s = set([1, 2, 3])
>>> s.add(3)
>>> print s
set([1, 2, 3]) 刪除set中的元素時，用set的remove()方法： >>> s = set([1, 2, 3, 4])
>>> s.remove(4)
>>> print s
set([1, 2, 3]) 注意：如果刪除的元素不存在set中，remove()會報錯： 用add()可以直接新增，而remove()前需要判斷。 Python之呼叫函式 Python內建了很多有用的函式，我們可以直接呼叫。 要呼叫一個函式，需要知道函式的名稱和引數，比如求絕對值的函式 abs，它接收一個引數。 可以直接從Python的官方網站檢視文件：
http://docs.python.org/2/library/functions.html#abs 也可以在互動式命令列通過 help(abs) 檢視abs函式的幫助資訊。 呼叫 abs 函式： >>> abs(100)
100
>>> abs(-20)
20
>>> abs(12.34)
12.34 呼叫函式的時候，如果傳入的引數數量不對，會報TypeError的錯誤，並且Python會明確地告訴你：abs()有且僅有1個引數，但給出了兩個： >>> abs(1, 2)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: abs() takes exactly one argument (2 given) 如果傳入的引數數量是對的，但引數型別不能被函式所接受，也會報TypeError的錯誤，並且給出錯誤資訊：str是錯誤的引數型別： >>> abs('a')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: bad operand type for abs(): 'str' 而比較函式 cmp(x, y) 就需要兩個引數，如果 x<y，返回 -1，如果 x==y，返回 0，如果 x>y，返回 1： >>> cmp(1, 2)
-1
>>> cmp(2, 1)
1
>>> cmp(3, 3)
0 Python內建的常用函式還包括資料型別轉換函式，比如   int()函式可以把其他資料型別轉換為整數： >>> int('123')
123
>>> int(12.34)
12 str()函式把其他型別轉換成 str： >>> str(123)
'123'
>>> str(1.23)
'1.23' Python之編寫函式 在Python中，定義一個函式要使用 def 語句，依次寫出函式名、括號、括號中的引數和冒號:，然後，在縮排塊中編寫函式體，函式的返回值用 return 語句返回。 我們以自定義一個求絕對值的 my_abs 函式為例： def my_abs(x):
    if x >= 0:
        return x
    else:
        return -x 注意：函式體內部的語句在執行時，一旦執行到return時，函式就執行完畢，並將結果返回。因此，函式內部通過條件判斷和迴圈可以實現非常複雜的邏輯。 如果沒有return語句，函式執行完畢後也會返回結果，只是結果為 None。 return None可以簡寫為return。 Python函式之返回多值 # math包提供了sin()和 cos()函式，我們先用import引用它： import math
def move(x, y, step, angle):
    nx = x + step * math.cos(angle)
    ny = y - step * math.sin(angle)
    return nx, ny 這樣我們就可以同時獲得返回值： >>> x, y = move(100, 100, 60, math.pi / 6)
>>> print x, y
151.961524227 70.0 但其實這只是一種假象，Python函式返回的仍然是單一值： >>> r = move(100, 100, 60, math.pi / 6)
>>> print r
(151.96152422706632, 70.0) 用print列印返回結果，原來返回值是一個tuple！ 但是，在語法上，返回一個tuple可以省略括號，而多個變數可以同時接收一個tuple，按位置賦給對應的值，所以，Python的函式返回多值其實就是返回一個tuple，但寫起來更方便。 Python之遞迴函式 在函式內部，可以呼叫其他函式。如果一個函式在內部呼叫自身本身，這個函式就是遞迴函式。 舉個例子，我們來計算階乘 n! = 1 * 2 * 3 * ... * n，用函式 fact(n)表示，可以看出： fact(n) = n! = 1 * 2 * 3 * ... * (n-1) * n = (n-1)! * n = fact(n-1) * n 所以，fact(n)可以表示為 n * fact(n-1)，只有n=1時需要特殊處理。 於是，fact(n)用遞迴的方式寫出來就是： def fact(n):
    if n==1:
        return 1
    return n * fact(n - 1) 上面就是一個遞迴函式。可以試試： 遞迴函式的優點是定義簡單，邏輯清晰。理論上，所有的遞迴函式都可以寫成迴圈的方式，但迴圈的邏輯不如遞迴清晰。 使用遞迴函式需要注意防止棧溢位。在計算機中，函式呼叫是通過棧（stack）這種資料結構實現的，每當進入一個函式呼叫，棧就會加一層棧幀，每當函式返回，棧就會減一層棧幀。由於棧的大小不是無限的，所以，遞迴呼叫的次數過多，會導致棧溢位。可以試試計算 fact(10000)。 Python之定義預設引數 定義函式的時候，還可以有預設引數。 例如Python自帶的 int() 函式，其實就有兩個引數，我們既可以傳一個引數，又可以傳兩個引數： >>> int('123')
123
>>> int('123', 8)
83 int()函式的第二個引數是轉換進位制，如果不傳，預設是十進位制 (base=10)，如果傳了，就用傳入的引數。 可見，函式的預設引數的作用是簡化呼叫，你只需要把必須的引數傳進去。但是在需要的時候，又可以傳入額外的引數來覆蓋預設引數值。 我們來定義一個計算 x 的N次方的函式: def power(x, n):
    s = 1
    while n > 0:
        n = n - 1
        s = s * x
    return s 假設計算平方的次數最多，我們就可以把 n 的預設值設定為 2： def power(x, n=2):
    s = 1
    while n > 0:
        n = n - 1
        s = s * x
    return s 這樣一來，計算平方就不需要傳入兩個引數了： >>> power(5)
25 由於函式的引數按從左到右的順序匹配，所以預設引數只能定義在必需引數的後面。 Python之定義可變引數 如果想讓一個函式能接受任意個引數，我們就可以定義一個可變引數： def fn(*args):
    print args 可變引數的名字前面有個 * 號，我們可以傳入0個、1個或多個引數給可變引數： >>> fn()
()
>>> fn('a')
('a',)
>>> fn('a', 'b')
('a', 'b')
>>> fn('a', 'b', 'c')
('a', 'b', 'c') 可變引數也不是很神祕，Python直譯器會把傳入的一組引數組裝成一個tuple傳遞給可變引數，因此，在函式內部，直接把變數 args 看成一個 tuple 就好了。 定義可變引數的目的也是為了簡化呼叫 對list進行切片 ，取前3個元素，用一行程式碼就可以完成切片： >>> L[0:3]
['Adam', 'Lisa', 'Bart'] L[0:3]表示，從索引0開始取，直到索引3為止，但不包括索引3。即索引0，1，2，正好是3個元素。 如果第一個索引是0，還可以省略： >>> L[:3]
['Adam', 'Lisa', 'Bart'] 也可以從索引1開始，取出2個元素出來： >>> L[1:3]
['Lisa', 'Bart'] 只用一個 : ，表示從頭到尾： >>> L[:]
['Adam', 'Lisa', 'Bart', 'Paul'] 因此，L[:]實際上覆製出了一個新list。 切片操作還可以指定第三個引數： >>> L[::2]
['Adam', 'Bart'] 第三個引數表示每N個取一個，上面的 L[::2] 會每兩個元素取出一個來，也就是隔一個取一個。 把list換成tuple，切片操作完全相同，只是切片的結果也變成了tuple。 倒序切片 對於list，既然Python支援L[-1]取倒數第一個元素，那麼它同樣支援倒數切片 >>> L = ['Adam', 'Lisa', 'Bart', 'Paul']
>>> L[-2:]
['Bart', 'Paul']
>>> L[:-2]
['Adam', 'Lisa']
>>> L[-3:-1]
['Lisa', 'Bart']
>>> L[-4:-1:2]
['Adam', 'Bart'] 注意：記住倒數第一個元素的索引是-1。倒序切片包含起始索引，不包含結束索引。 對字串切片 字串 'xxx'和 Unicode字串 u'xxx'也可以看成是一種list，每個元素就是一個字元，操作結果仍然是字串 什麼是迭代 在Python中，迭代是通過 for ... in 來完成的 Python 的 for迴圈不僅可以用在list或tuple上，還可以作用在其他任何可迭代物件上。 因此，迭代操作就是對於一個集合，無論該集合是有序還是無序，我們用 for 迴圈總是可以依次取出集合的每一個元素。 注意: 集合是指包含一組元素的資料結構，我們已經介紹的包括：
1. 有序集合：list，tuple，str和unicode；
2. 無序集合：set
3. 無序集合並且具有 key-value 對：dict 而迭代是一個動詞，它指的是一種操作，在Python中，就是 for 迴圈。 迭代與按下標訪問陣列最大的不同是，後者是一種具體的迭代實現方式，而前者只關心迭代結果，根本不關心迭代內部是如何實現的。 索引迭代 Python中，迭代永遠是取出元素本身，而非元素的索引。 對於有序集合，元素確實是有索引的。有的時候，我們確實想在 for 迴圈中拿到索引，怎麼辦？ 方法是使用 enumerate() 函式： >>> L = ['Adam', 'Lisa', 'Bart', 'Paul']
>>> for index, name in enumerate(L):
...     print index, '-', name
...
0 - Adam
1 - Lisa
2 - Bart
3 - Paul 使用 enumerate() 函式，我們可以在for迴圈中同時繫結索引index和元素name。但是，這不是 enumerate() 的特殊語法。實際上，enumerate() 函式把： ['Adam', 'Lisa', 'Bart', 'Paul'] 變成了類似： [(0, 'Adam'), (1, 'Lisa'), (2, 'Bart'), (3, 'Paul')] 因此，迭代的每一個元素實際上是一個tuple： for t in enumerate(L):
    index = t[0]
    name = t[1]
    print index, '-', name 如果我們知道每個tuple元素都包含兩個元素，for迴圈又可以進一步簡寫為： for index, name in enumerate(L):
    print index, '-', name 這樣不但程式碼更簡單，而且還少了兩條賦值語句。 可見，索引迭代也不是真的按索引訪問，而是由 enumerate() 函式自動把每個元素變成 (index, element) 這樣的tuple，再迭代，就同時獲得了索引和元素本身。 迭代dict的value dict 物件有一個 values() 方法，這個方法把dict轉換成一個包含所有value的list，這樣，我們迭代的就是 dict的每一個 value： d = { 'Adam': 95, 'Lisa': 85, 'Bart': 59 }
print d.values()
# [85, 95, 59]
for v in d.values():
    print v
# 85
# 95
# 59 如果仔細閱讀Python的文件，還可以發現，dict除了values()方法外，還有一個 itervalues() 方法，用 itervalues() 方法替代 values() 方法，迭代效果完全一樣： d = { 'Adam': 95, 'Lisa': 85, 'Bart': 59 }
print d.itervalues()
# <dictionary-valueiterator object at 0x106adbb50>
for v in d.itervalues():
    print v
# 85
# 95
# 59 那這兩個方法有何不同之處呢？ 1. values() 方法實際上把一個 dict 轉換成了包含 value 的list。 2. 但是 itervalues() 方法不會轉換，它會在迭代過程中依次從 dict 中取出 value，所以 itervalues() 方法比 values() 方法節省了生成 list 所需的記憶體。 3. 列印 itervalues() 發現它返回一個 <dictionary-valueiterator> 物件，這說明在Python中，for 迴圈可作用的迭代物件遠不止 list，tuple，str，unicode，dict等，任何可迭代物件都可以作用於for迴圈，而內部如何迭代我們通常並不用關心。 如果一個物件說自己可迭代，那我們就直接用 for 迴圈去迭代它，可見，迭代是一種抽象的資料操作，它不對迭代物件內部的資料有任何要求。 迭代dict的key和value dict 物件的 items() 方法返回的值： >>> d = { 'Adam': 95, 'Lisa': 85, 'Bart': 59 }
>>> print d.items()
[('Lisa', 85), ('Adam', 95), ('Bart', 59)] 可以看到，items() 方法把dict物件轉換成了包含tuple的list，我們對這個list進行迭代，可以同時獲得key和value： >>> for key, value in d.items():
...     print key, ':', value
...
Lisa : 85
Adam : 95
Bart : 59 和 values() 有一個 itervalues() 類似， items() 也有一個對應的 iteritems()，iteritems() 不把dict轉換成list，而是在迭代過程中不斷給出 tuple，所以， iteritems() 不佔用額外的記憶體。 生成列表 要生成list [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]，我們可以用range(1, 11)： >>> range(1, 11)
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10] 但如果要生成[1x1, 2x2, 3x3, ..., 10x10]怎麼做？方法一是迴圈： >>> L = []
>>> for x in range(1, 11):
...    L.append(x * x)
...
>>> L
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100] 但是迴圈太繁瑣，而列表生成式則可以用一行語句代替迴圈生成上面的list： >>> [x * x for x in range(1, 11)]
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100] 這種寫法就是Python特有的列表生成式。利用列表生成式，可以以非常簡潔的程式碼生成 list。 寫列表生成式時，把要生成的元素 x * x 放到前面，後面跟 for 迴圈，就可以把list創建出來。 複雜表示式 使用for迴圈的迭代不僅可以迭代普通的list，還可以迭代dict。 假設有如下的dict： d = { 'Adam': 95, 'Lisa': 85, 'Bart': 59 } 完全可以通過一個複雜的列表生成式把它變成一個 HTML 表格： tds = ['<tr><td>%s</td><td>%s</td></tr>' % (name, score) for name, score in d.iteritems()]
print '<table>'
print '<tr><th>Name</th><th>Score</th><tr>'
print '\n'.join(tds)
print '</table>' 注：字串可以通過 % 進行格式化，用指定的引數替代 %s。字串的join()方法可以把一個 list 拼接成一個字串。 把打印出來的結果儲存為一個html檔案，就可以在瀏覽器中看到效果了： <table border="1">
<tr><th>Name</th><th>Score</th><tr>
<tr><td>Lisa</td><td>85</td></tr>
<tr><td>Adam</td><td>95</td></tr>
<tr><td>Bart</td><td>59</td></tr>
</table> 條件過濾 列表生成式的 for 迴圈後面還可以加上 if 判斷。例如： >>> [x * x for x in range(1, 11)]
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100] 如果我們只想要偶數的平方，不改動 range()的情況下，可以加上 if 來篩選： >>> [x * x for x in range(1, 11) if x % 2 == 0]
[4, 16, 36, 64, 100] 有了 if 條件，只有 if 判斷為 True 的時候，才把迴圈的當前元素新增到列表中。 多層表示式 for迴圈可以巢狀，因此，在列表生成式中，也可以用多層 for 迴圈來生成列表。 對於字串 'ABC' 和 '123'，可以使用兩層迴圈，生成全排列： >>> [m + n for m in 'ABC' for n in '123']
['A1', 'A2', 'A3', 'B1', 'B2', 'B3', 'C1', 'C2', 'C3'] 翻譯成迴圈程式碼就像下面這樣： L = []
for m in 'ABC':
    for n in '123':
        L.append(m + n)