Python学习笔记--列表及元组

一、列表

（一）、列表的创建与访问

列表作为Python的一种数据结构，它容许存放不同的数据类型，在创建列表时，使用中括号将要存放的数据包裹起来即可，不同元素之间使用逗号分隔

heros = ["绿巨人", "钢铁侠", 3000, '黑寡妇']

同样，列表也是一个序列，即可迭代对象，所以可以使用 for 循环来访问列表中的每一个元素

for each in heros:
    print(each)

当想要访问列表中的某一个元素时，可以使用下标索引的方式

heros[0]

'绿巨人'

正序的索引，其下标值从 0 开始；倒序的索引，其下标值从 -1 开始

那么，如果想要一次访问多个元素呢？

这时就可以使用列表切片，其实就是将之前的单个下标值变成一个下标范围即可

heros[0: 2]
['绿巨人'，'钢铁侠']

可以发现切片有点像 for 循环中的 range 函数，即 [start : stop] 的参数形式（都不包含 stop ），同样，切片与 range 函数相同，也支持第三个参数，即步进的跨度值

heros[::2]
['绿巨人'， 3000]

（二）、列表的操作方法

1. 增

向列表中添加元素，可以使用 append() 方法，它可以在列表的末尾添加一个指定的元素

heros.append("蜘蛛侠")

当需要添加多个元素时，可以使用 extend() 方法，它允许直接添加一个可迭代对象（必须是可迭代对象），添加的对象会存放在原列表最后的一个元素的后面

heros.extend(["鹰眼", "美国队长"])

 同样，我们也可以使用切片的方法来添加元素（后续介绍）

如果想要在列表的某一位置插入元素，可以使用 insert() 方法，该方法有两个参数，一个是待插入的位置，一个是待插入的元素

heros.insert(0, "蝙蝠侠")

2. 删

将列表中指定的元素删除，可以使用 remove() 方法

heros.remove(3000)

如果列表中有多个相同的待删除元素，remove() 方法只会删除下标值最小的第一个元素；如果指定的待删除元素不存在时，程序则会报错

将列表中指定位置的元素删除，可以使用 pop()  方法，它的参数就是列表的下标值

heros.pop(1)

将列表清空，即删除列表中的所有元素，可以使用 clear() 方法

3. 改

修改列表中的单个元素，可以使用下标索引加上赋值运算符的方式

heros[0] = "超人"

如果要一次修改列表中的多个元素，则可以使用切片的方式

heros[:3] = ["猪猪侠", "熊大", "电击小子"]

上述代码的功能是对原列表的前三个元素进行替换，实际上，它分为两步实现，首先删除赋值号（=）左边指定的内容，然后将包含在赋值号（=）右边的可迭代对象中的片段插入左边被删除的位置

如果列表中的数据类型全是数字，则可以对这些数值进行排序，这时可以使用 sort() 方法，该方法默认是正序排序，如果要逆序排序，则可以再调用一次 reverse() 方法，该方法是将首尾对应下标的元素互换位置，但 sort() 方法其实支持两个参数（后续介绍）

4. 查

如果要查找某个指定元素在列表中出现的次数，可以使用 count() 方法

heros.count("绿巨人")

如果要查找某个指定元素在列表中的位置，可以使用 index() 方法，该方法会返回指定元素在列表中的下标值，当列表有多个相同指定元素时，则会返回第一个指定元素的下标，即返回最小下标值

同时，index() 方法还有两个可选参数，index(x, start, end)即指定开始查找和结束的位置

5. 加法与乘法

列表与字符串一样都是序列，在字符串中，加法代表将两个字符串进行拼接。在列表也是如此，使用加号运算符可将两个列表拼接，而乘法运算符则是重复对象中的内容 n 次

s = [1, 2, 3]
t = [4, 5, 6]
s + t
[1, 2, 3, 4, 5, 6]
s * 2
[1, 2, 3, 1, 2, 3]

6. 嵌套列表

即在列表中存放列表，使用嵌套列表可以实现矩阵运算

在之前的一维列表中，使用 for 循环可以迭代访问列表中的每一个元素，严格来说，是使用一层 for 循环，所以在访问嵌套列表时，需要使用多层 for 循环迭代

s = [[1, 2, 3], [4, 5 ,6], [7, 8 ,9]]
for i in s:
    for j in i:
        print(j, end = ' ')
    print()

    
1 2 3 
4 5 6 
7 8 9 

同样，也可以使用多重下标索引的方式来访问嵌套列表中的元素

7. 浅拷贝与深拷贝

先介绍同一性运算符 is ，它是用于检验两个变量是否指向同一个对象的运算符

x = "Yu"
y = "Yu"
x is y
True
x = [1, 2, 3]
y = [1, 2, 3]
x is y
False

可以发现，对于两个相同的字符串而言， is 运算符的结果是True；而对于两个相同的列表， is 运算符的结果是 False

