Python 学习第4天，续上一篇《Python基础 · 数据类型全解析（2）》^o^y
本篇详解集合、字典相关内容：
一、集合（Set）
“集合” 是无序不重复序列，性质类比数学中的 “集合” 概念。
· 无序性：同样的元素，通过不同的排列顺序列入集合中，其生成的集合相等；
· 不可重复性：一个集合中，同样的元素仅出现 1 次。
计算机在处理集合中存储的元素时，需要进行 “哈希计算”，存储的顺序按照计算所得的哈希值排列。因此，“集合” 中仅能存储可以进行哈希计算的数据类型，反之不可存储（一般来说，不可变的数据类型可以进行哈希计算，可变的数据类型是不可以进行哈希计算）。
1. 集合的生成
(1) 用 { , , ,……} 直接定义；
(2) 用 set() 直接定义一个空集合。
注意：当 变量名 = {} 的 {} 中没有任何元素时，该变量是 “字典”，而非 “集合”。
代码示例：
s_1 = {1, 2, 3, "go", ("我是", "一个元组")}
print(s_1)
print(type(s_1))
s_2 = {}
print(s_2)
print(type(s_2))
s_3 = set()
s_3.add(1)
print(s_3)
print(type(s_3))
运行结果：
{1, 2, 3, 'go', ('我是', '一个元组')}
<class 'set'>
{}
<class 'dict'>
{1}
<class 'set'>
2. 增、删、改、查
(1) 增加：
· 集合.add(需要添加的元素) ：往 “集合” 中添加元素，由于集合根据哈希值排序，一般无法指定存入位置。（注意：每次只能增加一个元素）
(2) 删除：
· 集合.pop() ：从 “集合” 中删除排在集合最末尾的元素。由于集合根据哈希值排序，删除前，一般肉眼无法确定哪一个元素会被删除；
· 集合.remove(需要删除的元素) ：根据元素的字面量指定删除 “集合” 中的元素（注意：每次只能删除一个元素）；
· 集合.clear() ：删除集合中的所有元素。
(3) 修改：’
由于 “集合” 是无序序列，无法通过索引的形式提取要修改的元素，我们可以通过 remove() 函数先指定删除想修改的元素，再用 add() 函数添加想更新进集合的函数。
(4) 查询：
通过遍历的方式查看每个元素。
代码示例：
names_1 = {"张三", "李四", "王五", "赵六"}
names_2 = {"Amy", "Tom", "Evan"}
print(names_1)
print("———————————–")
names_1.add("卢七")
print(names_1)
print("———————————–")
names_1.pop()
print(names_1)
names_1.remove(input("请输入姓名："))
print(names_1)
names_1.clear()
print(names_1)
print("———————————–")
print(names_2)
names_2.remove("Tom")
names_2.add("Green")
print(names_2)
运行结果：
{'李四', '王五', '赵六', '张三'}
———————————–
{'赵六', '卢七', '李四', '王五', '张三'}
———————————–
{'卢七', '李四', '王五', '张三'}
请输入姓名：李四
{'卢七', '王五', '张三'}
set()
———————————–
{'Amy', 'Tom', 'Evan'}
{'Amy', 'Evan', 'Green'}
3. 集合的计算
| 运算 | 格式 | 含义 |
| 交 | 集合1 & 集合2 | 将“集合1”“集合2”中都出现过的元素提取出来，组成一个新的集合。 |
| 集合1.intersection(集合2) | ||
| 并 | 集合1 | 集合2 | 将“集合1”“集合2”合并成一个集合，新集合中，重复的元素仅出现一次。 |
| 集合1.union(集合2) | ||
| 差 | 集合1 – 集合2 | 将“集合1”中出现的“集合2”的元素删除，组成一个新的集合。 |
| 集合1.difference(集合2) |
代码示例：
names_1 = {"张三", "Tom", "李四", "王五", "赵六", "Green"}
names_2 = {"Amy", "Tom", "Evan", "张三"}
print(names_1)
print(names_2)
print("———————————–")
print(names_1 & names_2)
print(names_1.intersection(names_2))
print("———————————–")
print(names_1 | names_2)
print(names_1.union(names_2))
print("———————————–")
print(names_1 – names_2)
print(names_1.difference(names_2))
运行结果：
{'赵六', '张三', 'Tom', '王五', '李四', 'Green'}
{'Amy', '张三', 'Tom', 'Evan'}
———————————–
{'张三', 'Tom'}
{'张三', 'Tom'}
———————————–
{'Amy', '王五', '李四', 'Green', '赵六', '张三', 'Tom', 'Evan'}
{'Amy', '王五', '李四', 'Green', '赵六', '张三', 'Tom', 'Evan'}
———————————–
{'赵六', '李四', '王五', 'Green'}
{'赵六', '李四', '王五', 'Green'}
二、字典（Dictionary）
“字典” 是无序 key-value 集合，即以 “键值对” 的形式存储的集合（“键” 类似于标签，“值” 就是指标签所代表的字面量）。
1. 字典的生成
(1) 用 {key1:value1, key2:value2, key3:value3. ……} 直接定义；
(2) 用 {} 直接定义一个空字典；
(3) 用 dict() 直接定义一个空字典。
注意：
(1) “键” 必须是可以进行哈希计算的数据类型，即不可变的数据类型，如数字、字符串、元组；
(2) “值” 可以是任意的数据类型。
代码示例：
students = {"001":"张三", "002":"李四", "003":"王五"}
course = {1:"语文", 2:"数学",3:"英语"}
dic_1 = {}
dic_2 = dict()
print(type(students))
print(type(course))
print(type(dic_1))
print(type(dic_2))
运行结果：
<class 'dict'>
<class 'dict'>
<class 'dict'>
<class 'dict'>
2. 增、删、改、查
(1) 增加：根据键值对的形式往一个字典中添加元素；
· 字典[键] = 值
注意：如果所添加的 “键” 在原字典中已经存在，那么在增加元素后的字典中，该 “键” 对应的值为新添加的值（由于一个字典中相同的“键”仅能出现 1 次，旧值被新值覆盖）。
· 字典.setdefault(键，值)
注意：如果如果所添加的 “键” 在原字典中已经存在（即原字典中，该 “键” 默认值），那么新的值将不会覆盖旧的值。
(2) 删除：根据具体的 “键” 删除字典中的该元素；
· 字典.pop(键)
· del 字典[键]
· 字典.clear()，清空字典
(3) 修改：可用 “增加” 中的方法对字典进行修改；
(4) 查询：通过具体的 “键” 查询其存储的 “值”
· 字典[键] ：如果 “键” 不存在，运行结果会报错；
· 字典.get(键) ：如果 “键” 不存在，运行结果返回None。
代码示例：
dic = {}
print(dic)
print("—————-")
dic["Amy"] = "草莓奶昔"
print(dic)
dic["Amy"] = "牛油果奶昔"
print(dic)
dic.setdefault("Green", "冰美式")
print(dic)
dic.setdefault("Amy", "焦糖拿铁")
print(dic)
print("—————-")
dic.pop("Amy")
print(dic)
dic["Tom"] = "伯牙绝仙"
dic["Evan"] = "芒果河粉"
print(dic)
del dic["Tom"]
print(dic)
dic.clear()
print(dic)
print("—————-")
results = {"Evan":99, "Amy":98, "Tom":80}
print(results)
print(results["Amy"])
print(results.get("Amy"))
print(results.get("Green"))
运行结果：
{}
—————-
{'Amy': '草莓奶昔'}
{'Amy': '牛油果奶昔'}
{'Amy': '牛油果奶昔', 'Green': '冰美式'}
{'Amy': '牛油果奶昔', 'Green': '冰美式'}
—————-
{'Green': '冰美式'}
{'Green': '冰美式', 'Tom': '伯牙绝仙', 'Evan': '芒果河粉'}
{'Green': '冰美式', 'Evan': '芒果河粉'}
{}
—————-
{'Evan': 99, 'Amy': 98, 'Tom': 80}
98
98
None
3. 循环与嵌套
(1) 循环：一般用于获取键值对。
代码示例：
results = {"Evan":99, "Amy":98, "Tom":80}
print(results)
print(type(results))
print("————————————-")
### 运用for循环查看字典中的键
for key in results:
print(key)
print("————————————-")
### 运用for循环查看字典中键所存储的值
for value in results:
print(results[value])
print("————————————-")
### 运用for循环查看字典中的键，以及键中存储的值
for key_value in results:
print(key_value,results[key_value])
print("————————————-")
### 运用for循环获取字典中的键值对
for item in results.items():
print(item)
print("—————–")
for key, value in results.items():
# 即ket,value对results.items()中包含的键值对进行解构（解包）
# key被results.items()中的”键“赋值，value被”值“赋值
print(key,value)
print("————————————-")
### 字典、列表转换
print(list(results))
print(type(list(results)))
print("————————————-")
### 将所有的键存入列表中
print(list(results.keys()))
### 将所有键所存储的值存入列表中
print(list(results.values()))
print("————————————-")
### 获取字典中的键值对
print(results.items())
print(list(results.items()))
运行结果：
{'Evan': 99, 'Amy': 98, 'Tom': 80}
<class 'dict'>
————————————-
Evan
Amy
Tom
————————————-
99
98
80
————————————-
Evan 99
Amy 98
Tom 80
————————————-
('Evan', 99)
('Amy', 98)
('Tom', 80)
—————–
Evan 99
Amy 98
Tom 80
————————————-
['Evan', 'Amy', 'Tom']
<class 'list'>
————————————-
['Evan', 'Amy', 'Tom']
[99, 98, 80]
————————————-
dict_items([('Evan', 99), ('Amy', 98), ('Tom', 80)])
[('Evan', 99), ('Amy', 98), ('Tom', 80)]
(2) 嵌套：根据 “字典中的 ‘值’ 可以是任意类型的数据”，我们可以将任意数据放在 “值” 的位置以完成嵌套。例如，字典嵌套字典的形式常常用于存储 “某属性的分属性”。
代码示例：
students = {
"00101":{"Name":"Amy", "class":"1班", "result":97},
"00201":{"Name":"Tom", "class":"2班", "result":99},
"00123":{"Name":"Green","class":"1版", "result":90}
}
### 我想知道 00123 号学生是谁？他的成绩是多少？
print(students["00123"]["Name"], students["00123"]["result"])
运行结果：
Green 90
可喜可贺，关于“数据类型”的学习全面结束！！
