python元祖列表字典集合区别 python元组列表集合字典

列表、元组、字典和集合

在 Python 编程中，我们既需要独立的变量来保存一份数据，也需要序列来保存大量数据。

列表（list）和元组（tuple）比较相似，它们都按顺序保存元素，所有的元素占用一块连续的内存，每个元素都有自己的索引，因此列表和元组的元素都可以通过索引（index）来访问。

它们的区别在于：列表是可以修改的，而元组是不可修改的。

字典（dict）和集合（set）存储的数据都是无序的，每份元素占用不同的内存，其中字典元素以 key-value 的形式保存。

1、序列：

序列，指的是一块可存放多个值的连续内存空间，这些值按一定顺序排列，可通过每个值所在位置的编号（称为索引）访问它们。

序列类型包括字符串、列表、元组、集合和字典，这些序列支持以下几种通用的操作，但比较特殊的是，集合和字典不支持索引、切片、相加和相乘操作。

序列切片：

切片操作是访问序列中元素的另一种方法，它可以访问一定范围内的元素，通过切片操作，可以生成一个新的序列。

语法格式：

strname[start : end : step]

• strname：表示序列的名称；
• start：表示切片的开始索引位置（包括该位置），此参数也可以不指定，会默认为 0，也就是从序列的开头进行切片；
• end：表示切片的结束索引位置（不包括该位置），如果不指定，则默认为序列的长度；
• step：表示在切片过程中，隔几个存储位置（包含当前位置）取一次元素，也就是说，如果 step 的值大于 1，则在进行切片去序列元素时，会“跳跃式”的取元素。

str = "中国惊奇先生，狐妖小红娘"
print(str[:2])   # 中国
print(str[1:7])   # 国惊奇先生，
print(str[3:])    # 奇先生，狐妖小红娘
print(str[::2])   # 中惊先，妖红
print(str[:])   # 中国惊奇先生，狐妖小红娘

序列相加：

Python 中，支持两种类型相同的序列使用“+”运算符做相加操作，它会将两个序列进行连接，但不会去除重复的元素。

str02 = "神墓"
print("画江湖之不良人，" + "万妖谱，" + str02)   # 画江湖之不良人，万妖谱，神墓

序列相乘：

Python 中，使用数字 n 乘以一个序列会生成新的序列，其内容为原来序列被重复 n 次的结果。

str03 = "hello"
print(str03 * 5)   # hellohellohellohellohello

检查元素是否包含在序列中：

Python 中，可以使用 in 关键字检查某元素是否为序列的成员。

str04 = 'h'
print(str04 in "hello world!")   # true

not in 关键字，它用来检查某个元素是否不包含在指定的序列中。

和序列相关的内置函数：

函数	功能
len()	计算序列的长度，即返回序列中包含多少个元素。
max()	找出序列中的最大元素。注意，对序列使用 sum() 函数时，做加和操作的必须都是数字，不能是字符或字符串，否则该函数将抛出异常，因为解释器无法判定是要做连接操作（+ 运算符可以连接两个序列），还是做加和操作。
min()	找出序列中的最小元素。
list()	将序列转换为列表。
str()	将序列转换为字符串。
sum()	计算元素和。
sorted()	对元素进行排序。
reversed()	反向序列中的元素。
enumerate()	将序列组合为一个索引序列，多用在 for 循环中。

str05 = "hello,world"
print(max(str05))   # w
print(min(str05))   # ,
print(sorted(str05))   # [',', 'd', 'e', 'h', 'l', 'l', 'l', 'o', 'o', 'r', 'w']

2、列表操作：

1、什么是列表？

• 需求：经常需要将一组（不只一个）数据存储起来，以便后边的代码使用。
• 数组（Array），它就可以把多个数据挨个存储到一起，通过数组下标可以访问数组中的每个元素。
• Python 中没有数组，但是加入了更加强大的列表。如果把数组看做是一个集装箱，那么 Python 的列表就是一个工厂的仓库。

**列表 **会将所有元素都放在一对中括号[ ]里面，相邻元素之间用逗号,分隔。

lst = [1,2,3,4,5]

**列表 **中的元素，个数没有限制，只要是 Python 支持的数据类型就可以。

列表 可以存储整数、小数、字符串、列表、元组等任何类型的数据，并且同一个列表中元素的类型也可以不同。

