字典的性质和集合

1.字典

1.1 字典的增删改

1.增、改
字典[key] =值 - 当key存在的时候是修改key对应的值，当key不存在的时候添加键值对

dog = {'name':'旺财','age':3,'breed':'土狗'}
print(dog)  # {'name': '旺财', 'age': 3, 'breed': '土狗'}
dog['gender'] = '公狗'
print(dog)  # {'name': '旺财', 'age': 3, 'breed': '土狗', 'gender': '公狗'}
dog['breed'] = '中华田园犬'
print(dog)  # {'name': '旺财', 'age': 3, 'breed': '中华田园犬', 'gender': '公狗'}

2.删

1.del 字典[key] 删除字典中指定的key对应的键值对

dog = {'name': '旺财', 'age': 3, 'breed': '中华田园犬', 'gender': '公狗'}
del dog['gender']
print(dog)  # {'name': '旺财', 'age': 3, 'breed': '中华田园犬'}

2.字典.pop(key) - 取出字典中指定key对应的值

result = dog.pop('age')
print(dog,result)     # {'name': '旺财', 'breed': '中华田园犬'} 3

1.2 字典的相关操作

1.字典不支持加法和乘法、比较大小（只支持比较相等的运算）

2.in 和not in – 判断字典中是否存在指定的key

3)dict,len

print('a' in {'name':'a','age':12})  # False
print('name' in {'name':'a','age':12})  # True

dict(数据) - 将数据转换成字典
a.数据必须是序列
b.序列中的元素必须是小序列，而且小序列有且只有两个元素，第一个元素必须是不可变的

list1 = [(10,20),'ab',range(2)]
print(list1)  # [(10, 20), 'ab', range(0, 2)]
dog = {'name': '旺财', 'age': 3, 'breed': '中华田园犬', 'gender': '公狗'}
result = list(dog)   # 只转换key，不转换值
print(result)  # ['name', 'age', 'breed', 'gender']
print(len(dog))  # 4

1.3字典的推导式

1.{表达式1：表达式2 for 变量 in 序列}
2.{表达式1：表达式2 for 变量 in 序列 if 条件语句}
3.dict(表达式 for x in 序列） - 表达式必须是有且只有两个元素，第一个元素必须是不可变的

result = {x : x**2 for x in range(3)}
print(result)  # {0: 0, 1: 1, 2: 4}
result = {x:None for x in ['name','age','gender']}
print(result)  # {'name': None, 'age': None, 'gender': None}
result = {x: x//2 for x in range(11,20) if x % 2 ==0}
print(result)   # {12: 6, 14: 7, 16: 8, 18: 9}
dog = {'name': '旺财', 'age': 3, 'breed': '中华田园犬', 'gender': '公狗'}
result = {dog[x]:x for x in dog}  # {'旺财': 'name', 3: 'age', '中华田园犬': 'breed', '公狗': 'gender'}
print(result)
result = dict((dog[x],x) for x in dog)
print(result)    # {'旺财': 'name', 3: 'age', '中华田园犬': 'breed', '公狗': 'gender'}

1.4字典的相关方法

1)字典.clear() - 清空字典

dog = {'旺财': 'name', 3: 'age', '中华田园犬': 'breed', '公狗': 'gender'}
dog.clear()
print(dog) # {}

2)字典.copy() - 复制字典产生一个一模一样的新字典(跟列表的复制与赋值的性质相似）

dog = {'旺财': 'name', 3: 'age', '中华田园犬': 'breed', '公狗': 'gender'}
dog1 =dog
print(dog1)
dog.clear()  # {'旺财': 'name', 3: 'age', '中华田园犬': 'breed', '公狗': 'gender'}
print(dog,dog1) # {} {}

3）dict.fromkeys(序列） - 创建一个字典，将序列中的所有的元素作为字典key，值默认都是None

result = dict.fromkeys(['name','age','gender',100])  # {'name': None, 'age': None, 'gender': None, 100: None}
print(result)

4. values\keys\items

字典.values() - 获取字典中所有的值；返回的不是列表是另一种序列
字典.keys() - 获取字典中所有的键 ；返回的不是列表是另一种序列
字典.items() - 获取字典中的键值对；返回的是序列，序列中的元素是每个键值对对应的元组

dog = {'name': '旺财', 'age': 3, 'breed': '中华田园犬', 'gender': '公狗'}
result = dog.values()
print(result)  # dict_values(['旺财', 3, '中华田园犬', '公狗'])
print(list(result))  # ['旺财', 3, '中华田园犬', '公狗']
print(dog.keys())  # dict_keys(['name', 'age', 'breed', 'gender'])
# 输出的结果虽然不是列表，但可以转换成列表在取出来使用
print(dog.items())  # dict_items([('name', '旺财'), ('age', 3), ('breed', '中华田园犬'), ('gender', '公狗')])
for x in dog.items():
    print(x)
for x,y in dog.items():
    print('x:',x,'y:',y)  # x取到所有的键，y取到所有的值

5)字典.setdefault(key,value) - 在字典中添加键值对（不会在key存在的时候进行修改操作）

dog.setdefault('weight',20)
print(dog) # {'name': '旺财', 'age': 3, 'breed': '中华田园犬', 'gender': '公狗', 'weight': 20}
dog.setdefault('name','来福')
print(dog)  # 如果存在，不操作

6）字典.update(序列) - 将序列中所有的元素作为键值对添加到字典中，序列必须是能转换成字典的序列。

字典1.update(字典2) - 将字典2中的键值对全部添加到字典1中

dict1 = {'a':10}
dict1.update({'b':20,'c':30})
print(dict1)  # {'a': 10, 'b': 20, 'c': 30}
dict1.update(['bc',('name','张山'),['age',100]])
print(dict1) # {'a': 10, 'b': 'c', 'c': 30, 'name': '张山', 'age': 100}

2.集合

1.什么是集合

集合是容器型数据类型；将{}作为容器的标志，元素之间用逗号隔开：{元素1，元素2，…}
集合是可变的；集合是无序的
元素：1.不可变的数据。2.元素是唯一的。

# 空集合：{}不是空集合，是空字典
set1 = {}
print(type(set1))   # <class 'dict'>
set1 = set()
print(type(set1),len(set1))  # <class 'set'> 0
# 集合是无序的
print({1,2,3} == {3,2,1})  # True
# 集合的元素必须是不可变的类型的数据
set2 = {23,'ss',(2,3)}
print(set2)  # {(2, 3), 'ss', 23}
# set3 = {23,'sd',[2,3]}
# print(set3)   # TypeError: unhashable type: 'list'
# 集合的元素是唯一的(集合有自动去重功能，但是只能去元素是不可变的序列的重)
set4 = {10,20,30,10,10}
print(set4)   # {10, 20, 30}

2.增删改查

1）查：集合只能遍历

ball = {'乒乓球','篮球','羽毛球','高尔夫','网球'}
for x in ball:
    print(x)  # 

2)增

