Python3 列表

前言：

本文主要介绍python中的列表（list），主要内容包括 列表简介、列表的特性、列表的基本操作、其他操作的函数&方法。

一、列表简介

列表 list 是Python3编程语言中的基本数据类型之一，也是一个非常重要的通用序列。其它的编程语言中一般都会把它叫做“数组”。简单说来，列表就是一组有序的数据，每一个数据都有其特定的位置，即索引。

1、列表的定义

用中括号(方括号) [ ] 来代表列表list，左括号开始，右边括号代表结束。如：

list = [1,2,3]
print(type(list))

输出结果：

<class 'list'>

二、列表的特性

1、 异构性

列表中的数据可以是任何数据类型，包括数字、字符串和其他列表。如：

list = [1,1.20,"hello",[3,4]]print("第0个元素类型：",type(list[0])," 第0个元素的值：",list[0])
print("第1个元素类型：",type(list[1])," 第1个元素的值：",list[1])
print("第2个元素类型：",type(list[2])," 第2个元素的值：",list[2])
print("第3个元素类型：",type(list[3])," 第3个元素的值：",list[3])

输出结果：

第0个元素类型： <class 'int'>   第0个元素的值： 1
第1个元素类型： <class 'float'>   第1个元素的值： 1.2
第2个元素类型： <class 'str'>   第2个元素的值： hello
第3个元素类型： <class 'list'>   第3个元素的值： [3, 4]

2、 元素个数可变

可以动态地添加、修改或删除其中的元素,如：

list = ['a', 'b', 'c']
print("原始列表： ",list)list.insert(0, 'x')
print("插入‘x’到列表元素0位置： ",list)del list[1]
print("删除列表元素1： ",list)

输出结果：

原始列表：  ['a', 'b', 'c']
插入‘x’到列表元素0位置：  ['x', 'a', 'b', 'c']
删除列表元素1：   ['x', 'b', 'c']

3、直接访问元素

这个和C语言、Java 语言中的数组类似，可以指定某个位置来访问列表中的元素，如第一个元素、最后一个元素等。如：

list = ['a', 'b', 'c']
print(list[1])

输出结果：

b

三、列表的基本操作

有了列表之后，我们就可以对它进行操作了，比如索引、切片、查询、修改、追加、插入、删除、扩展、统计等等。和很多其他数据结构一样，我们可以把这些操作分为四类：增、删、改、查。

1、增

在 Python 中，有三种方法去给列表增加元素，分别是追加（append）、插入（insert）和扩展（extend）。

1）追加

从字面意义理解，追加就是在列表最后增加元素。

list = ['a', 'b']
list.append('c')
print(list) 

输出结果：

['a', 'b', 'c']

通过调用 list.append() 方法，传入需要追加的元素，就可以在列表的最后添加这个元素。

2）插入

插入的意思，就是在指定的位置之前，添加上指定的元素。

list = ['a', 'b', 'c']
list.insert(0, 'x')
print(list) 
list.insert(2, 'y')
print(list) 
list.insert(-1, 'z')
print(list) 

输出结果：

['x', 'a', 'b', 'c']
['x', 'a', 'y', 'b', 'c']
['x', 'a', 'y', 'b', 'z', 'c']

通过调用 list.insert() 方法，传入指定的位置和需要追加的元素，就可以在列表的指定的位置之前添加这个元素。

3）扩展

扩展的意思是，将一个列表追加到一个列表后面。

list1 = ['a', 'b', 'c']
list2 = ['e', 'f', 'g']
list1.extend(list2)
print(list1) 

输出结果：

['a', 'b', 'c', 'e', 'f', 'g']

通过调用 list.extend() 方法，传入一个列表，就会在原有的列表后追加上另一个列表中的元素。直接使用 += 运算符也可以实现相同的效果，如：

list = ['a', 'b', 'c']
list += ['e', 'f', 'g']
print(list) 

2、删

Python 中根据不同的使用场景，有几种不同的删除元素的方法，分别是删除指定下标的元素、删除指定值的元素、删除列表中的最后一个元素和清空列表。

1）删除指定下标的元素

list = ['a', 'b', 'c']
del list[1]
print(list)

