[Python] 深入理解列表和元组

在学习的C语言中有数组可以用来存储数据，那么在Python中是否也有这样的工具呢？接下来让可莉来给大家讲解列表和元组这两个强力工具吧~

                                     

                                        专栏：《Python》

                                        blog：Keven ’ s blog

在 Python 中，列表和元组是两种常用的序列数据类型，用于存储和操作一组数据。虽然它们的用

途相似，但它们在一些方面有很大的不同。在本篇博客中，可莉将跟着大家一起深入了解它们的特

点、用法和区别。

列表

在编程中，我们经常需要变量来保存数据，如果要保存的数据数量较少的话我们可以创建变量来进行保存，那如果数据很多呢？这时候就要引入列表的概念了。

创建列表

创建列表有两种方式：

alist = [ ] #第一种
alist = list() #第二种

print(type(alist))

如果需要往里面设置初始值, 可以直接写在 [ ] 当中

alist = [1, 2, 3, 4]
print(alist)

与Java和C++不同，在列表中可以存储不同类型的数据

alist = [1, 'hello', True]
print(alist)

访问下标

我们可以用下标运算符[ ] 来访问列表中的任意元素。通常，我们把 [ ] 中填写的数字成为下标或者索引。

alist = [1, 2, 3, 4]
print(alist[2])

下标是从0开始的，也就是说0对应的是列表中第一个元素，1对应的第二个元素，以此类推，如果列表的大小是n个元素，那么最大的下标就是n - 1。

通过下标不仅能访问数据，也能修改数据：

alist = [1, 2, 3, 4]
alist[2] = 100
print(alist)

当访问元素时下标超出有效范围时，程序会抛出异常：

alist = [1, 2, 3, 4]
print(alist[100])

我们可以用len来得到列表的大小：

alist = [1, 2, 3, 4]
print(len(alist))

通过len得到列表大小后在之后的运用中会使操作更加方便。

在Python中一个与C++，Java不同的地方就是它的列表元素可以用负数下标来获取，具体对应元素如下图所示。

我们通过代码运行看下：

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

运行结果：

                                     

切片操作

通过下标操作是一次取出里面第一个元素.通过切片, 则是一次取出一组连续的元素, 相当于得到一

个子列表。

• 使用 [ : ] 的方式进行切片操作

alist = [1, 2, 3, 4]
print(alist[1:3])

                           

alist[1:3] 中的 1:3 表示的是 [1, 3) 这样的由下标构成的前闭后开区间.

也就是从下标为 1 的元素开始(2), 到下标为 3 的元素结束(4), 但是不包含下标为 3 的元素.

所以最终结果只有 2, 3 

• 切片操作中可以省略前后边界（具体规则如下）

alist = [1, 2, 3, 4]
print(alist[1:]) # 省略后边界, 表示获取到列表末尾
print(alist[:-1]) # 省略前边界, 表示从列表开头获取
print(alist[:]) # 省略两个边界, 表示获取到整个列表.

                  

• 切片操作还可以指定 "步长" , 也就是 "每访问一个元素后, 下标自增几步"

alist = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
print(alist[::1])
print(alist[::2])
print(alist[::3])
print(alist[::5])

• 切片操作指定的步长还可以是负数, 从后往前进行取元素. 表示 "每访问一个元素之后, 下标自减几步"

alist = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
print(alist[::-1])
print(alist[::-2])
print(alist[::-3])
print(alist[::-5])

• 如果切片中填写的数字越界了, 不会有负面效果. 只会尽可能的把满足条件的元素都取到

但如果两个界限都超出了范围的话就会取不到元素，但也没有报错：

alist = [1, 2, 3, 4]
print(alist[100:200])

                                     

遍历列表元素

下面将进行讲解如何进行遍历数列元素。

for循环

下面这个方法的for循环只适合对列表中的元素进行只读状态，不能改变列表中的元素：

alist = [1, 2, 3, 4]
for elem in alist:
    print(elem)

                        

