第五章组合数据类型

最新推荐文章于 2024-05-30 11:43:13 发布

养个小橘猫

最新推荐文章于 2024-05-30 11:43:13 发布

阅读量754

点赞数 27

分类专栏： Python 文章标签： python

本文链接：https://blog.csdn.net/lxl_15139204961/article/details/137511973

版权

Python 专栏收录该内容

14 篇文章 0 订阅

订阅专栏

第五章组合数据类型

序列的索引及切片操作

字符串是有序的字符序列。属于序列结构的还有列表、元组、集合和字典。其中列表和元组叫有序序列；集合和字典叫无序序列。同时列表、元组、集合和字典又是Python中的组合数据类型。

序列是一个用于存储多个值的连续空间，每个值都对应一个整数的编号，称为索引。
在这里插入图片描述

#正向递增索引
s='helloworld'
for i in range(0,len(s)):
    print(i,s[i],end='\t\t')
print()
#反向递减索引
for i in range(-len(s),0):
    print(i,s[i],end='\t\t')

print()
print(s[9],s[-1]) #对应的是同一个位置

在这里插入图片描述

切片操作：
注意：切片操作可以应用于所有的序列类型。“切片”指的是访问序列元素的一种方法，只不过访问的不是一个，而是一定范围内的元素。通过切片操作可以生成一个新的序列。
在这里插入图片描述
举例：

s='HelloWorld'
#切片操作
s1=s[0:5:2] #索引从0开始，到5结束(不包含5)，步长为2
print(s1)
#省略了开始位置，start默认从0开始
print(s[:5:1])
#省略开始位置start，省略步长step。(省略步长时，步长为1)
print(s[:5:])
#省略结束位置
print(s[0::1]) #stop,默认到序列的最后一个元素（包含最后一个元素）

print(s[5::])
print(s[5:]) #这一句与上一句代码功能相同，省略了结束，省略了一个步长

#省略开始位置，省略结束位置，只写步长
print(s[::2]) #分别获取0，2,4,6,8索引位置上的元素

#步长为负数
print(s[::-1]) #可以将字符串变得逆序
print(s[-1:-11:-1]) #这句代码可以替换上一句，两句的效果一样

在这里插入图片描述

注意学习如何实现字符串逆序操作(在上述代码的最后两句)，关键在于步长为负数：

#步长为负数
print(s[::-1]) #可以将字符串变得逆序
print(s[-1:-11:-1]) #这句代码可以替换上一句，两句的效果一样

在这里插入图片描述

求逆序数的操作如下：

n=1234
reverse=0
while n>0:
    remain=n%10
    n=n//10
    reverse=reverse*10 + remain
print(reverse)

在学习了将字符串逆序的操作后，求逆序数亦可用如下方法：

n=1234
s=str(n)
s1=s[::-1]
n=int(s1)
print(n)

序列的相关操作

操作符/函数	描述说明
x in s	如果x是s的元素，结果为True，否则结果为False
x not in s	如果x不是s的元素，结果为True，否则结果为False
len(s)	序列s中元素的个数(即序列的长度)
max(s)	序列s中元素的最大值
min(s)	序列s中元素的最小值
s.index(x)	序列s中第一次出现元素x的位置
s.count(x)	序列s中出现x的总次数

序列亦有相加、相乘操作。前面学过字符串相加操作，序列包括字符串、列表、元组、集合和字典。

#序列相加操作。前面学过字符串相加操作，序列包括字符串、列表、元组、集合和字典
s1='Hello'
s2='World'
print(s1+s2)

#序列的相乘操作
print(s1*5) #将对字符串s1输出5遍
print('-'*40)

在这里插入图片描述

其他操作：

s='helloworld'
print('e在helloworld中存在吗？',('e' in s))
print('v在helloworld中存在吗？',('v' in s))

print('e在helloworld中不存在吗？',('e' not in s))
print('v在helloworld中不存在吗？',('v' not in s))

#内置函数的使用
print('len()',len(s))
print('max()',max(s)) #最大值、最小值是按照ASCII码计算的
print('min()',min(s))

#序列对象的方法，使用序列的名称，打点调用
print('s.index():',s.index('o')) #o在s中第一次出现的索引位置 4
#print('s.index():',s.index('v')) #ValueError: substring not found,报错的原因是v在字符串中不存在，不存在所以找不到
print('s.count():',s.count('o')) #统计o在字符串s中出现的次数

在这里插入图片描述

