无序的容器并没有储存顺序（也许在内存地址上有顺序），所以不能使用序列容器的方法

字典 { Dict }

L -无序容器（无序数据结构） - 图1

定义字典

L -无序容器（无序数据结构） - 图2

  1. {key:value, key2:value2}
  3. # 定义一个字典dict
  4. #    用"{}"括起来，每个元素用','号隔开即可
  5. #    每个元素都有一个"key"键值与"value"值相互对应
  6. #
  7. # 注意："key"键值不能重复
  1. # 示例
  2. bid = {"Name":"Hibari", "UID":"7565634", "Level":"5"}
  3. print(type(bid))
  4. print(bid)
  6. # 输出
  7. <class 'dict'>
  8. {'Name': 'Hibari', 'UID': '7565634', 'Level': '5'}

常用操作、方法

——————-修改———————

值查询 ：D[key]

值修改 ：D[key] = vaule

元素删除 ：del D[key]

添加添加 ：D[new_key] =vaule

L -无序容器（无序数据结构） - 图3

  1. bid = {"Name":"Hibari", "UID":"7565634", "Level":"5"}
  3. # 值查询
  4. print(bid["Name"])
  6. # 值修改
  7. bid["Name"] = "HibariCN"
  8. print(bid["Name"])
  10. # 添加新元素
  11. bid["New"] = "Vip"
  12. print(bid)
  14. # 元素删除
  15. del bid["UID"]
  16. print(bid)
  19. # ================================
  20. # 输出
  21. HibariCN
  22. {'Name': 'HibariCN', 'UID': '7565634', 'Level': '5', 'New': 'Vip'}
  23. {'Name': 'HibariCN', 'Level': '5', 'New': 'Vip'}

——————-查询———————

键值查询 ：D[key]

L -无序容器（无序数据结构） - 图4

  1. # 示例
  2. dict1={"A":"Hibari", "B":"HibariCN"}
  3. print (Dict1[1])
  5. # 输出
  6. Hibaricn

键值查询 ：get( )

是用于代替D[key]的
L -无序容器（无序数据结构） - 图5

  1. D.get(key, default=None)  # 只能用于dict类型
  3. # 参数说明：
  4. #    D            dict字典（需要查询的字典）
  5. #    key            key键值（查询的键值）
  6. #    default=None    元素值
  7. #
  8. # 功能说明：
  9. #    查询'k'值是否在字典'D'中，如果存在，返回与键值相对于的值
  10. #    如果不存在返回"None"
  1. # ================================
  2. # 示例
  3. bid = {"Name":"Hibari", "UID":"7565634", "Level":"5", "vipType":"year"}
  4. print(bid.get("Name"))
  5. print(bid.get("ID"))
  7. # 输出
  8. Hibari
  9. None
  10. # ================================
  1. # D.get(key)与D[key]的区别
  3. # 当键值'Key'不在字典'D'时
  4. #    D.get(key)     返回None
  5. #    D[key]        报错KeyError

键值判断 ：in \ not in (成员运算符)

  1. # 返回值：
  2. #    布尔（在集合中返回True，否则返回False）
  4. # 功能说明：
  5. #     通过成员运算符可以判断某个元素的'Key'键值，是否在集合中
  1. # ================================
  2. # 示例
  3. bid = {"Name":"Hibari", "UID":"7565634", "Level":"5"}
  4. print("key:", ("Name" in bid))
  5. print("Value:", ("Hibari" in bid))
  6. print("key:", ("ID" in bid))
  7. print("key:", ("UID" not in bid))
  9. # 输出
  10. key: True
  11. Value: False
  12. key: False
  13. key: False
  14. # ================================

——————-遍历———————

遍历键值 ：keys( )