而通过下标的方法来访问可以对列表中的元素进行访问并且修改和操作：

alist = [1, 2, 3, 4]
for i in range(0, len(alist)):
    print(alist[i])

这个与上面的打印效果效果相同，接下来再举例一个进行修改元素的例子：

alist = [1, 2, 3, 4]
for i in range(0, len(alist)):
    alist[i] = 0
print(alist)

                        

while循环

alist = [1, 2, 3, 4]
i = 0
while i < len(alist):
    print(alist[i])
    i += 1

通过添加 i 的增加来控制循环。

新增元素

append

我们可以用append的方法向列表后面增添一个元素：

alist = [1, 2, 3, 4]
alist.append('hello')
print(alist)

此处的append是搭配列表对象alist来使用的，而不是作为一个独立的函数，是一种搭配对象的函数。

insert

我们可以通过insert来对列表中任意位置进行增添元素：

a  = [1, 2, 3, 4]
a.insert(1, 'hello')
a.insert(100, 'hello')
print(a)

函数的第一个形参位置填写的是要访问的位置的下标，第二个位置是要添加的元素。如果要添加的位置超出了列表的范围，它还是会尽量的进行添加，则添加到了列表的最后位置。

查找元素

用 in 查找

a = [1, 2, 3, 4]
print(1 in a)
print(10 in a)
print(1 not in a)
print(10 not in a)

可以通过in来进行查找，当in加上not时相当于对in进行逻辑取反。当用in找到元素时就会返回True，否则为False，用not in则是逻辑相反。

                                 

用 index 查找

使用 index 方法, 查找元素在列表中的下标. 返回值是一个整数. 如果元素不存在, 则会抛出异常。

alist = [1, 2, 3, 4]
print(alist.index(2))
print(alist.index(10))

删除元素
 

pop

alist = [1, 2, 3, 4]
alist.pop(2)
print(alist)

可以用pop来删除元素，如果只是alist.pop的话删除的是列表的最后一个元素，如果在（ ）中填写下标的话，那么pop就会通过下标来删除对应下标的元素。

remove

alist = [1, 2, 3, 4]
alist.remove(2)
print(alist)

                    

通过在remove的（ ）中填写要删除的元素即可达到删除对应元素的效果。

连接列表

使用 + 拼接

此处的 + 结果会生成一个新的列表. 而不会影响到旧列表的内容。

alist = [1, 2, 3, 4]
blist = [5, 6, 7]
print(alist + blist)

     

extend

使用 extend 方法, 相当于把一个列表拼接到另一个列表的后面。a.extend(b) , 是把 b 中的内容拼接到 a 的末尾. 不会修改 b, 但是会修改 a。

alist = [1, 2, 3, 4]
blist = [5, 6, 7]
alist.extend(blist)
print(alist)
print(blist)

    

元组

元组和列表相比，基本是一致的。

元组用（）表示（或者tuple（））：

atuple = ( )
atuple = tuple()

元组与列表最大的区别就是：元组不能修改里面的元素, 列表则可以修改里面的元素

因此, 像读操作,比如访问下标, 切片, 遍历, in, index, + 等, 元组也是一样支持的，但是, 像写操作,

比如修改元素, 新增元素, 删除元素, extend 等, 元组则不能支持。

元组在 Python 中很多时候是默认的集合类型. 例如, 当一个函数返回多个值的时候：

def getPoint():
    return 10, 20

result = getPoint()
print(type(result))

可莉的总结

• 列表和元组都是日常开发最常用到的类型. 最核心的操作就是根据 [ ] 来按下标操作.
• 在需要表示一个 "序列" 的场景下, 就可以考虑使用列表和元组.
• 如果元素不需要改变, 则优先考虑元组.
• 如果元素需要改变, 则优先考虑列表.

希望大家通过和可莉一起学习这篇博客能可以你更好地理解列表和元组，并选择适当的数据类型来处理你的数据，加油~