python核心编程 第七章 字典，集合 练习

#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()

# 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

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

# 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


#对输入进行处理，去[],保存为集合
#要考虑输入为空集的处理
#输入格式为[],变成'',然后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