一、序列和索引
1、序列和索引
序列用于存储多个值的连续空间，每个值都对应一个整数的编号，称为索引
点击查看代码
示例5-1使用索引检索字符串中的元素
#正向递增
s='helloworld'
for i in range(0,len(s)):
print(i,s[i],end='\t\t')
print('\n----------------------')
#反向递减
for i in range(-10,0):
print(i,s[i],end='\t\t')
print('\n',s[9],s[-1])
2、切片操作
序列[start:end:step]
点击查看代码
示例5-2序列的切片操作
s='HelloWorld'
#切片操作
s1=s[0:5:2] #索引从0开始，到5结束（不包含5）步长为2
print(s1)
#省略开始位置，start默认从0开始
print(s[:5:1])
#省略开始位置,省略步长step,默认步长为1
print(s[:5:])
#省略结束位置
print(s[0::1])#stop默认到序列最后一个(包含最后一个）
print(s[5::])
print(s[5:])#12行代码与13行代码功能相同，省略了结束，省略了步长
#更改步长，步长更改为2
print(s[0:5:2])
#省略开始与结束只写步长
print(s[::2])#分别获取 0,2,4,8索引上的元素
#步长为负数
print(s[::-1])
#可以替换为
print(s[-1:-11:-1])
3、序列的相加操作
点击查看代码
示例5-3序列的相加和相乘操作
s='hello'
s2='world'
print(s+s2)#产生一个新的字符串序列
#序列的相乘
print(s*5)
print('-'*40)
点击查看代码
示例5-4序列的相关操作符和函数的使用
s=('helloworld')
print('e在helloworld中存在吗？',('e'in s))#in的使用
print('v在helloworld中存在吗？',('v'in s))
#not in 的使用
print('e在helloworld中存在吗？',('e'not in s))#not in的使用
print('v在helloworld中存在吗？',('v'not in s))
#内置函数的使用
print('len():',len(s))
print('max():',max(s))
print('min():',min(s))
#序列对象的相关方法，使用序列名称打点调用
print('s.index():',s.index('o')) #o在s中第一次出现的索引位置
#print('s.index():',s.index('v'))#ValueError: substring not found,报错的原因是v在字符串中不存在，所以找不到
print('s.count():',s.count('o'))#统计o在s中出现的次数
二、列表类型
1、列表的创建方式
1）使用[]直接创建列表
列表名=[element1,element2......,elementN]
2）使用内置函数list()创建列表
列表名=list(序列)
列表的删除
del 列表名
点击查看代码
示例5-5列表的创建与删除
#直接使用【】创建列表
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(len(lst))
print(max(lst3))
print(min(lst3))
print(lst2.count('o'))#统计o的个数
print(lst2.index('o'))#o在列表lst2中第一次出现的位置
#列表的删除
lst4=[10,20.30]
#删除列表
del lst4
#print(lst4)#NameError: name 'lst4' is not defined. Did you mean: 'lst'?
enumerate函数的使用语法结构
for index,item in enumerate(lst)
#输出index(序号，从0开始)和item
点击查看代码
示例5-6列表的遍历操作
lst=['hello','world','pathon','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):#省略start不写，直接写起始值
print(index,item)
2、列表的相关操作
补充：
1、修改特定位置（索引）的元素值
lst[索引]=值
2、在列表内添加一批元素
lst.extend(数据容器名)
3、删除列表元素
del lst[索引] 或 pop lst[索引]
点击查看代码
示例5-7列表的相关操作
lst=['hello','world','pathon']
print('原列表：',lst,id(lst))
#增加元素的操作
lst.append('sql')
print('增加元素之后',lst,id(lst))
#使用insert(_index,x)在指定位置插入元素x
lst.insert(1,100)
print(lst)
#列表元素的删除操作、
lst.remove('world')
print('删除元素之后的列表：',lst,id(lst))
#使用pop(index),根据索引将元素取出，然后再删除
print(lst.pop(1))
print(lst)
#清除列表中所有元素clear()
# lst.clear()
# print(lst,id(lst))
#列表的反向
lst.reverse()#不会产生新的列表，在原列表的基础上进行的、
print(lst)
#列表的拷贝，将产生一个新的列表对象
new_lst=lst.copy()
print(lst,id(lst))
print(new_lst,id(new_lst))
#列表元素的修改
#根据索引进行修改元素
lst[1]='mysql'
print(lst)
3、列表的排序操作
1）列表对象的sort方法
lst.sort(key=None,reverse=False)
key表示排序的规则，reverse表示排序方式（Flase默认升序，True表示降序）
2)内置函数sorted()
sorted(iterable,key=None,reverse=False)
iterable表示排序对象
点击查看代码
示例5-8列表的排序操作
lst=[4,56,3,78,40,56,89]
print('原列表:',lst)
#列表排序，默认升序、
lst.sort()#排序在原列表基础上产生，不会产生新的列表
print('升序',lst)
#排序，降序
lst.sort(reverse=True)
print('降序',lst)
print('------------------------')
lst2=['banana','apple','Cat','Orange']
print('原列表',lst2)
#升序排列先拍大写再排小写
lst2.sort()
print('升序',lst2)
#降序先排小写，再排大写
lst2.sort(reverse=True)
print('降序',lst2)
#忽略大小写进行比较
lst2.sort(key=str.lower)#转成小写在进行排序
print(lst2)
示例5-9列表的排序
lst=[4,56,3,78,40,56,89]
print('原列表:',lst)
#排序
asc_lst=sorted(lst)
print('升序',asc_lst)
print('原列表',lst)
#降序
desc_lst=sorted(lst,reverse=True)
print('降序',desc_lst)
print('原列表',lst)
lst2=['banana','apple','Cat','Orange']
print('原列表',lst2)
#忽略大小写进行排序
new_lst2=sorted(lst2,key=str.lower)
print('原列表',lst2)
print('排列后的列表',new_lst2)
4、列表生成式
lst=[expression for item in range]
lst=[expression for item in range if condition]
点击查看代码
示例5-10列表生成式的使用
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 _ in range(10)]
print(lst)
#从列表中选择符合元素组成新的列表
lst=[i for i in range(10) if i%2==0]
print(lst)
5、二维列表的遍历
for row in 二维列表:
for item in row:
pass
点击查看代码
示例5-11二维列表的遍历和生成式
#创建二维列表
lst=[
['城市','环比','同比'],
['北京',102,103],
['上海',104,504],
['深圳',100,39]
]
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)
三、元组类型
不可变类型，没有相关增删改一系列操作，只可以获取和用for遍历元素
1、元组的创建
1）使用()直接创建元组
元组名=(element1,element2,......,elementN)
2)使用内置函数tuple()创建元组
元组名=tuple(序列)
2、删除元组
del 元组名
点击查看代码
示例5-12元组的创建与删除
#使用（）创建元组
t=('hello',[10,20,30],'pathon','world')
print(t)
#使用内置函数创建元组
t=tuple('helloworld')
print(t)
t=tuple([10,20,30])
print(t)
print('10在元组是否存在：',(10 in t))
print('10在元组是否存在：',(10 not in t))
print('最大值：',max(t))
print('最小值：',min(t))
print('len；',len(t))
print('t.index:',t.index(10))
print('t.count:',t.count(10))
#如果元组中只有一个元素
t=(10)
print(t,type(t))
#如果元组中只有一个元素，逗号不能省
y=(10,)
print(y,type(y))
#元组的删除
del t
#print(t)#NameError: name 't' is not defined,删除后不存在t
示例5-13元组的访问与遍历
t=('pathon','hello','world')
#根据索引访问元组
print(t[0])
t2=t[0:3:2]#元组支持切片操作
print(t2)
#元组的遍历
for item in t:
print(item)
#for+range()+len()
for i in range(len(t)):
print(i,t[i])
#使用enumerate()
for index,item in enumerate(t):
print(index,'--->',item)
for index,item in enumerate(t,start=11):#序号从11开始
print(index,'--->',item)
示例5-14元组生成式
t=(i for i in range(1,4))
print(t)#输出生成器对象
# t=tuple(t)
# print(t)
#遍历
# for item in t:
# print(item)
print(t.__next__())
print(t.__next__())
print(t.__next__())
t=tuple()
print(t)
字典类型
可变数据类型，字典中key无序，‘key’唯一且为不可变序列
1、字典类型的创建方式
1）使用{}直接创建字典
d={key1:value1,key2......}
2)使用内置函数dict()创建字典
dict(key1=value1,key2=value2......)
- 通过映射函数创建字典
zip(lst1,lst2)
点击查看代码
示例5-15字典的创建与删除
#(1)创建字典
d={10:'cat',20:'dog',30:'pet',20:'zoo'}
print(d)#key相同时，value值进行了覆盖
#(2)zip函数
lst1=[10,20,30,40]
lst2=['cat','dog','pet','zoo','car']
zipobj=zip(lst1,lst2)
print(zipobj)#<zip object at 0x0000025F0D533FC0>
#print(list(zipobj))#[[(10, 'cat'), (20, 'dog'), (30, 'pet'), (40, 'zoo')]
d=dict(zipobj)
print(d)#{10: 'cat', 20: 'dog', 30: 'pet', 40: 'zoo'}
#使用参数创建字典
d=dict(cat=10,dog=20)#左侧cat是key，右侧的是value
print(d)
t=(10,20,30)
print({t:10})#t是key，10是value，元组可以作为字典中的key
# lst=[10,20,30]
# print({lst:10})#TypeError: unhashable type: 'list';列表不能作为字典中的key
#字典属于序列
print('max',max(d))
print('min',max(d))
print('len',len(d))
#字典的删除
del d
#print(d)
2、字典的访问与遍历
字典元素的取值
d[key]或d.get(key)
字典元素的遍历
1)遍历出key和value的元组
for element in d.items():
pass
2)分别遍历出key 和value
for key.value in d.items():
pass
点击查看代码
示例5-16字典的访问与遍历
d={'hello':10,'world':20,'pathon':30}
#访问字典中的元素
#（1）使用d[key]
print(d['hello'])
#(2)d.get(key)
print(d.get('hello'))
#二者之间是有区别的，如果key不存在，d[get]报错d.get(key)可以指定默认值
# print(d['java'])#KeyError: 'java'
print(d.get('java'))#None
print(d.get('java','不存在'))
#字典的遍历
for item in d.items():
print(item)#key=value组成的一个元素
#使用for循环遍历时，分别获取key和value
for key,value in d.items():
print(key,'--->',value)
3、字典的相关操作
点击查看代码
示例5-17字典的相关操作
d={1001:'李梅',1002:'王华',1003:'张锋'}
print(d)
#向字典中添加元素
d[1004]='张丽丽'#直接使用赋值运算符向字典中添加元素
print(d)
#获取字典中的元素
keys=d.keys()
print(keys)#dict_keys([1001, 1002, 1003, 1004])
print(list(keys))
print(tuple(keys))
#获取字典中所有的value
values=d.values()
print(values)
print(list(values))
print(tuple(values))
#如何将字典中的数据转为键值对的形式
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)
#Pathon中一切对皆象，每个对象都有一个bool值
print(bool(d))
4、字典生成式
d={key:value for item in range}
d={key:value for key,value in zip(lst1,lst2)}
点击查看代码
示例5-18字典生成式
import random
d={item :random.randint(1,100) for item in range(4)}
print(d)
#创建两个列表
lst=[1001,100,1003]
lst2=['陈美美','王一一','李乐乐']
d={key:value for key,value in zip(lst,lst2)}
print(d)
集合类型
1、集合创建
1）使用{}创建集合
s={element1,element2,....,elementN}
2）使用内置函数创建集合
s=set(可迭代对象)
2、集合的删除
del 集合名
点击查看代码
示例5-19集合的创建与删除
#使用{}创建集合
s={10,20,30}
print(s)
#集合只能存储不可变数据类型
# s={[10,20],[30,40]}#TypeError: unhashable type: 'list'
# print(s)
#使用set()创建集合
s=set()#创建了空集合，空集合的布尔值为Flase
print(s)
s={}#创建的是集合还是字典？
print(s,type(s))#创建的是字典
s=set('helloworld')
print(s)#无序且不重复
s2=set([10,20,30])
print(s2)
s3=set(range(1,10))
print(s3)
#集合属于序列的一种
print('max',max(s3))
print('min',min(s3))
print('len',len(s3))
print('9在集合中存在吗',(9 in s3))
print('9在集合中不存在吗',(9 not in s3))
#集合的删除
del s3
#print(s3)#NameError: name 's3' is not defined. Did you mean: 's'?
3、集合的相关操作符
交集 A&B
并集 A|B
差集 A-B
补集 A^B
点击查看代码
示例5-20集合的操作符
A={10,20,30,40,50}
B={30,50,88,76,20}
#交集操作
print(A&B)
#并集操作
print(A|B)
#差集操作
print(A-B)
#补集操作
print(A^B)
4、集合的相关操作
点击查看代码
示例5-21集合的相关操作
s={10,20,30}
#向集合中添加元素
s.add(100)
print(s)
#删除元素
s.remove(20)
print(s)
#清空集合中所有元素
# s.clear()
# print(s)
#集合的遍历操作
for item in s:
print(item)
#使用enumerate()函数
for index,item in enumerate(s):
print(index,'--->',item)
#集合的生成式
s={i for i in range(1,10)}
print(s)
s={i for i in range(1,10) if i%2==1}
print(s)
Pathon3.11的新特性
1、结构模式匹配
match data:
case {}:
pass
case []:
pass
case ():
pass
case _:
pass
点击查看代码
示例5-22结构的模式匹配
data=eval(input('请输入要匹配的数据:'))
match data:
case {'name':'ysj','age':20}:
print('字典')
case [10,20,30]:
print('元组')
case (10,20,40):
print('元组')
case _:
print('相当于多重if中的else')
2、字典合并运算符 |
点击查看代码
示例5-23合并字典的运算符
d1={'a':10,'b':20}
d2={'c':30,'d':40}
print(d1|d2)
match data1,data2:
case data1,data2:
pass
点击查看代码
示例5-24同步迭代
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串葡萄')
点击查看代码
实战一
lst=[88,89,92,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)
#方法2
for index,value in enumerate(lst):
if str(lst[index]) != '0':
lst[index]='19'+str(value)#拼接年份再赋值
else:
lst[index] = '200' + str(value)
print(lst)
#我的思路
#实战1
# lst=[88,89,92,98,00,99]
# print('原列表：',lst)
#
# for i in range(0,len(lst)):
# if lst[i]==00:
# lst2=lst[i]
# lst.pop(i)
# lst.insert(i,2000+lst2)
# else:
# lst2 =lst[i]
# lst.pop(i)
# lst.insert(i, 1900+ lst2)
# print(lst)
编写代码时存在问题：在列表中判断商品时，无法实现部分匹配——>可以采用切片操作
点击查看代码
实战二
#我的思路
lst=list()
for i in range(5):
commodity=input('请输入商品编号和名称进行商品入库，每次只能输入一个商品：')
lst.append(commodity)
for j in range(0,len(lst)):
print(lst[j])
lst2=list()
for k in range(0,len(lst)):
com1=input('请输入要购买的编号：')
for l in range(0,len(lst)):
if com1==lst[l][0:4]:
print('商品已成功添加到购物车')
lst2.append(lst[l])
break
if com1!=lst[l][0:4] and com1!='q':
print('该商品不存在')
if com1=='q':
break
print('------------------------')
lst2.sort(reverse=True)
print('您的购物车产品为：')
for m in range(0,len(lst2)):
print(lst2[m])
#老师思路
#创建一个空列表，用于存储入库商品信息
lst=[]
for i in range(5):
goods=input('请输入商品编号和名称进行商品入库，每次只能输入一个商品：')
lst.append(goods)
#输出所有的商品信息
for item in lst:
print(item)
#创建一个空列表，用于存储购物车中的shangp
cart=[]
while True:
flag=False#没有商品
num=input('请输入要购物的商品编号：')
#遍历商品列表，查询一下购买商品是否存在
for item in lst:
if num==item[0,4]:#切片操作，从商品中切出序号
flag=True#代表商品已经找到
cart.append(item)
print('商品已成功添加到购物车')
break#退出for循环
if not flag and num!='q': #not flag==False
print('该商品不存在')
if num=='q':
break
print('-'*50)
print('您购物车已选商品为：')
cart.reverse()
for item in cart:
print(item)
点击查看代码
#创建二维列表
lst=[
['车次','出发站-到达站','出发时间','到达时间间隔','历时时长'],
['G1569','北京南-天津南','18:06','18:39','00:33'],
['G1567','北京南-天津南','18:15','18:49','00:34'],
['G8917','北京南-天津南','18:20','19:19','00:59'],
['G203','北京南-天津南','18:35','19:09','00:34']
]
for row in lst:
for item in row:
print(item,end='\t')
print()
print('----------')
train=input('请输入要购买的车次：')
passager=input('请输入乘车人，如果是多位乘车人使用逗号分隔：')
lst2=[]#存储乘车信息
for item in lst:
lst2.append(item[0])
if train==item[0]:
print('您已购买',item[0],item[1],item[2],'开，请',passager,'尽快换取纸质车票.[铁路客服]')
break
lst2.clear()
点击查看代码
#我的思路
#创建二维列表
lst=[
['车次','出发站-到达站','出发时间','到达时间间隔','历时时长'],
['G1569','北京南-天津南','18:06','18:39','00:33'],
['G1567','北京南-天津南','18:15','18:49','00:34'],
['G8917','北京南-天津南','18:20','19:19','00:59'],
['G203','北京南-天津南','18:35','19:09','00:34']
]
for row in lst:
for item in row:
print(item,end='\t')
print()
print('----------')
train=input('请输入要购买的车次：')
passager=input('请输入乘车人，如果是多位乘车人使用逗号分隔：')
lst2=[]#存储乘车信息
for item in lst:
lst2.append(item[0])
if train==item[0]:
print('您已购买',item[0],item[1],item[2],'开，请',passager,'尽快换取纸质车票.[铁路客服]')
break
lst2.clear()
#老师思路
#创建字典存储车票信息，使用车次做key，其他信息作为你value
dict_ticket={
'G1569':['北京南-天津南','18:06','18:39','00:33'],
'G1567':['北京南-天津南','18:15','18:49','00:34'],
'G8917':['北京南-天津南','18:20','19: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=' \t\t')
#换行
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('对不起，选择车次不存在')
点击查看代码
s=set()
for i in range(1,5):
#i=str(i)
#num=input('请输入第'+i+'位好友的姓名与电话：')
num=input('请输入第{i}位好友的姓名与电话：')
s.add(num)
for item in s:
print(item)
