05.Python遍历与散列（字典、集合常用方法运算、容器的for遍历及其它常用公共方法操作的列表总结+代码示例）

集合set

概述：是一种无序且不重复的数据结构，由一组唯一的元素组成，可以进行交集、并集、差集等常见的集合操作，创建集合使⽤“ { } ”或 “set()”，元素之间用“,”隔开。

PS：集合 set 元素的数据类型可以是除了列表、集合和字典之外的任何数据类型（可hash，不可变以保证唯一性）。

元素操作

方法	功能描述
set.add( E )	如果元素 E 不存在，则将元素 E 添加入集合list
set.update( Es )	Es 可迭代，将 Es 内元素迭代展开，逐个加入 list 并去重
set.remove( E )	删除集合 list 中的指定元素 E，如果数据不不存在则报错
set.discard( E )	删除集合 list 中的指定元素 E，如果元素不存在也不报错
set.pop( )	随机删除集合中的某个数据，并将这个数据返回
E in / not in set	判断数据 E 是否存在于集合中
len(set)	返回集合 set 的长度，即元素的个数
set.clear( )	清空集合中的所有元素

demo_set1 = {1, 2, 3, '4', '5', '6', (7, 8), '9', '0'}
print(type(demo_set1))  # 输出： 
demo_set2 = set()
print(demo_set2)  # 输出：set()
demo_set3 = set([1, 2, 5, 8, 3, 1, 6, 2, 3, 6, 9, 0])  # 列表转集合，自动去重
print(demo_set3)  # 输出：{0, 1, 2, 3, 5, 6, 8, 9}
demo_set2.add('abc')
print(demo_set2)  # 输出：{'abc'}
demo_set2.update(demo_set3)
print(demo_set2)  # 输出：{0, 1, 2, 3, 5, 6, 8, 9, 'abc'}
demo_set2.remove(0)
print(demo_set2)  # 输出：{1, 2, 3, 5, 6, 8, 9, 'abc'}
print(demo_set2.pop(), demo_set2)  # 输出随机
demo_set2.clear()

集合运算

函数方法	符号	功能描述
one_set.union(other_set)	|	返回两个集合元素的并集（去重）
one_set.intersection(other_set)	&	获取两个集合元素的交集
one_set.difference(other_set)	-	获取 one_set 中有而 other_set 中没有的元素集合
one_set.symmetric_difference(other_set)	^	两个集合中仅出现在其中一个集合中的元素的集合

one_set = {'a','b','c','d','e','f','g'}
other_set = {'e','f','g','h','i','j','k'}
union_set1 = one_set.union(other_set)
print(union_set1)           # {'a','b','c','d','e','f','g','h','i','j','k'}
print(other_set | one_set)  # {'a','b','c','d','e','f','g','h','i','j','k'}
union_set1 = one_set.intersection(other_set)
print(union_set1)           # {'e', 'f', 'g'}
print(one_set & other_set)  # {'e', 'f', 'g'}
union_set1 = one_set.difference(other_set)
print(union_set1)           # {'a','b','c','d'}
print(one_set - other_set)  # {'a','b','c','d'}
union_set1 = one_set.symmetric_difference(other_set)
print(union_set1)           # {'a','b','c','d','h','i','j','k'}
print(one_set ^ other_set)  # {'a','b','c','d','h','i','j','k'}

PS：每次输出集合结果的内容一致，但是集合的排序可能不同。

字典dict

概述：是一种无序可变的数据结构，用于存储键-值对（Key-Value Pairs）。字典中的键具有唯一性，不允许重复，键必须是不可变的对象，值可以是任意对象。

PS：适用于关联性数据存储，如个人姓名、年龄、身高、体重等信息，并通过 key 提供了快速的查找和访问能力。

常用操作

添加/更新：使用【 dict[key] = value】语法将键值对添加到字典中，如果键已存在则更新对应的 value 值。

value获取：使用【 dict[key] 】语法根据键获取对应的值，如果键不存在则引发KeyError异常。

