Python核心编程第二版 第七章课后答案

注：我使用的python3.5。 其中range和xrange，input和raw_input已经合并

7-1.字典方法。哪个字典方法可以用来把两个字典合并到一起。

dict.update(dict2)将字典dict2的键-值对添加到字典dict。不能使用dict1+dict2这种方式

7-2.字典的键。我们知道字典的值可以是任意的Python对象，那字典的键又如何呢？请试着将除数字和字符串意外的其他不同类型的对象作为字典的键，看看哪些类型可以，哪些不行。对那些不能作为字典的键的对象类型，你认为是什么原因呢？

可哈希对象（不变类型）---数字，字符串和元组（但要加以限制）
不可哈希对象（可变类型）--列表，字典，集合
需要注意的是：值相等的数字代表同一个键，元组作为键时，其元素必须是可哈希的。
内建函数hash()可以判断某个对象是否可以做一个字典的键，如果非可哈希类型作为参数传递给hash()方法，会产生TypeError错误，否则会产生hash值，整数。
【注】元组当中的元素存在可变对象时，无法hash

7-3.字典和列表的方法。
(a)创建一个字典，并把这个字典中的键按照字母顺序显示出来。
(b)现在根据已经按照字母顺序排列好的键，显示出这个字典中的键和值。
(c)同(b)，但这次是根据已按照字母顺序排序好的字典的值，显示出这个字典中的键和值（注意：对字典和哈希表来说，这样做一般没什么实际意义，因为大多数访问和排序（如果需要）都是基于字典的键，这里只把它作为一个练习）。

sorted(dict.items(), key=lambda item:item[0])

注:这里的dict.items()实际上是将d转换为可迭代对象，items()方法将字典的元素转化为了元组，而这里key参数对应的lambda表达式的意思则是选取元组中的第二个元素作为比较参数（如果写作key=lambda item:item[0]的话则是选取第一个元素作为比较对象，也就是key值作为比较对象。lambda x:y中x表示输出参数，y表示lambda函数的返回值），所以采用这种方法可以对字典的value进行排序。注意排序后的返回值是一个list，而原字典中的名值对被转换为了list中的元组。

7-4.建立字典。给定两个长度相同的列表，比如说，列表[1，2，3，...]和['abc', 'def', 'ghi', ...]，用这两个列表里的所有数据组成一个字典。像这样：{1:'abc', 2:'def', 3:'ghi', ...}

num = [1,2,3]
str1 = ['abc','def','ghi']
dict1 = {}
for i in range(len(num)):
    dict1[num[i]] = str1[i]

7-7.颠倒字典中的键和值。用一个字典做输入，输出另一个字典，用前者的键做值，前者的值做键。

for key, value in dict1.items():
    dict2[value] = key

7.8.人力资源。创建一个简单的雇员姓名和编号的程序，让用户输入一组雇员姓名和编号。你的程序可以提供按照姓名排序输出的功能，雇员姓名显示在前面，后面是对应的雇员编号。附加：添加一项功能，按照雇员编号的顺序输出数据。

def infoRegister():
    pr = 'Please enter your name:'
    pr2 = 'Please enter the number:'
    
    dict1 = {}
    while True:
        keys = input(pr)
        if keys == 'quit':
            break
        value = input(pr2)
        dict1[keys] = value
        
    return dict1

def keysSort(dic):
    dict = sorted(dic.items(), key = lambda d:d[0])
    print(dict)

def valueSort(dic):
    dict= sorted(dic.items(), key=lambda d:d[1]) 
    print(dict)

if __name__ == '__main__':
    d = infoRegister()
    keysSort(d)
    valueSort(d)

 7.9.翻译。(a)编写一个字符翻译程序（功能类似于Unix中的tr命令）。我们将这个函数叫做tr()，他又三个字符串做参数：源字符串、目的字符串、基本字符串，语法定义如下：def tr(srcstr,dststr,string)。srcstr的内容是你打算“翻译”的字符集合，dststr是翻译后得到的字符集合，而string是你打算进行翻译操作的字符串。举例来说，如果srcstr='abc',dststr='mno',string='abcdef'。那么tr()的输出将是'mnodef'。注意这里len(srcstr)=len(dststr)。在这个联系里，你可以使用内建函数chr()和ord()，但它们并不一定是解决这个问题所必不可少的函数。
(b)在这个函数里增加一个标志函数，来处理不区分大小写的翻译问题。
(c)修改你的程序，使它能够处理删除字符的操作。字符串srcstr中不能够映射到字符串dststr中的中字符的多余字符都将被过滤掉。换句话说，这些字符没有映射到dststr字符串中的任何字符，因此就从函数返回的字符里给过滤掉了。举例来说，如果scrstr='abcdef',dststr='mno',string='abcdefghi'，那么tr()将输出'mnoghi',注意这里len(srcstr)>=len(dststr).