["xiaoche", 1, [2,3,4] , 3.0, (5,6,7)]

注意：一般列表中只放入同一类型的数据，这样可以提高程序的可读性。

2、创建列表：

• 使用 [ ] 直接创建：

listname = [element1 , element2 , element3 , ... , elementn]
# 例如：
num = [1, 2, 3, 4, 5, 6, 7]
name = ["Jack", "tom"]
program = ["php", "Python", "Java"]

# 也可以是个空列表：
lst = []

• 使用list()函数创建：

# 将字符串转换成列表
list1 = list("hello")
print(list1)

# 将元组转换成列表
tuple1 = ('Python', 'Java', 'C++', 'JavaScript')
list2 = list(tuple1)
print(list2)

# 将字典转换成列表
dict1 = {'a':100, 'b':42, 'c':9}
list3 = list(dict1)
print(list3)

# 将区间转换成列表
range1 = range(1, 6)
list4 = list(range1)
print(list4)

# 创建空列表
print(list())

3、访问列表元素

• 使用索引（Index）访问列表中的某个元素（得到的是一个元素的值）。
• 使用切片访问列表中的一组元素（得到的是一个新的子列表）。

lst = [10,20,30,40,45]
print(lst)     # [10, 20, 30, 40, 45]
print(lst[3])   # 40
print(lst[2:])    # [30, 40, 45]

4、删除列表：

对于已经创建的列表，如果不再使用，可以使用del关键字将其删除。

• 但是在实际开发中，并不经常用del来删除列表。
• Python 自带的垃圾回收机制会自动销毁无用的列表，即使开发者不手动删除，Python 也会自动将其回收。

del lst    # 删除列表
print(lst)

删除列表之后，在打印列表会报错，如下图：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-1fv4yekq-1678548787538)(assets/image-20230301222645223.png)]

5、列表添加元素：

实际开发中，经常需要对 Python 列表进行更新，包括向列表中添加元素、修改表中元素以及删除元素。

1）使用+运算符可以将多个序列连接起来；

name_list = ["jack","tom","andy","lihua"]
age_list = [21,19,32,43]
print(name_list + age_list)   # ['jack', 'tom', 'andy', 'lihua', 21, 19, 32, 43]

从上面，我们不难看出，使用+会生成一个新的列表，原有的列表不会被改变。

2）append()方法添加元素

append() 方法用于在列表的末尾追加元素。

lst = ['java','python','linux']
lst.append("php")
print(lst)   # ['java', 'python', 'linux', 'php']

lst.append((1,2,3))
print(lst)  # ['java', 'python', 'linux', 'php', (1, 2, 3)]

lst.append(["apple","banana"])
print(lst)  # ['java', 'python', 'linux', 'php', (1, 2, 3), ['apple', 'banana']]

从上面可以看出，当给 append() 方法传递列表或者元组时，此方法会将它们视为一个整体，作为一个元素添加到列表中，从而形成包含列表和元组的新列表。

3）extend()方法添加元素

extend() 和 append() 的不同之处在于：extend() 不会把列表或者元祖视为一个整体，而是把它们包含的元素逐个添加到列表中。

item = ['java','python','linux']
item.extend('C')
print(item)  # ['java', 'python', 'linux', 'C']

t = (1,2,3)
item.extend(t)
print(item)   # ['java', 'python', 'linux', 'C', 1, 2, 3]

item.extend(['Vue','html'])
print(item)   # ['java', 'python', 'linux', 'C', 1, 2, 3, 'Vue', 'html']

4）insert()方法插入元素

append() 和 extend() 方法只能在列表末尾插入元素，如果希望在列表中间某个位置插入元素，那么可以使用 insert() 方法。

当插入列表或者元祖时，insert() 也会将它们视为一个整体，作为一个元素插入到列表中，这一点和 append() 是一样的。

lst = ['Python', 'C++', 'Java']
lst.insert(1, 'linux')
print(lst)  # ['Python', 'linux', 'C++', 'Java']

t = (1,2)
lst.insert(2,t)
print(lst)   # ['Python', 'linux', (1, 2), 'C++', 'Java']

lst.insert(1,['js','html'])
print(lst)   # ['Python', ['js', 'html'], 'linux', (1, 2), 'C++', 'Java']

