Python一维、二维列表用法总结

什么是List？

List是Python3中非常常用的一种数据类型，是一种可变的、有序的、可以包含任何类型元素的数据集合。我们经常需要对其进行一些操作来获取我们所需的数据。如获取第一个元素、最后一个元素、对其重新排序等等。

List的操作有什么？

List主要有以下几种操作：索引、切片、查询、修改、追加、插入、删除、扩展、统计、排序、获取下标、拷贝等等

那么，就让我们来一一看一下上述的操作是怎么实现的呢？

一、索引（list[i]）

一个List中，经常包含了许多元素，就如List[1, 2, 3, 4, 5, 6, 7]所示，其中包含了7个元素。而每个元素都有其对应的下标，从前往后依次的下标是0，1，2，3，4，5，6。而Python3中，下标既可以从前往后取，也可以从后往前取。从后往前依次是-7，-6，-5，-4，-3，-2，-1。如下所示：

由上我们不难看出：

• List的正向下标是从0开始的
• List的反向下标是从-1开始的
• 当我们的List中有n个元素的时候，正向下标依次是0, 1, 2, 3, 4 ... n-2, n-1
• 当我们的List中有n个元素的时候，反向下标依次是-n，-n+1, -n+2, -n+3 ... -2, -1

当我们需要获取相应下标下的元素时，我们只需要在List后方的方括号内写入下标即可（list[下标]），如：

colors = ['blue', 'red', 'yellow', 'pink', 'white', 'black']
list[0] # 'blue'
list[1] # 'red'
list[2] # 'yellow'
list[3] # 'pink'
list[-1] # 'black'
list[-2] # 'white'

二、切片（list[a : b]）

为什么要使用切片呢？因为从刚刚的索引，我们不难发现，我们使用索引的时候，我们只能从List中，去获得单个元素。而在我们的开发过程中，很经常需要获取到多个元素。那么通过循环一个个去获取元素是一件低效且麻烦的事情，因此，当我们需要获取多个连续的元素时，我们一般采用索引的方式。

切片中，有几个不同的用法，具体请往下看：

list[a : b]

colors = ['blue', 'red', 'yellow', 'pink', 'white', 'black']
colors[1 : 3] # ['red', 'yellow']

从上述代码中，我们可以看出，当我们使用list[a : b]格式的切片时，我们所要获得的元素，是从下标为a的元素开始...到下标为b的元素之前的所有元素。上述例子中，我们要获取的是，从下标为1开始...到下标为3之前的元素，即为下标为1、2的元素，所以我们获得的结果是：
['red', 'yellow']

list[a : ]

colors = ['blue', 'red', 'yellow', 'pink', 'white', 'black']
colors[1 : ] # ['red', 'yellow', 'pink', 'white', 'black']

从上述代码中，我们可以看出，当我们使用list[a : ]格式的切片时，我们所要获得的元素，是从下标为a的元素开始的所有List内的元素。上述例子中，我们要获取的是，从下标为1开始的所有List内的元素，即为下标为1、2、3、4、5的元素，所以我们获得的结果是：
['red', 'yellow', 'pink', 'white', 'black']

list[ : b]

colors = ['blue', 'red', 'yellow', 'pink', 'white', 'black']
colors[ : 4] # ['blue', 'red', 'yellow', 'pink']

从上述代码中，我们可以看出，当我们使用list[ : b]格式的切片时，我们所要获得的元素，是从下标为0的元素开始...直到下标为b的元素之前的元素。上述例子中，我们要获取的是，从下标为0开始...直到下标为b的元素之前的元素，即为下标为0、1、2、3的元素，所以我们获得的结果是：
['blue', 'red', 'yellow', 'pink']

list[ : ]

colors = ['blue', 'red', 'yellow', 'pink', 'white', 'black']
colors[ : ] # ['blue', 'red', 'yellow', 'pink', 'white', 'black']

