【Python】列表和元组_python列表与元组

一. 概念介绍

我们知道变量就是内存空间，它用来表示和存储数据。如果代码中需要表示的数据个数比较少，我们直接创建多个变量即可：

num1 = 10
num2 = 10
num3 = 10
…

但是有的时候，代码中需要表示的数据特别多，甚至也不知道具体要表示多少个数据。这个时候，就需要用到列表和元组了，它们类似于其他编程语言中的“数组”。

就像我们去超市买辣条，如果就只是买一两根辣条，那咱们可以直接拿着辣条就走了。
但是如果一次买个十根八根的，这个时候用手拿就不好拿，超市老板就会给我们个袋子。
这个袋子，就相当于 列表。

元组和列表相比，是非常相似的。只是列表里的元素可以修改调整，而元组中的元素是创建元组的时候就设定好的，之后不能再修改调整。

二. 列表

1. 创建列表

创建列表主要有两种方式（推荐第一种）

# 1、直接使用字面值来创建
# 其中 [] 就表示一个空的列表
a = []
print(a)

# 2、使用 list() 来创建
b = list()
print(b)
1
2
3
4
5
6
7
8

输出结果：

几点说明
（1） 如果需要往里面设置初始值，可以直接写在 [ ] 当中，元素之间用逗号来分割

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

-------运行结果-------
[1, 2, 3, 4]
1
2
3
4
5

（2）列表中存放的元素允许是不同的类型（这一点和 C++/Java 差别较大）

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

-------运行结果-------
[1, 'hello', True]
1
2
3
4
5

2. 访问元素

1、可以通过下标访问操作符 [ ] 来获取到列表中的任意元素，我们把 [ ] 中填写的数字，称为 下标 或者 索引

ls = [1, 2, 3, 4]
# 下标是从 0 开始计数的, 因此下标为 2 , 则对应着 3 这个元素
print(ls[2])  # 3
1
2
3

注意区分创建列表和访问元素时的 [ ]

2、通过下标不光能读取到元素内容，还能修改元素的值

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

-------运行结果-------
[1, 2, 100, 4]
1
2
3
4
5
6

因为下标是从 0 开始计算的，因此下标的有效范围是[0, 列表长度-1]。如果下标超出列表的有效范围，会抛出异常：

3、使用内建函数 len 可以获取到列表的长度（元素个数）

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

-------运行结果-------
4
1
2
3
4
5

PS： len 可以传字符串、列表、元组、字典、自定义的类等变量。

4、Python 中的下标，其实还可以写成负数，表示 "倒数第几个元素"

ls = [1, 2, 3, 4]
print(ls[-1])  # 4
# ls[-1] 相当于 ls[列表长度 - 1]
print(ls[len(ls)-1])  

-------运行结果-------
4
1
2
3
4
5
6
7

3. 切片操作

通过对列表进行切片操作，可以访问到列表中一段连续区间的数据：

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

-------运行结果-------
[2, 3, 4]
1
2
3
4
5

PS：对列表进行切片时，区间的范围是左闭右开

使用切片时可以省略边界

a = [1, 2, 3, 4]
# 省略右边界，表示左边界开始，取到整个列表结束
print(a[1:])
# 省略左边界，表示从从列表的0号元素开始，取到右边界
print(a[:3])
# 同时省略左、右边界，表示取列表的全部元素
print(a[:])

-------运行结果-------
[2, 3, 4]
[1, 2, 3]
[1, 2, 3, 4]
1
2
3
4
5
6
7
8
9
10
11
12

PS：边界为负数（n）的话，表示的是倒数第 n 个元素

设置步长

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

-------运行结果-------
[1, 2, 3, 4, 5, 6, 7, 8, 9, 0]
[1, 3, 5, 7, 9]
1
2
3
4
5
6
7

PS：步长为负数时，表示从后往前取元素

4. 列表的遍历

遍历指的是把列表中的每个元素都依次取出来，然后进行某种操作。我们可以通过以下三种方式遍历列表：

• 范围-for
• 普通的 for 循环
• while 循环

4.1 范围-for

4.2 普通的 for 循环

通过下标遍历列表元素

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

for i in range(0, len(a)):
    a[i] += 10

print(a)

-------运行结果-------
[11, 12, 13, 14, 15, 16, 17, 18, 19, 20]
1
2
3
4
5
6
7
8
9

4.3 while 循环

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

i = 0
while i < len(a):
    a[i] += 10
    i += 1

print(a)

-------运行结果-------
[11, 12, 13, 14, 15, 16, 17, 18, 19, 20]
1
2
3
4
5
6
7
8
9
10
11

5. 插入元素

5.1 append() 方法

append() 方法只能在列表最后位置插入新元素

a = [1, 2, 3, 4]
# 在最后位置插入元素'hello'
a.append('hello')
print(a)

-------运行结果-------
[1, 2, 3, 4, 'hello']
1
2
3
4
5
6
7

补充说明：

5.2 insert() 方法

insert() 方法可以在列表的任意位置插入新元素