输出结果：

['a', 'c']

del list[index] 可以删除指定下标的元素,index 是要删除元素的索引值。

2）删除指定值的元素

list = ['a', 'b', 'c', 'a', 'b', 'c','b', 'c']
list.remove('c')
print(list)

输出结果：

['a', 'b', 'a', 'b', 'c', 'b', 'c']    #第二第三个'c'没有删除。

通过 list.remove[element] 方法，删除列表中与传入元素值相同的元素，这个方法只会删除第一个匹配到的元素。

3）删除列表中的最后一个元素

list = ['a', 'b', 'c', 'd', 'e']
deleted = list.pop()
print(deleted) 
print(list) 
list.pop(1)
print(list) 

输出结果：

e
['a', 'b', 'c', 'd']
['a', 'c', 'd']

list.pop() 会删除列表中的最后一个元素，这个方法会返回被删除的元素。这个方法也可以传值，传值时会删除对应下标的元素，与 del 的效果是一样的。也就是说 list.pop() 等价于 list.pop(-1)。

4）清空列表

list = ['a', 'b', 'c', 'd', 'e']
list.clear()
print(list) 

输出结果：

[]  #空列表

通过 list.clear 方法，清空整个列表。

3、改

想要修改列表中的某个值，直接给那个位置重新赋值即可。

list = ['a', 'b', 'd']
list[2] = 'c'
print(list)

输出结果：

['a', 'b', 'c']

4、查

查的操作包括：索引、切片、查询、统计。

1）索引

索引的操作就是根据位置获取数组中的单个值，比如我们有一个包含 5 个数字的列表，这 5 个数字对应的下标分别是：0, 1, 2, 3, 4，如果想要取下标为 n 的元素，在表示列表的变量后加方括号，在方括号内写入下标即可，如：

list = [1, 2, 3, 4, 5]
print(list[0]) 
print(list[2]) 

输出结果：

1
3

此外，还可以倒着取：

list = [1, 2, 3, 4, 5]
print(list[-1]) 
print(list[-3]) 

输出结果：

5
3

倒着索引[1, 2, 3, 4, 5]的下标为 -5，-4，-3，-2，-1，就是倒数第一个即元素5的索引号是-1。

2）切片

切片就是从列表中取多个元素的操作。下面我们看几个例子：

list = ['a', 'b', 'c', 'd', 'e', 'f', 'g']
print(list[1:3])
print(list[-3:-1]) 
print(list[:3])
print(list[:])

输出结果：

['b', 'c']
['e', 'f']
['a', 'b', 'c']
['a', 'b', 'c', 'd', 'e', 'f', 'g']

可以从例子看出来切片的几种写法和功能：

1. list[a:b]：取列表中下标为 a ~ b -1 的元素，可以用区间表示为 [a, b)
2. list[a:]：取列表中下标为 a ~ 列表最后的元素
3. list[:b]：取列表中下标为 b - 1 及其之前的元素
4. list[:]：取列表中的所有元素

切片还有一种写法是 list[a🅱️c]，这种切片语法会返回从位置 a 开始（包括 a），到位置 b 结束（但不包括 b），每隔 c 个元素取一个元素（c为1，隔0个元素,以此类推），组成的子列表。如果 a、b、c 中有某个值缺失，则默认值为 0、列表长度和 1（缺失的 a 参数默认是 0，缺失的 b 参数默认是列表长度，缺失的 c 参数默认是 1）。如：

list = ['a', 'b', 'c', 'd', 'e', 'f', 'g']
print(list[2::])
print(list[::2])

输出结果：

['c', 'd', 'e', 'f', 'g']   #从第三个元素开始，每隔0个元素，输出1个元素，直到输出完列表中所有的元素。
['a', 'c', 'e', 'g']   #从第0个元素开始，每隔1个元素，输出1个元素，直到输出完列表中所有的元素。

3）查询

查询是指根据元素查找在列表中的位置。

list = ['a', 'b', 'c', 'd', 'e', 'f', 'g']
print(list.index('a')) 
print(list.index('c'))

输出结果：

0
2

