第四天学习——字典与集合

字典

简介

假如要统计学生信息，包括学号、姓名、年龄等，如果使用列表，多名学生就要嵌套，要查看信息就要循环遍历，十分麻烦，这时就可以考虑使用字典。字典dict()是列表意外python中使用最灵活的内置数据类型，使用{}包裹。

• 可变的
• 无序的
• key对应value，用冒号“:”连接，两者组成一个元素
• key不可重复
• 字典通过key来访问元素

基本格式

dict1={key1:value1,key2:value2,...,keyn,valuen}

value可以取任意数据类型，但key不可以，必须为不可变数据类型，即key必须可哈希。

可哈希—>不可变

不可哈希—>可变

基本操作

(1)创建

空字典

dict1={}
dict2=dict()
print(type(dict1),type(dict2))
#<class 'dict'> <class 'dict'>

多元素

dict1={'id':3280293,'name':'jono','age':18}
print(type(dict1),dict1)
#<class 'dict'> {'id': 3280293, 'name': 'jono', 'age': 18}

强转

dict1=dict(id=21646,name='Tom',age=18)
print(type(dict1),dict1)
key=('id','name','age')
vaule=(21646,'Tom',18)
dict2=dict(zip(key,vaule))
print(type(dict2),dict2)
#<class 'dict'> {'id': 21646, 'name': 'Tom', 'age': 18}
#<class 'dict'> {'id': 21646, 'name': 'Tom', 'age': 18}

通过字典的fromkeys方法创建字典

格式

dict.fromkeys(seq,value=None)

• 创建并返回一个字典
  • 以seq中的元素作为该字典的key
  • value的值作为该字典中所有的key对应的初始值，若不提供默认为None

dict1=dict.fromkeys(['Tom','Jack','Lucy'],666)
print(dict1)
#{'Tom': 666, 'Jack': 666, 'Lucy': 666}

(2)增

• 直接添加键值对,
  • 若不存在该键，则增加一个键值对
  • 若存在，则会更新该键对应值

dict1={}
dict1['key1']='vaule1'
print(dict1)
#{'key1': 'vaule1'}

小测试：输入多个学生的学号、姓名、年龄，保存成字典，并存在list内

list1 = []
while 1:
    id = int(input('请输入你的学号：'))
    name = input('请输入你的姓名：')
    age = int(input('请输入你的年龄：'))
    dict1 = {'id': id, 'name': name, 'age': age}
    list1.append(dict1)
    x = input("是否要继续，其余任意键继续，输入q退出:")
    if x == 'q':
        break
print(list1)

• dict2.update(dict1)

  把字典dict1中的键值对更新到dict2中

  • 两个字典的键完全不同，则将dict1的键值对全部添加到dict2中
  • 若存在相同的键，则更新dict1中对应的值

dict1={'Job':'IT','hobby':'Read'}
dict2={'name':'jack','hobby':'Swim'}
dict3={'id':123,'name':'Tom','age':18}
dict1.update(dict2)
print(dict1)
dict1.update(dict3)
print(dict1)
#{'Job': 'IT', 'hobby': 'Swim', 'name': 'jack'}
#{'Job': 'IT', 'hobby': 'Swim', 'name': 'Tom', 'id': 123, 'age': 18}

(3)删

• dict.pop
  • 格式：dict.pop(key,defalut)
    • 如果key存在于dict中，删除并返回dict[key]
    • 若不存在，给出默认值则返回默认值，若没给默认值，则报错
  • dict.popitem会随机删除一个key,但是字典本身无序，会默认删除可视的最后一个key

dict1={'id':123,'name':'Tom','age':18}
print(dict1.pop('id'，852))
print(dict1.pop('bs'，1256))
print(dict1)
#123  #因为已存在的key，会返回key对应值
#1256 #因为字典中没有'bs'key,会返回后面的默认值，若没有默认值则报错
#{'name': 'Tom', 'age': 18}
dict1={'id':123,'name':'Tom','age':18}
print(dict1.popitem())
print(dict1)
#('age', 18)#无论多少次都是删除我们看到的最后一个key
#{'id': 123, 'name': 'Tom'}

• del dict[key]

dict1={'id':123,'name':'Tom','age':18}
del dict1['id']#如果是del dict1,是删除dict1变量
print(dict1)
#{'name': 'Tom', 'age': 18}

• clear()

dict1={'id':123,'name':'Tom','age':18}
dict1.clear()
print(dict1)
#{}  #清除字典

(4)改

• 直接修改

dict1={'id':123,'name':'Tom','age':18}
dict1['id']=1548#直接对已存在的键值对进行修改
print(dict1)
#{'id': 1548, 'name': 'Tom', 'age': 18}

