列表相关操作

原创已于 2022-07-30 09:14:36 修改 · 365 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#python

于 2022-07-30 09:07:58 首次发布

本文详细介绍了Python编程中的列表类型，包括列表的创建、基本操作、遍历、增删改查方法。重点讲解了列表的下标、切片、成员运算、比较运算以及列表推导式等核心概念，旨在帮助读者深入理解Python列表的使用。

容器类型（一）：列表

1. 列表

1.列表的性质

list []

容器符号：[],数据类型：list
列表是有序的数据类型(每个元素有自己固定的位置，俗称为‘下标’)
列表是可变的(能够对列表中元素进行增删改查操作)
列表中可以保存任意类型的数据(整型，浮点型，嵌套列表等)
列表中允许出现重复元素。

2.列表的基本操作

列表的创建
可用[]创建或者list关键字创建
例如

a=[1,2,3]
print(type(a))	# <class 'list'>
list1 = []
list2 = list()
list3 = [1,1.1,True,'abcd',[1,2,3],None,(1,2,3),{'name':20},{1,2,3}]
# 列表的性质4，可以嵌套字典，列表，元组，集合等。
print(list1,list2,list1==list2)
print(list3)

列表的运算

列表的拼接

list1 = [1,2,3]
lsit2 = ['a','b']
print(list1+list2)	# [1,2,3,'a','b']

列表的重复

list1 = [1,2]
print(list1 * 5)	# [1,2,1,2,1,2,1,2,1,2]

列表的成员运算(in、not in)

list3 = [1,1.1,True,'abcd',[1,2,3],None,(1,2,3),{'name':20},{1,2,3}]
print(1 in list3)	#True
print([1] in list3)	#False

列表的比较运算
容器类型比较大小比较的是相同位置的子元素大小，比较第一对相同类型不同子元素的大小,按照从前往后的顺序比较，类型不同会报错
元素个数可以不同

list1 = [1,2,3]
list2 = [1,1,100]
print(list1>list2)	# True,判断的是第一对相同类型不同子元素的大小(2>1)
list3 = [1,'a','c']
list4 = [1,2,2,4]
print(list1 > list3)	# 报错
print(list1 > list4)	# True

列表的下标
有序容器[下标数字]
列表中每个元素都有自己的位置，称为下标
下标分为正向下标和负向下标
正向下标从左向右，从0开始，依次递增
负向下标从右向左，从-1开始，依次递减

# 通过下标获取元素：有序容器[下标数字]
list1 = [1,2,3]
print(list[0],list[-3])		# 1  1

列表的切片
切片：获取有序容器中某一部分元素，得到的结果是和原容器相同类型的容器
操作为：有序容器[M:N:step]---->左闭右开[M,N),与range类似
步长，起始位置，结束位置都可以不写，步长默认为1，起始位置默认为下标0，结束位置默认为下标-1。
切片中正向下标和负向下标可以混用

list3 = [1,1.1,True,'abcd',[1,2,3],None,(1,2,3),{'name':20},{1,2,3}]
print(list3[0:8])   #[1, 1.1, True, 'abcd', [1, 2, 3], None, (1, 2, 3), {'name': 20}]
# 由于是左闭右开，下标8的位置无法取到
print(list3[0:9])   #[1, 1.1, True, 'abcd', [1, 2, 3], None, (1, 2, 3), {'name': 20}, {1, 2, 3}]
print(list3[8:0:-1])    #[{1, 2, 3}, {'name': 20}, (1, 2, 3), None, [1, 2, 3], 'abcd', True, 1.1]
print(list3[1:-1:2])    #[1.1, 'abcd', None, {'name': 20}]
print(list3[::-1])		#[{1, 2, 3}, {'name': 20}, (1, 2, 3), None, [1, 2, 3], 'abcd', True, 1.1, 1]

通过下标获取元素时，下标不能越界。会报错
在切片中允许下标越界

list1 = ['英雄联盟', 'CS:GO', '超级马里奥', '原神', '魂斗罗', '王者荣耀', 'PUBG']
# 1.获取['英雄联盟','PUBG']
print(list1[0:7:6])
print(list1[-7::6])
# 2.获取'原神'
print(list1[3])
print(list1[-4])
# 3.获取['王者荣耀','原神','CS:GO']
print(list1[-2::-2])
# 4.获取['魂斗罗','原神','超级马里奥']
print(list1[-3:1:-1])

print(list1[10])	# 报错
print(list1[0:10])	# 打印list1中所有内容

三. 列表的遍历

list1 = [1,2,3,4]
# 1. 直接遍历
for i in list1:
	print(i)
# 2. 间接遍历：通过下标遍历(有序的才可以间接遍历)
# len函数可以获取有序容器的长度
print(len(list1))
for index in range(len(list1)):
	print(f'{index}--->{list1[index]}')

# 3. enumerate(),类似与间接遍历，能够将列表中的每个元素及下标放在一个元组中，多个元组组成一个可迭代对象，可迭代对象即为可以做遍历
print(enumerate(list1))

四、列表的增删改

增：
append：追加，向列表的末尾添加元素
insert：插入，向列表的任意位置添加元素
extend：追加，从一个容器中将所有元素添加到列表末尾