lst.insert(0,"hello")
print(lst)   # ['hello', 'Python', ['js', 'html'], 'linux', (1, 2), 'C++', 'Java']

注意：insert() 主要用来在列表的中间位置插入元素，如果你仅仅希望在列表的末尾追加元素，那我更建议使用 append() 和 extend()。

6、列表删除元素：

在 Python 列表中删除元素主要分为以下 3 种场景：

• 根据目标元素所在位置的索引进行删除，可以使用 del 关键字或者 pop() 方法；
• 根据元素本身的值进行删除，可使用列表（list类型）提供的 remove() 方法；
• 将列表中所有元素全部删除，可使用列表（list类型）提供的 clear() 方法。

1）del：根据索引值删除元素

del 不仅可以删除整个列表，还可以删除列表中的某些元素。

• del 可以删除单个元素，也可以删除一段连续的元素。

lst = ['java','python','php','html','linux','C++','Vue']
del lst[3]
print(lst)   # ['java', 'python', 'php', 'linux', 'C++', 'Vue']

del lst[-1]
print(lst)  # ['java', 'python', 'php', 'linux', 'C++']

lst02 = ['java','python','php','html','linux','C++','Vue']
del lst02[2:5]
print(lst02)  # ['java', 'python', 'C++', 'Vue']

lst03 = ['java','python','php','html','linux','C++','Vue']
del lst03[-4:-1]
print(lst03)   # ['java', 'python', 'php', 'Vue']

注意：使用切片删除时左闭右开的。

2） pop()：根据索引值删除元素

pop() 方法用来删除列表中指定索引处的元素：listname.pop(index)

• 如果不写 index 参数，默认会删除列表中的最后一个元素，类似于数据结构中的“出栈”操作。

lst04 = ['apple','banana', 'watermelon', 'orange']
lst04.pop(2)
print(lst04)  # ['apple', 'banana', 'orange']

lst04.pop()
print(lst04)   # ['apple', 'banana']

3）remove()：根据元素值进行删除

remove() 方法，会根据元素本身的值来进行删除操作。

• remove() 方法只会删除第一个和指定值相同的元素，而且必须保证该元素是存在的，否则会引发 ValueError 错误。

num = [23,67,98,342,21,43,23]
num.remove(67)
print(num)  # [23, 98, 342, 21, 43, 23]

num.remove(23)
print(num)  # [98, 342, 21, 43, 23]

num.remove(23)
print(num)   # [98, 342, 21, 43]

num.remove(12)
print(num)  # ValueError: list.remove(x): x not in list

4） clear()：删除列表所有元素

clear() 用来删除列表的所有元素，也即清空列表。

num = [23,67,98,342,43]
num.clear()
print(num)

7、列表修改元素：

1） 修改单个元素

修改单个元素非常简单，直接对元素赋值即可。

num = [23,54,76,98,12]
num[2] = 100
print(num)   # [23, 54, 100, 98, 12]

num[-1] = -190
print(num)   # [23, 54, 100, 98, -190]

2） 修改一组元素

Python 支持通过切片语法给一组元素赋值。

num = [40,23,54,76,33]
num[1:3] = [1,2,3,4]
print(num)   # [40, 1, 2, 3, 4, 76, 33]

num = [1,2,3,4,5,6]
num[1:4] = [10,20]
print(num)   # [1, 10, 20, 5, 6]

• 如果不指定步长（step 参数），Python 就不要求新赋值的元素个数与原来的元素个数相同；
• 这意味，该操作既可以为列表添加元素，也可以为列表删除元素。
• 如果对空切片（slice）赋值，就相当于插入一组新的元素。

num = [10,20,30,40,50]
num[3:3] = [100,200,300]
print(num)  # [10, 20, 30, 100, 200, 300, 40, 50]

注意：使用切片语法赋值时，Python 不支持单个值。

使用切片语法时也可以指定步长（step 参数），但这个时候就要求所赋值的新元素的个数与原有元素的个数相同。

8、列表查找元素：

Python 列表（list）提供了 index() 和 count() 方法，它们都可以用来查找元素。

1）index() 方法用来查找某个元素在列表中出现的位置（也就是索引）。

• 如果该元素不存在，则会导致 ValueError 错误，所以在查找之前最好使用 count() 方法判断一下。

