python合集（5）------------集合与字典

1.集合

• 集合（set）是一个无序的不重复元素序列

1.1集合的创建

1). 使用大括号 { } 或者 set() 函数创建集合;
2). 创建一个空集合必须用 set() 而不是 { } ； { } 是用来创建一个空字典
3). 集合的元素必须时不可变数据类型。

s = {1,1,2,4,2,4} 
print(s, type(s)) #{1, 2, 4} <class 'set'> ,集合（set）的去重本质
s1 = {} 
print(s1, type(s1)) #{} <class 'dict'>  #字典（dict）
s2 = set{}
print(s2, type(s2)) #set() <class 'set'>

1.2. 集合的特性

不支持+,*, index, slice(集合的无序不重复特性);支持in和not in
print(2 in {1, 2, 3, 4})  #Truede
print(2 not in {1, 2, 3, 4}) #False

1.3. 集合的常用操作

1.3.1 增加

**add: 添加单个元素
update: 添加多个元素**
set = {9,8,7}
set.add(10)
print(set) # {8, 9, 10, 7}
set1 = {9,8,7}
set1.update({10,11,12})
print(set1) #{7, 8, 9, 10, 11, 12}

1.3.2 删除

 **remove: 如果元素存在，删除，否则报错**
 **discard: 如果元素存在，删除，否则do nothing**
 **pop: 随机**
 **注：删除元素，集合为空则报错**
set = {10,9,8,7}
set.remove(10)
print(set)    #{8, 9, 7}

set1 = {9,8,7,10,11,12}
set1.discard(10)
print(set1)   #{7, 8, 9, 11, 12}

set2 = {5,56,55,89}
set2.pop()
print(set2)   #{89, 5, 55}

1.3.3查看

 差集: s1 - s2
 交集: s1 & s2
 对称差分: s1 ^ s2
 并集: s1 | s2
set1 = {9,8,7,10,11,12}
set2 = {9,8,7}
print(set1-set2) #{10, 11, 12}
print(set2&set1) #{8, 9, 7}
print(set2^set1) #{10, 11, 12}
print(set2 | set1) #{7, 8, 9, 10, 11, 12}
print(set1.issubset(set2))  # False
print(set1.isdisjoint(set2)) # False

1.3.4 frozenset

frozenset(set的不可变版本，支持set不改变集合本身的方法) 的作用主要有两点：
当集合元素不需要改变时，使用 frozenset 代替 set 更安全。
当某些 API 需要不可变对象时，必须用 frozenset 代替set。比如 dict 的 key 必须是不可变对象，因此只能用 frozenset；再比如 set 本身的集合元素必须是不可变的，因此 set 不能包含 set，set 只能包含 frozenset。

s = frozenset({1, 2, 3})
print(s, type(s)) #frozenset({1, 2, 3}) <class 'frozenset'>

2.字典

• 一种可变容器模型，且可存储任意类型对象。 键一般是唯一的，如果重复最后的一个键值对会替换前面的，值不需要唯一
  

2.1 字典的创建dict

d = {'name':'westos', 'age':18, 'city':'西安'}
print(d, type(d))  #{'name': 'westos', 'age': 18, 'city': '西安'} <class 'dict'>
d1 = {} #空字典
print(d1, type(d1)) #{} <class 'dict'>

2.2. 字典的特性

# 不支持+,*, index, slice(同集合)
# 支持in和not in
d = {"name":"westos", "age":18, "city":"西安"}
print('name' in d)  # True， 判断是否为所有key值得成员
print("westos" not in d) # False

2.3. 字典的常用方法

2.3.1查看

查看所有 keys, values, items
查看局部 d[key], d.get(key), d.get(key, default-value)

d = {'name':'卡维尔', 'age':22,'天赋':'控水' ,'种族':'亚特兰蒂斯'}
print(d, type(d))
print(d.keys())	# 查看字典所有的key值
print(d.values())	# 查看字典所有的value值
print(d.items())	# 查看字典所有的key-value值(item元素)
print(d['name'])	# 查看key为name对应的value值
#print(d['wife'])	# 查看key对应的vlaue值，如果不存在会报错。
print(d.get('wife'))# 查看key对应的vlaue值， 如果存在则返回，如果不在在则返回None.
print(d.get('wife', "大表姐"))	# 查看key对应的vlaue值， 如果存在则返回，如果不在在则返回默认值.
输出：
D:\python\python.exe C:/Users/萧然之雪/PycharmProjects/pythonProject/6-21/字典.py
{'name': '卡维尔', 'age': 22, '天赋': '控水', '种族': '亚特兰蒂斯'} <class 'dict'>
dict_keys(['name', 'age', '天赋', '种族'])
dict_values(['卡维尔', 22, '控水', '亚特兰蒂斯'])
dict_items([('name', '卡维尔'), ('age', 22), ('天赋', '控水'), ('种族', '亚特兰蒂斯')])
卡维尔
None
大表姐