list1= [1,2,3]
list1.append(4)
print(list1)	# [1, 2, 3, 4]
list1.insert(0,5)
print(list1)	# [5, 1, 2, 3, 4]
# append 和 insert依次都只能添加一个元素，insert(m,value)--->m为位置下标，value为要添加的内容
list1.extend('123')	# 字符串也属于容器
print(list1)	# [5, 1, 2, 3, 4, '1', '2', '3']
list1.extend(['a','b'])
print(list1)	# [5, 1, 2, 3, 4, '1', '2', '3', 'a', 'b']

删
del ：语法：del 有序容器[下标]，下标不可越界，否则会报错。

list1=[1,2,3,4,5,6,7,8]
del list1[6]
print(list1)	# [1, 2, 3, 4, 5, 6, 8]

remove ：语法列表名.remove(value),一次只删除一个，如果存在多个，即从左向右按顺序删除遇到的第一个。指定元素必须存在，否则会报错

list1 =[1,2,1,2,3,2,3]
list1.remove(1)
print(list1)	# [2, 1, 2, 3, 2, 3]
print(list1.remove)	# 返回值为：None

pop ：语法列表名.pop(下标)，下标可以不写，默认删除最后一个元素

list1 =[1,2,1,2,3,2,3]
list1.pop()
print(list1)	# [1, 2, 1, 2, 3, 2]
list1.pop(3)
print(list1)	# [1, 2, 1, 3, 2]
print(list1.pop(3))	#3
print(list1)	# [1,2,1,2]

clear ：语法

list1=['java','oython','java']
list1.clear()
print(list1)	# []
# 清除列表中所有元素

改
有序容器[下标] = 值

list1 =[1,2,1,2,3,2,3]
list1[5] = 'Java'
print(list1)	# [1, 2, 1, 2, 3, 'Java', 3]

函数

查找列表中的元素下标：index
index方法默认从左向右查找，找到元素立即停止查找，返回下标。
可以指定index开始查找元素的位置。index找不到元素会报错。

list1=['java','oython','java']
result = list1.index('java')
# 不指定位置，默认从第一个开始查找
print(result)	# 0
result1 = list1.index('java',1)
# 指定位置，从指定下标位置开始查找
print(result1)	# 2

sum、max、min(操作对象必须是数字)

list1 = [1,2.0,3,4,5.0]
print(sum(list1))	# 15.0
print(max(list1))	# 5.0
print(min(list1))	# 1
list2 = [1,2.0,3,'a']
print(sum(list2))	# 存在字符串类型会报错

reverse:将列表倒序，直接对列表本身进行修改

list1 = [1,2,3]
list1.reverse()
print(list1)		# [3,2,1]

sort，sorted：对列表排序
sort默认升序排序，修改列表本身，sort内存在默认reverse = False，手动修改为True后将变成降序
列表名.sort()
sorted与sort类似，但sorted不能对列表本身发生修改
sorted(列表名)

list1=[1,2,9,4,17,6]
list1.sort()
print(list1)	# [1, 2, 4, 6, 9, 17]
list1.sort(reverse=True)	#倒序输出
print(list1)	# [17, 9, 6, 4, 2, 1]
# sort会改变列表本身
list2=[1,2,9,4,17,6]
print(sorted(list2),list2)	# [1, 2, 4, 6, 9, 17] [1, 2, 9, 4, 17, 6]
print(sorted(list2,reverse=True),list2)		# [17, 9, 6, 4, 2, 1] [1, 2, 9, 4, 17, 6]
# sorted不会改变列表本身

count:统计某个元素出现次数

list3 = [2, 5, 1, 7, 0]
print(list3.count(2))	# 1
print(list3.count(9))	# 0
# 没有元素不会报错，统计次数为0

五. 列表推导式(列表生成式)

生成有元素的列表(在某些场景下能代替append)
列表生成式性能优于append

语法1:[表达式 for 变量 in 容器]
例如：将100以内5的倍数添加到列表中。

# 利用append实现
list1 = []
for i in range(5,101,5):
	list1.append(i)
print(list1)
# 利用列表推导式实现
list2 = [i for i in range(5,101,5)]
print(list2)
# 将某个元素在列表中重复N次
# 如果for中变量没有实际意义，可以使用下划线"_"代替
list3 = [[1, 2, 3] for _ in range(10)]
print(list3)	# 等同于[1,2,3]*3

语法2：[符合条件的表达式 for 变量 in 容器 if 条件]

list4 = [i for i in range(101) if i % 5 == 0]
print(list4)
# 可结合三目运算符
list5 = [True if i % 5 == 0 else False for i in range(11)]
print(list5)

语法3
[表达式 for 变量1 in 容器1 for 变量2 in 容器2]
for 循环嵌套

# 利用此语法打印九九乘法表
list6 = [f'{i} * {j} = {i * j}' for i in range(1, 10) for j in range(1, i + 1)]
print(list6)

# 使用列表推导式生成5个人的3科成绩
import random
# 表达式里面使用列表的嵌套
score = [[random.randint(0, 100) for _ in range(3)]for _ in range(5)]
print(score)
# 代码换行
num = 1 \
      + \
      2 \
      + \
      3 + \
      4 + 5 + 6 + \
      10
print(num)