《Python核心编程》 第七章 映射和集合类型 - 习题

标签：style   blog   http   color   java   使用   io   strong   

课后习题

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

 答：

dict1 = {‘1‘ :‘ python‘ }
dict2 = {‘2‘ :"hello" }
dict1.update(dict2)
dictAll = dict1
print dictAll

Result：

{‘1‘: ‘ python‘, ‘2‘: ‘hello‘}

7–2. 字典的键。我们知道字典的值可以是任意的 Python 对象，那字典的键又如何呢？请试

着将除数字和字符串以外的其他不同类型的对象作为字典的键，看一看，哪些类型可以，哪些不行？
对那些不能作字典的键的对象类型，你认为是什么原因呢？

 答：

　　大多数Python对象都可以作为键；但是它们必须是可哈希的对象。像列表和字典这样的可变类型，由于它们不是可哈希的，所以不能作为键。

　　解释器调用哈希函数，根据字典中键的值来计算存储你的数据的位置。如果键是可变对象，它的值可变。如果键发生变化，哈希函数就会映像到不同的地址来存储数据。如果这样的情况发生，哈希函数就不能可靠的存储或者获取相关的数据。

 7–3. 字典和列表的方法。 

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

答：

# -*- coding: UTF-8 -*-
‘‘‘
Created on 2014年7月9日
@author: User
‘‘‘
# a 创建一个字典，并把这个字典中的键按照字母顺序显示出来。 
dict1 = {"a" :1 ,"b" :"python","e" :3,"d" :"r"            }
print sorted(dict1.keys())
print sorted(dict1.keys(),reverse=True)
print "-"*60

#(b) 现在根据已按照字母顺序排序好的键，显示出这个字典中的键和值。 
list1 = dict1.keys()
for i in list1:
    print "key =",i,"  ""value=",dict1[i]  

print "-"*60
#(c)同(b),但这次是根据已按照字母顺序排序好的字典的值，显示出这个字典中的键和值。
list2 = sorted(dict1.keys())
for i in list2:
    print "key =",i,"  ""value=",dict1[i]

Result:

[‘a‘, ‘b‘, ‘d‘, ‘e‘]
[‘e‘, ‘d‘, ‘b‘, ‘a‘]
------------------------------------------------------------
key = a   value= 1
key = b   value= python
key = e   value= 3
key = d   value= r
------------------------------------------------------------
key = a   value= 1
key = b   value= python
key = d   value= r
key = e   value= 3

7-4.建立字典。给定两个长度相同的列表，比如说，列表[1, 2, 3,...]和[‘abc‘, ‘def‘, 

‘ghi‘,...],用这两个列表里的所有数据组成一个字典，像这样：{1:‘abc‘, 2: ‘def‘, 3: ‘ghi‘,...}
答：

# -*- coding: UTF-8 -*-
‘‘‘
Created on 2014年7月9日
7-4.建立字典。给定两个长度相同的列表，比如说，列表[1, 2, 3,...]和[‘abc‘, ‘def‘, 
‘ghi‘,...],用这两个列表里的所有数据组成一个字典，像这样：{1:‘abc‘, 2: ‘def‘, 3: ‘ghi‘,...} 
@author: User
‘‘‘
list1 = [1,2,3,4,5,6]
list2 = ["abc","edf","ghi","jkl","mno","pqr"]
if __name__ == "__main__":
    dictMerger = {}.fromkeys(list1)
    print dictMerger
    for i in range(len(list2)):
        dictMerger[i] = list2[i]
        
    print dictMerger