语法格式： listname.index(obj, start, end)

num = [12,54,21,65,342,21]
#检索列表中的所有元素
print(num.index(21))  # 2
#检索1~5之间的元素
print(num.index(65,1,5))  # 3
#检索2之后的元素
print(num.index(342,2))  # 4
#检索一个不存在的元素
print(num.index(100))  # ValueError: 100 is not in list

2） count() 方法用来统计某个元素在列表中出现的次数

• 如果 count() 返回 0，就表示列表中不存在该元素，所以 count() 也可以用来判断列表中的某个元素是否存在。

num = [1,2,3,4,5,2,2,3,4]
print("2在列表中共出现了%d次" %num.count(2))  # 2在列表中共出现了3次
if num.count(100):
    print("列表中有100")
else:
    print("列表中没有100")

3、元组操作：

元组（tuple）是 Python 中另一个重要的序列结构，和列表类似，元组也是由一系列按特定顺序排序的元素组成。

元组和列表（list）的不同之处在于：

• 列表的元素是可以更改的，包括修改元素值，删除和插入元素，所以列表是可变序列；
• 而元组一旦被创建，它的元素就不可更改了，所以元组是不可变序列。
• 元组的所有元素都放在一对小括号( )中，相邻元素之间用逗号,分隔。
• 元组可以存储整数、实数、字符串、列表、元组等任何类型的数据，并且在同一个元组中，元素的类型可以不同。但是不推荐这样。
• 元组是 tuple 类型。

1）创建元组：

通过( )创建元组后，一般使用=将它赋值给某个变量。

t = (1,2,2,3)
print(type(t),t)

当元组中只有一个字符串类型的元素时，该元素后面必须要加一个逗号,，否则 Python 解释器会将它视为字符串。

t2 = ('hello')
print(type(t2))  # <class 'str'>

t3 = ('hello', )
print(type(t3))  # <class 'tuple'>

使用tuple()函数创建元组：

#将字符串转换成元组
tup1 = tuple("hello")
print(tup1)

#将列表转换成元组
list1 = ['Python', 'Java', 'C++', 'JavaScript']
tup2 = tuple(list1)
print(tup2)

#将字典转换成元组
dict1 = {'a':100, 'b':42, 'c':9}
tup3 = tuple(dict1)
print(tup3)   # ('a', 'b', 'c')

#将区间转换成元组
range1 = range(1, 6)
tup4 = tuple(range1)
print(tup4)

#创建空元组
print(tuple())

2） 访问元组元素

• 使用索引访问单个元素。
• 使用切片访问一组元素。

url = tuple("www.baidu.com")
print(url)   # ('w', 'w', 'w', '.', 'b', 'a', 'i', 'd', 'u', '.', 'c', 'o', 'm')
print(url[4])  # b
print(url[-2])  # o

print(url[1:5])  # ('w', 'w', '.', 'b')
print(url[-6:-1])  # ('d', 'u', '.', 'c', 'o')

3）修改元组

元组是不可变序列，元组中的元素不能被修改，所以我们只能创建一个新的元组去替代旧的元组。

• 对元组变量进行重新赋值。

t5 = (1,2,3,5)
print(t5)  #(1, 2, 3, 5)
t5 = ('java', 'python', 'linux')
print(t5)  # ('java', 'python', 'linux')

• 通过连接多个元组（使用+可以拼接元组）的方式向元组中添加新元素。

t6 = (10,20,30)
t7 = ('jack', 'tom', 'andy')
print(t6 + t7)  # (10, 20, 30, 'jack', 'tom', 'andy')

4） 删除元组

当创建的元组不再使用时，可以通过 del 关键字将其删除。

t8 = ('java', 'python', 'linux', 'C++')
print(t8)  # ('java', 'python', 'linux', 'C++')
del t8
print(t8)  # NameError: name 't8' is not defined. Did you mean: 't'?

Python 自带垃圾回收功能，会自动销毁不用的元组，所以一般不需要通过 del 来手动删除。

4、有序无序、可变与不可变

有序无序：是指可以使用下标索引的方式获取到值数据类型；只要是能够调用用_ iter _()方法获取值的数据类型都是可迭代对象；

• 有序数据类型：字符串、列表、元组。
• 无序数据类型：字典、集合。