从上述代码中，我们可以看出，当我们使用list[ : ]格式的切片时，我们所要获得的元素，是整个列表中的所有元素。上述例子中，我们要获取的是，整个列表中的所有元素，即为下标为0、1、2、3、4、5的元素，所以我们获得的结果是：
['blue', 'red', 'yellow', 'pink', 'white', 'black']

list [a : b : c]

colors = ['blue', 'red', 'yellow', 'pink', 'white', 'black']
colors[1 : 5 : 2] # ['red', 'pink']

从上述代码中，我们可以看出，当我们使用list[a : b : c]格式的切片时，我们所要获得的元素，从下标为a的元素直到下标为b的元素前，从下标a开始递增c的所有元素。上述例子中，我们要获取的是，从下标为1的元素直到下标为5的元素前，从下标1开始递增2的所有元素，即为下标为1、3的元素，所以我们获得的结果是：
['red', 'pink']

这个方法有个扩展是，list[ : : c]

colors = ['blue', 'red', 'yellow', 'pink', 'white', 'black']
colors[ : : 2] # ['blue', 'yellow', 'white']

三、查询

在开发过程中，我们时常会需要知道一个元素在列表里的下标，从而对该元素进行操作。那么我们要如何去获取到相应元素的下标呢？

colors = ['blue', 'red', 'yellow', 'pink', 'white', 'black']
colors.index('red') # 1
colors.index('yellow') # 2

我们通过去调用index()这个方法，传入我们需要查询的元素，即可获得该元素在列表中的下标。如，当我们要在colors中查询'red'的位置时，我们使用colors.index('red')，便可以获得'red'的下标，1。

注意：我们不能传入多个元素去一次性获取多个下标。

四、修改

在我们开发过程中，经常会遇到数据更新的时候，比如我们有一个列表，里面存放了集中颜色提供展示，当我们在某种场景下，我们需要去替换掉其中某个颜色的时候，我们就需要去用到修改的方法：

colors = ['blue', 'red', 'yellow', 'pink', 'white', 'black']
colors[1] = 'green' # ['blue', 'green', 'yellow', 'pink', 'white', 'black']

要去修改我们的列表中元素之前，我们首先要知道，我们要修改的元素的下标，知道下标后，我们可以直接调用list[i] = sth的方法，直接将该下标中的元素给替换成我们需要的就可以了。比如上述例子中，我们需要替换颜色列表中的'red'为'green'。已知red的下标为1，所以我们可以直接用colors[1] = 'green'来替换掉'red'。

五、增加

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

追加（list.append(element)）

colors = ['blue', 'red', 'yellow', 'pink', 'white', 'black']
colors.append('green') # ['blue', 'red', 'yellow', 'pink', 'white', 'black', 'green']

追加的意思，就是在列表的最后，添加上所需要添加的元素。如上述代码，我在colors列表后，添加了'green'元素，所以展示出来的代码就会是：
['blue', 'red', 'yellow', 'pink', 'white', 'black', 'green']

插入（list.insert(index, elemtnt)）

colors = ['blue', 'red', 'yellow', 'pink', 'white', 'black']
colors.insert(1, 'green') # ['blue', 'green', 'red', 'yellow', 'pink', 'white', 'black']

插入的意思，就是在列表中所需要的位置之前，添加上所需要添加的元素。如上述代码，我在colors列表当前下标为1的元素之前，添加了'green'元素，所以展示出来的代码就会是：
['blue', 'green', 'red', 'yellow', 'pink', 'white', 'black']

六、删除

在我们开发中，常常会遇到一些场景，需要删除现有列表中的某些数据。比如，我们有个任务列表，当我们完成任务的时候，我们就要把该任务从代办列表中移除掉。这个时候，我们就需要用到删除的语句。

colors = ['blue', 'red', 'yellow', 'pink', 'white', 'black']
del colors[0] # ['red', 'yellow', 'pink', 'white', 'black']
colors.remove('pink') # ['red', 'yellow', 'white', 'black']
colors.pop() # ['red', 'yellow', 'white']