集合.add(元素） - 在集合中添加指定元素

ball.add('足球')
print(ball)  # {'乒乓球', '羽毛球', '足球', '篮球', '高尔夫', '网球'}

集合.update(序列) - 将序列中的元素全部添加到集合中

set5 = set()
set5.update('abc')
print(set5)  # {'c', 'b', 'a'}
set5.update({'name':'小明','age':18})
print(set5)  # {'b', 'c', 'age', 'a', 'name'}

3)删

集合.remove(元素) - 删除指定元素，如果元素不存在就报错

ball.remove('高尔夫')
print(ball) # {'足球', '网球', '乒乓球', '羽毛球', '篮球'}

ball.discard(元素) - 删除指定元素，如果元素存在不报错

ball.discard('网球')
print(ball)  # {'乒乓球', '羽毛球', '足球', '篮球'}
# ball.remove('桌球')
# print(ball)   # 报错
ball.discard('桌球')
print(ball)   # 不报错

4）集合中不能直接修改元素，只能先删除在增加

3.数学集合运算：交集、并集、差集、对称差集、子集、真子集

s1 = {1,2,3,4,5,6,7,8}
s2 = {5,6,7,8,9}
# 1）交集：&
# 集合1 & 集合2   -   获取两个集合公共的部分
print(s1 & s2)  # {8, 5, 6, 7}
# 2)并集：|
print(s1 | s2)  # {1, 2, 3, 4, 5, 6, 7, 8, 9}
# 3)差集：-
# 集合1 - 集合2    -   获取集合1中但是不在集合2中的所有的元素
print(s1-s2)  # {1, 2, 3, 4}
print(s2 - s1)  # {9}
# 4)对称差集：^（相当于先求并集再减求交集）
# 集合1 ^集合2    -    获取只在集合1和只在集合2中所有的元素，不包含公共部分
print(s1^s2)  # {1, 2, 3, 4, 9}
# 5)子集和真子集
# 集合1 >= 集合2   判断集合2是否是集合1的子集
# 集合1 > 集合2    判断集合2是否是集合1的真子集
print({100,200,300}>={1,2})    # False
print({1,2,3}>={1,2})   # True

4.集合相关的操作

1）in 和 not in

2)max,min,sorted,sum,set,len

print(10 in {10,20})  # True
# 2)max,min,sorted,sum,set,len
print(max({10,23,34}))  # 34
print(sorted({23,5,13,56,34,23,5})) # [5, 13, 23, 34, 56]
print(sum({2,3,5}))  # 10
print(len({1,2,3,4,3,5}))  # 5重复的无效

3.作业

3.用三个集合表示三门学科的选课学生姓名(一个学生可以同时选多门课)
a. 求选课学生总共有多少人
b. 求只选了第一个学科的人的数量和对应的名字
c. 求只选了一门学科的学生的数量和对应的名字
d. 求只选了两门学科的学生的数量和对应的名字
e. 求选了三门学生的学生的数量和对应的名字

# set0 = {'小A','小B','小C','小D','小E','小F','小G','小H'}
chinese = {'小A','小B','小C','小D','小E','小F'}
english = {'小D','小E','小F','小G','小H'}
math = {'小B','小C','小D','小H'}
print('--------------a-------------')
print(len(chinese | english | math))
print('--------------b-------------')
result = chinese - english - math
print(result,len(result))
print('--------------c-------------')
result = (chinese - (english | math))|(english-(chinese|math))|(math-(chinese|english))
print(result,len(result))
print('--------------d-------------')
result = ((chinese| english)-math)|((chinese|math)-english)|((english|math)-chinese)
print(result,len(result))
print('--------------e------------')
result = chinese & english & math
print(result,len(result))