列表、元组

点击这里，边看视频讲解，边学习以下内容

前面介绍过字符串，字符串对象是具有 序列 特性的。

Python中的列表(英文叫list) 和元组(英文叫tuple) 也是 序列 特性的，它们也是非常常用的数据类型。

列表

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

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

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

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

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

nameList = []

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

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

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

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

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

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

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

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

列表的sequence操作

刚才说了，列表也是有sequnce特性的。当然也支持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

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

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, '你好']]

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

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

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

当然可以这样

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

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

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

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

这种写法称之为 切片赋值

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

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

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

合并两个列表

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

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

您需要高效学习，找工作？点击咨询报名实战班

点击查看学员就业情况

元组

点击这里，边看视频讲解，边学习以下内容

元组（Tuple）也是一种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('hello 在列表中存在')

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]

函数返回列表或者元组

函数的返回值可以是一个列表或者元组对象，像这样

def func1():
    age = input('请输入年龄')
    gender = input('请输入性别')
    return  [age,gender]

当我们有多个数据对象需要在函数里面返回的时候，就可以放到列表中。

当然也可以放到元组中返回，像这样

def func1():
    age = input('请输入年龄')
    gender = input('请输入性别')
    return  (age,gender)

如果是放在元组中返回，可以简单写成这样

def func1():
    age = input('请输入年龄')
    gender = input('请输入性别')
    return  age,gender

因为元组的括号是可以省略的

课后练习

去做练习

列表、元组

列表

列表的sequence操作

改变列表内容

合并两个列表

您需要高效学习，找工作？ 点击咨询 报名实战班

点击查看学员就业情况

元组

元组的sequence操作

元组内容不可变

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

多个变量同时赋值

函数返回列表或者元组

课后练习

您需要高效学习，找工作？点击咨询报名实战班