列表的基本操作

整数类型、浮点数类型、字符串类型都是不可变数据类型，而列表是Python中的可变数据类型，也叫可变序列。

列表是指：
1、是指一系列的按特定顺序排列的元素组成。
2、是Python中内置的可变序列。
3、在Python中使用 [ ] 定义列表，元素与元素之间使用英文的逗号分隔
4、列表中的元素可以是任意的数据类型

列表是组合数据类型，组合数据类型的存值有很多个，而且数据类型可以不一致。

列表的创建方式有两种：
(1) 使用 [ ] 直接创建列表。
语法结构如下：

列表名=[element1,element2,…,elementN]

(2) 使用内置函数list()创建列表
语法结构如下：

列表名=list(序列)

列表的删除(语法结构如下)：

del 列表名

#使用 [ ] 直接创建列表
lst=['hello','world',98,100.5]
print(lst)

#使用内置函数list()创建列表
lst2=list('helloworld')
lst3=list(range(1,10,2)) #从1开始到10结束，步长为2，不包括10
print(lst2)
print(lst3)

#列表是序列的一种，对序列的操作符，运算符，函数均可以使用
print(lst+lst2+lst3) #序列中的相加操作
print(lst*3) #序列的相乘操作
print(len(lst))
print(max(lst3))
print(min(lst3))

print(lst2.count('o')) #统计o的个数
print(lst2.index('o')) #o在列表lst2中第一次出现的位置

#列表的删除操作
lst4=[1,2,3,4,5,6,7,8,9]
print(lst4)
#删除列表
del lst4
#print(lst4) #报错NameError: name 'lst4' is not defined

在这里插入图片描述

enumerate函数

enumerate：枚举。

enumerate()函数使用语法结构：

for index,item in enumerate(lst):
输出index和item

注意：这里的index并不是索引，而是序号。可以手动修改序号的起始值。(index,item都是自己起的变量名)

列表的遍历操作

列表的遍历操作有三种实现方式：
1、方法一：使用for循环遍历列表元素。
2、方法二：使用列表的索引。需要用到for循环，range()函数，len()函数，根据索引进行遍历。
3、方法三：使用enumerate()函数。

#列表的遍历操作
lst = ['hello','world','python','php']
#方法一：使用for循环遍历列表元素
for item in lst:
    print(item)

#方法二：使用列表的索引。需要用到for循环，range()函数，len()函数，根据索引进行遍历
for i in range(0,len(lst)):
    print(i,'--->',lst[i])

#方法三：使用enumerate()函数
for index,item in enumerate(lst):
    print(index,item) #index是序号，不是索引

#手动修改序号的起始值
for index,item in enumerate(lst,start=1):
    print(index,item)

for index,item in enumerate(lst,1): #start省略不写，直接写起始值也可以
    print(index,item)

在这里插入图片描述

列表的特有操作

列表是Python中的可变数据类型，在Python中的可变数据类型具有增、删、改、查这样的方法。当进行增、删、改时，列表的内存地址是不变的。

列表的相关操作方法：

列表的方法	描述说明
lst.append(x)	在列表lst最后增加一个元素
lst.insert(index,x)	在列表中第index位置增加一个元素
lst.clear()	清除列表lst中所有元素
lst.pop(index)	将列表lst中第index位置的元素取出，并从列表中将其删除
lst.remove(x)	将列表lst中出现的第一个元素x删除
lst.reverse(x)	将列表lst中的元素反转
lst.copy()	拷贝列表lst中的所有元素，生成一个新的列表

# 列表的相关操作
lst = ['hello', 'world', 'python', 'php']
print('原列表：', lst, id(lst))  # Python 中 id() 函数用于获取对象的内存地址

# 增加元素的操作
lst.append('sql')
print('增加元素后的列表：', lst, id(lst))  # 可变数据类型：元素个数可变，但内存地址不变

# 使用insert(index,x)在指定的index位置上插入元素x
lst.insert(1, 100)
print(lst, id(lst))

# 列表元素的删除操作
lst.remove('world')
print('删除元素之后的列表', lst, id(lst))

# 使用pop(index)根据索引将元素取出，然后再删除
print(lst.pop(1))
print(lst, id(lst))

# 清除列表中所有的元素
# lst.clear()
# print(lst,id(lst))

# 列表的反向
lst.reverse()  # 不会产生新的列表，在原列表的基础上进行的
print(lst, id(lst))