L -无序容器（无序数据结构） - 图6

  1. D.keys()
  2. # 参数说明
  3. #     D            字典Dict
  4. #
  5. # 返回值：
  6. #    values()    dict_keys([list]) 【特殊的List列表，需要用list()方法转换成list】
  7. #
  8. # 功能说明：
  9. #    返回值"dict_keys"通常用于遍历字典
  10. #    通过list()函数可以转换成列表
  1. # ================================
  2. # 示例
  3. bid = {"Name":"Hibari", "UID":"7565634", "Level":"5"}
  4. for i in bid.keys():
  5.     print("key:", i)
  6.     print("value:", bid[i],"\n")
  9. # 输出
  10. key: Name
  11. value: Hibari
  13. key: UID
  14. value: 7565634
  16. key: Level
  17. value: 5
  18. # ================================
  1. # dict_keys转list
  1. # ================================
  2. # 示例
  3. bid = {"Name":"Hibari", "UID":"7565634", "Level":"5"}
  4. a = list(bid.keys())
  5. print(type(bid.keys()))
  6. print(bid.keys)
  7. print(a)
  9. # 输出
  10. <class 'dict_keys'>
  11. dict_keys(['Name', 'UID', 'Level'])
  12. ['Name', 'UID', 'Level']

遍历值：value( )

L -无序容器（无序数据结构） - 图7

  1. D.values()
  2. # 参数说明
  3. #     D            字典Dict
  4. # 返回值：
  5. #    values()：    dict_values([list])【特殊的List列表，需要用list()方法转换成list】
  1. # ================================
  2. # 示例
  3. bid = {"Name":"Hibari", "UID":"7565634", "Level":"5"}
  4. for i in bid.values():
  5.     print(i)
  7. # 输出
  8. Hibari
  9. 7565634
  10. 5
  11. # ================================
  1. # dict_values转list
  1. # ================================
  2. # 示例
  3. bid = {"Name":"Hibari", "UID":"7565634", "Level":"5"}
  4. a = list(bid.values())
  5. print(type(bid.values()))
  6. print(bid.values)
  7. print(a)
  9. # 输出
  10. <class 'dict_values'>
  11. dict_keys(['Hibari', '7565634', '5'])
  12. ['Hibari', '7565634', '5']
  13. # ================================

——————-其他———————

字典返回元组 ：items( )

L -无序容器（无序数据结构） - 图8

  1. D.items()
  3. # 参数说明
  4. #     D            字典Dict
  5. # 返回值：
  6. #    items()        <class 'dict_items'>【特殊的List列表，需要用list()方法转换成list】
  1. # ================================
  2. # 示例
  3. bid = {"Name":"Hibari", "UID":"7565634", "Level":"5"}
  4. a = list(bid.items())
  5. print(type(bid.items()))
  6. print(bid.items())
  7. print(a)
  9. # 输出
  10. <class 'dict_items'>
  11. dict_items([('Name', 'Hibari'), ('UID', '7565634'), ('Level', '5')])
  12. [('Name', 'Hibari'), ('UID', '7565634'), ('Level', '5')]
  13. # ================================
  1. # ================================
  2. # 示例2：遍历字典
  3. bid = {"Name":"Hibari", "UID":"7565634", "Level":"5"}
  4. for i in bid.items():
  5.     print(i)
  7. # 输出
  8. ('Name', 'Hibari')
  9. ('UID', '7565634')
  10. ('Level', '5')
  11. # ================================

长度查询 ：len( )

L -无序容器（无序数据结构） - 图9

  1. len(object)
  3. # 参数说明：
  4. #    object：    集合\字典（查询的字符串，或者序列）
  5. #
  6. # 返回值：
  7. #    len()：    整数（返回元素的个数）
  1. # ================================
  2. # 示例
  3. bid = {"Name":"Hibari", "UID":"7565634", "Level":"5"}
  4. bid2 = {"5", "5", "5", "a"}
  5. print(len(bid))
  6. print(len(bid2))
  8. # 输出
  9. 3
  10. 2
  11. # ================================

更多列表方法：