可变与不可变：指是否能够对序列进行增、删、改操作；并且，增删改操作后的对象地址不发生改变。

• 不可变数据类型：整形，浮点型，字符串，复数，布尔，元组，固定集合。
• 可变数据类型：列表，字典，集合。

5、字典操作：

python 字典（dict）是一种无序的、可变的序列，它的元素以“键值对（key-value）”的形式存储。

字典类型是 Python 中唯一的映射类型。

• 它指的是元素之间相互对应的关系，即通过一个元素，可以唯一找到另一个元素。

主要特征	解释
通过键而不是通过索引来读取元素	字典类型有时也称为关联数组或者散列表（hash）。它是通过键将一系列的值联系起来的，这样就可以通过键从字典中获取指定项，但不能通过索引来获取。
字典是任意数据类型的无序集合	和列表、元组不同，通常会将索引值 0 对应的元素称为第一个元素，而字典中的元素是无序的。
字典是可变的，并且可以任意嵌套	字典可以在原处增长或者缩短（无需生成一个副本），并且它支持任意深度的嵌套，即字典存储的值也可以是列表或其它的字典。
字典中的键必须唯一	字典中，不支持同一个键出现多次，否则只会保留最后一个键值对。
字典中的键必须不可变	字典中每个键值对的键是不可变的，只能使用数字、字符串或者元组，不能使用列表。

dit = {'id':1, 'name':'xiaoche', 'email':'[e-mail]'}
print(dit,type(dit))

1） 创建字典：

使用 { } 创建字典：

• 键和值之间使用冒号:分隔。
• 相邻元素之间使用逗号,分隔。
• 同一字典中的各个键必须唯一，不能重复。

scores = {
    '语文': 98,
    '数学': 81,
    '英语': 87,
    '体育': 21,
}
print(scores)  # {'语文': 98, '数学': 81, '英语': 87, '体育': 21}

#使用元组和数字作为key
dict1 = {(20, 30): 'great', 30: [1,2,3]}
print(dict1)

#创建空元组
dict2 = {}
print(dict2)

从上面可以看出：字典的键可以是整数、字符串或者元组，只要符合唯一和不可变的特性就行；字典的值可以是 Python 支持的任意数据类型。

通过 fromkeys() 方法创建字典：

lst = ['语文', '数学', '英语']
scores = dict.fromkeys(lst,80)  # 默认值为80，若不写，则为none
print(scores)

通过 dict() 映射函数创建字典

a = dict(name = '张三', passwd = 1234)
print(a)  # {'name': '张三', 'passwd': 1234}

通过应用 dict() 函数和 zip() 函数，可将前两个列表转换为对应的字典。

t1 = ('英语', '数学', '语文')  # #还可以是字符串或列表
l1 = [90,87,45]   #还可以是字符串或元组
a = dict(zip(t1,l1))
print(a)

2） 访问字典元素

通过键来访问对应的值。

• 元素无序，位置不固定，不能使用切片一次性访问多个元素。

d2 = {
    'id': 1,
    'name': 'xiaoch',
    'age': 21,
    'address': '杭州',
}
print(d2)  # {'id': 1, 'name': 'xiaoch', 'age': 21, 'address': '杭州'}
print(d2['name'])  # xiaoch
print(d2['id'])   # 1
print(d2['eamil'])  # KeyError: 'eamil'

注意，键必须是存在的，否则会抛出异常。

get() 方法来获取指定键对应的值

• 当指定的键不存在时，get() 方法不会抛出异常。

d2 = {
    'id': 1,
    'name': 'xiaoch',
    'age': 21,
    'address': '杭州',
}
print(d2.get('email'))  # none
print(d2.get('address'))  # 杭州

当键不存在时，get() 返回空值 None，如果想明确地提示用户该键不存在，那么可以手动设置 get() 的第二个参数。

print(d2.get('email', '[e-mail]'))  # [e-mail]

3） 删除字典：

和删除列表、元组一样，手动删除字典也可以使用 del 关键字。

del d2
print(d2)  # NameError: name 'd2' is not defined

Python 自带垃圾回收功能，会自动销毁不用的字典，所以一般不需要通过 del 来手动删除。

4） 字典添加键值对：

• 直接给不存在的 key 赋值即可。