# 列表的拷贝，将产生一个新的列表对象
new_lst = lst.copy()
print(lst, id(lst))
print(new_lst, id(new_lst))

# 列表元素的修改操作
# 根据索引进行修改元素
lst[1] = 'mysql'
print(lst)

在这里插入图片描述

列表的排序操作

在这里插入图片描述
注意：
(1) 列表对象的sort方法是在原列表的基础上进行排序，不会产生新的列表对象。
(2) 内置函数 sorted( ) 排序后则会产生新的列表对象，而原列表不变。

(1) 列表对象的sort方法练习：

# 列表的排序操作
lst = [1, 2, 3, 4, 5, 6, 7, 8, 9]
print('原列表：', lst)

# 使用sort()方法
# 排序，默认是升序
lst.sort()  # 排序是在原列表的基础上进行的，不会产生新的列表对象
print('升序', lst)

# 排序，降序
lst.sort(reverse=True)
print('降序：', lst)

# 英文字母也是可以排序的，是按照ASCII码值
lst2 = ['banana', 'apple', 'Cat', 'Orange']
print('原列表：', lst2)
# 升序排序，先排大写，再排小写。(根据ASCII码)
lst2.sort()
print('升序：', lst2)
# 降序,先排小写，再排大写
lst2.sort(reverse=True)
print('降序：', lst2)

# 自己指定排序规则
# 忽略大小写进行比较。忽略大小写我直接把所有的都转成小写，或都转成大写。
# lower()函数：将字符串都转成小写。需要注意，这里作为参数lower不能加括号。参数不加括号，调用才加括号
lst2.sort(key=str.lower)
print(lst2)

在这里插入图片描述

(2) 内置函数sorted()练习：

# 列表的排序操作
lst = [1, 2, 3, 4, 5, 6, 7, 8, 9]
print('原列表：', lst)

# 使用sorted()方法。注意：使用sorted方法会产生一个新的列表对象
# 排序，默认是升序
asc_lst = sorted(lst)
print('升序：', asc_lst)
print('原列表：', lst)

# 降序
desc_lst = sorted(lst, reverse=True)
print('降序：', desc_lst)
print('原列表：', lst)

# sorted亦可对字符串进行排序，同样是按照ASCII码值
lst2 = ['banana', 'apple', 'Cat', 'Orange']
print('原列表：', lst2)
new_lst = sorted(lst2, key=str.lower)  # 忽略大小写进行排序
print('升序：', new_lst)

在这里插入图片描述

列表生成式

在创建列表时可以用如下方式：

lst = [1, 2, 3, 4, 5, 6, 7, 8, 9]

即手动的在 [ ] 中填元素。

除了直接手动的将元素值写到 [ ] 当中之外，还可以通过列表生成式去创建列表中的元素。

列表生成式的语法结构：

lst = [expression for item in range]
lst = [expression for item in range if condition]

# 列表生成式
import random

lst = [item for item in range(1, 11)]
print(lst)

lst = [item * item for item in range(1, 11)]
print(lst)

lst = [random.randint(1, 100) for i in range(10)]
print(lst)

# 从列表中选择符合条件的元素组成新的列表
lst = [i for i in range(10) if i % 2 == 0]
print(lst)

在这里插入图片描述

二维列表

在这里插入图片描述

# 创建二维列表
lst = [
    ['城市', '环比', '同比'],
    ['北京', 102, 103],
    ['上海', 104, 105],
    ['深圳', 106, 107]
]
print(lst)

# 遍历二维列表使用双层for循环
for row in lst:  # 行
    for item in row:  # 列
        print(item, end='\t')
    print()  # 换行

# 列表生成式生成一个4行5列的二维列表
lst2 = [[j for j in range(5)] for i in range(4)]
print(lst2)

在这里插入图片描述

元组

与列表不同的是，元组是Python中的不可变数据类型，元组没有增、删、改的一系列操作。对于元组类型，只可以根据索引获取元素或使用 for 循环遍历元素。

元组：
1、是Python中内置的不可变序列。
2、在Python中使用 ( ) 定义元组，元素与元素之间使用英文的逗号分隔。
3、元组中只有一个元素的时候，逗号也不能省略。

元组的创建方式有两种：
(1) 使用 ( ) 直接创建元组：
语法结构如下：

元组名 = (element1,element2,…,elementN)

(2) 使用内置函数 tuple( ) 创建元组
语法结构如下：

元组名 = tuple(序列)

删除元组：

del 元组名