https://docs.python.org/zh-cn/3.9/tutorial/datastructures.html#looping-techniques

  1. list.append(x)
  2. 在列表的末尾添加一个元素。相当于 a[len(a):] = [x] 。
  4. list.extend(iterable)
  5. 使用可迭代对象中的所有元素来扩展列表。相当于 a[len(a):] = iterable 。
  7. list.insert(i, x)
  8. 在给定的位置插入一个元素。第一个参数是要插入的元素的索引，所以 a.insert(0, x) 插入列表头部， a.insert(len(a), x) 等同于 a.append(x) 。
  10. list.remove(x)
  11. 移除列表中第一个值为 x 的元素。如果没有这样的元素，则抛出 ValueError 异常。
  13. list.pop([i])
  14. 删除列表中给定位置的元素并返回它。如果没有给定位置，a.pop() 将会删除并返回列表中的最后一个元素。（ 方法签名中 i 两边的方括号表示这个参数是可选的，而不是要你输入方括号。你会在 Python 参考库中经常看到这种表示方法)。
  16. list.clear()
  17. 删除列表中所有的元素。相当于 del a[:] 。
  19. list.index(x[, start[, end]])
  20. 返回列表中第一个值为 x 的元素的从零开始的索引。如果没有这样的元素将会抛出 ValueError 异常。
  22. 可选参数 start 和 end 是切片符号，用于将搜索限制为列表的特定子序列。返回的索引是相对于整个序列的开始计算的，而不是 start 参数。
  24. list.count(x)
  25. 返回元素 x 在列表中出现的次数。
  27. list.sort(*, key=None, reverse=False)
  28. 对列表中的元素进行排序（参数可用于自定义排序，解释请参见 sorted()）。
  30. list.reverse()
  31. 反转列表中的元素。
  33. list.copy()
  34. 返回列表的一个浅拷贝。相当于 a[:] 。

集合 { Set }

L -无序容器（无序数据结构） - 图10

定义集合

L -无序容器（无序数据结构） - 图11

  1. {value, value1, value2}
  3. # 定义一个集合set
  4. #    用"{}"括起来，每个元素用','号隔开即可
  5. #
  6. # 注意："value"不能重复，重复的会被去除
  1. # ================================
  2. # 示例
  3. bid = {"5", "5", "5", "a"}
  4. print(type(bid))
  5. print(bid)
  7. # 输出
  8. <class 'set'>
  9. {'a', '5'}
  10. # ================================
  12. # ================================
  13. # 示例2：创建空集
  14. bid = set()
  16. # ================================

常用操作、方法

——————-修改———————

添加元素 ：add( )

L -无序容器（无序数据结构） - 图12

  1. S.add(values)
  3. # 参数说明：
  4. #    S        集合
  5. #    valuse    值（需要添加到集合中的值）
  6. # 功能说明：
  7. #    向集合中添加元素
  1. # ================================
  2. # 示例
  3. bid = {"Hibari", "7565634", "5"}
  4. bid.add("VIP")
  5. print(bid)
  7. # 输出
  8. {'5', '7565634', 'VIP', 'Hibari'}
  9. # ================================

列表追加到集合 ：updata( )

L -无序容器（无序数据结构） - 图13

  1. S.update(L)
  3. # 参数说明：
  4. #    S        集合
  5. #    L        列表（需要添加到集合中的列表）
  6. # 功能说明：
  7. #    将列表'L'中的元素添加到集合'S'中
  8. #    注意，如果列表中含有重复的元素，会被清除
  9. #    利用集合不重复的特性，可以为列表去重
  1. # ================================
  2. # 示例
  3. bid = {"Hibari", "7565634", "5"}
  4. bid.update([5,5,5,6,7,8])
  5. print(bid)
  7. # 输出
  8. {'5', 5, 6, 7, 8, 'Hibari', '7565634'}
  9. # ================================

——————-删除———————

删除元素 ：remove( )

删除元素 ：discard( )

