• 不允許一個鍵對應多個值

每個鍵只能對應一個項。也就是說，一個鍵對應多個值是不允許的（像列表，元組和其他字典這樣的容器對象是可以的）。當有鍵發生沖突（即字典鍵重復賦值），取最后（最近）的賦值。

• 鍵必須是可哈希的

大多是python對象可以作為鍵；但它們必須是可哈希的對象，像列表，字典這樣的可變類型，由于它們不是可哈希的，所以不能作為鍵。
所有不可變的類型都是可哈希的，因此它們都可以作為字典的鍵。一個要說明的問題是：值相等的數字表示相同的鍵。換句話說就是，整型數字1和浮點型1.0的哈希值是相同的，即它們是相同的鍵。

模擬登陸數據系統(userpw.py)

#!/usr/bin/env python

db  = {}

def newuser():
    prompt = 'login desired: '
    while True:
        name = raw_input(prompt)
        if db.has_key(name):
            prompt = ' name taken,try another: '
            continue
        else:
            break
    pwd = raw_input('passwd: ')
    db[name] = pwd

def olduser():
    name = raw_input('login: ')
    pwd = raw_input('passwd:')
    passwd = db.get(name)
    if pwd == passwd:
        print 'Welcome back', name
    else:
        print 'login incorrent'

def showmenu():
    prompt = """
(N)ew user login
(E)xisting user login
(Q)uit

Enter a choice: """

done = False
    while not done:

        chosen = False
        while not chosen:
            try:
                choice = raw_input(prompt).strip()[0].lower()
            except (EOFError,KeyboardInterrupt):
                choice = 'q'
            print '\n Your picked: ' % choice
            if choice not in 'neq':
                print 'invalid option,try again'
            else:
                chosen = True
        
        if choice == 'q':done = True
        if choice == 'n':newuser()
        if choice == 'e':olduser()

if __name__ == '__main__':
    showmenu()

while-else 循環舉例(maxFact.py)

#!/user/bin/env python

def showMaxFactor(num):
    count = num / 2
    while count > 1:
        if num % count == 0:
            print 'largest factor of %d is %d' %(num,count)
            break
        count -= 1
    else:
        print num,"is prime"

for eachNum in range(10,21):
    showMaxFactor(eachNum)

#這個程序顯示出10~20中的數組的最大公約數。該腳本也會提示這個數是否是素數。

什么是迭代器

迭代器是一組數據結構，你可以利用它們的索引從0開始一直"迭代"到序列的最后一個條目。迭代器用起來很靈巧，你可以迭代不是序列但表現出序列行為的對象，例如字典的鍵、一個文件的行、等等。當你使用循環迭代一個對象條目時，你幾乎分辨不出它是迭代器還是序列。你不必去關注這些，因為python讓它像一個序列那樣操作。

為什么要使用迭代器

• 提供了可擴展的迭代器接口
• 對列表迭代帶來了性能的增強
• 在字典迭代中性能提升
• 創建真正的迭代接口，而不是原來的隨機對象訪問
• 與所有已經存在的用戶定義的類以及擴展的模擬序列和映射的對象向后兼容
• 迭代非序列集合（例如映射和文件）時，可以創建更簡潔可讀的代碼

for i in seq:
    do_something_to(i)
#under the covers now really behaves like this:
實際上是這樣工作的：
fetch = iter(seq)
while True:
    try:
        i = fetch.next()
    except StopInteration:
        break
    do_something_to(i)

#字典和文件是另外兩個可迭代的python數據類型。字典的迭代器會遍歷他的鍵（key）。for eachKey in myDict.key() 可以縮寫成 for eachKey in myDict 例如：

>>> legends = {('Poe','author'):(1809,1849,1976),('Guadi','architect'):(1852,1906,1987)}

>>> for eachLegend in legends:
          print 'Name: %s\tOccupation: %s' %eachLegend
          print ' Birth: %s\tDeath:%s\tAlbum: %s\n' % legends[eachLegend]

$
Name: Poe Occuption: author 
 Birth: 1809 Death: 1849 Album: 1976
$

#文件對象生成的迭代器會自動調用readline()方法。這樣，循環就 可以訪問文本文件的所有行。程序員可以使用更簡單的 for eachLine in myFile 替代 for eachLine in myFile.readlines()

>>> myFile = open('config-win.txt')
>>> for eachLine in myFile:
...        print eachLine

如何創建迭代器

對一個對象調用iter()就可以得到它的迭代器。它的 語法如下:

iter(obj)
iter(func, sentinel )
#如果你傳遞一個參數給iter()，它會檢查你傳遞的是不是一個序列，如果是，那么很簡單：根據索引從0一直迭代到序列結束。另一個創建迭代器的方法是使用類，一個實現了__ite__()和next()的方法的類可以作為迭代器使用
#如果是傳遞兩個參數給iter(),它會重復調用func，直到迭代器的下個值等于sentinel

列表解析

#列表解析的語法：
[expr for iter_var in iterable]
#這個語句的核心在于for循環，它迭代iterable對象所有的條目。前面的expr應用于序列的每一個成員，最后的結果是該表達式生成的列表。
>>> map(lambda x: x**2,range(6))
[0,1,4,9,16,25]

也可以使用下面的這樣的列表解析來替換它:
>>> [x ** 2 for x in range(6) ]
[0,1,4,9,16,25]

#擴展版本的語法：
[expr for iter_var in iterable if cond_expr]

#這個語法在迭代時會過濾或"捕獲"滿足條件表達式cond_expr的序列成員

生成器表達式

生成器表達式是列表解析的一個擴展，生成器是特定的函數，允許你返回一個值，然后"暫停"代碼的執行，稍后恢復。
列表解析的一個不足就是必要生成所有的數據，用以創建整個列表。這可能對有大量數據的迭代器有負面效應。
生成器表達式在Python2.4中被引入，它與列表解析非常相似，而且它們的基本語法基本相同;不過它并不真正創建數字列表，而是返回一個生成器，這個生成器在每次計算出一個條目后，把這個條目"生成"（yield）出來，生成器表達式使用了"延遲計算"（lazy evaluation），所以它在使用內存上更加高效。

列表解析:
[expr for iter_var in iterable if cond_expr]
生成器表達式:
(expr for iter_var in iterable if cond_expr)

讀取文件的行的首選方法：

f = open('/etc/motd','r')
longest = 0
allLines = f.readline()
f.close()
for line in allLines:
    linelen = len(line.strip())
    if linelen > longest:
        longest = linelen
return longest

f = open('/etc/motd','r')
longest = 0
allLines = [x.strip() for x in f.readlines() ]
f.close()
for  line in allLines:
    linelen = len(line)
    if linelen > longest:
        longest = linelen
return longest

f = open('/etc/motd','r')
allLineslens = [len(x.strip()) for x in f]
f.close()
return max(allLineslens)

f = open('/etc/motd','r')
longest = max(len(x.strip()) for x in f)
f.close()
return longest

with open('/etc/motd') as f:
    longest = max(len(x.strip()) for x in f)
return longest

#一行式
return max(len(x.strip()) for x in open ('/etc/motd'))