列表、元组

前面介绍过字符串,字符串对象是具有sequence特性的。

Python中其它两个常用的数据类型 列表(英文叫list) 和 元组(英文叫tuple) 也是sequence特性的

列表的定义

列表对象 经常被用来存储 其它数据对象。

我们可以把列表想象为 一连串的储物格,就像下面这样

image

其中每个储物格里面都可以存储 任何类型 的对象

注意:是任何类型的对象, 整数、小数、字符串、函数、等等 都可以。 也可以存储另一个列表对象。

Python代码中,我们可以这样定义一个空的列表,赋值给一个变量

nameList = []

方括号用来表示一个列表。


如果定义列表的时候,里面就存放了一些数据对象,只需要填写到方括号里面就可以了。

每个对象之间用逗号隔开。

比如

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

这个列表里面就包含了多种类型的对象: 整数、小数 、 字符串。

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

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

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

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

列表的sequence操作

刚才说了,列表也是有sequnce特性的。当然也支持sequence操作。

就是:

可以用元素索引的方式取出里面的元素;

也可以用切片操作 截取一部分内容生成新的列表。



列表的 索引和切片操作和 字符串是 类似的。

比如上面的列表,其索引如下所示

image

列表每个元素的索引是从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

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

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指向的对象

改变列表内容

和我们前面学过的其它数据类型不同,列表对象有个特点,它的内容是可以变化的

比如

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

a[0] = '你好'
print(a)

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

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



如果这样写

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

a[-1][-1] = '你好'
print(a)

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

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


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

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

结果a的值是

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


列表的元素还可以填写表达式,解释器会自动计算结果,放入列表中,比如

var = 100
a = [1, 2, var*3 + 20, 'hello', [7, 8, '你好']]
print(a)

结果a的值是

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



元组

元组也是一种sequence特性的类型, 它和列表非常相似,除了一点: 元组的内容是不能改变的

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

nameList = ()

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


如果定义元组的时候,里面就存放了一些数据对象,只需要填写到括号里面就可以了。

每个对象之间用逗号隔开。

比如

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

这个元组里面就包含了多种类型的对象: 整数、小数 、 字符串。

元组里面的每个对象,就称之为元组的一个元素。

甚至还可以包含另一个列表或者元组作为元素,如下

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

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

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

a = (1, )

否则 这样写的话

a = (1)

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




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

a = 1, 2, 3.14, 'hello'

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

a = 1, 



元组的sequence操作

刚才说了,元组也是有sequnce特性的。当然也支持sequence操作。

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

元组的 索引和切片操作和 列表、字符串是 类似的。

比如

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

元组的切片也后字符串类似,想象用刀去切取其中的一部分,该在哪里下刀,就使用哪里的索引

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]   为什么? 自己想一想

元组内容不可变

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

比如

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

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

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

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




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

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

结果 a的值就变成了

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

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

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

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

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

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

具体的例子如下:

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

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

if 'boy' not in tuple1:
    print('boy 在元组中不存在')    

多个变量同时赋值

我们可以像下面这样把 列表 或者 元组 中的元素直接赋值给变量

x,y = (1,2)   # x 的值为 1, y 的值为 2
print(x,y)   

name, age = ['李逵', 33] # name 的值为 '李逵', age 的值为 33
print(name,age)

但是注意,这样赋值,变量的个数一定要和 列表/元组 中元素的个数相等。

像下面这样就会出错了

x,y = (1,2,3)   
b,c = [1]




课后练习

去做练习

上一页 下一页