通过调用 list.index() 方法，传入需要查找的元素，就可以得到对应的下标的值。我们不能传入多个元素去一次性获取多个下标。如果我们传入了一个不存在的元素，就会报错：

list = ['a', 'b', 'c', 'd', 'e', 'f', 'g']
print(list.index('none'))

输出结果：

# 报错：
ValueError: 'none' is not in list

4）统计

统计是用来统计列表内相同元素的个数的。

list = ['a', 'b', 'b', 'c', 'c', 'c']
print(list.count('a')) 
print(list.count('b')) 
print(list.count('c')) 
print(list.count('d')) 

输出结果：

1
2
3
0

四、其他操作的函数&方法

Python 还有一些和列表相关的其他函数和方法。

1、统计列表元素个数

len() 函数中传入要统计的列表，这个函数返回传入列表包含的元素个数。

list = ['a', 'b', 'c', 'd', 'e']
print(len(list)) 

输出结果：

5

2、最大值/最小值

min() 函数返回列表中的最小值，max() 函数返回列表中的最大值。

list = [1, 2, 3, 4, 5]
print(min(list)) 
print(max(list)) 

输出结果：

1
5

3、将可迭代对象转换为列表

在 Python 中，可以将可迭代对象（例如元组，集合或字典等）转换为列表， 如果传入的参数不是可迭代的对象就会报错。

#将元组转换为列表
my_tuple = (1, 2, 3, 4, 5)
my_list = list(my_tuple)
print(my_list)# 将集合转换为列表
my_set = {1, 2, 3, 4, 5}
my_list = list(my_set)
print(my_list)# 将字典的键转换为列表
my_dict = {'a': 1, 'b': 2, 'c': 3}
my_list = list(my_dict.keys())
print(my_list)

输出结果：

[1, 2, 3, 4, 5]
[1, 2, 3, 4, 5]
['a', 'b', 'c']

4、反转

list.reverse() 方法会将传入列表的元素反转。

list = ['a', 'b', 'c']
list.reverse()
print(list) 

输出结果：

['c', 'b', 'a']

5、排序

list.sort() 方法用于原地排序列表中的元素（即修改列表本身，而不是返回一个新的排序后的列表）。该方法不返回任何值，因此不能将其赋值给另一个变量。这个函数支持传入两个参数，一个为指定排序的 key，默认为 None，一个是否反转，默认为 False。

list.sort(key=None, reverse=False)    #reverse传入 True 则是需要反转，False 则是不需要，这个参数默认为 False

如下面代码：

#对列表进行升序排序
my_list = [3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5]
my_list.sort()
print(my_list)# 对列表进行降序排序
my_list = [3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5]
my_list.sort(reverse=True)
print(my_list)

输出结果：

[1, 1, 2, 3, 3, 4, 5, 5, 5, 6, 9]
[9, 6, 5, 5, 5, 4, 3, 3, 2, 1, 1]

key 这个参数可以指定按什么来排序，比如我们想要按照数字的绝对值升序排列，那么就可以指定 key：

my_list = [1, -3, 5, -4, 2]
my_list.sort(key=abs)
print(my_list)

输出结果：

[1, 2, -3, -4, 5]

注意：list.sort() 方法会直接修改原列表，而不会返回新列表。如果你想要保留原始列表，同时得到一个已排序的列表，则可以使用 sorted() 函数，它会返回一个新列表。如：

#对列表进行升序排序，并保留原始列表
my_list = [3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5]
sorted_list = sorted(my_list)
print(my_list)
print(sorted_list)

输出结果：

[3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5]
[1, 1, 2, 3, 3, 4, 5, 5, 5, 6, 9]

sorted() 函数可以接受一个可迭代对象作为其第一个参数（例如列表、元组、集合、字典等），第二个参数为key,第三个参数为reverse。

my_list = [1, -3, 5, -4, 2]
sorted_list = sorted(my_list, key=abs, reverse=True)
print(my_list)
print(sorted_list)

输出结果：

[1, -3, 5, -4, 2]
[5, -4, -3, 2, 1]

6、复制

list.copy() 用于复制列表，类似于 list[:]。

list1 = ['a', 'b', 'c']
list2 = list1.copy()
print(list2)

输出结果：

['a', 'b', 'c']