在上述的代码中，我们一共用了三种删除的方法，让我们分别来看看这些方法：

del list[index]

调用del list[index]方法，我们可以直接删除列表中，指定下标的元素。上述代码中，我们选择删除了下标为0的代码，所以我们将列表中的'blue'给删除了。所以结果如下所示：
['red', 'yellow', 'pink', 'white', 'black']

list.remove(element)

调用list.remove(element)方法，我们可以将列表中与element相同的元素删除。上述代码中，我们选择了删除列表中出现的第一个'pink'。所以代码如下所示：
['red', 'yellow', 'white', 'black']
调用这个方法的时候，如果列表中有多个'pink'的话，也只会删除第一个'pink'，而不会将所有的'pink'都删除。

list.pop()

调用list.pop()方法，我们会将列表中的最后一个元素给删除。这边用到的是栈的概念。栈是一个先进后出的模型，当我们对栈push的时候，就会把元素给加到栈的列表的最后，而当我们对栈pop的时候，我们就会将栈的列表最后的元素给移除掉。当我们调用colors.pop()方法的时候，我们就会把最后的'black'给移除掉。所以结果如下所示：
['red', 'yellow', 'white']
同时list.pop()方法的括号内，也可以传值，传的是index下标。如，我们要将下标为1的元素给删除的话，我们就写list.pop(1)。

colors = ['blue', 'red', 'yellow', 'pink', 'white', 'black']
colors.pop(1) # ['blue', 'yellow', 'pink', 'white', 'black']

七、扩展（list.extend(new_list)）

扩展，是将一个列表追加到另一个列表后面，组成一个新的列表。

colors = ['blue', 'red', 'yellow', 'pink', 'white', 'black']
other_colors = ['green', 'gray', 'orange']
colors.extend(other_colors) # ['blue', 'red', 'yellow', 'pink', 'white', 'black', 'green', 'gray', 'orange']

从上述代码中可以看出，当我们调用colors.extend(other_colors)的时候，会将other_colors中的元素遍历出来，再一次添加到colors列表之后。从而形成新的colors列表（colors变量名不变，变量内的列表发生变化）。

注意： extend后的变量名要避免写成字符串的形式，因为字符串是个由字符组成的元组，所以会将每个字符给遍历出来当成元素添加到列表最后。 如：

colors = ['blue', 'red', 'yellow', 'pink', 'white', 'black']
colors.extend('other') # colors = ['blue', 'red', 'yellow', 'pink', 'white', 'black', 'o', 't', 'h', 'e', 'r']

八、统计（list.count(element)）

列表的统计方法，是用来统计列表内相同元素的个数的。如可以用在查重删除的场景下。我们查出一个列表内，相同元素a的个数有3个，那么我们就可以删除掉2个重复元素达到去重的目的。

colors = ['blue', 'red', 'yellow', 'pink', 'white', 'black', 'blue', 'red', 'yellow', 'red', 'yellow']
colors.count('blue') # 2
colors.count('red') # 3

上述代码中，调用colors.count('red')去统计colors列表中，一共有多少个'red'元素。列表回去匹配与'red'完全相同的元素之后，返回了3，表示列表中，一共有三个'red'元素。

九、排序

对列表内的元素进行排序，我们需要调用list.sort(self, key = None, reverse = False)方法。 因为列表中，可以兼容众多不同数据类型，所以针对不同的数据类型，我们传的key是不同的。如：

• 针对数字类型排序，我们可以使key = int
• 针对字符串内容排序，我们可以使key = str
• 针对字符串的长度排序，我们可以使key = len
• 等等等等……

nums = [1, 22, 35, 63, 3, 11, 7]
nums.sort() # 默认数字从小到大排列
print(nums) # [1, 3, 7, 11, 22, 35, 63]
nums.sort(reverse = True) # 从大到小排列
print(nums) # [63, 35, 22, 11, 7, 3, 1]