7–5. userpw2.py. 下面的问题和例题 7.1 中管理名字-密码的键值对数据的程序有关。
(a)修改那个脚本，使它能记录用户上次的登录日期和时间(用 time 模块)，并与用户密码一起
保存起来。程序的界面有要求用户输入用户名和密码的提示。无论户名是否成功登录，都应有提示，
在户名成功登录后，应更新相应用户的上次登录时间戳。如果本次登录与上次登录在时间上相差不
超过 4 个小时，则通知该用户： “You already logged in at: <last_ login_timestamp>.”
(b) 添加一个“管理”菜单，其中有以下两项:(1)删除一个用户 (2)显示系统中所有用户的名
字和他们的密码的清单。
(c) 口令目前没有加密。请添加一段对口令加密的代码(请参考 crypt, rotor, 或其它加密模块)
(d) 为程序添加图形界面，例如，用 Tkinter 写。
(e) 要求用户名不区分大小写。
(f) 加强对用户名的限制，不允许符号和空白符。
(g)合并“新用户”和“老用户”两个选项。如果一个新用户试图用一个不存在的用户名登录，
询问该用户是否是新用户，如果回答是肯定的，就创建该帐户。否则，按照老用户的方式登录。

 答：（暂时想不出来，能力有限，泪崩）

7-6. 列表和字典。创建一个简单的股票证券投资数据系统。其中应至少包含四项数据：股市
行情显示器符号，所持有的股票，购买价格及当前价位 - 你可以随意添加其他数据项，比如收益率，
52 周最高指数、最低指数，等等。
用户每次输入各列的数据构成一个输出行。每行数据构成一个列表。还有一个总列表，包括了
所有行的数据。数据输入完毕后，提示用户选择一列数据项进行排序。把该数据项抽取出来作为字
典的键，字典的值就是该键对应行的值的列表。提醒读者：被选择用来排序的数据项必须是非重复
的键，否则就会丢失数据，因为字典不允许一个键有多个值。
你还可以选择其他计算输出，比如，盈亏比率，目前证券资产价值等。

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

 答：（看到希望了）

# -*- coding: UTF-8 -*-
‘‘‘
Created on 2014年7月16日
7-7. 颠倒字典中的键和值。用一个字典做输入，输出另一个字典，用前者的键做值，前者的值做键。
@author: User
‘‘‘
d1 = {‘1‘:‘f‘,‘2‘:‘e‘,‘3‘:‘c‘,‘4‘:‘d‘}
d2 = {}
list1 = d1.keys()
list2 = d1.values()
for list1,list2 in d1.items():
    d2[list2] = list1
   


if __name__ == "__main__":
    print d2
    pass

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

答：

# -*- coding: UTF-8 -*-
‘‘‘
Created on 2014年7月16日
path：E:\Se\core_python\src@author: Administrator
function：
7-8. 人力资源。创建一个简单的雇员姓名和编号的程序。让用户输入一组雇员姓名和编号。
你的程序可以提供按照姓名排序输出的功能，雇员姓名显示在前面，后面是对应的雇员编号。附加
题：添加一项功能，按照雇员编号的顺序输出数据。
‘‘‘
d1 = { }
d2 = { }
while True:
    name = raw_input(‘name:‘)
    if name == ‘-1‘:
        break
    pid =raw_input(‘id:‘)
    d1[name] =pid
    d2[pid] = name

for key in sorted(zip(*d1.items())[0]):
                print key , d1[key]

for key in sorted(zip(*d2.items())[0]):
                print key , d2[key]

运行结果：

name:wu
id:1
name:ming
id:2
name:zhi
id:3
name:python
id:4
name:-1
ming 2
python 4
wu 1
zhi 3
1 wu
2 ming
3 zhi
4 python

 7-9. 翻译 

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

答：（网上找来的一个答案，研究了好久，比我厉害的人太多了） 

def tr(srcstr, dststr, string,casemap=True):
    assert len(srcstr)>=len(dststr)
    
    table = dict(zip(srcstr,dststr))
    if len(srcstr) > len(dststr):
        temp = {}.fromkeys(srcstr[len(dststr):])
        table.update(temp)
        
    ls = [ ]
    for ch in string:
        if not casemap:
            if ch.lower() in table:
                ls.append(table[ch.lower()])
            elif ch.upper() in table:
                ls.append(table[ch.upper()])
            else:
                ls.append(ch)
            continue
        
        if ch in table:
            ls.append(table[ch])
        else:
            ls.append(ch)
        
    ls = [ch for ch in ls if ch]
    return " ".join(ls)
    
print tr(‘abc‘, ‘mno‘, ‘abcdef‘)  
print tr(‘aBcdef‘, ‘mno‘, ‘abcdefghi‘, False)   

 7–10. 加密。 

