python基础语法–列表

大家好，欢迎来到IT知识分享网。

一、列表的概念

列表（List）是一种有序、可变、允许重复元素的数据结构。列表用于存储一组相关的元素，并且可以根据需要动态地进行增加、删除、修改和访问。以下是列表的主要特点和操作：

1. 有序性： 列表中的元素是按照它们被添加到列表中的顺序进行排列的，因此列表是有序的数据结构，你可以通过索引来访问列表中的元素。
2. 可变性： 列表是可变的，这意味着你可以随时对列表中的元素进行增加、删除或修改。这使得列表成为处理动态数据集合的理想选择。
3. 元素类型： 列表中的元素可以是任意类型的数据，包括整数、浮点数、字符串、列表、元组、字典等。
4. 允许重复元素： 列表中可以包含重复的元素，即使相同的元素出现多次，它们也会被分别存储在不同的位置。

二、列表的操作

Python列表的常见操作包括：

• 访问元素： 使用索引访问列表中的特定元素，索引从0开始。
• 修改元素： 使用索引来修改列表中特定位置的元素。
• 增加元素： 使用 append() 方法在列表末尾添加一个元素，使用 insert() 方法在指定位置插入一个元素，或者使用 extend() 方法将另一个列表的元素添加到当前列表的末尾。
• 删除元素： 使用 del 语句、remove() 方法或 pop() 方法删除列表中的元素。
• 切片： 使用切片操作来获取列表的子列表。
• 列表操作符： 使用 + 操作符进行列表的连接，使用 * 操作符进行列表的重复。
• 列表方法： Python提供了许多列表方法，如 append()、insert()、remove()、pop()、index()、count()、sort()、reverse() 等，用于对列表进行各种操作。

1. 创建列表

• 使用中括号

# 创建一个空列表 L = [] # 创建一个有元素的列表 L = ['Python', 18, 3.14]

• 使用 list类的构造方法

# 创建一个空列表 L = list() L = list(range(1, 6)) L = list(['Python', 18, 3.14])

2、访问元素

后面的举例，全部使用的是这个列表：

• 获取指定元素的索引

如果想要获得列表中指定元素的索引，可以调用方法index，而列表中每一个元素都有两个索引，该方法只返回两个整数索引中大于0的那个索引。

L = [5,3,7,9,2,1,7,6] print(L.index(9)) # 3

如果列表中含有多个指定元素，index方法返回的是列表第一次出现指定元素大于零的索引。

L = [5,3,7,9,2,1,7,6] print(L.index(0)) # 2

如果列表中不含有执行元素，会直接进行报错。

调用方法index时还可以指定起始索引start和结束索引stop这两个参数。

#只指定起始索引start(不能只指定结束索引) print(L.index(7,3)) # 6

指定索引从3之后进行查找

#只指定起始索引start和指定结束索引stop print(L.index(7,3,5)) 

• 通过索引获得元素

直接使用方括号+下标的方式，就可以获得下标所对应的元素

列表名[下标]

• 使用切片获得多个元素

语法格式：

[start:stop:step]

1、得到的切片仍然是列表，是原始列表的片段的一份拷贝。
2、得到的切片不包括索引stop对应的元素。
3、如果不指定step，其默认值是1，此时语法格式可以简化为[start:stop]。
4、当step为正数时：
如果不指定start，切片的第一个元素默认是列表的第一个元素。
如果不指定stop，切片的最后一个元素默认是列表的最后一个元素。
从索引start开始以step为步长向后计算切片。
5、当step为负数时：
如果不指定start，切片的第一个元素默认是列表的最后一个元素。
如果不指定stop，切片的最后一个元素默认是列表的第一个元素。
从索引start开始以step为步长向前计算切片。

6、切片操作是允许索引越界的

print(L[:]) # [5,3,9,4,0,6,8,1,7,2] print(L[::-1]) # [2,7,1,8,6,0,4,9,3,5] print(L[:100]) # [5,3,9,4,0,6,8,1,7,2] print(L[-100:]) # [5,3,9,4,0,6,8,1,7,2]

7、可以调用内置函数slice(类slice的构造方法)创建slice类型的对象
内置函数slice有三种调用方式：
1）slice(stop)
2）slice(start,stop)
3）slice(start,stop,step)
start、stop和step的默认值都是None。
slice(start,stop,step)与 start:stop:step 是等价的。

L=[5,3,9,4,0,6,8,1,7,2] print(L[1:7:2]) # [3,4,6] print(L[slice(1,7,2)]) # [3,4,6]

