python基础篇-字典和集合_python 集合 字典

一、字典

1. 字典的定义

字典（Dictionary）是用于存储键值对的数据结构，通常表示为花括号 {} 内部包含一系列的键值对。每个键值对包含两部分，即键和对应的值，中间用冒号 : 分隔。而键-值对之间用逗号（，）分割。如：a={key1:value1,key2:value2}。

2. 注意事项

1. 键必须唯一：字典中的每个键必须是唯一的，如果出现重复键，后面的键会覆盖前面的键。

2. key需要不变类型，value可以是任意类型。

3. 字典是可变类型，可以进行增删改查

3. 字典的常用操作

1. 创建字典

使用花括号 {} 或者 dict() 内置函数来创建一个字典。

#使用花括号创建字典
my_dict = {'name': '清微', 'age': 25, 'gender': '女'}
print(my_dict)     #输出结果：{'name': '清微', 'age': 25, 'gender': '女'}
 
#使用 dict() 函数创建字典
my_dict = dict(name='清微', age=20, gender='女')
print(my_dict)    #输出结果：{'name': '清微', 'age': 20, 'gender': '女'}

2. 添加元素

1. 要向字典中添加元素，可以使用赋值语句来为指定键设置对应的值

a={"最有魅力的歌手":"周琛"}
#增加元素
a["最红的歌手"]="毛不易"   # 向字典中添加新的键值对
print(a)    #输出结果：{'最有魅力的歌手': '周琛', '最红的歌手': '毛不易'}

2. 使用 update() 方法添加新的键值对

#修改的键不存在于字典中，则会将其作为新的键值对添加到字典中
my_dict = {'name': '清微', 'age': 25}
my_dict.update({'gender': '女'})  # 修改 'age' 键对应的值并添加 'gender' 键值对
print(my_dict)  #输出结果：{'name': '清微', 'age': 25, 'gender': '女'}
 
#update() 方法也可以接受另一个字典作为参数进行更新
my_dict = {'name': '清微', 'age': 25}
new_dict = {'age': 26, 'gender': '女'}
my_dict.update(new_dict)  # 使用另一个字典 new_dict 来更新 my_dict
print(my_dict)  # 输出：{'name': '清微', 'age': 26, 'gender': '女'}

3. 删除元素

1. 使用 del 关键字删除指定键值对

my_dict = {'name': '清微', 'age': 25}
del my_dict['age']  
print(my_dict)  #输出结果：{'name': '清微'}

2. 使用 pop() 方法删除指定键值对并返回该键对应的值

#使用字典的 pop() 方法来删除指定的键值对，并返回该键对应的值
my_dict = {'name': '清微', 'age': 25}
age = my_dict.pop('age')  # 删除 my_dict 中的 'age' 键值对并返回该键对应的值
print(age)    #输出结果：25
print(my_dict)    #输出结果：{'name': '清微'}
 
#使用 pop() 方法删除的键不存在于字典中，则会抛出 KeyError 异常
age = my_dict.pop('ctiy')  
print(my_dict)    #输出结果：KeyError: 'ctiy'

4. 修改元素

1. 使用索引运算符修改指定键对应的值

可以使用索引运算符 [] 和赋值语句来修改字典中指定键对应的值。

my_dict = {'name': '清微', 'age': 25}
my_dict['age'] = 26  
print(my_dict)  #输出结果：{'name': '清微', 'age': 26}

2. 使用 update() 方法修改指定键对应的值

my_dict = {'name': '清微', 'age': 25}
my_dict.update({'age': 26})
print(my_dict)  #输出结果：{'name': '清微', 'age': 26}

5. 遍历字典

1. 遍历字典所有的键

可以使用 for 循环遍历字典的所有键。

my_dict = {'name': '清微', 'age': 25}
for key in my_dict:
    print(key)

输出结果：
name
age

2. 遍历字典所有的值

可以使用 values() 方法获取字典中的所有值，并使用 for 循环遍历这些值。

my_dict = {'name': '清微', 'age': 25}
for value in my_dict.values():
    print(value)

输出结果：
清微
25

3. 遍历字典所有的键值对

可以使用 items() 方法获取字典中的所有键值对，并使用 for 循环遍历这些键值对。

my_dict = {'name': '清微', 'age': 25}
for key, value in my_dict.items():
    print(key, value)

输出结果：
name 清微
age 25

ps：Python 中的 items() 方法是字典对象的一个方法，用于返回一个由所有字典键值对组成的新视图对象。这个新视图对象可以遍历原始字典中的所有键值对，每个键值对作为一个元组 (key, value) 的形式出现。

6. 获取字典键、值或键值对列表

1. 获取字典键列表

可以使用 keys() 方法获取字典中所有的键，并将它们组成一个列表。

my_dict = {'name': '清微', 'age': 25, 'gender': '女'}
# 获取字典中的所有键，并将它们组成一个列表
keys_list = list(my_dict.keys())
print(keys_list)    #输出结果：['name', 'age', 'gender']

2. 获取字典值列表

可以使用 values() 方法获取字典中所有的值，并将它们组成一个列表。

my_dict = {'name': '清微', 'age': 25, 'gender': '女'}
# 获取字典中的所有值，并将它们组成一个列表
values_list = list(my_dict.values())
print(values_list)    #输出结果：['清微', 25, '女']

3. 获取字典键值对列表

可以使用 items() 方法获取字典中所有的键值对，并将它们组成一个列表。

my_dict = {'name': '清微', 'age': 25, 'gender': '女'}
# 获取字典中的所有键值对，并将它们组成一个列表
items_list = list(my_dict.items())
print(items_list)    #输出结果：[('name', '清微'), ('age', 25), ('gender', '女')]

二、集合

1. 集合的定义

