Python基础语法学习：列表和元组

前面学变量的时候，一个变量基本对应一个数据。

例如：

num1 = 10
num2 = 20
num3 = 30

数据少的时候这样写没什么问题，但如果一下子有几十个、几百个数据，再一个个创建变量就很麻烦。

这时候就需要一种能够批量保存数据的结构。

Python 中很常见的就是：

列表 list 和元组 tuple。

---

一、什么是列表

列表可以理解成一个"数据容器"。

例如：

alist = [1, 2, 3, 4]

一个列表里可以保存多个元素。

而且 Python 的列表比较灵活，不要求里面所有元素都是同一种类型：

alist = [1, 'hello', True]

这种写法也是合法的。

创建空列表：

alist = []

也可以：

alist = list()

---

二、通过下标访问列表

Python 的列表和 C++ 数组一样，都支持下标访问。

例如：

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

输出：

3

因为 Python 的下标从 0 开始：

下标 0 → 1
下标 1 → 2
下标 2 → 3
下标 3 → 4

不仅可以读取，还可以通过下标修改：

alist[2] = 100

---

三、列表长度和负数下标

使用：

len(alist)

可以得到列表中的元素个数。

如果：

alist = [1, 2, 3, 4]

那么有效下标是：

0 ~ 3

超出范围就会抛出异常。

Python 还有一个很方便的功能：

负数下标。

例如：

print(alist[-1])

表示最后一个元素。

也就是：

alist[-1]

等价于：

alist[len(alist) - 1]

所以：

-1 → 倒数第1个
-2 → 倒数第2个
-3 → 倒数第3个

---

四、切片

如果只想拿一个元素，可以使用下标。

如果想一次拿出一段连续的数据，就可以使用切片。

基本写法：

alist[开始:结束]

例如：

alist = [1, 2, 3, 4]

print(alist[1:3])

结果：

[2, 3]

这里的范围是：

[1, 3)

也就是包含下标 1，不包含下标 3。

这个规则和 range() 一样，也是左闭右开。

---

五、切片可以省略边界

例如：

alist = [1, 2, 3, 4]

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

表示从下标 1 一直到列表结尾。

print(alist[:-1]) # [1, 2, 3]

表示从开头取到最后一个元素之前。

而：

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

可以得到整个列表。

---

六、切片还可以设置步长

完整的切片形式是：

alist[start:end:step]

第三个参数就是步长。

例如：

alist = [1,2,3,4,5,6,7,8,9,10]

print(alist[::2]) # [1, 3, 5, 7, 9]

就是隔一个元素取一个。

也可以使用负数步长：

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

可以把列表倒过来。

而且切片的边界即使超出范围，一般也不会直接报错，而是尽可能取出符合要求的元素。

---

七、遍历列表

列表最常见的操作之一就是遍历。

最简单的方法是：

alist = [1, 2, 3, 4]

for elem in alist:
    print(elem)

这样就能一个一个取出元素。

也可以通过下标：

for i in range(0, len(alist)):
    print(alist[i])

还可以使用 while：

i = 0

while i < len(alist):
    print(alist[i])
    i += 1

---

八、向列表中添加元素

最常用的是 append：

alist = [1, 2, 3, 4]

alist.append('hello')

print(alist)

它会把元素放到列表末尾。

---

九、insert插入元素

如果不想放在末尾，而是想放到指定位置，可以使用：

alist.insert(1, 'hello')

第一个参数表示插入位置的下标。

这里还出现了一个概念：

方法（method）

例如：

alist.append()
alist.insert()

这些方法都依附于 alist 这个对象。

可以简单理解成：

函数：独立存在
方法：依附于某个对象

---

十、查找列表元素

判断某个元素是否存在，可以使用：

2 in alist

返回的是布尔值：

True
False

例如：

alist = [1, 2, 3, 4]

print(2 in alist) # True
print(10 in alist) # False

也可以用：

alist.index(2)

查找元素所在的下标。

如果元素不存在，index 会抛出异常。

---

十一、删除元素

删除列表元素有几种常见方式。

pop()

删除最后一个元素：

alist.pop()

也可以指定下标：

alist.pop(2)

remove()

按照元素值删除：

alist.remove(2)

这里删除的是值为 2 的元素。

所以：

pop → 按位置删
remove → 按值删

---

十二、列表拼接

两个列表可以直接使用 +：

alist = [1, 2, 3, 4]
blist = [5, 6, 7]

print(alist + blist)

这里会生成一个新的列表，原来的两个列表不会被修改。

也可以使用：

alist.extend(blist)

这样是把 blist 中的数据添加到 alist 末尾。

alist 会被修改
blist 不会被修改

---

十三、元组是什么

元组和列表非常像。

列表：

alist = [1, 2, 3]

元组：

atuple = (1, 2, 3)

最重要的区别只有一个：

列表可以修改，元组不能修改。

例如：

alist[0] = 100

可以。

但是：

atuple[0] = 100

不可以。

---

十四、元组支持哪些操作？

虽然元组不能修改，但是很多"读操作"还是支持的。

例如：

下标访问
切片
遍历
in
index
+

都可以使用。

但是这些修改操作不能用：

修改元素
新增元素
删除元素
extend

---

十五、为什么有了列表还需要元组？

既然列表这么灵活，为什么还需要元组？

主要有两个方面。

第一，元组不可修改。

如果一个函数接收到列表，而你又不能确定这个函数内部会不会修改它，那么传递元组会更加安全。

第二，后面学习字典的时候会接触哈希。

字典的 key 必须是可哈希对象，而可哈希的前提之一就是不可变，所以元组可以作为字典的 key，列表则不能。

另外，Python 中函数返回多个值的时候，经常就是返回一个元组：

def getPoint():
    return 10, 20

result = getPoint()

这里 result 实际上就是一个元组。

---

十六、列表和元组怎么选？

可以直接这么理解：

数据需要修改 → 列表
数据不希望修改 → 元组

两个都是 Python 中非常常用的序列类型，核心操作都围绕下标、切片和遍历展开。

---