python 核心编程第七章

字典与集合：操作符，内建函数，内建方法。

字典

什么是映射：

键-值 相对应。无序存储。Keys()或values()返回一个列表。item()返回键值对应的列表。
用处：性能好，用健查询对应值相当快。

字典的操作。

检查字典中是否有某个键用has_key()或者in操作符。
del dict{'name'}删除键为name的条目
dict.cear()删除所有条目
dict.pop()删除并返回“name”条目
cmp()可比较字典的长度，键值大小，完全一样返回0
dict()创建一个字典，参数若是可迭代对象，生成键值对应的一个字典。
hash()返回对象的哈希值(所有不可变类型都是可哈希的)

字典类型方法

dict.fromkeysc (seq,val=None)c 创建并返回一个新字典，以 seq 中的元素做该字典的键，val 做该字典中所有键对应的初始值(如果不提供此值，则默认为 None)
dict.get(key,default=None)a 对字典 dict 中的键 key,返回它对应的值 value，如果字典中不存在此键，则返回 default 的值(注意，参数 default 的默认值为 None)
dict.has_key(key) 如果键(key)在字典中存在， 返回 True， 否则返回 False. 在 Python2.2版本引入 in 和 not in 后，此方法几乎已废弃不用了，但仍提供一个可工作的接口。
dict.items() 返回一个包含字典中(键, 值)对元组的列表
dict.keys() 返回一个包含字典中键的列表
dict.iter()d 方法 iteritems(), iterkeys(), itervalues()与它们对应的非迭代方法一样，不同的是它们返回一个迭代子，而不是一个列表。
dict.popc (key[, default])c 和方法 get()相似，如果字典中 key 键存在，删除并返回 dict[key]，如果 key 键不存在，且没有给出 default 的值，引发 KeyError 异常。
dict.setdefault(key,default=None)e 和方法 set()相似，如果字典中不存在 key 键，由 dict[key]=default 为它赋值。
dict.update(dict2)a 将字典 dict2 的键-值对添加到字典 dict
dict.values() 返回一个包含字典中所有值的列表

集合

1. 基本介绍：集合的概念来自数学，在python为集合类型。分为可变集合和不可变集合。
   使用set()和forzenset()来创建一个集合。
2. 基本操作：可以使用in和 not in 判断元素是否属于一个集合
   使用.add()增加集合的元素，.update()。使用.remove()来删除元素。

集合基本操作符（交，并，补）

联合（|）。交集（&）。补集（-）。
从已存在集合添加成员使用（|=）。 保留交集（&=）。 差更新（-=）
对称差分更新（^=）

集合的内建方法：

s.issubset(t) 如果 s 是 t 的子集，则返回 True,否则返回 False
s.issuperset(t) 如果 t 是 s 的超集，则返回 True,否则返回 False
s.union(t) 返回一个新集合，该集合是 s 和 t 的并集
s.intersection(t) 返回一个新集合，该集合是 s 和 t 的交集

s.difference(t) 返回一个新集合，该集合是 s 的成员，但不是 t 的成员
s.symmetric_difference(t) 返回一个新集合，该集合是 s 或 t 的成员，但不是 s 和 t 共有的成员
s.copy() 返回一个新集合，它是集合 s 的浅复制
可变集合的方法：
s.update(t) 用 t 中的元素修改 s, 即，s 现在包含 s 或 t 的成员
s.intersection_update(t) s 中的成员是共同属于 s 和 t 的元素。
s.difference_update(t) s 中的成员是属于 s 但不包含在 t 中的元素
s.symmetric_difference_update(t) s 中的成员更新为那些包含在 s 或 t 中，但不 是 s和 t 共有的元素
s.add(obj) 在集合 s 中添加对象 obj
s.remove(obj) 从集合s中删除对象obj； 如果obj不是集合s中的元素(obj notin s)，将引发 KeyError 错误
s.discard(obj) 如果 obj 是集合 s 中的元素，从集合 s 中删除对象 obj；
s.pop() 删除集合 s 中的任意一个对象，并返回它
s.clear() 删除集合 s 中的所有元素