创建元组练习：

# 使用小括号创建元组
t = ('hello', [1, 2, 3], 'python', 'world')
print(t)

# 使用内置函数tuple()创建元组
t = tuple('helloworld')
print(t)

t = tuple([1, 2, 3])
print(t)

在这里插入图片描述

元组是序列，所以序列的一些操作元组也能用。

# 元组是序列的一种，序列中的操作，元组也可以使用
t = (1, 2, 3, 4, 5, 6, 7, 8, 9)
print('6在元组中是否存在：', (6 in t))
print('6在元组中是否不存在：', (6 not in t))
print('最大值：', max(t))
print('最小值：', min(t))
print('len:', len(t))
print('t.index:', t.index(6))
print('t.count:', t.count(6))

在这里插入图片描述

注意：元组中只有一个元素的时候，逗号也不能省略。

t = (1)
print(t, type(t))  # 1 <class 'int'>

#如果元组中只有一个元素，逗号不能省
t = (1,)
print(t, type(t))  # (1,) <class 'tuple'>

在这里插入图片描述

元组的删除(同列表的删除是一样的)：

# 元组的删除
t = (1, 2, 3, 4, 5, 6, 7, 8, 9)
del t
print(t)  # NameError: name 't' is not defined

元组的遍历

元组的遍历同列表的遍历是一样的(也有三种方式)。切片操作可以应用于所有的序列，元组是序列的一种，故元组也能切片。

t = ('python', 'hello', 'world')

# 根据索引访问元组
print(t[0])

# 切片操作可以应用于所有的序列，元组是序列的一种，故元组也能切片
t2 = t[0:3:2]
print(t2)

# 元组的遍历
for item in t:
    print(item, end='\t')

print()

# for+range()+len()
for i in range(len(t)):
    print(t[i], end='\t')

print()

# 使用enumerate()
for index, item in enumerate(t):
    print(index, '--->', item)

# index是序号，可以手动修改。
for index, item in enumerate(t, start=1):  # start可以省略
    print(index, '--->', item)

在这里插入图片描述

元组生成式

前面提到的列表是有生成式的，其实元组也有生成式，只不过元组生成式的结果是一个生成器对象，需要转化为元组或者列表才能看到内容。

# 元组的生成式
t = (i for i in range(1, 4))
print(t)

t = tuple(t)
print(t)
for item in t:
    print(item)

在这里插入图片描述

元组生成式的结果是生成器对象，要想看到里面的内容除了转成元组或列表后遍历外，还可以使用__next__()方法。注意：需要用生成器对象调用__next__()方法。同时使用生成器对象.__next__() 会取出一个生成器对象中的一个元素，一旦取出，该元素在生成器对象中就不存在了。

# 元组的生成式
t = (i for i in range(1, 4))
print(t)

# t = tuple(t)
# print(t)
# for item in t:
#     print(item)

# 元组生成式的结果是生成器对象，要想看到里面的内容除了转成元组或列表后遍历外，还可以使用__next__()方法
# 注意：需要用生成器对象调用__next__()方法
print(t.__next__())
print(t.__next__())
print(t.__next__())

# 注意：生成器对象.__next__() 会取出一个生成器对象中的一个元素，一旦取出，该元素在生成器对象中就不存在了
t = tuple(t)
print(t)

在这里插入图片描述

元组和列表的区别

元组和列表的区别如下：

元组	列表
不可变序列	可变序列
无法实现增、删、改操作	append()、insert()、remove()、pop()等方法实现增、删、改操作
支持索引访问元素，支持切片，不支持修改元素	支持索引访问元素，支持切片，支持修改元素
访问和处理速度快	访问和处理速度慢
可以作为字典的键	不能作为字典的键

Python中不可变序列无法实现增、删、改操作；可变序列可以实现增、删、改操作。元组的访问和处理速度快，而列表的访问和处理速度慢，主要就是因为列表是可变序列。

字典

字典类型是根据一个信息查找另一个信息的方式构成了“键值对”，它表示索引用的键和对应的值构成的成对关系。
在这里插入图片描述

在字典中没有整数索引的概念，所以要想检索字典当中的元素可以通过键去检索元素。

字典也是Python中的可变数据类型，因此也具有增、删、改等一系列操作。与列表不同的是，字典中的元素是无序的(字典底层用了hash)，第一个添加到字典当中的元素在内存当中它并不一定是在第一位的。字典中键要求必须唯一，只能有一个，不能有重复；但是值可以重复。而且字典中的键必须是不可变序列，因此字符串、整数、浮点数、元组可以作为键，而属于可变数据类型的列表不可以作为键。

