【Python学习笔记】列表、元组

Python中的 列表(英文叫list) 和 元组(英文叫tuple) 也是 序列 特性的，支持索引和切片操作。

1. 列表（List）

列表（List）对象经常被用来 存储 任何数据类型对象。

Python代码中，我们可以这样定义一个空的列表，赋值给一个变量，方括号用来表示一个列表。

nameList = []
1

如果定义列表的时候，里面就存放了一些数据对象，只需要填写到方括号里面就可以了。每个对象之间用逗号隔开。比如

a = [1, 2, 3.14, 'hello']
1

列表里面的每个对象，就称之为列表的一个元素。

甚至还可以包含另一个列表作为元素，如下

a = [1, 2, 3.14, 'hello', [7,8,9] ]
1

最后一个元素 就是 另外的一个列表对象 [7,8,9]

2. 列表的sequence操作

列表可以用元素索引的方式取出里面的元素; 也可以用切片操作 截取一部分内容生成新的列表。

列表每个元素的索引是从0开始的，支持正数索引，也支持负数索引。

a = [1, 2, 3.14, 'hello', [7,8,9] ]
a[0]    # 就是 1
a[1]    # 就是 2
a[4]    # 就是 [7,8,9]
a[-1]   # 也是 [7,8,9]
a[-4]   # 也是 2
a[-1][0]  # a[-1] 是[7,8,9],  a[-1][0] 就是 [7,8,9] 里面的第一个元素，就是 7
1
2
3
4
5
6
7

列表的切片也和字符串类似，想象用刀去切取其中的一部分，该在哪里下刀，就使用哪里的索引

a = [1, 2, 3.14, 'hello', [7,8,9] ]
a[0:3]      # 结果是   [1, 2, 3.14]
a[:3]       # 结果也是 [1, 2, 3.14]
a[3:5]      # 结果是   ['hello', [7,8,9] ]
a[3:]       # 结果也是 ['hello', [7,8,9] ]

a[-1][:2]   # 结果是   [7,8]

print(a)      
# 结果还是 [1, 2, 3.14, 'hello', [7,8,9] ] 
# 上面对a的切片操作是产生新的对象，并不会改变a指向的对象
1
2
3
4
5
6
7
8
9
10
11

3. 改变列表内容

a = [1, 2, 3.14, 'hello', [7,8,9] ]
print(a)

a[0] = '你好'
print(a)
1
2
3
4
5

执行上面的代码，可以发现，最后列表变量 a 的内容变成了

['你好', 2, 3.14, 'hello', [7, 8, 9]]
1

如果这样写

a = [1, 2, 3.14, 'hello', [7,8,9] ]
print(a)

a[-1][-1] = '你好'
print(a)
1
2
3
4
5

就改变了列表里面的列表 的内容，a就变成了

[1, 2, 3.14, 'hello', [7, 8, '你好']]
1

---

列表的元素也可以填写变量，比如

var = [7, 8, '你好']
a = [1, 2, 3.14, 'hello', var]
print(a)
1
2
3

结果a的值是

[1, 2, 3.14, 'hello', [7, 8, '你好']]
1

如果我们只是要把下面的列表

list1 = [0, 1, 2, 3, 4, 5]
1

其中 1,2,3 换成 a,b,c ， 该怎么做呢？

当然可以这样

list1[1] = 'a'
list1[2] = 'b'
list1[3] = 'c'
1
2
3

但是一个个的写有点麻烦，列表支持这样一部分内容整体替换

list1 = [0, 1, 2, 3, 4, 5]
list1[1:4] = ['a','b','c']
1
2

结果 list1 就变成了 [0, ‘a’, ‘b’, ‘c’, 4, 5]

这种写法称之为 切片赋值

切片赋值甚至支持替换的元素 比 被替换的元素多， 像这样

list1 = [0, 1, 2, 3, 4, 5]
list1[1:4] = ['a','b','c','e','f','g','h']
1
2

结果 list1 就变成了 [0, ‘a’, ‘b’, ‘c’, ’e’, ‘f’, ‘g’, ‘h’, 4, 5]

4. 合并两个列表

列表中要添加另外一个列表的内容很简单，用加号就可以了

>>> a = [1,2,3]
>>> a += [4,5,6]
>>> a
[1, 2, 3, 4, 5, 6]
1
2
3
4

---

5. 元组

元组（Tuple）也是一种sequence特性的类型， 它和列表非常相似，也可以存放任何类型的数据对象，除了一点： 元组的内容是 不能改变的,

Python代码中，我们可以这样定义一个空的元组，赋值给一个变量

nameList = ()
1

圆括号用来表示一个元组。

如果定义元组的时候，里面就存放了一些数据对象，只需要填写到括号里面就可以了。每个对象之间用逗号隔开。

比如

a = (1, 2, 3.14, 'hello')
1

如果元组中只有一个元素，必须要在后面加上逗号，像这样

a = (1, )
1

否则这样写的话

a = (1)
1

a就是 数字1 了， 而不是包含 数字1 的元组

定义元组还可以去掉圆括号，像这样

a = 1, 2, 3.14, 'hello'
1

但是这样定义的时候，如果元组中只有一个元素，必须要在后面加上逗号，像这样

a = 1, 
1

6. 元组的sequence操作

同列表一样，元组也支持用元素索引的方式取出里面的元素; 也支持用切片操作截取一部分内容作子列表。

7. 元组内容不可变

和列表不同，元组对象的内容是不可以变化的

比如

a = (1, 2, 3.14, 'hello', [7,8,9])
a[0] = '你好'
1
2

执行上面的代码，解释器会报如下错误

Traceback (most recent call last):
  File "", line 1, in <module>
TypeError: 'tuple' object does not support item assignment
1
2
3

意思是说元组的内容是不可以改变的。

但是元组中的列表的内容却是可以改变的，比如

a = (1, 2, 3.14, 'hello', [7,8,9])
a[-1][0] = '你好'
print(a)
1
2
3

结果 a的值就变成了

(1, 2, 3.14, 'hello', ['你好', 8, 9])
1

8. 判断元素是否在列表或元组中

有时候，我们要检查列表、元组对象中是否存储我们要找的元素。 我们可以通过 in 这个关键字 ，比如

a in var   		# 检查 a 是否在var 中存在，存在返回True，否则返回False
1

而 not in 则判断是否不存在，比如

a not in var   	# 检查 a 是否不在var 中，存在返回 False，否则返回 True
1

具体的例子如下：

list1 = [1,2,3,4, 'hello']
tuple1 = (1,2,3,4, 'hello')

if 'hello' in list1:
    print('hello 在列表中存在')

if 'boy' not in tuple1:
    print('boy 在元组中不存在') 
# 运行结果
$ python main.py
hello 在列表中存在
boy 在元组中不存在
1
2
3
4
5
6
7
8
9
10
11
12

upChars = 'abcdefghijklmnopqrstuvwxyzABCDEF'
print('abc' in upChars)
print('aaaa' in upChars)
print('aaaa' not in upChars)
# 运行结果
$ python main.py
True
False
True
1
2
3
4
5
6
7
8
9