我们也可以直接使用reverse()方法对列表的元素进行反转排序。

nums = [1, 3, 7, 11, 22, 35, 63]
nums.reverse()
print(nums) # [63, 35, 22, 11, 7, 3, 1]
nums.reverse()
print(nums) # [1, 3, 7, 11, 22, 35, 63]

注意：如果列表内的元素的类型不统一的话，不能使用排序方法，否则会导致崩溃

十、拷贝

我们在开发中，会经常用到拷贝。但是拷贝有分浅拷贝（copy）和深拷贝（deepcopy）。两者之间存在细微差别，需要视具体的情况而使用。

• 浅拷贝：只为列表元素的第一层开辟新地址，而第二层共用第一层的地址。故第二层中的元素变成了元组而不是列表。
• 深拷贝：会为每一层都开辟新的地址，确保每一层的拷贝的列表都仍是可修改的列表，而非元组

十一、去重复

方法一：     

用内置函数set:

list1 = [1, 2, 3, 3, 4, 4, 5, 6, 6, 6, 7, 8, 9]
list2 = list(set(list1))
print(list2)

方法二：

遍历去除重复

list1 = [1, 2, 3, 3, 4, 4, 5, 6, 6, 6, 7, 8, 9]
list2=[]
for i in list1:
if not i in list2:
list2.append(i)
print(list2)

列表推导式

list1 = [1, 2, 3, 3, 4, 4, 5, 6, 6, 6, 7, 8, 9]
list2=[]
[list2.append(i) for i in list1 if not i in list2]

十二、判断 list 中是否包含某个元素

可以通过in和not in关键字来判读

abcList = ['a', 'b', 'c', 1, 2, 3]
if 'a' in abcList:
print('a is in abcList')
if 'd' not in abcList:
print('d is not in abcList')
if 1 in abcList:
print('1 is in abcList')

listname=[[元素1],[元素2],[元素3]......[元素n]]

arry=[]#创建一个空列表
for i in range(4):
    arry.append([])#在空列表中再添加一个空列表
    for j in range(5):
        arry[i].append(j)#为内层列表添加元素
print(arry)

list_=[]
for i in range(5):
     list_.append([])
     for j in range(6):
           list_[i].append(j)
print(list_)
[[0, 1, 2, 3, 4, 5], [0, 1, 2, 3, 4, 5], [0, 1, 2, 3, 4, 5], [0, 1, 2, 3, 4, 5], [0, 1, 2, 3, 4, 5]]

arry=[[i for j in range(5)]for i in range(4)]
print(arry)

list_=[[i for j in range(2)]for i in range(3)]
list_
[[0, 0], [1, 1], [2, 2]]

listname[下标1][下标2]

arry=[[i for j in range(5)]for i in range(4)]
print(arry)

str1="床前明月光"
str2="疑是地上霜"
str3="举头望明月"
str4="低头思故乡"
verse=[list(str1),list(str2),list(str3),list(str4)]#定义一个二维列表
print(verse) #横版
for i in range(4):#循环古诗的每一行
   for j in range(5):#循环每一行的每一个字（列）  
      if j==4:#如果是一行中的最后一个字
        print(verse[i][j])#换行输出
      else:
       print(verse[i][j],end=' ')#不换行输出verse.reverse()#对列表进行逆序排序
床 前 明 月 光
疑 是 地 上 霜
举 头 望 明 月
低 头 思 故 乡
print("——竖版——")
for i in range(5):#循环每一行的每一个字（列）
    for j in range(4):#循环新逆序排列后的第一行
        if j==3:#如果是最后一行
           print(verse[j][i])#换行输出
        else:
           print(verse[j][i],end=' ')#不换行输出
床 疑 举 低
前 是 头 头
明 地 望 思
月 上 明 故
光 霜 月 乡