#encoding=utf-8
import random
#dict.update(dict2)a 将字典 dict2 的键-值对添加到字典 dict
# 7–1. 字典方法。哪个字典方法可以用来把两个字典合并到一起？
dict1 = {1:‘w‘,2:‘y‘}
dict2 = {3:‘t‘}
dict1.update(dict2)
print dict1
# 7–2. 字典的键。我们知道字典的值可以是任意的 Python 对象，那字典的键又如何呢？请试
# 着将除数字和字符串以外的其他不同类型的对象作为字典的键，看一看，哪些类型可以，哪些不行？
# 对那些不能作字典的键的对象类型，你认为是什么原因呢？
#字符串，数字是不可变类型，可以
#列表不可以，元组里面元素都是字符串或数字时候可以，其他元组不可以
# 7–3. 字典和列表的方法。
# (a) 创建一个字典，并把这个字典中的键按照字母顺序显示出来。
dict3 = {‘please‘:‘w‘,‘love‘:‘z‘,‘me‘:‘y‘}
s= dict3.keys()#.sort() #获取键的列表
print s
print s.sort() #对列表进行排序
print s
# (b) 现在根据已按照字母顺序排序好的键，显示出这个字典中的键和值。
for i in s:
print i,dict3[i]
# (c)同(b),但这次是根据已按照字母顺序排序好的字典的值，显示出这个字典中的键和值。(注
# 意：对字典和哈希表来说，这样做一般没有什么实际意义，因为大多数访问和排序(如果需要)都是
# 基于字典的键，这里只把它作为一个练习。)
# 7-4. 建立字典。给定两个长度相同的列表，比如说，列表[1, 2, 3,...]和[‘abc‘, ‘def‘,
# ‘ghi‘,...],用这两个列表里的所有数据组成一个字典， 像这样： {1:‘abc‘, 2: ‘def‘, 3: ‘ghi‘,...}
list1 = [1,2,3]
list2 = [‘w‘,‘z‘,‘y‘]
dict4 = {}
for i in range(3):
dict4[list1[i]] = list2[i]
print dict4
# 7-7. 颠倒字典中的键和值。用一个字典做输入，输出另一个字典，用前者的键做值，前者的
# 值做键。
dict5 = {}
for key in dict3:
dict5[dict3[key]]=key
print dict3
print dict5
# 7-8. 人力资源。创建一个简单的雇员姓名和编号的程序。让用户输入一组雇员姓名和编号。
# 你的程序可以提供按照姓名排序输出的功能，雇员姓名显示在前面，后面是对应的雇员编号。附加
# 题：添加一项功能，按照雇员编号的顺序输出数据。
dict6 ={}
while True:
s = raw_input("input name & id,‘z‘ Stop")
if s == ‘z‘:
break
list = s.split(‘&‘)
dict6[list[0]] = list[1]
print dict6
print ‘sort by name‘
Key = dict6.keys()
Key.sort()
for key in Key:
print key,dict6[key]
print ‘sort by id‘
dict7 = {}
for key in dict6:
dict7[dict6[key]]=key
Key = dict7.keys()
Key.sort()
for key in Key:
print key,dict7[key]
# 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(), 但它们并不一定是解决这个问题所必不
# 可少的函数。
def tr(srcstr,dststr,string):
dict4 = {}
for i in range(len(srcstr)):
dict4[srcstr[i]] = dststr[i]
print dict4
if ‘a‘ in dict4:
print dict4[‘a‘]
str = ‘‘
for i in range(len(string)):
if string[i] in dict4:
str += dict4[string[i]]
else:
str += string[i]
print str
# string = string.replace(srcstr,dststr)
# print string
tr(‘abc‘,‘mno‘,‘abcdef‘)
# (b) 在这个函数里增加一个标志符参数，来处理不区分大小写的翻译问题。
# (c)修改你的程序， 使它能够处理删除字符的操作。字符串 srcstr 中不能够映射到字符串 dststr
# 中字符的多余字符都将被过滤掉。换句话说，这些字符没有映射到 dststr 字符串中的任何字符，因
# 此就从函数返回的字符里被过滤掉了。举例来说：如果 srcstr == ‘abcdef‘, dststr == ‘mno‘,
# string == ‘abcdefghi‘, 那么 tr()将输出‘mnoghi‘. 注意这里 len(srcstr) >= len(dststr).
def trc(srcstr,dststr,string):
dict4 = {}
for i in range(len(srcstr)):
if i < len(dststr):
dict4[srcstr[i]] = dststr[i]
else:
dict4[srcstr[i]] = ‘‘
print dict4
if ‘a‘ in dict4:
print dict4[‘a‘]
str = ‘‘
for i in range(len(string)):
if string[i] in dict4:
str += dict4[string[i]]
else:
str += string[i]
print str
trc(‘abc‘,‘d‘,‘abcdef‘)
# 7–10. 加密。
# (a) 用上一个练习的思路编写一个"rot13"翻译器。 "rot13"是一个古老而又简单的加密方法，
# 它把字母表中的每个字母用其后的第 13 个字母来代替。字母表中前半部分字母将被映射到后半部分，
# 而后半部分字母将被映射到前半部分，大小写保持不变。举例来说，‘a‘将被替换为‘n‘,‘X‘将被替
# 换为‘K‘; 数字和符号不进行翻译。
def dict13():
dict = {}
for i in range(65,78):
dict[chr(i)]=chr(i+13)
dict[chr(i+13)] = chr(i)
j = i + 32
dict[chr(j)]=chr(j+13)
dict[chr(j+13)] = chr(j)
return dict
def rot13():
string = raw_input(‘please input/n‘)
dict1 = dict13()
str = ‘‘
for i in range(len(string)):
if string[i] in dict1:
str += dict1[string[i]]
else:
str += string[i]
print str
rot13()
# (b)在你的解决方案的基础上加一个应用程序，让它提示用户输入准备加密的字符串(这个算法
# 同时也可以对加密后的字符串进行解密)，如下所示:
def dict31():
dict = {}
dict1 = dict13()
for key in dict1:
dict[dict1[key]] = key
return dict
def rot31():
string = raw_input(‘please input/n‘)
dict1 = dict31()
str = ‘‘
for i in range(len(string)):
if string[i] in dict1:
str += dict1[string[i]]
else:
str += string[i]
print str
rot31()
# % rot13.py
# Enter string to rot13: This is a short sentence. Your string to en/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 to en/decrypt was: [Guvf
# vf n fubeg fragrapr.].
# The rot13 string is: [This is a short sentence.].
# w = ‘What‘
# w.lower
# 7–11. 定义。什么组成字典中合法的键? 举例说明字典中合法的键和非法的键。
#键必须是可哈希的（不可变的）
#不允许一个键对应多个值
# 7-12. 定义。
# (a)在数学上，什么是集合?
#由一个或多个元素组成，确定性，互斥性，无序性
# (b)在 Python 中，关于集合类型的定义是什么？
#集合对象是一组无序排列的可哈希的值，集合成员可以做字典中的键
s = set(‘cheeseshop‘)#可变集合
s.add(‘z‘)
s.update(‘wyt‘)
print s
‘k‘ in s
t = frozenset(‘wyt‘)#不可变集合
s == t
s | t #合集
s&t#交集
s-t#差集
s^t#对称差分，属于s，属于t，不属于s和t的合集
# 7–13. 随机数。修改练习 5-17 的代码：使用 random 模块中的 randint()或 randrange()方
# 法生成一个随机数集合： 从 0 到 9(包括 9)中随机选择，生成 1 到 10 个随机数。这些数字组成集合
# A(A 可以是可变集合，也可以不是)。同理，按此方法生成集合 B。每次新生成集合 A 和 B 后，显示
# 结果 A | B 和 A & B
def randomset():
s = set(‘‘)
N = random.randint(1,10)
for i in range(N):
s.add(random.randint(0,9))
return s
A = randomset()
B = randomset()
print A | B
print A & B
# 7–14. 用户验证。修改前面的练习，要求用户输入 A | B 和 A & B 的结果，并告诉用户他(或
# 她)的答案是否正确，而不是将 A | B 和 A & B 的结果直接显示出来。如果用户回答错误，允许他(或
# 她)修改解决方案，然后重新验证用户输入的答案。如果用户三次提交的答案均不正确，程序将显示
# 正确结果。
# 附加题：运用你关于集合的知识， 创建某个集合的潜在子集，并询问用户此潜在子集是否真是
# 该集合的子集，要求和主程序一样有显示更正和答案的功能。
s = set(‘1,2,3,4,5,6‘)
t = set(‘2,3,5,6,1,4‘)
print type(‘1,2,3,4,5,6‘)
print s,t
print s == t
#encoding=utf-8
import random
#产生随机集合
def randomset():
s = set(‘‘)
N = random.randint(1,10)
for i in range(N):
s.add(random.randint(0,9))
return s
A = randomset()
B = randomset()
print A,B
#print A|B,A&B
# A = set()
# B = set()
# A.add(1)
# A.add(2)
# B.add(2)
# print A|B,A&B
#对输入进行处理，去[],保存为集合
#要考虑输入为空集的处理
#输入格式为[],变成‘‘,然后set(‘‘)
def input_to_set(S1):
set1 = set()
if S1 != ‘[]‘:
u1,u2 = S1.split(‘[‘)
u1,u3 = u2.split(‘]‘)
list1 = u1.split(‘,‘)
for i in list1:
j = int(i) #列表中单独字符串转换为数字
set1.add(j)
#print set1
return set1
i = 0
while i < 3:
str1 = raw_input(‘A | B is:‘)
str2 = raw_input(‘A & B is:‘)
S1 = input_to_set(str1)
S2 = input_to_set(str2)
# print S1 == A|B
# print S2 == A&B
if (S1 == A|B and S2 == A&B):
print ‘correct‘
break
else:
print ‘error‘
i += 1
#print i 三次输错，输出正确答案
if i == 3:
print A|B,A&B