a = [1, 2, 3, 4]
a.insert(1, 'hello')
# 下标超过范围时，默认在最后位置插入
a.insert(100, 'world')
print(a)

-------运行结果-------
[1, 'hello', 2, 3, 4, 'world']
1
2
3
4
5
6
7
8

6. 删除元素

6.1 pop() 方法

使用 pop() 可以按照下标位置来删除元素

1）如果不写下标，则默认删除最后一个元素

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

-------运行结果-------
[1, 2, 3]
1
2
3
4
5
6

2）可以指明下标来删除特定位置的元素

如果下标超出范围，就会抛异常，而不是返回-1，因为在 Python 中负数下标也是有效的。

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

-------运行结果-------
[1, 3, 4]
1
2
3
4
5
6

6.2 remove() 方法

与 pop() 通过下标删除元素的方法不同，remove() 方法是通过值来删除元素，如果这个值不存在于列表中则会抛异常。

a = ['aa', 'bb', 'cc', 'dd']
a.remove('cc')
print(a)

-------运行结果-------
['aa', 'bb', 'dd']
1
2
3
4
5
6

7. 查找元素

7.1 in 和 not in 操作符

a = ['aa', 'bb', 'cc', 'dd']
print('cc' in a) # True
print('ff' in a) # False
print('cc' not in a) # False
print('ff' not in a) # True
1
2
3
4
5

7.2 index() 方法

index() 方法用来查找给定元素在元素中的下标，如果元素不存在，就会抛异常。

a = ['aa', 'bb', 'cc', 'dd']
print(a.index('bb')) # 1
1
2

8. 列表拼接

8.1 +和+=

使用 + 可以拼接两个列表，且原列表不会发生改变：

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

-------运行结果-------
[1, 2, 3, 4, 5, 6, 7, 8]
1
2
3
4
5
6
7

使用 += 时，被拼接列表的值会发生改变：

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

-------运行结果-------
[1, 2, 3, 4, 5, 6, 7, 8]
[5, 6, 7, 8]
1
2
3
4
5
6
7
8
9

8.2 extend() 方法

注意 extend() 方法没有返回值：

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

-------运行结果-------
None
[1, 2, 3, 4, 5, 6, 7, 8]
1
2
3
4
5
6
7
8
9

None 非常类似于C语言中的 NULL，或者 Java 里的 null

三. 元组

1. 基本介绍

元组和列表的区别在于：列表的可以修改，而元组永远保持初始化的值。实际在设计函数参数时，我们可以把形成设为元组类型，这样可以保证函数内部不可修改形成对象的值。

2. 元组的使用

1）创建元组

同样也是有两种方式创建元组

a = ()
b = tuple()
print(type(a))
print(type(b))

-------运行结果-------
<class 'tuple'>
<class 'tuple'>
1
2
3
4
5
6
7
8

2）创建元组的时候，指定初始值

a = (1, 2, 3, 4)
print(a)

-------运行结果-------
(1, 2, 3, 4)
1
2
3
4
5

3）元组中的元素可以是任意类型的

a = ('a', 3, True, [])
print(a)

-------运行结果-------
('a', 3, True, [])
1
2
3
4
5

4）可以通过下标来访问元组中的元素，下标范围是 [0, len-1]

a = (1, 2, 3, 4)
print(a[1])
print(a[-1])
# 下标不能越级，否则会抛异常
# print(a[100])

-------运行结果-------
2
4
1
2
3
4
5
6
7
8
9

5）通过切片来获取元组中的一个部分

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

-------运行结果-------
(2, 3)
1
2
3
4
5

6）可以使用 for、while 循环来遍历元组

a = (1, 2, 3, 4)
# 1、范围for
for elem in a:
    print(elem)

# 2、普通 for 循环
for i in range(0, len(a)):
    print(a[i])

# 3、while 循环
i = 0
while i < len(a):
    print(a[i])
    i += 1
1
2
3
4
5
6
7
8
9
10
11
12
13
14

7）可以使用 in、not in 来判断元素是否存在，使用 index 查找元素下标

a = (1, 2, 3, 4)
print(3 in a)
print(3 not in a)
print(a.index(3))

-------运行结果-------
True
False
2
1
2
3
4
5
6
7
8
9

8）可以使用 + 来拼接两个元组

a = (1, 2, 3, 4)
b = (5, 6, 7, 8)
print(a + b)

-------运行结果-------
(1, 2, 3, 4, 5, 6, 7, 8)
1
2
3
4
5
6

9）元组只支持 “读” 操作，不能支持 “写” 操作

a = (1, 2, 3, 4)
a[1] = 20

-------运行结果-------
TypeError: 'tuple' object does not support item assignment
1
2
3
4
5

10）当进行多元赋值的时候，其实本质上是按照元组的方式来进行工作的

def Func():
    x = 10
    y = 20
    return x, y

print(type(Func()))

# 这里会把元组的元素依次取出来，赋值给a、b
a, b = Func()

-------运行结果-------
<class 'tuple'>
1
2
3
4
5
6
7
8
9
10
11
12