dit = {
    '语文': 91,
    '数学': 87,
    '英语': 76,
}
print(dit)  # {'语文': 91, '数学': 87, '英语': 76}

dit['体育'] = 32
print(dit)  # {'语文': 91, '数学': 87, '英语': 76, '体育': 32}

dit['java'] = 96
print(dit)  # {'语文': 91, '数学': 87, '英语': 76, '体育': 32, 'java': 96}

5） 字典修改键值对：

Python 字典中键（key）的名字不能被修改，我们只能修改值（value）。

• 将原先的值修改。

dit['语文'] = 79
print(dit)  # {'语文': 79, '数学': 87, '英语': 76, '体育': 32, 'java': 96}

6） 字典删除键值对：

del dit['英语']
del dit['体育']
print(dit)   # {'语文': 79, '数学': 87, 'java': 96}

7） 字典是否存在键值对：

• 一般是判断字典是否包含指定的键。
• 用in 或者 not in 运算符。

print('数学' in dit)  # True
print('python' in dit)  # False

8） 字典中的方法：

使用 dir(dict) 来查看该类型包含哪些方法。

print(dir(dict))
['clear', 'copy', 'fromkeys', 'get', 'items', 'keys', 'pop', 'popitem', 'setdefault', 'update', 'values']

① keys、values、items方法

• keys() 方法用于返回字典中的所有键（key）；
• values() 方法用于返回字典中所有键对应的值（value）；
• items() 用于返回字典中所有的键值对（key-value）。

d2 = {'语文': 87, '数学': 98, '英语': 76}
print(d2.keys())  # dict_keys(['语文', '数学', '英语'])
print(d2.values())  # dict_values([87, 98, 76])
print(d2.items())   # dict_items([('语文', 87), ('数学', 98), ('英语', 76)])

若想操作这几个方法的返回值：

• 使用 list() 函数，将它们返回的数据转换成列表。
• 使用 for in 循环遍历它们的返回值。

l2 = list(d2.keys())
print(l2)   # ['语文', '数学', '英语']

for i in d2.keys():
    print(i)
语文
数学
英语

② copy()方法：

copy() 方法返回一个字典的拷贝，也即返回一个具有相同键值对的新字典。

d3 = {'one': 1, 'two': 2, 'three': 3}
d4 = d3.copy()
print(id(d3), d3)  # 1493226277248 {'one': 1, 'two': 2, 'three': 3}
print(id(d4), d4)  # 1493226287168 {'one': 1, 'two': 2, 'three': 3}

注意，copy() 方法所遵循的拷贝原理，既有深拷贝，也有浅拷贝。

• 上面的例子是深拷贝，对键值对进行了拷贝，从新开了个新内存来存放。
• 对于某些列表类型的值来说，此方法对其做的是浅拷贝，也就是说，d4 中的 [1,2,3] 的值不是自己独有，而是和 d3 共有。

d3 = {'one': 1, 'two': 2, 'three': [1,2,3]}
d4 = d3.copy()
print("列表id", id(d3['three']), "字典d3的id", id(d3))  # 列表id 2557259429568 字典d3的id 2557256518016
print("列表id", id(d4['three']), "字典d4的id", id(d4))  # 列表id 2557259429568 字典d4的id 2557256527936

d3['four'] = 4
print(d3)  # {'one': 1, 'two': 2, 'three': [1, 2, 3], 'four': 4}
print(d4)   # {'one': 1, 'two': 2, 'three': [1, 2, 3]}

d3['three'].remove(1)
print(d3)   # {'one': 1, 'two': 2, 'three': [2, 3], 'four': 4}
print(d4)   # {'one': 1, 'two': 2, 'three': [2, 3]}

③ update() 方法

update() 方法可以使用一个字典所包含的键值对来更新己有的字典。

• 如果被更新的字典中己包含对应的键值对，那么原 value 会被覆盖；
• 如果被更新的字典中不包含对应的键值对，则该键值对被添加进去。

d5 = {'one': 1, 'two': 2, 'three': 3}
d5.update({'one': 10, 'four': 20})
print(d5)  # {'one': 10, 'two': 2, 'three': 3, 'four': 20}

④ pop() 和 popitem() 方法

