Python随记（8）字典 集合

字典

1. 字典就是用’ {} ‘定义，由键和值构成，这一对称为以项。键一定时独一无二的，值不必它可以时任何数据类型。但必须是不可变的，就像字符串，数或元组。创建空字典 empty = {}。
   用dict()内置函数创建字典：dict1 = dict(((‘a’,1),(‘b’,2))) dict()函数的参数是一个序列，所以要打包成一个元组或列表当参数，
   还可以通过映射关系创建字典： dict1 = dict(a=1,b=2,c=3) 但是这里的键不能加上引号的，否则会报错。
   通过给键赋值扩充字典：dict1['d'] = 4

# 各种创建字典的方法
>>> a = dict(one=1, two=2, three=3)
>>> b = {'one': 1, 'two': 2, 'three': 3}
>>> c = dict(zip(['one', 'two', 'three'], [1, 2, 3]))
>>> d = dict([('two', 2), ('one', 1), ('three', 3)])
>>> e = dict({'three': 3, 'one': 1, 'two': 2})

2. 访问字典的值：就跟序列一样 dict1['a'] >>>1如果键不存在就报错。另外字典不允许同一个键出现两次，如果出现两次，后一次的键就会被记住，前面的就没了。

3. 内置方法;fromkeys() 创建并返回一个新的字典，有两个参数，第一个是键，第二个值是可选的，默认时None。dict1.fromkeys((1,2,3),('a','b','c')) >>dict1={1:('a','b','c'),2:('a','b','c'),3:('a','b','c')}fromkeys()只能赋一个值，而且不能用来修改，只能创建一个新的字典。

4. 访问字典：keys() 返回字典的键，values() 返回指定的值，items（） 返回项，当索引不在字典中时就会报错。

5. get（key，default） 当键不在时，就不会报错返回none，如果希望返回其他值，设置第二个参数。dect.get(1,没有撒）。另外如果不知道一个键是否在字典中，可以使用成员资格操作符（in/not in )

6. clear() 清空字典
   copy() 拷贝整个字典 注意与 dict1 = dict2（只是把对对象的引用拷贝去了，如果dict1改变了，dict2也会跟着改变） 这种拷贝时不一样的。 dict2 = dict1.copy() dict2就是独立的了
   pop(key,default)和popitem() pop()是给定键弹出对应值，popitem（）是随机弹出一个项，并删除。
   setdafault(key,default) 跟get()差不多，区别是在字典中找不到对应的键时会自动添加。
   update() 更新字典dict1 = {'a':1,'b':2,'c':3} dict1.update(c=5) >>dict1={'a':1,'b':2,'c':5}

7. 收集参数，两个星号（**),表示将参数打包成字典的形式。

def test(**params):
	print(params)
>>>>test(a=1,b=2,c=3,d=4)
>{'a':1,'b':2,'c':3,'d':4}

8. 字典支持无极限嵌套：一层套一层再来一层。

dict1={
	'外层1':{
		'中层1'：{'内层1'，'内层2'}
		'中层2':{'内层3','内层4'}}}

>>> dict1['外层1']
{'中层1': {'内层2', '内层1'}, '中层2': {'内层4', '内层3'}}
>>> dict1['外层1']['中层2']
{'内层4', '内层3'}

9. 一个通讯录的小程序，，，蛮好玩的

print('|--- 欢迎进入通讯录程序 ---|')
print('|--- 1：查询联系人资料  ---|')
print('|--- 2：插入新的联系人  ---|')
print('|--- 3：删除已有联系人  ---|')
print('|--- 4：退出通讯录程序  ---|')
dict1 = dict()
while True:
    user = int(input('请输入指令：'))
    if user == 4:
        break
    if user == 1:
        name = input('请输入联系人姓名：')
        if name in dict1:
            print(name + ' : ' + dict1[name])
        else:
            print('您输入的人名不在通讯录中。')
    if user == 2:
        name = input('请输入联系人姓名：')
        if name in dict1:
            print('联系人已经存在了：' + name + ' : ' + dict1[name])
            if input('是否要修改资料：YES/NO') == 'YES' or 'yes':
                dict1[name] = input('请输入用户的电话：')
        else:
            dict1[name] = input('请输入电话')
    if user == 3:
        name = input('请输入姓名：')
        if name in dict1:
            del dict1[name]
        else:
            print('不存在')
