联想说 Python 基础 12 - 列表

列表

列表类型

列表也是复合数据类型之一，它的语法格式是这样的：

[元素1, 元素2, ......]

在格式和形式上似乎和元祖差不多，那要它何用？

这就要说一下列表的 特点 了：

1. 可变类型：列表是可变的，定义之后可以对数据本身进行增删改查
2. 有序：列表是有序的，有顺序和位置，从0开始。
3. 有多个成员数据：成员之间用逗号隔开
4. 可以是任意数据类型：列表中的元素可以是数字、字符串、列表等
5. 数据可以重复：列表中的元素可以重复

其他都差不多，唯一不同的是列表是可变类型，也就是说列表可以增删改查，而元祖只能查。所以一般情况下，列表的使用场景更多。

Python 中用 list 关键字表示 列表，如果使用 type() 查看数据类型是 list 的话，那就是列表了。

列表常用方法

索引、切片、遍历 都是概念性的东西，在列表中同样适用，跳过。

列表部分测试用列表：

lb = [1, 2, 3, 4, 5, 6]

查

通用的，并且在前面提到过的，这里就不重复详细说了，这里看点不一样的。

1. len()

2. in

3. index()

4. count()

5. sort()：排序

   sort 翻译成中文是排序的意思，所以这个函数的作用就是对列表排序

   由于上面提供的测试列表本来就是有序的，所以这里重新定义列表排序：

   lbst = [1, 3, 2, 4, 5, 6]
   print(lbst.sort())  # None
   print(lbst)  # [1, 2, 3, 4, 5, 6]
   

   从结果可以看出，lbst.sort() 返回的是 None，出现了它，则说明函数没有给你返回东西。

   再次打印原来的列表，被打乱的列表再次有序了。所以 sort() 是对原列表排序。

6. reverse()：倒置

   reverse() 用来将原来的列表倒置过来（并不排序），它改变的同样是原来的列表：

   lbst = [1, 3, 2, 4, 5, 6]
   print(lbst.reverse())  # None
   print(lbst)  # [6, 5, 4, 2, 3, 1]
   

增

列表与元祖不同，它是可以在创建好了之后再向里面添加元素的，主要有这么一些方法：

1. insert()：插入，向指定索引添加元素，不会覆盖原来的元素，会后移

   res = lb.insert(0, 30)
   print(res)  # None
   print(lb)  # [30, 1, 2, 3, 4, 5, 6, 10, 20, 21, 22]
   

   insert 需要两个参数，第一个参数表示插入元素的索引值，第二个参数表示要插入的元素。

   当插入元素后，原来的元素会后移一位。

2. append()：追加，向当前列表中追加元素（实参）

   res = lb.append(10)
   print(res)  # None
   print(lb)  # [1, 2, 3, 4, 5, 6, 10]
   

   参数是需要追加元素的值，会追加到元素的最后面。

   如果你想把两个列表合在一起，那就不能使用 append。如果是用 append 的话，新列表会作为原列表中的一个元素。

3. extend()：扩展，将其他列表扩充到当前列表（实参）

   res = lb.extend([20, 21, 22])
   print(res)  # None
   print(lb)  # [1, 2, 3, 4, 5, 6, 10, 20, 21, 22]
   

   extend 就可以实现两个列表的合并，但不能追加元素。

4. 序列运算：+ 或者 *

   除了 extend 函数可以实现合并外，还可以使用 + 将两个列表合并：

   new_lb = ['a', 'b', 'c', 'd']
   print(lb + new_lb)  # [30, 1, 2, 3, 4, 5, 6, 10, 20, 21, 22, 'a', 'b', 'c', 'd']
   

   * 也可以运算，不过它并不是用在多个列表，而是将列表复制一份再扩充到当前列表（可以自己尝试）。

改

由于列表是可变的，所以其中的元素也可以修改。

修改某个东西需要先找到它，才能改变，而找到列表中的某个元素，我们可以使用索引。

而修改值，只需要覆盖掉原来的值就行。

