Python字典集合基础

Python字典集合

• • • 字典
    • • 字典的应用场景
      • 创建
      • 字典常见 *** 作
      • • 增加
        • 删除
        • • del
          • clear()
        • 修改
        • 查找
        • • key值查找
          • get()
          • keys()
          • values()
          • items()
      • 循环遍历
      • • 遍历keys
        • 遍历values
        • 遍历key-value
    • 集合
    • • 集合使用场景
      • 集合的创建
      • 集合常见 *** 作
      • • 增加
        • • add()
          • update()
        • 删除数据
        • • remove()
          • discard()
        • 查找
        • 复制
        • • copy()
        • 交并差
        • • 交(A ∩ \cap ∩B)
          • 并(A ∪ \cup ∪B)
          • 差(A-B)
        • 判断
        • • 子集
          • 父集
          • 有相同元素

字典 字典的应用场景

• 思考1： 如果有多个数据，例如：‘Tom’, ‘男’, 20，如何快速存储？

• 答：列表

list1 = ['Tom', '男', 20]

• 思考2：如何查找到数据’Tom’？

• 答：查找到下标为0的数据即可。

list1[0]

• 思考3：如果将来数据顺序发生变化，如下所示，还能用list1[0]访问到数据’Tom’吗？。

list1 = ['男', 20, 'Tom']

• 答：不能，数据’Tom’此时下标为2。

• 思考4：数据顺序发生变化，每个数据的下标也会随之变化，如何保证数据顺序变化前后能使用同一的标准查找数据呢？

• 答：字典，字典里面的数据是以键值对形式出现，字典数据和数据顺序没有关系，即字典不支持下标，后期无论数据如何变化，只需要按照对应的键的名字查找数据即可。

创建

特点：

• 符号为大括号
• 数据为键值对形式出现
• 各个键值对之间用逗号隔开

# 有数据字典
dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}

# 空字典
dict2 = {}

dict3 = dict()

• 一般称冒号前面的为键(key)；冒号后面的为值(value)。

• key须为不可变数据类型，如数字类型，字符串，元组…一般使用字符串

字典常见 *** 作 增加

dict[key]=value

• 如果key存在则修改这个key对应的值；如果key不存在则新增此键值对。

student= {'name': 'Tom', 'age': 20, 'gender': '男'}

student['name'] = 'Rose'
print(student)
# {'name': 'Rose', 'age': 20, 'gender': '男'}

student['id'] = 110
print(student)
# {'name': 'Rose', 'age': 20, 'gender': '男', 'id': 110}

删除 del

del dict
del dict[key]

• 删除字典或删除字典中指定键值对。

student= {'name': 'Tom', 'age': 20, 'gender': '男'}

del student['gender']
print(student)
# 结果：{'name': 'Tom', 'age': 20}

del student
print(student)
#报错

clear()

dict.clear()

• 清空字典,得到空字典

student = {'name': 'Tom', 'age': 20, 'gender': '男'}

student.clear()
print(student)  # {}

修改

dict[key]=value

• 如果key存在则修改这个key对应的值 value；如果key不存在则新增此键值对。

查找 key值查找

dict[key]

• 如果当前查找的key存在，则返回对应的值value；否则则报错。

student = {'name': 'Tom', 'age': 20, 'gender': '男'}
print(student['name'])  # Tom
print(student['id'])  # 报错

get()

dict.get(key, default)

• 如果当前查找的key存在，则返回对应的值；如果当前查找的key不存在则返回第二个参数(default)，如果省略第二个参数，则返回None。

如:

student = {'name': 'Tom', 'age': 20, 'gender': '男'}
print(student.get('name'))  # Tom
print(student.get('id', 110))  # 110
print(student.get('id'))  # None

keys()

dict.keys()

• 返回字典的全部keys,以dict_keys类的形式(某种序列)

student = {'name': 'Tom', 'age': 20, 'gender': '男'}
print(student.keys())  
# dict_keys(['name', 'age', 'gender'])

values()

dict.values()

• 返回字典的全部values,以dict_values类的形式(某种序列)