练习：

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)合并“新用户”和“老用户”两个选项。如果一个新用户试图用一个不存在的用户名登录，
询问该用户是否是新用户，如果回答是肯定的，就创建该帐户。否则，按照老用户的方式登录。

import string
import base64
db = dict(root=("YWRtaW4="))#键值为name，值为密码和登录时间。
def log_in():
    name=raw_input("name:")
    password = raw_input("password:")
    if encryption(password)== db.get(name):
        print "登陆成功"
        return True,name
    elif None==db.get(name)[0]:
        option=raw_input("用户名不存在是否新建此用户,请输入y或者n")
        if option=="y"or option=="Y":
            db[name]=encryption(password)
            print "用户%s已完成注册"%name, db
            return True,name
        else:
            return False
    else:
        raw_input("密码错误请重新输入，按回车键继续")
        log_in()
def manage():
    option = raw_input("""选项
1.删除一个用户
2.显示所有用户""")
    if option=="1":
        name=raw_input("请输入要删除的用户名")
        del db[name]
    else:
        print db.keys()
def examine(name):
    name=name.lower()#吧名字默认为小写存储进去。
    for i in name:
        if i in string.punctuation +" ":
            return False
    return name
def encryption(password):
    return base64.encodestring(password)#加密密码
def menu():
    option=raw_input("请选择功能：
1.登陆
2管理")
    if option == "1":
        log_in()
    else:
        manage()
if __name__=="__main__":
    menu()

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

date_base=[]
sort="1.股票代号  2.所持股票  3.购买价格 4.当前价位 5.收益率
"
def user_input():
    date = raw_input("股票代号  所持股票  购买价格 当前价位：
").split(" ")
    date_base.append(date)
    print "输入数据已保存"
    print date
def date_sort():#把排序的依据提取到列表，排序后作为字典的key
    option = int(raw_input("请选择排序的依据
"+sort))
    user_dict = dict([(row[option-1],row) for row in date_base])
    keys = [row[option-1] for row in date_base]
    return sorted(keys),user_dict
def show(keys,user_dict):
    for key in keys:
        print user_dict.get(key)
        
for i in range(3):
    user_input()
keys,user_dict=date_sort()
#print keys, user_dict
show(keys,user_dict)

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

dict1 = {1:2,3:4}
dict2 = {}
for key,value in dict1.items():
    dict2[value] = key
print dict2

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

import string
lower = string.lowercase*3
upper = string.uppercase*3
punctuation = string.punctuation*2
def code_ro13(str_temp,encrypt=13):
    new_string=""
    for i in str_temp:
        if i in lower:
            new_string += lower[lower.find(i,26) + encrypt]
        elif i in upper:
            new_string += upper[upper.find(i,26) + encrypt]
        elif i in punctuation:
            new_string += punctuation[punctuation.find(i) +encrypt]
        else:
            new_string += str((int(i)+encrypt)%10)
    return new_string

if __name__== "__main__":
    while 1:
        user_input = raw_input("请输入想要的功能和要加密的字符串,中间用空格隔开。
1.加密
2.解密
").split(" ")
        string = user_input[1]
        if user_input[0]=="1":
            print code_ro13(string)
        else:
            print code_ro13(string,-13)
        raw_input("按回车键继续")

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

import random
def create_num():
    assemble = []
    for i in range(random.randint(1, 10)):
        x = random.randint(0,9)
        if x not in assemble:
            assemble.append(x)
    return assemble

def intersect(a,b):
    intersect = []
    for i in a:
        if i in b:
            intersect.append(i)
    return intersect

def merge(a,b):
    for i in a:
        if i not in b:
            b.append(i)
    return b

if __name__ =="__main__":
    a=create_num();b=create_num()
    print a,b
    print "a和b的交集是",intersect(a,b)
    print  "
a和b的并集是",merge(a,b)