因此，列表的元素的修改可以通过 列表[索引] = 值 来实现。

试一试：

lb[0] = 66
print(lb)  # [66, 2, 3, 4, 5, 6]

删

1. remove() ：移除列表中的元素（值）

   res = lb.remove(1)
   print(res)  # None
   print(lb)  # [2, 3, 4, 5, 6]
   

   移除的是原来列表中的元素。

   需要注意的是，参数是列表中的元素，而不是索引的值（删除一个）。

2. pop()：弹出列表中索引对应的元素

   print(lb)  # [1, 2, 3, 4, 5, 6]
   res = lb.pop(1)
   print(res)  # 2
   print(lb)  # [1, 3, 4, 5, 6]
   

   pop 是弹出，参数表示的是元素的索引，将原列表中索引对应的元素弹出来，原来列表中就少了这个元素。

   既然叫弹出而不是删除，那么这个值是可以获取到的。跟前面不同的是，pop 是有返回值的，这个值就是弹出的值。

3. del：删除列表

   del lb
   print(lb)  # NameError: name 'lb' is not defined
   

   del 列表后，该列表就不存在了，再次使用该列表就会出现未定义错误。

使用 remove 移除元素的时候会存在问题。

因为 remove 移除的是原列表中的元素，所以下次循环的列表就和上次的循环不一样，导致出现错误。

解决方案：循环列表的元素不要改变，复制一个新的列表用于循环，就不会变化。

列表推导式

什么是列表推导式

列表推导式是 Python 语言特有的一种语法结构，可以看成是一种特殊的数据处理方式，用于转换和过滤数据。

一般刚接触的看到这样一段描述，大多数都会懵一会，列表推导式到底是啥？

我们还是贯彻我们的理念 - 联想 来讲。

列表我们知道，推导式数学中也学过。不过考虑到这么久没接触数学，可能会忘记，这里再稍微复习一下。

在数学中推导式通常是指通过已知的公式、定理或条件，推导出新的结论或新的公式的计算式。

比如 正弦函数 y=sinx，y'=cosx。

你也不需要知道这个公式干嘛的，只需要知道推导出这个公式后，我们再解题就会简单很多。

所以所谓的推导式非常大的一个作用就是让我们的操作变简单，而这里的推导式是列表的，所以列表推导式会简化列表的一些操作（表达式创建和过滤）。

列表推导式的使用

如果上面的说明还不能够让你了解列表推导式的好处，那接着看看使用列表推导式和不使用列表推导式的区别。

需求：将列表中的每个元素都加 1。

不使用列表推导式：

new_lb = []
for i in range(0, len(lb)):
    new_lb.append(lb[i] + 1)

print(new_lb)  # [2, 3, 4, 5, 6, 7]

使用列表推导式：

new_lb = [lb[i] + 1 for i in range(0, len(lb))]
print(new_lb)  # [2, 3, 4, 5, 6, 7]

这两个得到的结果一模一样，但是从代码量来看，使用列表推导式的则会少很多。

从代码层面就能很明显的看出使用列表推导式和不使用列表推导式的区别。

列表推导式的语法

[表达式 for 迭代处理的元素 in 可迭代对象]

说一下其中的注意内容：

• 可迭代对象

  迭代可以理解为更新换代，你要有得换，肯定得有多个，这不就是元祖、列表之流吗（字符串其实也是）。

• 迭代处理的元素

  它其实就是遍历得到的迭代对象中的具体的元素

• 表达式

  可以是 Python 中的任意表达式，比如加法运算；

  另外，在表达式中是可以使用到迭代处理的元素的。

• []

  最外面的中括号也不能少，中括号是用来定义列表的，所以这里是把表达式生成的每个值作为该列表的新的元素。

其实列表推导式还可以过滤，它的语法是这样的：

[表达式 for 迭代处理的元素 in 可迭代对象 if 判断]

这个就不多说了，这里给个例子，可以自行尝试：

new_lb = [lb[i] + 1 for i in range(0, len(lb)) if lb[i] > 3]
print(new_lb)  # [5, 6, 7]