一、字典(dict)
字典是另一种可变容器模型，且可存储任意类型对象。
字典的每个键值 key=>value 对用冒号 : 分割，每个对之间用逗号(,)分割，整个字典包括在花括号 {} 中 ,格式如下所示：
d ={key1 :,:,:}
字典的特性：
1) 字典是没有顺序的，是任意对象的无序集合。
2) 字典的键是唯一的，不能多次出现，多次出现时取最后一个值。
3) 字典中的值可以取任意数据类型，但键只能使用不可变类型(字符串、数字或元组)。
4) 字典中的元素可增删。
5) 因为没有顺序，所以不存在索引。
# 创建空字典
my_dict = {}
# 创建非空字典
person = {"name": "张三", 'age': 18}
或
person = dict({"name": "张三", 'age': 18})dict
一、增加
字典中的键是唯一的，增加元素就是直接通过键值对进行添加
students = {"1000": "张三", '1001': "susan", "1002": "lily", "1003": "李四"}
students[1004] = "哈哈"
print(students)View Code
二、修改
修改已有键/值对，新的值会替代原有的值
students = {"1000": "张三", '1001': "susan", "1002": "lily", "1003": "李四"}
students[1001] = "赵四"
print(students)View Code
三、删除
删除指定键值对，del 字典[key]
删除指定键值对并返回被删除的值，字典.pop(key)
删除字典中的最后一对键和值,并以元组的形式返回，字典.popitem()
清空字典，字典.clear()
删除字典，del 字典名
students = {"1000": "张三", '1001': "susan", "1002": "lily", "1003": "李四"}
# del students['1001'] # 删除字典中指定的键和值，{'1000': '张三', '1002': 'lily', '1003': '李四'}
# name = students.pop("1001") # 删除字典中指定的键和值，并返回被删除的值{'1000': '张三', '1002': 'lily', '1003': '李四'}
# print(name) # susan
# name =students.popitem() #删除字典中的最后一对键和值 {'1000': '张三', '1001': 'susan', '1002': 'lily'},并以元组的形式返回:
# print(name) # ('1003', '李四')
# students.clear() # 清空字典{}
print(students)
# del students #删除整个字典
# students.pop("1005") # 删除不存在的键值对，会报异常KeyError: '1005'View Code
四、查找
students = {"1000": "张三", '1001': "susan", "1002": "lily", "1003": "李四"}
# print("1000" in students) # 判断字典中的值是否存在，True
# name= students["1001"] # 根据键取值，若键不存在报错 KeyError
# name = students.get("1001") # 使用get取值，若键不存在则返回None
# name = students.get("1005","lala") # 使用get取值，若键存在则返回对应的值，若键不存在则返回指定的值lala
# print(name)View Code
五、内置函数
len(dict) 计算字典元素个数，即键的总数。
str(dict) 输出字典可打印的字符串表示。
type(dict) 返回输入的变量类型，如果变量是字典就返回字典类型
students = {"1000": "张三", '1001': "susan", "1002": "lily", "1003": "李四"}
print(len(students)) # 计算字典元素个数 4
print(str(students)) # 输出字典可打印的字符串表示 {'1000': '张三', '1001': 'susan', '1002': 'lily', '1003': '李四'}
print(type(students)) # 返回输入的变量类型，如果是变量是字典类型就返回字典类型 <class 'dict'>View Code
六、常用方法
clear | 清空字典内容 |
get | 获取指定键对应值 |
items | 返回包含对象中所有变量及其值的2元组的列表 |
keys | 返回对象中所有键的元组形式 |
values | 返回对象中所有值的元组形式 |
pop | 如果键在字典中，则移除它并返回其值，否则返回默认值。如果未给定默认值且键不在字典中，则会引发键错误。 |
students = {"1000": "张三", '1001': "susan", "1002": "lily", "1003": "李四"}
teachers = {"T001":"王老师","T002":"张老师","T003":"李老师",}
seq = ('Name','Age','class')
students.update(teachers) # 字典合并{'1000': '张三', '1001': 'susan', '1002': 'lily', '1003': '李四', 'T001': '王老师', 'T002': '张老师', 'T003': '李老师'}
students2 = students.copy() #返回一个字典的浅复制 {'1000': '张三', '1001': 'susan', '1002': 'lily', '1003': '李四'}
print(students)
print(students.fromkeys(seq,2)) # fromkeys() 函数用于创建一个新字典，以序列 seq 中元素做字典的键，value 为字典所有键对应的初始值,{'Name': 2, 'Age': 2, 'class': 2}
print(students.items()) #以列表返回可遍历的(键, 值) 元组数组,dict_items([('1000', '张三'), ('1001', 'susan'), ('1002', 'lily'), ('1003', '李四')])
print(students.keys()) #以列表返回一个字典所有的键,dict_keys(['1000', '1001', '1002', '1003'])
print(students.values()) #以列表返回字典中的所有值,dict_values(['张三', 'susan', 'lily', '李四'])View Code
遍历字典
students = {"1000": "张三", '1001': "susan", "1002": "lily", "1003": "李四"}
#方法1
for key in students:
print(key,students[key]) #打印key和value的值，推荐使用这种方式，速度快
#方法2
for k,v in students.items(): #会先把dict转成list,这种方式不推荐，因为会把字典转换成列表，效率不高,数据量大时莫用
print(k,v)View Code
字典排序（sorted）
# 排序 sorted
students = {"1000": "张三", '1001': "susan", "1002": "lily", "1003": "李四"}
print('排序：',sorted(students)) #默认按键排序 ['1000', '1001', '1002', '1003']
name = sorted(students.values()) #values排序, ['lily', 'susan', '张三', '李四']
print(name)
dict1 = sorted(students.items()) #key,value默认按key排序,[('1000', '张三'), ('1001', 'susan'), ('1002', 'lily'), ('1003', '李四')]
print(dict1)
dict1 = sorted(students.items(),key=lambda item:item[1]) #按value排序,[('1002', 'lily'), ('1001', 'susan'), ('1000', '张三'), ('1003', '李四')]
print(dict1)View Code
二、集合(set)
集合（set）是一个无序的不重复元素序列。可以使用大括号 { } 或者 set() 函数创建集合，格式为：parame ={value01,value02,...} 或者 parame = set(value)
注意：创建一个空集合必须用{ }，因为 { } 是用来创建一个空字典。
# 创建集合
# 1、直接创建
set1 = {1,2,3,2} #创建一个数值集合,自动去重{1, 2, 3}
# 2、使用set()函数强制类型转换创建，my_set = set(iteration)，iteration是一个可迭代对象，它可以是元组、列表或range对象
set1 = set([3,5,9,10]) #创建一个数值集合
set1 = set('hello world') #创建一个唯一字符的集合 ,{'e', 'w', ' ', 'd', 'l', 'o', 'r', 'h'}
print(set1)set
元素有以下几个特性：
1) 无序性，集合中保存的元素是没有顺序的。
2) 多样性，集合中可以保存多种数据类型的元素。
3) 唯一性，集合中的元素都是唯一存在的，不会重复出现。
一、增加
s.add()，将元素 x 添加到集合 s 中，如果元素已存在，则不进行任何操作。
s.update()，添加多个元素，且参数可以是列表，元组，字典等，x 可以有多个，用逗号分开
name = {"张三","李四","王五","susan","lily"}
name.add("xiaowang") # 添加一项 {lily', 'susan', '张三', '李四', 'xiaowang', '王五'}
name.update(["xiaohong","xiaolan"]) # 添加列表{'张三', 'susan', '李四', 'lily', '王五', 'xiaohong', 'xiaolan'}
name.update(('pear','apple')) # 添加元组{'李四', 'pear', 'apple', '张三', 'susan', 'lily', '王五'}
name.update([1,2],[3,4]) # 添加多项{'李四', 1, 2, 3, 4, '王五', 'susan', 'lily', '张三'}
print(name)View Code
二、删除
s.remove()，将元素 x 从集合 s 中移除，如果元素不存在，则会发生错误
s.discard()，将元素 x 从集合 s 中移除，如果元素不存在，不会发生错误
s.pop()，随机删除集合中的一个元素，删除的为集合的左面第一个元素，并返回
s.clear()，清空集合
del s ，删除集合
name = {"张三","李四","王五","susan","lily"}
name.remove("王五") # 删除指定元素 王五{'李四', '张三', 'lily', 'susan'}
name.discard("haha") # 删除不存在的元素不会报错， {'李四', '张三', 'lily', 'susan'}
s = name.pop() # 随机删除集合最左面的第一个元素，并返回 {'李四', 'lily', '王五', 'susan'} , 张三
print(s)
name.clear() # 清空集合, set()
print(name)
del name # 删除集合View Code
三、常用方法
in、not in，快速判断元素是否在集合内
len(s)，集合的长度，即元素的个数
s.copy() ，复制
name = {"张三","李四","王五","susan","lily"}
print( "张三" in name ) # True
print( "张三" not in name ) # False
name1 = name.copy() # 复制{'lily', 'susan', '李四', '张三', '王五'}
# print(name1)
print(len(name)) # 集合中元素的个数，5View Code
四、集合的运算（交集、并集和差集）
& 运算符 或者 intersection()方法，交集
| 运算符 或者 union()()方法，并集
- 运算符 或者 difference()()方法，差集
^ 运算符 或者 symmetric_difference()方法，两个集合不重复的元素
s.isdisjoint()，判断两个集合是否包含相同的元素，如果没有返回 True，否则返回 False。
<= 运算符 或者 s.issubset()，判断指定集合是否为该方法参数集合的子集
>= 运算符 或者 s.issuperset，判断该方法的参数集合是否为指定集合的子集
A = {'数学','语文','英语','物理','化学','生物'}
B = {'数学','语文','英语','政治','地理','历史'}
# 1、交集 &运算符 或者 intersection()方法
# intersection_update() 方法不同于 intersection() 方法，
# intersection() 方法是返回一个新的集合，
# intersection_update() 方法是在原始的集合上移除不重叠的元素。
print( A & B ) # 集合A和B中同时存在的元素 {'语文', '数学', '英语'}
print( A.intersection(B) ) # 集合A和B中同时存在的元素 {'语文', '数学', '英语'}
A.intersection_update(B) # 集合A和B中同时存在的元素 {'语文', '数学', '英语'}
print(A)
# 2、并集 |运算符 或者 union()方法
print( A | B ) # 集合A或者B中包含的所有元素 {'化学', '数学', '语文', '地理', '英语', '物理', '历史', '政治', '生物'}
print( A.union(B) ) # 集合A或者B中包含的所有元素 {'化学', '数学', '语文', '地理', '英语', '物理', '历史', '政治', '生物'}
# 3、差集 -运算符 或者 difference()方法
# difference_update() 方法与 difference() 方法的区别在于
# difference() 方法返回一个移除相同元素的新集合，
# difference_update() 方法是直接在原来的集合中移除元素，没有返回值。
print( A - B ) # 包含集合A而不包含集合B中的元素 {'化学', '生物', '物理'}
print( A.difference(B) ) # 包含集合A而不包含集合B中的元素 {'化学', '生物', '物理'}
A.difference_update(B) # 包含集合A而不包含集合B中的元素 {'化学', '生物', '物理'}
print(A)
# 4、两个集合不重复的元素 ^ 运算符 或者 symmetric_difference()方法
# symmetric_difference() 方法与 difference() 方法的区别在于
# symmetric_difference() 方法返回两个集合中不重复的元素集合，
# symmetric_difference_update() 移除当前集合中在另外一个指定集合相同的元素，并将另外一个指定集合中不同的元素插入到当前集合中。
print( A ^ B ) # 返回A、B两个集合中不重复的元素集合 {'历史', '政治', '物理', '生物', '化学', '地理'}
print( A.symmetric_difference(B) ) # 返回A、B两个集合中不重复的元素集合 {'历史', '政治', '物理', '生物', '化学', '地理'}
A.symmetric_difference_update(B) # 返回A、B两个集合中不重复的元素集合 {'历史', '政治', '物理', '生物', '化学', '地理'}
print(A)
# 5、判断两个集合是否包含相同的元素 isdisjoint()()方法
print( A.isdisjoint(B) ) # 判断两个集合是否包含相同的元素，有交集-False，无交集-True
# 6、判断指定集合是否为该方法参数集合的子集 运算符<= 或者 issubset()方法
print( A.isdisjoint(B) ) # 判断集合A是否为集合B的子集 ，是子集-True，不是子集-Flase
print( A <= B ) # 判断集合A是否为集合B的子集 ，是子集-True，不是子集-Flase
# 7、判断该方法的参数集合是否为指定集合的子集 运算符>= 或者 issuperset()方法
print( A.issuperset(B) ) # 判断集合B是否为集合A的子集 ，是子集-True，不是子集-Flase
print( A >= B ) # 判断集合B是否为集合A的子集 ，是子集-True，不是子集-FlaseView Code
