Python基础知识“入坑“--- 六、列表和元组

一、列表、元组定义

在我们编写代码的过程中，经常会使用到变量来保存或表示数据。当需要使用的变量个数少的时候我们可以逐个定义，但当我们要表示的变量个数很多时，该怎么办呢？

Python中提供了一种解决办法，叫列表。列表是一种可以批量表示或保存数据的方式。

元组也可以解决此类问题，只不过，元组和列表相比虽然是非常相似的，但列表中存放的元素可以进行修改调整；元组中存放的元素在创建元组时已经设定好了，不能进行修改调整。即列表可变，元组不可变。

声明：由于列表与元组相似，我们先对列表相关知识进行学习，再补充元组的知识！！！

二、创建列表

• 创建列表有两种方式：

a = [] #方法一
b = list() #方法二
print(type(a))
print(type(b))

列表的类型用list表示。

---

• 如果需要初始化列表，将初始化的值直接写在 “[]” 即可：

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

使用print函数直接打印列表中的内容。

---

• 列表中存放的元素可以是不同的数据类型：

a = [1, 5.2, 'hello', True]
print(a)

三、访问下标

• 可以通过下标访问操作符：[ ] 来获取列表中的任意元素：

a = [1, 2, 3, 4, 5]
print(a[2]) #3

在 [ ] 中填写的数字，就称为下标。

注意：下标是从0开始计算的。

---

• 通过下标访问到的元素，我们可以修改它的值：

a = [1, 2, 3, 4, 5]
a[2] = 300
print(a) # [1, 2, 300, 4, 5]

在上面这段代码中，我们将下标为2的元素（值为3）修改为300。

---

• 如果使用的下标的值超出的列表的范围，程序就会抛出异常：

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

---

• 列表的下标是从0开始的，所以下标的有效范围为 [0，列表长度 - 1]。使用len函数可以获取到列表元素个数：

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

---

• 在列表中，下标可以取负数，表示 倒数第几个元素：

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

使用负数表示下标的时候，倒数第一个数的下标为 -1。

四、切片操作

通过下标操作可以一次获取一个元素；而通过切片操作可以一次性取出一组连续的元素，相当于得到一个子列表。

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

a = [1, 2, 3, 4, 5]
print(a[1 : 3]) #[2, 3]

在使用切片操作时，范围为左闭右开的区间，如上面这段代码：[1 : 3] 表示的就是从下标为1的元素开始（包括下标为1的元素的值）到下标为3的元素结束（不包括下标为3的元素的值），所以得到的结果为 [2, 3]。

---

• 切片操作可以省略前后边界：

a = [1, 2, 3, 4, 5]
print(a[2:]) #省略后边界，表示一直获取到列表末尾
print(a[:3]) #省略前边界，表示从列表开头开始获取
print(a[:]) #省略两个边界，表示获取整个列表

运行结果如下：

要记得使用切片操作时，是左闭右开区间！！！

---

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

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

运行结果为：

在默认情况下，步长设定为1；当我们想要改变步长时，就可以指定步长的长度。

---

• 切片操作指定的步长还可以是负数，此时表示为从后往前读取元素。当步长为负数时，也就是 每访问一个元素后，下标自减几：

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

运行结果为：

---

• 如果切片中填写的数字越界了，程序并不会报错：

a = [1, 2, 3, 4, 5]
print(a[1 : 100]) #[2, 3, 4, 5]

五、遍历列表元素

遍历是指将元素逐个取出，再进行处理。

• 可以使用for循环直接对列表进行遍历：

a = [1, 2, 3, 4, 5]
for i in a:
    print(i)

在我们学习for循环的语法时，in后应该是一个可迭代对象，列表正是一个可迭代对象。

通过这样的打印形式，我们只可以获取列表中的元素，并不能对列表中的元素进行修改：

a = [1, 2, 3, 4, 5]
for i in a:
    i = i * 2
print(a) #[1, 2, 3, 4, 5]