• pop() 和 popitem() 都用来删除字典中的键值对。
• pop() 用来删除指定的键值对。
• popitem() 用来随机删除一个键值对。

d6 = {'数学': 95, '语文': 89, '英语': 90, '化学': 83, '生物': 98, '物理': 89}
d6.pop('英语')
print(d6)  # {'数学': 95, '语文': 89, '化学': 83, '生物': 98, '物理': 89}
d6.popitem()
print(d6)   # {'数学': 95, '语文': 89, '化学': 83, '生物': 98}

注意：说 popitem() 随机删除字典中的一个键值对是不准确的，虽然字典是一种无须的列表，但键值对在底层也是有存储顺序的，popitem() 总是弹出底层中的最后一个 key-value，这和列表的 pop() 方法类似，都实现了数据结构中“出栈”的操作。

⑤ setdefault() 方法：

setdefault() 方法用来返回某个 key 对应的 value。

• 如果该 key 存在，那么直接返回该 key 对应的 value；
• 如果该 key 不存在，那么先为该 key 设置默认的 defaultvalue，然后再返回该 key 对应的 defaultvalue。
• 如果没设置默认的 defaultvalue，则是none。

d7 = {'数学': 95, '语文': 89, '英语': 90}
d7.setdefault('物理', 17)
print(d7)  # {'数学': 95, '语文': 89, '英语': 90, '物理': 17}
d7.setdefault('化学')
print(d7)   # {'数学': 95, '语文': 89, '英语': 90, '物理': 17, '化学': None}
d7.setdefault('数学', 100)
print(d7)   # {'数学': 95, '语文': 89, '英语': 90, '物理': 17, '化学': None}

6、集合操作

1. 集合中的元素都是唯一的，互不相同。
2. Python 集合会将所有元素放在一对大括号 {} 中，相邻元素之间用“,”分隔。
3. 只能存储不可变的数据类型，包括整形、浮点型、字符串、元组

Python 中有两种集合类型，一种是 set 类型的集合，另一种是 frozenset 类型的集合，它们唯一的区别是，set 类型集合可以做添加、删除元素的操作，而 forzenset 类型集合不行。

1）创建set集合：

• 使用 {} 创建。

s1 = {1,'c',1,(1,2,3),'c'}
print(s1)

• 使用 set() 函数将字符串、列表、元组、range 对象等可迭代对象转换成集合。。

str = "hello,world"
s2 = set(str)
print(s2)   # {'d', 'r', 'o', 'l', 'h', 'e', ',', 'w'}

lst = ['python', 'java', 'linux']
s3 = set(lst)
print(s3)  # {'linux', 'python', 'java'}

t = ('英语', '数学', '语文')
s4 = set(t)
print(s4)   # {'语文', '英语', '数学'}

2） 问set集合元素：

使用循环结构，将集合中的数据逐一读取出来。

s02 = {'java', 'python', 'linux', 'C++'}
for i in s02:
    print(i,end=' ')   # python java C++ linux

3）删除set集合：

使用 del() 语句。python会自动释放不使用的set集合。

4）set集合添加元素：

使用add() 方法。

• 使用 add() 方法添加的元素，只能是数字、字符串、元组或者布尔类型（True 和 False）值。也就是不可变的数据。
• 不能添加列表，字典，集合这种可变数据。

s02.add('Vue')
print(s02)   # {'java', 'linux', 'Vue', 'C++', 'python'}

5） 集合删除元素：

使用 remove() 方法。

• 如果被删除元素本就不包含在集合中，则此方法会抛出 KeyError 错误。
• discard() 方法与remove() 用法一样，但是此方法不会抛出异常。

s02.remove('C++')
print(s02)   # {'linux', 'java', 'python', 'Vue'}

6） 集合做交集、并集、差集运算：

运算操作	Python运算符	含义	例子
交集	&	取两集合公共的元素	>>> set1 & set2 {3}
并集	|	取两集合全部的元素	>>> set1 | set2 {1,2,3,4,5}
差集	-	取一个集合中另一集合没有的元素	>>> set1 - set2 {1,2} >>> set2 - set1 {4,5}
对称差集	^	取集合 A 和 B 中不属于 A&B 的元素	>>> set1 ^ set2 {1,2,4,5}

7） 集合的方法：

dir(set)  # 查看集合的方法