• dict.setdefault()
  • 键存在，不改动，返回字典中的值
  • 不存在，在字典中添加相应的键值对，并返回对应的值

dict1={'id':123,'name':'Tom','age':18}
print(dict1.setdefault('name','Jack'))
print(dict1)
print(dict1.setdefault('money',5000))
print(dict1)
#Tom
#{'id': 123, 'name': 'Tom', 'age': 18}
#5000
#{'id': 123, 'name': 'Tom', 'age': 18, 'money': 5000}

(5)查

字典值的访问

• 通过key访问

dict1={'id':123,'name':'Tom','age':18}
print(dict1['id'])#若输入已存在的key，返回对应值，若不存在，会报错
print(dict1['isd'])
# 123  
# KeyError: 'isd'

• dict.get()
  • 语法格式：dict.get(key,defalut)

dict1={'id':123,'name':'Tom','age':18}
print(dict1.get('id'))#输入已存在的key，返回对应，不存在则返回defalut
print(dict1.get('isd'))#若没有输入defalut，则返回None
#123
#None

(6)遍历

dict1={'id':123,'name':'Tom','age':18}
print(dict1.keys())
print(dict1.values())
print(dict1.items())
for key in dict1:
    print(key,":",dict1[key],end=' ')
#dict_keys(['id', 'name', 'age'])
#dict_values([123, 'Tom', 18])
#dict_items([('id', 123), ('name', 'Tom'), ('age', 18)])
#id : 123 name : Tom age : 18 

集合

• 无序
• 不可重复
• 不可更改
  • 集合本身是可变的
  • 内部的元素是不可变

用途：

• 去重(列表---->集合，自动去重)
• 关系测试

(1)创建

• 空

set1=set()
print(type(set1))
#<class 'set'>
#如果像单独set={},因为字典也是{},会优先创建字典

• 单元素

set1={1}
print(type(set1))
#<class 'set'>

• 多元素

set1={1,2,3,4,6,5}
print(type(set1))
#<class 'set'>

• 强转

dict1={'Job':'IT','hobby':'Read'}
set1=set(dict1)
print(type(set1),set1)
#<class 'set'> {'hobby', 'Job'}
list1=[1,2,3,5,6]
set1=set(list1)
print(type(set1),set1)
#<class 'set'> {1, 2, 3, 5, 6}
str1='1245'
set1=set(str1)
print(type(set1),set1)
#<class 'set'> {'2', '4', '5', '1'}#无序，顺序是会改变的

(2)增

• set.update()

set1={1,2,3,4,6,5}
set1.update('563')#update不能添加int类型，且会将字符串中的数据切开依次加入集合
print(set1)
#{1, 2, 3, 4, 5, 6, '5', '3', '6'}

• set.add()

set1={1,2,3,4,6,5}
set1.add(94)#add可以添加int类型，会完整的加入集合
print(set1)
#{1, 2, 3, 4, 5, 6, 9}

(3)删

• set.pop()不输入默认删除，排序最小的数(按ASCII码)

set1={1,2,3,4,6,5}
set1.pop()
print(set1)
#{2, 3, 4, 5, 6}

• del

set1={1,2,3,4,6,5}
del set1     #删除了set1
print(set1)
#NameError: name 'set1' is not defined

• clear

set1={1,2,3,4,6,5}
set1.clear()
print(set1)
#set()

• remove

set1={1,2,3,4,6,5}
set1.remove(1)
print(set1)
#{2,3,4,6,5}

(4)不可改/查

(5)遍历

set1={1,2,3,'s','f','a','b',4,6,5}
for i in set1:
    print(i,end=' ')
for k in enumerate(set1):
    print(k,end=' ')
#f 1 2 3 s a 4 6 5 b   
#(0, 1) (1, 2) (2, 3) (3, 4) (4, 5) (5, 6) (6, 'f') (7, 's') (8, 'b') (9, 'a') 

(6)子集

a = set("abcd")
b = set("cdef")
c = set("abc")
print(a, b, c)
#{'1', '3', '2', '4'} {'5', '3', '4', '6'} {'1', '3', '2'}
print(c.issubset(a))
#True
print(c < a)
#True
print(c < b)
#False
print(a > c)
#True

(7)交集

a = set("12345")
b = set("3456")
print(a.intersection(b))
#{'3', '4'}
print(a & b)
#{'3', '4'}
print(a.intersection(b))
#{'3', '4'}

(8)并集

a = set("1234")
b = set("3456")
print(a.union(b))
print(a|b)
#{'6', '3', '1', '5', '4', '2'}
#{'6', '3', '1', '5', '4', '2'}

(9)差集

a = set("1234")
b = set("3456")
print(a.difference(b))
print(a - b)
#{'2', '1'}
#{'2', '1'}