print(L[:] # [5,3,9,4,0,6,8,1,7,2] print(L[slice(None,None,None)]) # [5,3,9,4,0,6,8,1,7,2]

• 使用运算符in检查是否存在指定元素

如果某个元素在列表中，返回True；如果不在，返回False；

print(5 in L) # True

还可以使用 not in 运算符检查某个元素是否存在指定元素：如果某个元素不在列表中，返回True；如果在，返回False；

3、修改元素

L = [3,4,5,6,7] 

• 通过索引修改指定元素

L[0] = 1

• 通过切片修改元素

L = [3,4,5,6,7] L[1:4] = [1,9,2] print(L) # [3,1,9,2,7]

L[1:2] = [5] print(L) # [3,5,9,2,7]

注意，即使通过切片修改一个值时，右边也需要使用方括号进行赋值

并且，等号两边的元素个数可以不同：

L[1:4] = [1,8]

切片[1:4]中有三个元素，而右边方括号内我只给了两个元素。

我们可以看到最终结果，不仅将原列表中的 5、9修改成为1、8，并且还把2删除了。

4、增加元素

• 调用方法append

在原始列表的最后一个元素后面追加一个元素。

L = [3,4,5,6,7] L.append(8) print(L) # [3,4,5,6,7,8]

这里还有一个小细节需要注意，append方法的返回值为None，因此不能进行链式调用：

print(L.append(8)) # 最终打印结果为None

append不仅能追加单独的值，还能追加列表(将列表作为一个整体进行追加)：

L = [3,4,5,6,7,8] L.append([9,10]) print(L) # [3,4,5,6,7,8,[9,10]]

• 调用方法extend

将所有元素依次添加到列表的末尾。

L = [3,4,5,6,7,8] L.extend([9,10]) print(L) # [3,4,5,6,7,8,9,10]

• 调用方法insert

在列表的任意位置添加一个元素。

L = [3,4,5,6,7] L.insert(3,8) print(L) # [3,4,5,8,6,7]

在下标为3的位置上插入一个8.

进行尾插的操作：

L = [3,4,5,6,7] L.insert(len(L),8) print(L) # [3,4,5,6,7,8]

ls1 = [1, 2, 3] ls2 = [4, 5, 6] ls1.insert(3, ls2) # [1, 2, 3, [4, 5, 6]]

• 使用切片

L = [3,4,5,6] L[2:2] = [8,9] print(L) # [3,4,8,9,5,6]

在下标为2的位置处，插入8，9

进行尾插操作：

L = [3,4,5,6] L[len(L):] = [8,9] print(L) # [3,4,5,6,8,9]

注意，使用切片和extend增加多个元素时，右边给定的元素需要使用[]括起来；对于+= ，如果不是在最后添加一个列表，而是添加多个元素时，是不需要加[]的；并且append一次只能添加一个元素（可以是单个值，也可以是一个列表）。

5、删除元素

• 使用remove方法

指定要删除的元素。

L = [3,4,5,6,5,7] L.remove(4) print(L) # [3,5,6,5,7]

如果列表中，存在多个指定元素，只删除第一次出现的元素；

如果列表中，不存在要删除的指定元素，则直接进行报错。

返回值为None.

• 使用pop方法

指定要删除元素的索引，并且返回索引所对应的元素。

L = [3,4,5,6,7] print(L.pop(2)) # 5 print(L) # [3,4,6,7]

如果给定的索引不存在，则进行报错：index error

如果不给定索引，则默认删除最后一个元素。

这里需要注意，使用pop方法给定的参数是一个索引，而remove方法的参数是要删除的数。

• 使用del方法

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

也可以删除一个切片：

del L[1:]

• 给指定的切片赋值为一个空列表

L[2:5] = []

• 将列表的所有元素删除

使用方法clear，如：

L.clear()

6、列表操作符

• 加法操作符

L1 = [1,2,3] L2 = [4,5,6] L3 = L1 + L2 print(L3) # [1,2,3,4,5,6] print(L1) # [1,2,3] print(L2) # [4,5,6]

注意，+= 操作符会修改列表本身，+操作符不会修改列表本身

L1 = L2 = [1,2] L1 = L1 + [3,4] print(L1,L2) #[1,2,3,4] [1,2] L1 = L2 = [1,2] L1 += [3,4] print(L1,L2) # [1,2,3,4] [1,2,3,4]

对于第一种形式：

对于第二种形式：

• 乘法操作符

运算规则：将列表中的元素重复n次后，生成一个新的列表，原始列表不发生变化

L1 = [1,2,3] L = L1 * 3 print(L) #[1,2,3,1,2,3,1,2,3] print(L1) #[1,2,3]

这个操作符常被用来进行初始化：

L = [0] * 5 print(L) # [0,0,0,0,0]

同样需要注意，*= 操作符也会修改列表本身

L1 = L2 = [1,2] L1 *= 3 print(L1,L2) # [1,2,1,2,1,2] [1,2,1,2,1,2]

7、比较运算符

print([2,3,8,6,7] < [2,3,9,5,1]) # True print([7,[2,6]] > [7,[2,5]]) # True

==与 is 的区别：==是“相等性“测试，is 是“同一性”测试。

a = b = [1,2,3] c = [1,2,3] print(a==b)) # True print(a == c) # True print(a is b) # True print(a is c) # False

8、反转列表和排序列表

反转列表：

• 使用reverse方法

L = [1,2,3,4,5] L.reverse() print(L) # [5,4,3,2,1]

• 使用内置函数reversed

内置函数reversed的返回值是一个迭代器对象，并且原列表不发生变化