PS：可以使用【 dict.get(key, default) 】方法来获取值，如果键不存在则返回指定的 default 默认值。

k-v对删除：使用【 del dict[key] 】语句删除指定的键值对，如果键不存在则引发KeyError异常（可以配合【 key in dict 】语法先检查再删除）。

man_dict = {'name': 'Tom', 'age': 20, 'gender': '男'}
print(man_dict['name'])             # 输出 Tom
man_dict['age'] = 23
print(man_dict)                     # 输出 {'name': 'Tom', 'age': 23, 'gender': '男'}
man_dict['height'] = 179
print(man_dict)                     # 输出 {'name': 'Tom', 'age': 23, 'gender': '男', 'height': 179}
print(man_dict.get('weight', '体重属性不存在'))        # 输出：体重属性不存在
del man_dict['other']               # KeyError: 'weight'，停止执行
if 'weight' in man_dict:            # 删除 K-V 改进版
    del man_dict['weight']
else:
    print('体重属性不存在')
man_dict['weight']                  # KeyError: 'weight'，停止执行
del man_dict                        # 从内存中删除变量

其它方法

常用方法	功能描述
dict.keys( )	获取一个包含字典所有键的视图
dict.values( )	获取一个包含字典所有值的视图
dict.items( )	获取一个包含字典所有键值对的视图
dict.copy( )	对字典 dict 进行复制
dict.update( other_dict )	将另一字典或键值对的添加到当前字典中，如 key 存在则更新 value 值
dict.pop(key, default)	若 key 存在，移除并返回对应 value 值，如不存在返回 default 默认值
dict.clear( )	清空字典内所有元素（是一个动作，无返回值）

PS：dict_values、dict_keys 和 dict_items 都是字典视图（view）对象的不同类型，这些视图对象类似于列表（List）或集合（Set），但它们并不是普通的列表或集合。

woman_dict = {'name': 'Nancy', 'age': 22, 'gender': '女'}
other_dict = {'name': 'Nancy', 'age': 23, 'weight': 52, 'height': '169'}
print(woman_dict.keys())                # dict_keys(['name', 'age', 'gender'])
print(woman_dict.values())              # dict_values(['Nancy', 22, '女'])
print(woman_dict.items())               # dict_items([('name', 'Nancy'), ('age', 22), ('gender', '女')])
woman_dict.update({'age': 20})
print(woman_dict)                       # {'name': 'Nancy', 'age': 20, 'gender': '女'}
woman_dict.update(other_dict)
print(woman_dict)                       # {'name': 'Nancy', 'age': 23, 'gender': '女', 'weight': 52, 'height': '169'}
print(woman_dict.pop('age','age不存在'))          # Nancy
print(woman_dict.pop('age','age不存在'))          # 不存在
print(woman_dict.copy())                # {'name': 'Nancy', 'gender': '女', 'weight': 52, 'height': '169'}
print(woman_dict.clear())               # None
print(woman_dict)                       # {}

容器操作

概述：Python 中字符串、列表、元组、字典等可以统称为容器，容器主要的公共操作有遍历、求长度、求最值等用法。

容器遍历

概述：Python 中主要使用 for 循环 进行容器的遍历，使用对象是可迭代的容器，同时可以搭配 enumerate( )函数， zip( ) 函数、列表推导等共同使用。

语法：for item in items:

my_string = "Hello, World!"
for char in my_string:
    print(char, end=', ')       # 最后结果：H, e, l, l, o, ,,  , W, o, r, l, d, !,
print()
my_tuple = (1, 2, 3, 4, 5)
for item in my_tuple:
    print(item, end=', ')       # 最后结果：1, 2, 3, 4, 5,
print()
my_list = ['apple', 'banana', 'cherry']
for item in my_list:
    print(item, end=', ')       # 最后结果：apple, banana, cherry,
print()
my_set = {1, 2, 3, 4, 5}
for item in my_set:
    print(item, end=', ')       # 最后结果：1, 2, 3, 4, 5,