在 Python 中，集合（set）是一种无序且不重复的数据类型，它可以用来存储多个元素。

在 Python 中，我们可以使用大括号 {} 或者 set() 函数来创建一个集合对象

# 使用大括号创建一个集合
my_set = {1, 2, 3}
print(my_set)    #输出结果：{1, 2, 3}
 
# 使用 set() 函数创建一个集合
my_set2 = set([10, 20, 30])
print(my_set2)    #输出结果：{10, 20, 30}

2. 创建空集合

在Python中，可以使用内置的 set() 函数来创建一个空集合。

my_set = set()
print(my_set)    #输出结果：set()

ps：如果使用花括号 {} 来创建空集合，会被解释为一个空字典。因此，应该使用 set() 函数来创建空集合。

3. 集合的常用操作

1. 去重

1. 使用集合（set）的去重功能对序列或列表进行去重，具体方式为：将序列转换为集合，再将集合转换回序列即可实现去重。

a = [1, 2, 2, 3, 4, 4]
b = set(a)
result = list(b)
print(result)    #输出结果：[1, 2, 3, 4]

2. 使用 set() 函数来创建集合并去重

# 直接使用 set() 函数来创建集合并去重
a = [1, 2, 2, 3, 4, 4]
result = list(set(a))
print(result)    #输出结果：[1, 2, 3, 4]

2. 元素的添加

1. 使用 add() 方法向集合中添加一个元素

a = {1, 2, 3}
a.add(4)  
print(a)     #输出结果：{1, 2, 3, 4}

2. 使用 update() 方法向集合中添加多个元素

update() 方法可以接受一个列表、元组、集合等可迭代对象作为参数，将其中的元素依次添加到集合中。

a = {1, 2, 3}
b = [4, 5, 6]
a.update(b)     
print(a)    #输出结果：{1, 2, 3, 4, 5, 6}

3. 元素的删除：

1. remove() 方法用于删除指定的元素，如果集合不存在该元素，则会抛出 KeyError 异常；

a = {1, 2, 3}
a.remove(2)   
print(a)      #输出结果：{1, 3}
 
 
#集合不存在该元素
a = {1, 2, 3}
a.remove(4)
print(a)      #输出结果：KeyError: 4

2. discard() 方法也用于删除指定的元素，但是如果集合不存在该元素，则什么也不做，不会抛出异常。

a = {1, 2, 3}
a.discard(2)
print(a)        #输出结果：{1, 3}
 
 
#集合不存在该元素，则什么也不做，不会抛出异常
a = {1, 2, 3}
a.discard(5)
print(a)        #输出结果：{1, 2, 3}

3. 使用 pop() 方法随机删除并返回集合中的一个元素。需要注意的是，由于集合是无序的，所以随机删除的元素是不确定的。

a = {1, 2, 3}
b = a.pop()    
print(a)        #输出结果：{2, 3}
print(b)        #输出结果：1

4. 判断成员关系

使用 in 关键字或 not in 关键字来判断一个元素是否是集合的成员。

#in 关键字
a = {1, 2, 3}
if 2 in a:
    print("2是集合a的成员")
else:
    print("2不是集合a的成员")    #输出结果：2是集合a的成员
 
 
#not in 关键字
a = {1, 2, 3}
if 4 not in a:
    print("4不是集合a的成员")
else:
    print("4是集合a的成员")    #输出结果：4不是集合a的成员

5. 集合并集、交集、差集

在 Python 中，可以使用以下符号和方法对集合进行运算：

1. |：并集运算符或 union() 方法或undate()方法

#|：并集运算符
a = {1, 2, 3}
b = {2, 3, 4}
c = a | b          #a和b的并集
print(c)           #输出结果：{1, 2, 3, 4}
 
#update()方法
a.update(b)        #a和b的并集，结果赋值给 a，等价于a|=b
print(a)           #输出结果：{1, 2, 3, 4}
 
#union() 方法用于返回两个集合的并集
c = a.union(b)
print(c)      #输出结果：{1, 2, 3, 4}

2. &：交集运算符或 intersection() 方法

#&：交集运算符
a = {1, 2, 3}
b = {2, 3, 4}
c = a & b          #a和b的交集
print(c)           #输出结果：{2, 3}
 
# intersection_update
a.intersection_update(b)        # a和b的交集，结果赋值给a，等价于a&=b
print(a)           #输出结果：{2, 3}

3. -：差集运算符或 difference() 方法

差集是指两个集合中仅属于其中一个集合而不属于另一个集合的元素的集合。即，集合 A 和集合 B 的差集 A - B 是由属于 A 但不属于 B 的所有元素组成的集合。

#-：差集运算符
a = {1, 2, 3}
b = {2, 3, 4}
c = a - b          #a和b的差集
d = b - a          #a和b的差集
print(c)           #输出结果：{1}
print(d)           #输出结果：{4}
 
# difference() 方法
a.difference_update(b)        # a和b的交集，结果赋值给a，等价于a-=b
print(a)           #输出结果：{1}

4. ^：对称差集运算符或 symmetric_difference() 方法

对称差集，有时也称为异或运算，是集合论中的一种基本二元运算。两个集合的对称差集包含了同时属于这两个集合的所有元素的补集，并且它们的并集就是这两个集合的并集减去交集。简单来说，对称差集运算只的是那些只属于其中一个集合而不属于另一个集合的元素所组成的集合。

#^：对称差集运算符
a = {1, 2, 3}
b = {2, 3, 4}
c =  a ^ b          # a 和 b 的对称差集
print(c)           #输出结果：{1, 4}
 
 
# symmetric_difference() 方法
a.symmetric_difference_update(b)  # a 和 b 的对称差集，结果赋值给 a，等价于 a ^= b
print(a)           #输出结果：{1, 4}