L = [1,2,3,4,5] iterator reversed(L) print(iterator) <list_reverseiterator object at 0x101fb4c18> print(list(iterator)) #[5,4,3,2,1] print(L) #[1,2,3,4,5]

• 使用sort方法

默认按照从小到大的顺序进行排序。

L=[5,3,8,1,6] L.sort() print(L) # [1,3,5,6,8]

调用方法sort时，可以指定参数reverse=True,从而按照逆序进行排序。

L.sort(reverse True) print(L) # [8,6,5,3,1] 

同样需要注意的是，sort方法的返回值也是None，不能进行链式调用。

• 使用内置函数sorted()

L=[5,3,8,1,6] print(sorted(L)) # [1,3,5,6,8] print(L) # [5,3,8,1,6]

内置函数sorted的返回值是排序后生成的新列表，且被排序的列表不发生变化

调用内置函数sorted时，可以指定参数reverse=True,从而按照逆序进行排序。

三、列表生成式

L = [] for i in range(1,7): L.append(i*i) print(L) # [1,4,9,16,25,36]

上述的解决方案有更好的替代，那就是使用列表生成式。

列表生成式的使用场景：凡是可以通过 for-in 循环创建的列表，都可以使用列表生成式来创建。

[表示列表元素的表达式 for 自定义的变量 in 可迭代对象]

L = [i*i for i in range(1,7)] print(L) # [1,4,9,16,25,36]

• 在列表生成式中使用 if 语句

L = [i*i for i in range(1,7) if not i%2] print(L) #[4,16,36]

• 在列表生成式中使用双重循环

L = [(i,j) for i in range(1,4) for j in range(1,4)] print(L) # [(1,1),(1,2),(1,3),(2,1),(2,2),(2,3),(3,1),(3,2),(3,3)]

以上代码相当于：

L = [] for i in range(1,4): for j in range(1,4): L.append((i,j))

• 列表生成式支持嵌套

matri×=[[1,2,3,4],[5,6,7,8],[9,10,11,12]] L = [[row[i] for row in matrix] for i in range(4)] print(L) # [[1,5,9],[2,6,10],[3,7,11],[4,8,12]]

上述代码相当于：

L=[] for i in range(4): L.append([row[i]for row in matrix]) print(L)

L = [] for i in range(4): l_row = [] for row in matrix: L_row.append(row[i]) L.append(l_row) print(L) #[[1,5,9],[2,6,10],[3,7,111,[4,8,12]]

注意，在嵌套时，先执行外面一个for循环语句；在使用双重循环时，先执行第一个for循环。

四、关于列表的一些题目

sum() 函数通常用于对数字列表进行求和，但也可以用于其他类型的列表，只要第二个参数提供了一个初始值，这个初始值用于累积结果。在你提供的例子中，sum(lst, []) 试图对列表的列表（即二维列表）进行求和，并使用空列表 [] 作为初始值。

sum() 函数会遍历 lst 中的每个子列表，并将它们与初始值（空列表 []）相加。因此，输出将是一个合并后的列表：[1, 2, 3, 4]

a = ['foo', 'bar', 'baz', 'quux', 'corge'] max(a[2:4] + ['grault'])

1. 列表切片: a[2:4]

这表示从列表 a 中提取从索引 2（包含）到索引 4（不包含）的元素。在 Python 中，列表的索引是从 0 开始的。因此，a[2:4] 会得到子列表 ['baz', 'quux']。
2. 列表连接: a[2:4] + ['grault']

这表示将上面得到的子列表 ['baz', 'quux'] 与新列表 ['grault'] 连接起来。连接后的新列表是 ['baz', 'quux', 'grault']。
3. 使用 max() 函数: max(a[2:4] + ['grault'])

max() 函数用于返回可迭代对象（如列表）中的最大值。在这个例子中，它返回连接后的列表 ['baz', 'quux', 'grault'] 中的“最大”字符串。这里的“最大”是基于字符串的字典序（即字母顺序）来确定的。

在字典序中，字符串的比较是基于字符的 ASCII 值。因此，max() 函数会返回列表中字典序最大的字符串。在这个例子中，'quux' 是字典序最大的字符串，所以 max(a[2:4] + ['grault']) 的结果会是 'quux'。

综上所述，整个语句 max(a[2:4] + ['grault']) 的结果是 'quux'。

print(list('Life','is','short','you','need','Python').count('is'))

这里，list() 函数被用来将字符串 'Life is short, you need Python' 转换成一个字符列表

['L', 'i', 'f', 'e', ' ', 'i', 's', ' ', 's', 'h', 'o', 'r', 't', '，', 'y', 'o', 'u', ' ', 'n', 'e', 'e', 'd', ' ', 'P', 'y', 't', 'h', 'o', 'n']

在这个列表中是不含有 ‘is’ 字符串的，因此最后的结果为0.

 本文参考以下资料，在此对该作者表示感谢：

《图解Python》学习路径：图解Python视频教程_Python学习路线-51CTO学堂

今天的分享就到这里了，如果，你感觉这篇博客对你有帮助的话，就点个赞吧！感谢感谢……