python核心编程-字典的键

• 不允许一个键对应多个值

每个键只能对应一个项。也就是说，一个键对应多个值是不允许的（像列表，元组和其他字典这样的容器对象是可以的）。当有键发生冲突（即字典键重复赋值），取最后（最近）的赋值。

• 键必须是可哈希的

大多是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'))