student = {'name': 'Tom', 'age': 20, 'gender': '男'}
print(student.values())  
# dict_values(['Tom', 20, '男'])

items()

• 返回字典的全部key和全部value,以dict_items类的形式(某种序列)

student = {'name': 'Tom', 'age': 20, 'gender': '男'}
print(student.items())  
# dict_items([('name', 'Tom'), ('age', 20), ('gender', '男')])

循环遍历 遍历keys

student = {'name': 'Tom', 'age': 20, 'gender': '男'}
for key in student.keys():
    print(key)
    
"""
name
age
gender
"""

遍历values

student = {'name': 'Tom', 'age': 20, 'gender': '男'}
for value in student.values():
    print(value)
    
"""
Tom
20
gender
"""

遍历key-value

student = {'name': 'Tom', 'age': 20, 'gender': '男'}
for item in student.items():
    print(item)
    
"""
('name','Tom')
('age',20)
('gender','男')
"""

student = {'name': 'Tom', 'age': 20, 'gender': '男'}
for key, value in student.items():
    print(f'{key} = {value}')
"""
name = Tom
age = 20
gender = 男
"""

集合 集合使用场景

• 特点:互异性,无序性
• 如果储存的数据集要求各个数据互不相同，可以考虑使用集合。

集合的创建

• 创建集合使用{}或set()， 但是如果要创建空集合只能使用set()，因为{}用来创建空字典。

var={value1,value2...}
var=set(sequence)   #sequence:序列
null_var=set()

• 特点：集合可以去掉重复数据；集合数据是无序的，故不支持下标

numset = {10, 30, 20, 10, 30, 40, 30, 50}
print(numset)
#{40,10,50,20,30}

charset = set('abbcddefg')
print(charset)
#{‘c','g','b','f','a','d','e'}

nullset = set()
print(type(nullset))  # set

nulldict = {}
print(type(nulldict))  # dict

集合常见 *** 作 增加 add()

set.add(value)

• 因为集合有去重功能，所以，当向集合内追加的数据是当前集合已有数据的话，则不进行任何 *** 作。

numset = {10, 20}
numset.add(100)
numset.add(10)
print(numset)  
# {100, 10, 20}

update()

set.update(sequence)

• 追加的数据是序列。

smallSet = {10, 20}
# smallSet.update(100)  # 报错
smallSet.update([100, 200])
smallSet.update('abc')
print(smallSet)
# {'a',100,200,10,'b','c',20}

删除数据 remove()

• 删除集合中的指定数据，如果数据不存在则报错。

numset = {10, 20}

numset.remove(10)
print(numset)
# {20}

numset.remove(10)  # 报错

discard()

• 删除集合中的指定数据，如果数据不存在也不会报错。

numset = {10, 20}

numset.discard(10)
print(numset)
# {20}

numset.discard(10)  # 无事发生，不报错

pop()

• 随机删除集合中的某个数据，并返回这个数据。

numset = {10, 20, 30, 40, 50}

luckyNum = numset.pop()
print(luckyNum)  #各种可能,但一直是某个数
print(numset)  #去掉了某个数

查找

in

• 判断数据在集合序列中( ∈ \in ∈)

not in

• 判断数据不在集合序列( ∉ \notin ∈/​)

s1 = {10, 20, 30, 40, 50}

print(10 in s1) #True
print(10 not in s1) #False

复制 copy()

• 返回一个拷贝的新集合

copyset=oldset.copy()

交并差 交(A ∩ \cap ∩B)

• 返回A、B共有的元素组成的集合

A&B
A.intersection(B)

并(A ∪ \cup ∪B)

• 返回A、B所有的元素组成的集合

A|B
A.union(B)

差(A-B)

• 返回A减去B中共有的元素后组成的集合

A.difference(B)
A-B

判断 子集

A.issubset(B)

• 判断A是否B的子集，返回True,False

父集

A.issuperset(B)

• 判断A是否是B的父集，返回True,False

有相同元素

A.isdisjoint(B)

• 判断A、B是否有相同元素，返回True,False