t=(10,20,30)
print({t:10}) #t是key，10是value。不可变数据类型都可以作为key，元组是不可变数据类型

lst=[10,20,30]
print({lst:10}) #TypeError: unhashable type: 'list'。列表是可变数据类型，不能作为key

在这里插入图片描述

字典类型的创建方式：
(1) 直接使用 { } 创建字典

d = {key1:value1,key2:value2,…}

(2) 使用内置函数 dict( ) 创建字典

dict(key1 = value1,key2 = value2,…)

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

zip(lst1,lst2) # 这里也可以是元组

在这里插入图片描述
需要注意的是如果使用 (3) ，实际上 zip( ) 函数返回的是一个zip对象，无法看到里面的内容，需要再用 dict() 函数转成字典，才能看到里面的内容。

# 创建字典。
# 方法一：直接使用{}
d = {10: 'cat', 20: 'dog', 30: 'pet', 20: 'zoo'}
print(d)  # key相同时，value值进行了覆盖

# 方法二：使用zip()
lst1 = [10, 20, 30, 40]
lst2 = ['cat', 'dog', 'pet', 'zoo', 'car']
zipobj = zip(lst1, lst2)
print(zipobj)  # <zip object at 0x000002042AA6E500>
# print(list(zipobj)) # [(10, 'cat'), (20, 'dog'), (30, 'pet'), (40, 'zoo')]
# 转成字典必须是zip对象，而上一句会将zip对象转成列表。所以要将上一句注释掉
d = dict(zipobj)
print(d)  # {10: 'cat', 20: 'dog', 30: 'pet', 40: 'zoo'}

# 方法三：使用dict()
d = dict(cat=10, dog=20)  # 左侧cat是key，右侧是value
print(d)

在这里插入图片描述

字典是序列的一种，因此序列的相关操作，字典亦可以使用。

# 字典属于序列，序列中的操作，在字典中也可以用
d = {'cat': 10, 'dog': 20, }

print('max:', max(d))
print('min:', min(d))
print('len:', len(d))

在这里插入图片描述

字典的删除同列表、元组的删除一样。

del 字典名

注意：字典中key是无序的。在Python 3.5及其之前的版本字典的key在输出时无序，但是从Python 3.6版本之后Python解释器进行了处理，所以才会看到输出的顺序与添加的顺序“一致”。
在这里插入图片描述

字典元素的访问及遍历

字典没有整数索引，字典是通过键来取值的。

字典元素的取值：

d[key] 或 d.get(key)

注意：这两种取值方式也是有点区别的，如果key不存在，d[key]会报错；而d.get(key)可以指定默认值。(见下方代码)

d = {'hello': 10, 'world': 20, 'python': 30}
# 访问字典中的元素
# (1)使用 d[key]
print(d['hello'])

# (2)使用 d.get(key)
print(d.get('hello'))

# 两种访问字典元素的方法是有区别的：如果key不存在，d[key]会报错；而d.get(key)可以指定默认值
# print(d['java'])  # KeyError: 'java'
print(d.get('java'))  # None
print(d.get('java', '不存在'))  # 指定默认值

在这里插入图片描述

字典元素的遍历：
(1) 遍历出key与value的元组：

for element in d.items():
pass

(2) 分别遍历出key和value

for key,value in d.items():
pass

d = {'hello': 10, 'world': 20, 'python': 30}
# 字典的遍历
for item in d.items():
    print(item)  # key=value组成的一个元组

# 在使用for循环遍历时，分别获取key，value
for key, value in d.items():
    print(key, '-->', value)

在这里插入图片描述

字典操作的相关方法

字典的相关操作方法：

字典的方法	描述说明
d.keys()	获取所有的key数据
d.values()	获取所有的value数据
d.pop(key,default)	key存在获取相应的value,同时删除key-value对，否则获取默认值
d.popitem()	随机从字典中取出一个key-value对，结果为元组类型，同时将该key-value从字典中删除
d.clear()	清空字典中所有的key-value对

d = {1001: '李梅', 1002: '王华', 1003: '张峰'}
print(d)

# 向字典中添加元素
d[1004] = '张三'  # 直接使用赋值运算符向字典中添加元素
print(d)