print('使用结束啦')

集合

1. 用大括号括起一堆数字但没有体现出映射关系。集合最大的特点就是唯一。num = {1,2,3,4,4,3,2,1} >>num {1,2,3,4}
   集合会自动删除重复数据，但是集合是无序的，所以不能索引元素
2. 创建集合：把元素用大括号括起来。用set() 内置函数。虽然不能去索引，但是可以用迭代去读取每个数据。 for i in num: print(i)
3. add()方法为集合添加元素，remove()方法去删除已知元素。如果希望集合跟元组一样不能随意添加删除元素，变成不可变的集合，可以用frozenset()函数set1 = frozenset({1,2,3,4,5)}

集合类型内建方法总结

集合（s）.方法名	等价符号	方法说明
s.issubset(t)	s <= t	子集测试（允许不严格意义上的子集）：s 中所有的元素都是 t 的成员
	s < t	子集测试（严格意义上）：s != t 而且 s 中所有的元素都是 t 的成员
s.issuperset(t)	s >= t	超集测试（允许不严格意义上的超集）：t 中所有的元素都是 s 的成员
s > t	超集测试（严格意义上）：s != t 而且 t 中所有的元素都是 s 的成员
s.union(t)	s | t	合并操作：s “或” t 中的元素
s.intersection(t)	s & t	交集操作：s “与” t 中的元素
s.difference	s - t	差分操作：在 s 中存在，在 t 中不存在的元素
s.symmetric_difference(t)	s ^ t	对称差分操作：s “或” t 中的元素，但不是 s 和 t 共有的元素
s.copy()		返回 s 的拷贝（浅复制）

s.updata() 可以添加元素，且参数可以是列表，元组，字典等

x=set('abcde')
y=set('bdxyz')
x-y  # 差集   difference
x|y  # xy 的并集  union
x&y # 交集   intersection
x^y # 不同时包含于xy 的值   symmetric_difference

{1,2,3} | {3,4}
{1,2,3}.union([3,4])
z=set(("Google", "Runoob", "Taobao"))
>>> z.update({1,3})
{1, 3, 'Google', 'Taobao', 'Runoob'}
>>> z.update([1,4],[5,6])  
{1, 3, 4, 5, 6, 'Google', 'Taobao', 'Runoob'}

以下方法仅适用于可变集合

s.update	s |= t	将 t 中的元素添加到 s 中
s.intersection_update(t)	s &= t	交集修改操作：s 中仅包括 s 和 t 中共有的成员
s.difference_update(t)	s -= t	差修改操作：s 中包括仅属于 s 但不属于 t 的成员
s.symmetric_difference_update(t)	s ^= t	对称差分修改操作：s 中包括仅属于 s 或仅属于 t 的成员
s.add(obj)		加操作：将 obj 添加到 s
s.remove(obj)		删除操作：将 obj 从 s 中删除，如果 s 中不存在 obj，将引发异常
s.discard(obj)		丢弃操作：将 obj 从 s 中删除，如果 s 中不存在 obj，也没事儿_
s.pop()		弹出操作：移除并返回 s 中的任意一个元素
s.clear()		清除操作：清除 s 中的所有元素

注：

1. s .update( “字符串” ) 与 s.update( {“字符串”} ) 含义不同:
   s.update( {“字符串”} ) 将字符串添加到集合中，有重复的会忽略。
   s.update( “字符串” ) 将字符串拆分单个字符后，然后再一个个添加到集合中，有重复的会忽略。

集合的作用

1. 过滤重复项，尽管会重新排序，但是在转换回来就好。提取列表，字符串和其他可迭代对象中的差异。
2. 通过转换成集合，借助集合进行顺序无关的等价测试。就像比较程序的输出，'spamp == 'asmp','set('spam') ==set('asmp'), sorted('spam')==sorted('asmp')# 排序 >>>(False,True,True）
3. 当你历遍一个图或其他有环结构，集合可以用于记录以访问的位置。就像对传递性模块重载和继承树打印，使用列表效率是低的。
4. 当处理较大的数据集（数据库的查询结果），两个集合交集就包含了所有共有对象。