---

• 使用for循环对下标进行访问：

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

在使用for循环对下标进行访问时，就可以修改元素的值：

a = [1, 2, 3, 4, 5]
for i in range(0, len(a)):
    if i == 3:
        a[i] = a[i] * 2
print(a) #[1, 2, 3, 8, 5]

---

• 也可以使用while循环，手动控制下标的变化，来遍历列表：

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

六、新增元素

• 使用 append 方法，向列表末尾插入一个元素（尾插）。

a = [1, 2, 3, 4, 5]
a.append(6)
print(a)

---

• 使用 insert 方法，向任意位置插入一个元素。

a = [1, 2, 3, 4, 5]
a.insert(1, 6)
print(a) #[1, 6, 2, 3, 4, 5]

insert 方法包含两个参数，第一个参数表示要插入元素的下标，第二个参数表示插入的元素。

在插入元素时，我们使用了insert和append方法。在这里，方法其实就是函数，只不过函数可以独立使用，而方法需要依赖某个对象才能使用。在使用方法时，我们需要通过 “.” 来调用方法。

七、查找元素

• 使用in操作符，判断元素是否在列表中，返回值是布尔类型：

a = [1, 2, 3, 4, 5]
print(1 in a) #True
print(6 in a) #False

• not in也可以判断元素是否在列表中：

a = [1, 2, 3, 4, 5]
print(1 not in a) #False
print(6 not in a) #True

---

• 使用 index 方法，查找元素在列表中的下标；如果存在，则返回下标的值；否则，程序就会抛出异常：

#元素在列表中
a = [1, 2, 3, 4, 5]
print(a.index(2)) #1

#元素不在列表中
a = [1, 2, 3, 4, 5]
print(a.index(6)) #程序抛出异常（如下图）

八、删除元素

• 使用 pop 方法删除列表最末端元素：

a = [1, 2, 3, 4, 5]
a.pop()
print(a) #[1, 2, 3, 4]

---

• 使用 pop 方法还可以根据下标删除元素：

a = [1, 2, 3, 4, 5]
a.pop(1)
print(a) #[1, 3, 4, 5]

---

• 使用 remove 方法，按照值删除元素：

a = [1, 2, 3, 4, 5]
a.remove(1)
print(a) #[2, 3, 4, 5]

九、连接列表

• 使用加号（+）可以将两个列表拼接在一起：

a = [1, 2, 3, 4, 5]
b = [6, 7, 8, 9, 10]
print(a + b) #[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

使用加号拼接列表的结果是一个新的列表，对原列表没有影响。

---

• 还可以使用 extend 方法，将一个列表拼接在一个列表的末尾：

a = [1, 2, 3, 4, 5]
b = [6, 7, 8, 9, 10]
a.extend(b)
print(a) #[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
print(b) #[6, 7, 8, 9, 10]

在上面这段代码中，“a.extend(b)” 的意思是将列表b的内容拼接到a的末尾，这就会导致a列表的内容发生改变，而b列表的内容不变。

十、元组

至此，有关列表的知识已经学习完成，我们再来学习一下元组（tuple）。

元组的功能和列表基本是一致的，最重要的区别就是：元组内部的元素不能修改，列表内部的元素可以修改！

1.创建元组

元组有两种创建方法：

a = () #方法一
b = tuple() #方法二
print(type(a)) #<class 'tuple'>
print(type(b)) #<class 'tuple'>

2.元组功能

因为元组和列表的本质区别在于：元组内部的元素不能修改，列表内部的元素可以修改！ 所以：

1.像列表中的读操作：访问下标、切片、遍历元素、in、index、加号拼接等，元组也一样支持使用。
2.像列表中的写操作：修改元素、新增元素、删除元素、extend拼接等，元组则不能支持使用。

3.类型应用

在Python中，很多场景下，元组其实是默认的集合类型，如：

def test():
    return 10, 20

result = test()
print(type(result)) #<class 'tuple'>

---

Ending。