因为字符串是常量，在内存中只开辟了一块区域存放， x 和 y 都指向了字符串，指向了同一个内存地址的同一个对象；而列表是变量，即使创建的两个列表相同，但是在内存中，它们会被分开存放，也就是说，二者是指向了不同内存地址的同一个对象，之间也就没有什么关系。举例子就是世界上名字相同的大有人在，但他们一般没有什么关系。

浅拷贝：可以使用 copy() 方法拷贝列表，也可以使用切片的语法来实现

x = [1, 2 ,3]
y = x.copy()
y
[1, 2, 3]
a = [1, 2, 3]
b = a[ : ]
b
[1, 2, 3]

但是要注意浅拷贝一般只适用于一维列表，不能对嵌套列表进行拷贝，因为浅拷贝的方法只是拷贝了外层的对象，如果包含嵌套对象的话，那拷贝的只是其引用

深拷贝：这时可以导入 copy 模块，其中包含两个函数， copy() 和 deepcopy() ，对应浅拷贝和深拷贝，可以调用 copy 模块中的 deepcopy() 函数来实现嵌套列表的深拷贝

import copy
x = [[1, 2 , 3], [4, 5, 6], [7, 8, 9]]
y = copy.copy(x)
x[1][1] = 0
x
[[1, 2, 3], [4, 0, 6], [7, 8, 9]]
y
[[1, 2, 3], [4, 0, 6], [7, 8, 9]]
x = [[1, 2 , 3], [4, 5, 6], [7, 8, 9]]
y = copy.deepcopy(x)
x[1][1] = 0
x
[[1, 2, 3], [4, 0, 6], [7, 8, 9]]
y
[[1, 2, 3], [4, 5, 6], [7, 8, 9]]

 deepcopy() 在拷贝外层对象的同时，也会将对象中所有引用的子对象一并进行拷贝

8. 列表推导式

列表推导式为 [  表达式 for 变量  in 可迭代对象 ]，首先因为是列表，所以是用中括号包裹起来，然后可以发现，里面的结构只是在 for 循环结构的基础上，在最左边加上了一个表达式。

oho = [1, 2, 3]
for i in range(len(oho)):
    oho[i] = oho[i] * 2

    
oho
[2, 4, 6]
oho = [1, 2, 3]
oho = [i * 2 for i in oho]
oho
[2, 4, 6]

虽然使用列表推导式可以和 for 循环达到一样的效果，但是二者本质上是不一样的。for 循环是通过迭代来对列表中的元素进行操作，而列表推导式则是创建一个新的列表，再将列表赋值给变量

在速度上，列表推导式的速度要比 for 循环的速度快上一倍，因为列表推导式是使用 C 语言执行，而 for 循环则是使用Python的虚拟机实现

列表推导式也可以添加条件筛选

words = ["Great", "FishC", "Brilliant", "Excellent", "Fantaistic"]
words = [i for i in words if i[0] == 'F']
words
['FishC', 'Fantaistic']

代码的执行顺序就是先迭代，再判断，最后执行最左边的表达式

同样，列表推导式也支持嵌套，嵌套的列表推导式对应嵌套的循环

matrix = [[1, 2, 3], [4, 5, 6], [7, 8 , 9]]
flatten = [col for row in matrix for col in row]
flatten
[1, 2, 3, 4, 5, 6, 7, 8, 9]

flatten = []

for row in matrix:
    for col in row:
        flatten.append(col)

        
flatten
[1, 2, 3, 4, 5, 6, 7, 8, 9]

对应外层的循环在列表推导式的左边，内层的循环在列表推导式的右边

二、元组

（一）、元组的创建与访问

元组与字符串、列表一样都是序列对象，而字符串作为常量不可修改，列表作为一种数据结构，可以存放不同的数据类型，元组则介于二者之间，它既能像列表一样，同时容纳多种类型的对象，也拥有字符串不可变的特性

在语法上，元组与列表的差别就是，元组在创建时，使用小括号或者不使用括号

rhyme = (1, 2, 3, "好哦")
rhyme
(1, 2, 3, '好哦')
rhyme = 1, 2, 3, "坏哦"
rhyme
(1, 2, 3, '坏哦')

元组只要用逗号将不同元素隔开就可以了

跟其他序列类型的对象一样，元组也可以使用下标索引的方式来获取元素

rhyme = 1, 2, 3, "坏哦"
rhyme
(1, 2, 3, '坏哦')
rhyme[0]
1
rhyme[-1]
'坏哦'

元组同样也支持切片操作，使用方式与列表相同

（二）、元组的操作方法

1. 查

由于元组拥有字符串一样不变的特性，所以对元组进行修改的操作都是不可行的

所以元组只支持 count() 和 index() 方法，即统计元素出现的次数以及查找相应元素的位置，与列表的效果是一样的

同样元组也支持拼接和重复，即加法与乘法运算符