2.3.2删除

d = {'name':'卡维尔', 'age':22,'天赋':'控水' ,'种族':'亚特兰蒂斯'}
d.pop('age')
print(d)
del d['name']
print(d)
输出：
{'name': '卡维尔', '天赋': '控水', '种族': '亚特兰蒂斯'}
{'天赋': '控水', '种族': '亚特兰蒂斯'}

2.3.3增加，修改

d = {'name':'卡维尔', 'age':22,'天赋':'控水' ,'种族':'亚特兰蒂斯'}
d['wife'] = '大表姐' #key不存在则添加
print(d)
d['wife'] = '斯嘉丽' #key存在则修改
print(d)
d.setdefault('武器','三叉戟') #key不存在则添加
print(d)
d.setdefault('武器','石中剑') #key存在则不进行操作
print(d)
输出：
{'天赋': '控水', '种族': '亚特兰蒂斯', 'wife': '大表姐'}
{'天赋': '控水', '种族': '亚特兰蒂斯', 'wife': '斯嘉丽'}
{'天赋': '控水', '种族': '亚特兰蒂斯', 'wife': '斯嘉丽', '武器': '三叉戟'}
{'天赋': '控水', '种族': '亚特兰蒂斯', 'wife': '斯嘉丽', '武器': '三叉戟'}

2.3.4遍历

for item  in d: #默认情况，字典只遍历key值
    print(item）
输出：
天赋
种族
wife
武器
for key,value in d.items(): #进阶，遍历字典的key和value
    print(f"key={key}, value={value}")
输出:
key=天赋, value=控水
key=种族, value=亚特兰蒂斯
key=wife, value=斯嘉丽
key=武器, value=三叉戟``

2.4.defaultdict

• defaultdict 提供default_factory 属性，该为不存在的 key 来自动生成生成默认的 value

from collections import  defaultdict

# 默认字典，设置默认value
d = defaultdict(int)
d['sss'] += 1
d['xxx'] += 1
print(d)  #defaultdict(<class 'int'>, {'sss': 1, 'xxx': 1})

d = defaultdict(list)
d['allow_users'].append('westos')
d['deny_users'].extend(['lee', 'root'])
print(d)  #{'allow_users': ['westos'], 'deny_users': ['lee', 'root']})

3.内置数据结构总结

可变和不可变

可变数据类型: list, set, dict
可以增删改。可变数据类型，允许变量的值发生变化，即如果对变量进行append、+=等这种操作后，只是改变了变量的值，而不会新建一个对象，变量引用的对象的地址也不会变化，不过对于相同的值的不同对象，在内存中则会存在不同的对象，即每个对象都有自己的地址，相当于内存中对于同值的对象保存了多份，这里不存在引用计数，是实实在在的对象。

不可变数据类型: 数值类型，tuple, str
不可以增删改。python中的不可变数据类型，不允许变量的值发生变化，如果改变了变量的值，相当于是新建了一个对象，而对于相同的值的对象，在内存中则只有一个对象，内部会有一个引用计数来记录有多少个变量引用这个对象。

4.测试

测试1

问题描述：
有一个列表，其中包括 10 个元素，例如这个列表是[1,2,3,4,5,6,7,8,9,0],要求将列表中的每个元素一次向前移动一个位置，第一个元素到列表的最后，然后输出这个列表。最终样式是[2,3,4,5,6,7,8,9,0,1]

list = [1,2,3,4,5,6,7,8,9,0]
list.append(list.pop(0))
print(list)
[2, 3, 4, 5, 6, 7, 8, 9, 0, 1]

测试2

• 随机生成n个1-1000之间的数，并排序

import random
n = int(input("please input n:"))
s=set()
for i in range(n):
  s.add(random.randint(1,1000))
print(sorted(s,reverse=True))