第五章 组合数据类型
第五章 组合数据类型
序列的索引及切片操作
字符串是有序的字符序列。属于序列结构的还有列表、元组、集合和字典。其中列表和元组叫有序序列;集合和字典叫无序序列。同时列表、元组、集合和字典又是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)
原文地址:https://blog.csdn.net/lxl_15139204961/article/details/137511973
免责声明:本站文章内容转载自网络资源,如本站内容侵犯了原著者的合法权益,可联系本站删除。更多内容请关注自学内容网(zxcms.com)!