a:

def tr(srcstr,dststr,string):
    srcstr_len = len(srcstr)
    string_len = len(string)
     
    elestring = list(string)
    loop_len = string_len - srcstr_len
    for i in range(loop_len):
        if string[i:i+srcstr_len] == srcstr:
            for num in range(srcstr_len):
                elestring[i+num] = dststr[num]
     
    newstring = ''.join(elestring)
    return newstring

b:

def tr(srcstr,dststr,string,Upper_equal_Lower=False):
    srcstr_len = len(srcstr)
    string_len = len(string)
    
    elestring = list(string)
    loop_len = string_len - srcstr_len
    for i in range(loop_len):
        if Upper_equal_Lower == False: 
            if string[i:i+srcstr_len] == srcstr:
                for num in range(srcstr_len):
                    elestring[i+num] = dststr[num]
        elif Upper_equal_Lower == True: 
            if string[i:i+srcstr_len].upper() == srcstr.upper():
                for num in range(srcstr_len):
                    elestring[i+num] = dststr[num]
      
    newstring = ''.join(elestring)
    return newstring

c:

def tr(srcstr,dststr,string,Upper_equal_Lower=False):
    srcstr_len = len(srcstr)
    dststr_len = len(dststr)
    string_len = len(string)
    numlen = srcstr_len - dststr_len
     
    i = 0  
    newstring = string
    loop_len = string_len - srcstr_len
    for a in range(loop_len):
        if Upper_equal_Lower == False: 
            if string[i:i+srcstr_len] == srcstr:
                if i > 0:
                    ele1 = newstring[:i-numlen]
                    ele2 = newstring[i+srcstr_len-numlen:]
                else:
                    ele1 = newstring[:i]
                    ele2 = newstring[i+srcstr_len:]
                    
                newstring = ele1 + dststr + ele2
                i = i + dststr_len -1
        elif Upper_equal_Lower == True: 
            if string[i:i+srcstr_len] == srcstr:
                if i > 0:
                    ele1 = newstring[:i-numlen]
                    ele2 = newstring[i+srcstr_len-numlen:]
                else:
                    ele1 = newstring[:i]
                    ele2 = newstring[i+srcstr_len:]
                    
                newstring = ele1 + dststr + ele2
                i = i + dststr_len -1
        i = i + 1
         
    return newstring

7-10.加密。(a)用上一个练习的思路编写一个“rot13”翻译器。“rot13”是一个古老而又简单的加密方法，它把字母表中的每个字母用其后的第13个字母来代替。字母表中前半部分字母将被映射到后半部分，而后半部分字母将被映射到前半部分，大小写保持不变。举例来说，'a'将被替换为'n'，'X'将被替换为'K'；数字和符号不进行翻译。

(b)在你的解决方案的基础上加一个应用程序，让它提示用户输入准备加密的字符串（这个算法同时也可以对加密后的字符串进行解密）。

dncr = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'
encr = 'nopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklm'
dict_encr = dict(zip(list(dncr),list(encr)))
dict_dncr = dict(zip(list(encr),list(dncr)))

def password_enter():
    pr = 'Please enter the password:'
    return input(pr)

def encryption():
    str1 = password_enter()
    l = []
    for i in str1:
        if i.isalpha() == True:
            l.append(dict_encr[i])
        else:
            l.append(i)
    
    newstr = ''.join(l)
    print( 'The encryption password is:' + newstr)
        
def dcrypted():
    str1 = password_enter()
    l = []
    for i in str1:
        if i.isalpha() == True:
            l.append(dict_dncr[i])
        else:
            l.append(i)
    
    newstr = ''.join(l)
    print( 'The dcrypted password is:' + newstr)
            
CMDs = {'e':encryption, 'd':dcrypted}
def rot13():
    pr = '''
    Please make a choice:
    (E)ncryption
    (D)ecrypted
    (Q)uit
    '''
     
    while True:
        try:
            choice = input(pr).strip()[0].lower()
        except(EOFError,KeyboardInterrupt,IndexError):
            choice = 'q'
         
        print('
You picked: [%s]' % choice)
         
        if choice == 'q':
            break
        CMDs[choice]()

if __name__ == '__main__':
    rot13()

7-12.定义。(a)在数学上，什么是集合？(b)在Python中，关于集合类型的定义是什么？

(a)集合是把人们的直观的或思维中的某些确定的能够区分的对象汇合在一起，使之成为一个整体(或称为单体)，这一整体就是集合。组成一集合的那些对象称为这一集合的元素（或简称为元）。
(b)python中集合对象（set）是一组无序排列的可哈希的值，包含两种类型：可变集合（set）和不可变集合（frozenset），所以set不是可哈希的，frozenset是可哈希的，能当作字典的键。