print()
my_dict = {'name': 'Alice', 'age': 25, 'city': 'New York'}
for key, value in my_dict.items():
    print(key, value, end=', ')     # 最后结果：name Alice, age 25, city New York,
print()
for key in my_dict.keys():
    print(key, end=', ')            # 最后结果：name, age, city,
print()
for value in my_dict.values():
    print(value, end=', ')          # 最后结果：Alice, 25, New York,
print()

zip( ) ：格式为【 zip(var1, var2 ...... varx) 】，函数可以将多个容器的元素一一配对，返回一个新的可迭代对象。当容器的长度不同时，只会迭代到最短的容器长度。

enumerate( )：格式为【 enumerate(iterable, start=0) 】，⽤于将⼀个可遍历的数据对象（如列表、元组或字符串）组合为一个索引序列，返回值是由元素索引下标和元素组成的二元组（index, value），索引起始值可以自定义，默认从0开始。

range( )：格式为【 range(start, stop, size_step) 】，函数有三个参数，起始值（默认为0），终止值，步长（默认为1）。它返回一个表示整数序列的可迭代对象，包含从 start 到 stop 之间的整数，但不包括stop本身。

"""  for 搭配推导式   """
demo = [1, 2, 3, 4, 5]
squared_demo = {x ** 2 for x in demo}
print(squared_demo)					# {1, 4, 9, 16, 25}
# demo、squared_demo 可以是元组、列表、集合等类型

"""  for 搭配 zip() 函数   """
names = ['Alice', 'Bob', 'Charlie', 'Jone', 'Nancy']
ages = [25, 30, 35]
for name, age in zip(names, ages):
    print(name, age, end=', ')      # 最后结果：Alice 25, Bob 30, Charlie 35,
print()

"""  for 搭配 enumerate() 函数   """
my_list = ['apple', 'banana', 'cherry']
for index, value in enumerate(my_list):
    print(index, value, end=', ')   # 最后结果：0 apple, 1 banana, 2 cherry,
print()
for index, value in enumerate(my_list,start=10):
    print(index, value, end=', ')   # 最后结果：10 apple, 11 banana, 12 cherry,
"""  for 搭配 range() 函数   """
for i in range(2, 9, 2):
    print(i)  						# 输出 2, 4, 6, 8
even_numbers = [x for x in range(10) if x % 2 == 0]
print(even_numbers)  				# 输出 [0, 2, 4, 6, 8]

其它操作

公共函数	功能描述
len( var )	统计并返回容器中元素的个数
max( var ) / min( var )	返回容器中的最大值/最小值
sum( var )	返回容器中所有元素的和
sorted( var )	返回一个新的已排序的列表list
reversed( var )	反转顺序之后返回一个迭代器对象
any( var )	判断是否存在非零或True元素
all( var )	判断元素是否全部为非零或True元素

PS：1、sum 函数仅适用于数字类型的容器；

2、reversed 函数仅适用于序列对象；

3、以上公共操作都具有返回值。

my_dict = {'a': 1, 'b': 2, 'c': 3}
print(len(my_dict))       		# 输出 3，字典的长度为键值对的数量
print(max(my_dict))       		# 输出 'c'，字典中的键按照字母顺序比较

demo_list = [0, 3, 1, 2, 7, 4, 5, 9]
print(len(demo_list))           # 输出 8
print(sum(demo_list))           # 输出 31
print(max(demo_list))           # 输出 9
print(sorted(demo_list))        # 输出 [0, 1, 2, 3, 4, 5, 7, 9]
print(list(reversed(demo_list)))      # 输出 [9, 5, 4, 7, 2, 1, 3, 0]
print(any(demo_list))           # 输出 True，因为集合中存在非零元素
print(all(demo_list))           # 输出 False，因为存在元素0

ch_list = ['张三', '李四', '王五', '赵六', '孙七', '周八']
print(max(ch_list))             # 输出 赵六