# 获取字典中所有的key
keys = d.keys()
print(keys)  # 得到的是一个对象：dict_keys([1001, 1002, 1003, 1004])
# 要想查看该dict_keys对象中的每一个值，可以转成列表或元组
print(list(keys))  # 转成列表
print(tuple(keys))  # 转成元组

# 获取字典中所有的value
values = d.values()
print(values)  # 得到的是一个对象：dict_values(['李梅', '王华', '张峰', '张三'])
# 要想查看该dict_values对象中的每一个值，可以转成列表或元组
print(list(values))  # 转成列表
print(tuple(values))  # 转成元组

# 将字典中的数据转成key-value的形式，以元组的方式进行展现
lst = list(d.items())
print(lst)

d = dict(lst)
print(d)

# 使用pop()函数
print(d.pop(1001))
print(d)

# 设置默认值
print(d.pop(1008, '不存在'))

# 随机删除
print(d.popitem())
print(d)

# 清空字典中所有的元素
d.clear()
print(d)

在这里插入图片描述

在Python中一切皆对象，每个对象都有一个布尔值。空列表、元组、字典的布尔值均为False。

# 在Python中一切皆对象，每个对象都有一个布尔值
lst = []  # 空列表
t = ()  # 空元组
d = {}  # 空字典
print(bool(lst))  # 空列表的布尔值为False
print(bool(t))  # 空元组的布尔值为False
print(bool(d))  # 空字典的布尔值为False

在这里插入图片描述

字典生成式

字典生成式的语法结构：

d = {key:value for item in range}
d = {key:value for key,value in zip(lst1,lst2)}

import random

d = {item: random.randint(1, 100) for item in range(4)}
print(d)

# 创建两个列表
lst1 = [1001, 1002, 1003]
lst2 = ['陈梅梅', '王一一', '李丽丽']
d = {key: value for key, value in zip(lst1, lst2)}
print(d)

在这里插入图片描述

集合

集合：
1、Python中的集合与数学中集合的概念一致；
2、Python中的集合是一个无序的不重复元素序列；
3、集合中只能存储不可变数据类型；
4、在Python中集合使用 { } 定义；
5、与列表、字典一样，都是Python中的可变数据类型；

集合只能存储不可变数据类型，因此可以存储字符串、整型、浮点型、元组；但是不能存储列表、字典。

集合使用 { } 定义。注意字典也是使用 { } 定义。

同空列表、元组、字典的布尔值为False一样，空集合的布尔值也为False。

集合的创建方式有两种：
(1) 使用 { } 直接创建集合：

s = {element1,element2,…,elementN}

(2) 使用内置函数 set() 创建集合

s = set(迭代对象)

集合的删除(同列表、元组、字典一样)：

del 集合名

# {}直接创建集合
s = {10, 20, 30, 40}
print(s)

# 集合只能存储不可变数据类型
# s = {[10, 20], [30, 40]}  # TypeError: unhashable type: 'list'

# 使用set()创建集合
s = set()  # 创建一个空集合。空集合的布尔值为False
print(s)
s = {}  # 使用这种方式创建的是字典，而非空集合
print(s, type(s))  # dict

s = set('helloworld')
print(s)  # {'l', 'd', 'w', 'h', 'e', 'r', 'o'}。集合是无序且不重复

s2 = set([10, 20, 30])
print(s2)

s3 = set(range(1, 10))
print(s3)

在这里插入图片描述

集合是序列的一种，序列的操作，集合也可以用。

s = set(range(1, 10))
print(s)
# 集合是序列的一种，序列的操作，集合也可以用
print('max:', max(s))
print('min:', min(s))
print('len:', len(s))

print('9在集合中存在吗？', (9 in s))
print('9在集合中不存在吗？', (9 not in s))

在这里插入图片描述

集合的操作符

集合与数学中集合的概念是一致的，在集合中有一些操作符：
在这里插入图片描述

# 集合操作符
A = {10, 20, 30, 40, 50}
B = {30, 50, 60, 70, 20}
# 交集操作
print(A & B)
# 并集操作。集合无序且不重复，取并集时会去除重复元素
print(A | B)
# 差集操作
print(A - B)
# 补集操作
print(A ^ B)

在这里插入图片描述

集合的操作方法

集合是Python中的可变数据类型，因此可以实现增、删、改操作。

集合的相关操作方法：

集合的方法	描述说明
s.add(x)	如果x不在集合s中，则将x添加到集合s
s.remove(x)	如果x在集合中，将其删除，如果不在集合中，程序报错
s.clear()	清除集合中所有元素