(a) 用上一个练习的思路编写一个"rot13"翻译器。"rot13"是一个古老而又简单的加密方法，
它把字母表中的每个字母用其后的第 13 个字母来代替。字母表中前半部分字母将被映射到后半部分，
而后半部分字母将被映射到前半部分，大小写保持不变。举例来说，‘a‘将被替换为‘n‘,‘X‘将被替
换为‘K‘; 数字和符号不进行翻译。
(b)在你的解决方案的基础上加一个应用程序，让它提示用户输入准备加密的字符串(这个算法
同时也可以对加密后的字符串进行解密)，如下所示:
% rot13.py
Enter string to rot13: This is a short sentence. Your string toen/decrypt was: [This
is a short sentence.].
The rot13 string is: [Guvf vf n fubeg fragrapr.].
%
% rot13.py
Enter string to rot13: Guvf vf n fubeg fragrapr. Your string toen/decrypt was: [Guvf
vf n fubeg fragrapr.].
The rot13 string is: [This is a short sentence.].

 答：（我参考修改的程序）

def rot13(srcstr):  
    ls1 = [chr((num + 13) % 26 + ord(‘a‘)) for num in range(26)]  
    ls2 = [chr(num + ord(‘a‘)) for num in range(26)]  
    table = dict(zip(ls2, ls1))  
    ls1 = "".join(ls1).upper()  
    ls2 = "".join(ls2).upper()  
    table.update(dict(zip(ls2, ls1))) 
  
    ls = []  
    for ch in srcstr:  
        if ch in table:  
            ls.append(table[ch])  
        else:  
            ls.append(ch)  
    return " ".join(ls)  
srcstr = raw_input("please input a string:")
print rot13(srcstr)

运行结果：

please input a string:123aBcxYz
1 2 3 n O p k L m

7–11. 定义。什么组成字典中合法的键? 举例说明字典中合法的键和非法的键。 

答：字典中的键必须是可哈希的，像列表和字典这样的可变类型，鱿鱼他们不是可哈希的，所以不能作为键。

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

 答：

a:数学上，把set称作由不同的元素组成的集合，集合的成员通常被称作集合元素。

b:Python中，集合对象是一组无序排列的可哈希的值。

7–13. 随机数。修改练习 5-17 的代码：使用 random 模块中的 randint()或 randrange()方
法生成一个随机数集合：从 0 到 9(包括 9)中随机选择，生成1到10个随机数。这些数字组成集合
A(A 可以是可变集合，也可以不是)。同理，按此方法生成集合 B。每次新生成集合A和B后，显示
结果 A | B 和 A & B

 答：

 不会列表解析

7–14. 用户验证。修改前面的练习，要求用户输入 A | B 和 A & B 的结果，并告诉用户他(或
她)的答案是否正确，而不是将 A | B 和 A & B 的结果直接显示出来。如果用户回答错误，允许他(或
她)修改解决方案，然后重新验证用户输入的答案。如果用户三次提交的答案均不正确，程序将显示
正确结果。
附加题：运用你关于集合的知识，创建某个集合的潜在子集，并询问用户此潜在子集是否真是
该集合的子集，要求和主程序一样有显示更正和答案的功能。
 答：不会列表解析，只能空着回头搞

7–15. 编写计算器。 这个练习取材于 http://math.hws.edu/ 在线免费 Java 教材中的练习
12.2。编写一个程序允许用户选择两个集合:A 和 B, 及运算操作符。例如，in, not in, &, |, ^, <,
<=, >, >=, ==, !=, 等. (你自己定义集合的输入语法，它们并不一定要像 Java 示例中那样用方括
号括住。)解析输入的字符串，按照用户选择的运算进行操作。你写的程序代码应该比 Java 版本的
该程序更简洁。

答：

(看完函数来写)

《Python核心编程》 第七章 映射和集合类型 - 习题,布布扣,bubuko.com

《Python核心编程》 第七章 映射和集合类型 - 习题

标签：style   blog   http   color   java   使用   io   strong   

原文地址：http://www.cnblogs.com/wuzhiming/p/3755340.html