• add() 方法，像集合中添加元素，上面已例举。
• clear() 方法。清空集合中的所有元素。

s02.clear()
print(s02)  # set()

• copy() 方法，拷贝集合元素。

s03 = {10,20,30}
s04 = s03.copy()
print(id(s03), s03)  # 2790463051744 {10, 20, 30}
print(id(s04), s04)  # 2790463050176 {10, 20, 30}

• difference() 方法。将 set1 中有而 set2 没有的元素给 set3。

s05 = {10,20,30}
s06 = {10,100,1000}
s07 = s05.difference(s06)
print(s07)  # {20, 30}

• difference_update() 方法。从 set1 中删除与 set2 相同的元素。

s05.difference_update(s06)
print(s05)  # {20, 30}

• discard() 方法。与remove() 方法用法一样，但是此方法不会抛异常。
• intersection()。取 set1 和 set2 的交集给 set3。

s08 = {10,20,30}
s09 = {30,40,50}
s10 = s08.intersection(s09)
print(s10)  # {30}

• intersection_update()。 取 set1和 set2 的交集，并更新给 set1。

s08.intersection_update(s09)
print(s08)  # {30}

• isdisjoint()。判断 set1 和 set2 是否有交集，有交集返回 False；没有交集返回 True。

print(s08.isdisjoint(s09))  # False

• issubset()。判断 set2 是否是 set1 的子集。

print(s08.issubset(s09))  # True

• pop()。取 set1 中一个元素，并赋值给 a。

a = s09.pop()
print(a)  # 40

• symmetric_difference()。取 set1 和 set2 中互不相同的元素，给 set3。

s = {10,20,30}
s02 = {10,100,1000}
s03 = s.symmetric_difference(s02)
print(s03)  # {100, 1000, 20, 30}

• symmetric_difference_update()。取 set1 和 set2 中互不相同的元素，并更新给 set1。
• union()。取 set1 和 set2 的并集，赋给 set3。

s03 = s.union(s02)
print(s03)  # {20, 100, 1000, 10, 30}

• update()。添加列表或集合中的元素到 set1。

ss = {1,2,3}
lst = ['jack', 'tom']
ss.update(lst)
print(ss)  # {1, 2, 3, 'tom', 'jack'}

tt = ('python', 'java')
ss.update(tt)
print(ss)  # {1, 2, 3, 'java', 'jack', 'tom', 'python'}

7、zip函数：

zip() 函数是 Python内置函数之一，它可以将多个序列（列表、元组、字典、集合、字符串以及 range() 区间构成的列表）“压缩”成一个 zip 对象。所谓“压缩”，其实就是将这些序列中对应位置的元素重新组合，生成一个个新的元组。

my_list = [11,12,13]
my_tuple = (21,22,23)
print([x for x in zip(my_list,my_tuple)])  # [(11, 21), (12, 22), (13, 23)]

my_dic = {31:2,32:4,33:5}
my_set = {41,42,43,44}
print([x for x in zip(my_dic)])  # [(31,), (32,), (33,)]

my_pychar = "python"
my_shechar = "shell"
print([x for x in zip(my_pychar,my_shechar)])  # [('p', 's'), ('y', 'h'), ('t', 'e'), ('h', 'l'), ('o', 'l')]

lst = [11,12,13]
t = (21,22,23)
print({x for x in zip(lst,t)})  # {(12, 22), (11, 21), (13, 23)}

d = {'id': 1, 'name': 'tom', 'age': 21}
s = {'linux', 'python', 'java'}
print({x for x in zip(d,s)})   # {('name', 'linux'), ('age', 'java'), ('id', 'python')}

当多个序列中元素个数不一致时，会以最短的序列为准进行压缩。

lst = [11,12,13]
t = (21,22,23,24,25)
print({x for x in zip(lst,t)})  # {(12, 22), (11, 21), (13, 23)}

8、reversed 函数

reversed 函数：对于给定的序列（包括列表、元组、字符串以及 range(n) 区间），该函数可以返回一个逆序序列的迭代器（用于遍历该逆序序列）。

lst = [1,2,3,4,5]
print([x for x in reversed(lst)])  # [5, 4, 3, 2, 1]

str = 'hello'
print([x for x in reversed(str)])  # ['o', 'l', 'l', 'e', 'h']