# 集合的相关操作
s = {10, 20, 30}

# 向集合中添加元素
s.add(100)
print(s)

# 删除元素
s.remove(20)
print(s)

# 清空集合中所有元素
s.clear()
print(s)

在这里插入图片描述

集合的遍历

集合的遍历有两种：
(1) 使用for循环
(2) 使用enumerate() 函数。

# 集合的遍历
s = {10, 20, 30}

# for
for item in s:
    print(item)

# enumerate()
# index是序号。且集合是无序的，没有索引
for index, item in enumerate(s):
    print(index, '-->', item)

在这里插入图片描述

集合的生成式

# 集合的生成式
s = {item for item in range(1, 10)}
print(s)

s = {item for item in range(1, 10) if item % 2 == 1}
print(s)

在这里插入图片描述

列表、元组、字典、集合的区别

列表、元组、字典、集合的区别：

数据类型	序列类型	元素是否可重复	是否有序	定义符号
列表list	可变序列	可重复	有序	[ ]
元组tuple	不可变序列	可重复	有序	( )
字典dict	可变序列	Key不可重复,Value可重复	无序	{ key : value }
集合set	可变序列	不可重复	无序	{ }

字典、集合无序的原因是二者在底层都用了hash。

Python 3.11 新特性

在前面讲过一个Python 3.11 新特性叫模式匹配。在模式匹配的基础上还有一个结构模式匹配，可以针对整个数据结构进行匹配。
(1) 结构模式匹配
语法结构如下：

match data:
    case {}:
        pass
    case []:
        pass
    case ():
        pass
    case _:
        pass

练习：

data = eval(input('请输入要匹配的数据：'))
match data:
    case {'name': 'lxl', 'age': 24}:
        print('字典')
    case [10, 20, 30]:
        print('列表')
    case (10, 20, 40):
        print('元组')
    case _:
        print('作用相当于多重if中的else')

(2) 字典合并运算符 |

d1 = {'a': 10, 'b': 20}
d2 = {'c': 30, 'd': 40}
merged_dict = d1 | d2
print(merged_dict)

(3) 同步迭代
语法结构如下：

match data1,data2:
    case data1,data2:
        pass

练习：

fruits = ['apple', 'orange', 'pear', 'grape']
counts = [10, 3, 4, 5]
for f, c in zip(fruits, counts):
    match f, c:
        case 'apple', 10:
            print('10个苹果')
        case 'orange', 3:
            print('3个橘子')
        case 'pear', 4:
            print('4个梨')
        case 'grape', 5:
            print('5串葡萄')

章节习题

在这里插入图片描述

st = [10, 20, 30, 40]
lst.append(('hello', 'world'))  # 这里是将一个元组作为一个元素添加到列表中
print(len(lst))

在这里插入图片描述

注意：
reverse()是没有返回值的，其是在原列表的基础上逆序，并不会产生新的列表。

lst = [1, 3, 5, 7, 9]
print(lst)
print(lst.reverse())
# reverse()是没有返回值的，其是在原列表的基础上逆序，并不会产生新的列表

在这里插入图片描述

注意：
元组只有一个元素时也要加逗号，否则会是整型。

t = (10)
print(type(t))
# 元组只有一个元素时也要加逗号，否则会是整型
t = (10,)
print(type(t))

在这里插入图片描述

练习题

练习一

需求：已知一个列表中存储的是员工的出生年份[88,89,90,98,00,99],由于时间比较久，出生的年份均为2位整数，现需要2位年份前加19，如果年份是00，将需要加上200。

lst = [88, 89, 90, 98, 00, 99]
print(lst)

# 遍历列表的方式
for index in range(len(lst)):
    if str(lst[index]) != '0':
        lst[index] = '19' + str(lst[index])  # 拼接年份，再赋值
    else:
        lst[index] = '200' + str(lst[index])
print('修改后的年份列表：', lst)

在这里插入图片描述

需求中 如果年份是00，将需要加上200 是因为 00 在列表中只会存储一个0。

也可以使用enumerate()函数实现：

lst = [88, 89, 90, 98, 00, 99]
print(lst)

# 使用enumerate()函数
for index, value in enumerate(lst):
    if str(value) != '0':
        lst[index] = '19' + str(value)  # 拼接年份，再赋值
    else:
        lst[index] = '200' + str(value)
print('修改后的年份列表：', lst)

在这里插入图片描述

