python基础语法--列表

一、列表的概念

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

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

二、列表的操作

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(小写的L)，因为 list 是列表对应的类名，
小写的L容易被误读或误写为阿拉伯数字1。

使用 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、比较运算符

可以使用如下比较运算符对两个列表进行比较：>、>=、<、<=、==、!=，is
比较规则为：首先比较两个列表中的第一个元素，如果相等则继续比较下一个元素，依次比较下去，直到两个列表中的元素不相等时，其比较结果就是两个列表的比较结果，并且两个列表中的所有后续元素将不再被比较。

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,从而按照逆序进行排序。

三、列表生成式

如果想要生成列表[1,4,9,16,25,36]，可以使用for-in循环：

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 语句

可以在列表生成式的for-in循环后添加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'])

列表切片: 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学堂

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