L -无序容器（无序数据结构） - 图14

  1. S.remove(value)
  2. S.discard(value)
  4. # 参数说明：
  5. #    S        集合 【需要进行删除操作的集合】
  6. #    value    值    【需要删除的元素】
  7. # 返回值：
  8. #    S            集合       【返回删除完成后的集合】
  9. #    remove()    无返回值 【删除的元素不存在时报错】
  10. #    discard()    无返回值 【不会报错】
  1. # ================================
  2. # 示例：remove()
  3. bid = {"Hibari", "7565634", "5"}
  4. bid.remove("7565634")
  5. print(bid)
  6. try:
  7.     bid.remove("7565634")
  8. except KeyError:
  9.     print("KeyErrer")
  11. # 输出
  12. {'Hibari', '5'}
  13. KeyErrer
  14. # ================================
  1. # ================================
  2. # 示例：discard()
  3. bid = {"Hibari", "7565634", "5"}
  4. bid.discard("7565634")
  5. bid.discard("7565634")
  6. print(bid)
  8. # 输出
  9. {'Hibari', '5'}
  10. # ================================

随机删除 ：pop( )

L -无序容器（无序数据结构） - 图15

  1. S.pop()
  3. # 参数说明：
  4. #    S        集合 【需要进行删除操作的集合】
  5. # 返回值：
  6. #    S            集合       【返回删除完成后的集合】
  7. #    pop()        值        【返回被删除后的值】
  8. # 功能说明：
  9. #    随机删除一个元素
  1. # ================================
  2. # 示例
  3. bid = {"Hibari", "7565634", "5"}
  4. for i in range(5):
  5.     try:
  6.         print("Delete:",bid.pop())
  7.     except KeyError:
  8.         print("Set = None")
  9.         break
  11. # 输出
  12. Delete: 5
  13. Delete: 7565634
  14. Delete: Hibari
  15. Set = None
  16. # ================================

——————-其他———————

长度查询 ：len( )

L -无序容器（无序数据结构） - 图16

  1. len(object)
  3. # 参数说明：
  4. #    object：    集合\字典（查询的字符串，或者序列）
  5. #
  6. # 返回值：
  7. #    len()：    整数（返回元素的个数）
  1. # ================================
  2. # 示例
  3. bid = {"Name":"Hibari", "UID":"7565634", "Level":"5"}
  4. bid2 = {"5", "5", "5", "a"}
  5. print(len(bid))
  6. print(len(bid2))
  8. # 输出
  9. 3
  10. 2
  11. # ================================

元素判断 ：in \ not in (成员运算符)

  1. # 返回值：
  2. #    布尔（如果元素在集合中返回True，否则返回False）
  3. # 功能说明：
  4. #     通过成员运算符可以判断某个元素是否在集合中
  1. # ================================
  2. # 示例
  3. bid = {"Hibari", "7565634", "5"}
  4. print("Hibari" in bid)
  5. print("ID" in bid)
  7. # 输出
  8. True
  9. False
  10. # ================================

集合运算 ：交并补

L 交 ：intersection( )

L 并 ：union( )

L 补 ：difference( )

  1. set1.intersection(set2) #交
  2. set1.union(set2)        #并
  3. set1.difference(set2)    #补
  5. # 参数说明：
  6. #    set1    集合1
  7. #    set2    集合2
  9. # 返回值：
  10. #    intersection()    集合
  11. #    union()            集合
  12. #    differece()        集合
  1. # ================================
  2. # 示例
  3. s1 = {1, 2, 3, 4}
  4. s2 = {3, 4, 5, 6}
  5. a = s1 & s2     # 交集
  6. b = s1 | s2        # 并集
  7. c = s1 - s2        # 差集
  8. d = s2 - s1
  9. print(a)
  10. print(b)
  11. print(c)
  12. print(d)
  14. # 输出
  15. {3, 4}
  16. {1, 2, 3, 4, 5, 6}
  17. {1, 2}
  18. {5, 6}
  19. # ================================
  1. # ================================
  2. # 示例
  3. s1 = {1, 2, 3, 4}
  4. s2 = {3, 4, 5, 6}
  5. a = s1.intersection(s2)
  6. b = s1.union(s2)
  7. c = s1.difference(s2)
  8. d = s2.difference(s1)
  9. print(a)
  10. print(b)
  11. print(c)
  12. print(d)
  14. # 输出
  15. {3, 4}
  16. {1, 2, 3, 4, 5, 6}
  17. {1, 2}
  18. {5, 6}
  19. # ================================