练习二

模拟购物流程。

需求：从键盘录入5个商品信息(1001手机)添加到商品列表中，展示商品信息，提示用户选择商品，用户选中的商品添加到购物车中(购物车中的商品要逆序)，用户选中的商品不存在需要有相应提示，当用户输入 ‘q’ 时循环结束，显示购物车中的商品。

# 创建一个空列表，用于存储入库的商品信息
lst = []
for i in range(5):  # 连续录入5件商品
    goods = input('请输入商品的编号和商品的名称进行商品入库，每次只能输入一件商品：')
    lst.append(goods)

# 输出所有的商品信息
for item in lst:
    print(item)

# 创建一个空列表，用于存储购物车中的商品
cart = []
while True:
    flag = False  # 代表没有该商品的情况
    num = input('请输入要加购的商品编号：')
    # 遍历商品列表，查询一下要购买的商品是否存在
    for item in lst:
        if num == item[0:4:1]:  # 切片操作，从商品中切出序号
            flag = True  # 代表商品已找到
            cart.append(item)  # 添加到购物车中
            print('商品已成功添加到购物车中')
            break  # 这里退出的是for循环
    if not flag and num != 'q':  # not flag 等价于 flag==False
        print('商品不存在')

    if num == 'q':
        break  # 退出while循环
print('-' * 50)
print('您购物车里已选择的商品为：')
cart.reverse()  # 最后添加的商品应该在购物车最上面。逆序
for item in cart:
    print(item)

在这里插入图片描述

练习三

模拟12306火车票订票流程。

需求：假设北京到天津有以下4个车次可供选择，用户选择所要购买的车次，进行购票进站。
运行效果：
在这里插入图片描述

分析：可以用字典存储车票的详细信息，其中车次可以作为key，其他信息作为value。

代码实现：

# 用字典存储车票的详细信息，其中车次可以作为key，其他信息作为value。
dict_ticket = {
    'G1569': ['北京南-天津南', '18:06', '18:39', '00:33'],
    'G1567': ['北京南-天津南', '18:15', '18:49', '00:34'],
    'G8917': ['北京南-天津西', '18:20', '18:19', '00:59'],
    'G203': ['北京南-天津南', '18:35', '19:09', '00:34']
}
print('车次   出发站-到达站   出发时间   到达时间   历时时长')
# 遍历字典中的元素
for key in dict_ticket.keys():
    print(key, end=' ')  # 为什么不换行，因为车次和车次的详细信息在一行显示
    # 根据key获取出来的值是一个列表
    for item in dict_ticket.get(key):  # 根据key获取值
        print(item, end='    ')
    # 换行
    print()

# 输入用户的购票车次
train_no = input('请输入要购买的车次：')
# 根据key获取值
info = dict_ticket.get(train_no, '车次不存在')  # info是一个列表类型。设置键不存在的默认值
if info != '车次不存在':
    person = input('请输入乘车人，如果是多位乘车人使用逗号分隔：')
    # 获取车次的出发站-到达站，还有出发时间
    s = info[0] + ' ' + info[1] + '开'
    print('您已购买了' + train_no + ' ' + s + '，请' + person + '尽快换取纸质车票。【铁路客服】')
else:
    print('对不起，选择的车次不存在')

在这里插入图片描述

练习四

模拟手机通讯录。

需求：从键盘录入5位好友的姓名和电话，由于通讯录是无序的，所以可以使用集合来实现。

# 创建一个空集合
s = set()
# 录入5位好友的姓名和手机号
for i in range(1, 6):
    info = input(f'请输入第{i}位好友的姓名和手机号：')
    # 添加到集合中
    s.add(info)

# 遍历集合
for item in s:
    print(item)

在这里插入图片描述

养个小橘猫

关注

27
点赞
踩
8

收藏

觉得还不错? 一键收藏
0
评论
第五章组合数据类型

字符串是有序的字符序列。属于序列结构的还有列表、元组、集合和字典。其中列表和元组叫有序序列；集合和字典叫无序序列。同时列表、元组、集合和字典又是Python中的组合数据类型。是一个用于存储多个值的连续空间，每个值都对应一个整数的编号，称为。切片操作：注意：切片操作可以。“切片”指的是访问序列元素的一种方法，只不过访问的不是一个，而是一定范围内的元素。通过切片操作可以生成一个新的序列。注意学习如何实现操作(在上述代码的最后两句)，关键在于。
复制链接

扫一扫