Python-列表总结（操作符、方法、内置函数、相关模块）

客官°小女子只卖身不卖艺 2022-12-04 09:19 171阅读 0赞

**目录**

上篇文章思考题

简介

创建与赋值

操作符

访问与更新（序列操作符切片）

判断元素是否存在（成员关系操作in,not in）

拼接列表（连接操作符+）

重复（重复操作符\*）

删除

方法

添加

删除

浅拷贝

统计

查找

逆序

排序

相关内置函数

列表长度

排序与反转

求和

list()

模拟数据结构

模拟栈

模拟队列

列表生成式

思考题

--------------------

# 上篇文章思考题 #

[Python-字符串总结（创建、操作符、方法、相关内置函数、相关模块）][Python-]

> 你不要过来啊  
> 不要过来啊  
> 要过来啊  
> 过来啊  
> 来啊  
> 啊

> <class 'bool'>
> 
> True

> 1.利用空格拆分每个单词，每个单词反转，再使用空格拼接成字符串
> 
> 2.利用空格拆分每个单词，反转单词列表，使用空格拼接为字符串，反转字符串
> 
> 3.反转字符串，将字符串用空格分割成单词列表，反转单词列表，单词列表用空格分隔转为字符串

# 简介 #

和字符串一样，列表也是序列式数据类型，并且可变，可以通过下标或切片操作来访问一个或多个连续元素。但是，列表更方便，而且，可以存储不同的数据类型的对象。

# 创建与赋值 #

使用\[\]创建，赋值操作符=进行赋值。

> >>> l = \[1,2.2,'lady\_killer',\[4,5\],True\]  
> >>> l  
> \[1, 2.2, 'lady\_killer', \[4, 5\], True\]

带着\[\]，是不是感觉很烦呀，你可以这样：

> >>> print(\*l)  
> 1 2.2 lady\_killer \[4, 5\] True

print(l)和print(\*l)为什么会不一样？这就要提到函数了，可以看：[Python-函数基础总结与内置函数][Python- 1]

<table style="width:500px;">  索引  
 <thead> 
  <tr> 
   <th><span style="color:#f33b45;"><strong>正索引</strong></span></th> 
   <th style="width:62px;">0</th> 
   <th style="width:80px;">1</th> 
   <th style="width:94px;">2</th> 
   <th style="width:88px;">3</th> 
   <th>4</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td><span style="color:#f33b45;"><strong>内容</strong></span></td> 
   <td style="width:62px;">1</td> 
   <td style="width:80px;">2.2</td> 
   <td style="width:94px;">'lady_killer'</td> 
   <td style="width:88px;">[4,5]</td> 
   <td>True</td> 
  </tr> 
  <tr> 
   <td><span style="color:#f33b45;"><strong>负索引</strong></span></td> 
   <td style="width:62px;">-5</td> 
   <td style="width:80px;">-4</td> 
   <td style="width:94px;">-3</td> 
   <td style="width:88px;">-2</td> 
   <td>-1</td> 
  </tr> 
 </tbody> 
</table>

# 操作符 #

## 访问与更新（序列操作符切片） ##

与[上一篇文章][Python-]重复的单个元素访问、获取连续元素、反转等不再赘述。

更新使用赋值操作符即可。

> >>> l\[0\]=10  
> >>> l  
> \[10, 2.2, 'lady\_killer', \[4, 5\], True\]

##  判断元素是否存在（成员关系操作in,not in） ##

> >>> 2.2 in l  
> True

> >>> 3.3 in l  
> False

## 拼接列表（连接操作符+） ##

只能是列表和列表拼接，不能和其他类型拼接。

> >>> l+s  
> \[10，2.2, 'lady\_killer', \[4, 5\], True, 6, 8\]

## 重复（重复操作符\*） ##

> >>> l = \['-'\]  
> >>> l\*10  
> \['-', '-', '-', '-', '-', '-', '-', '-', '-', '-'\]

# 删除 #

确定位置时，使用切片及关键字del

> >>> del l\[0\]  
> >>> l  
> \[\]
> 
> >>> l = \[1,2,3\]  
> >>> del l\[1:\]  
> >>> l  
> \[1\]

删除整个列表，del 列表名，一般不需要程序员去删除。

# 方法 #

## 添加 ##

append(x)，将 *x* 添加到序列的末尾 (等同于 `s[len(s):len(s)] = [x]`)。

> >>> l = \[1,2\]  
> >>> l.append(3)  
> >>> l  
> \[1, 2, 3\]

insert`(i, x),`在由 *i* 给出的索引位置将 *x* 插入 l (等同于**`l[i:i] = [x]`**)，i及后序元素后移。

> >>> l.insert(2,4)  
> >>> l  
> \[1, 2, 4, 3\]
> 
> >>> l\[3:3\] = \[5,6\]  
> >>> l  
> \[1, 2, 4, 5, 6, 3\]

`extend(t),`用序列 *t* 的内容扩展 *s。*

> >>> l = \[1,2,4,3\]  
> >>> s = (5,6,7)
> 
> >>> l.extend(s)  
> >>> l  
> \[1, 2, 4, 3, 5, 6, 7\]

## 删除 ##

`pop([i])，`提取在 *i* 位置上的项，并将其从列表中移除。默认为最后一个元素。

> >>> s = l.pop()  
> >>> s  
> 3

`remove(x)，`删除第一个等于 *x* 的元素，没有时ValueError。不确定是否存在时，先使用in进行检查。

> >>> l = \[1,3,5,3,6\]  
> >>> l.remove(3)  
> >>> l  
> \[1, 5, 3, 6\]
> 
> >>> l.remove(4)  
> Traceback (most recent call last):  
>   File "<stdin>", line 1, in <module>  
> ValueError: list.remove(x): x not in list

`clear()，`从 *s* 中移除所有项 (等同于 `del s[:]`)

>  >>> l.clear()  
> >>> l  
> \[\]

## 浅拷贝 ##

copy，创建 *s* 的浅拷贝 (等同于 `s[:]`)

> >>> s = l.copy()  
> >>> s  
> \[1, 3, 5, 3, 6\]  
> >>> l  
> \[1, 3, 5, 3, 6\]  
> >>> m = s  
> >>> m  
> \[1, 3, 5, 3, 6\]
> 
> >>> id(l);id(s);id(m)  
> 1806267157640  
> 1806267194824  
> 1806267194824

浅拷贝会新开辟内存，复制相同内容，赋值则是取个别名，故m、s指向同一个内存地址。

## 统计 ##

`count(x)，`*x* 在 *s* 中出现的总次数

> >>> l = \[1,2,'2',6,9.4,4,2\]  
> >>> l.count(2)  
> 2

## 查找 ##

`index(x[, i[, j]]),`*x* 首次出现项的索引号（范围\[i,j)），没有找到时ValueError。不确定是否存在时，先使用in进行检查。

> >>> l.index(2)  
> 1  
> >>> l.index(7)  
> Traceback (most recent call last):  
>   File "<stdin>", line 1, in <module>  
> ValueError: 7 is not in list

## 逆序 ##

reverse()，将列表中的元素逆序，就地反转，没有返回值。

> >>> l.reverse()  
> >>> l  
> \[2, 4, 9.4, 6, '2', 2, 1\]  
> >>> l\[::-1\]  
> \[1, 2, '2', 6, 9.4, 4, 2\]  
> >>> l  
> \[2, 4, 9.4, 6, '2', 2, 1\]

若需要列表本身反转，就用reverse()，如果要列表本身不变，得到反转后的，就用\[::-1\]。

## 排序 ##

sort(*\**, *key=None*, *reverse=False*)，此方法会对列表进行原地排序，只使用 `<` 来进行各项间比较。 异常不会被屏蔽 —— 如果有任何比较操作失败，整个排序操作将失败（而列表可能会处于被部分修改的状态)

*key* 指定带有一个参数的函数，用于从每个列表元素中提取比较键，(例如 `key=str.lower`)。默认值 `None` 表示直接对列表项排序而不计算一个单独的键值。

*reverse* 为一个布尔值。 如果设为 `True`，则每个列表元素将按反向顺序比较进行排序。

> >>> l = \[1,4,2,5,3\]  
> >>> l.sort()  
> >>> l  
> \[1, 2, 3, 4, 5\]  
> >>> l = \[1,5,3,'a',4\]  
> >>> l.sort()  
> Traceback (most recent call last):  
>   File "<stdin>", line 1, in <module>  
> TypeError: '<' not supported between instances of 'str' and 'int'  
> >>> l  
> \[1, 3, 5, 'a', 4\]  
> >>> l = \['ANDY','andy','lady','Lady','killer'\]  
> >>> l.sort(key=str.lower)  
> >>> l  
> \['ANDY', 'andy', 'killer', 'lady', 'Lady'\]  
> >>> l.sort(key=str.upper,reverse=True)  
> >>> l  
> \['lady', 'Lady', 'killer', 'ANDY', 'andy'\]

第二个例子,str和in不能比较，但是列表修改了部分

最后一个例子，\['ANDY', 'andy', 'killer', 'lady', 'Lady'\]降序排列保证了排序稳定性。

> >>> student = \[('frank',100),('yu',89),('lady',80),('killer',99)\] 
> 
> >>> student.sort(key=lambda stu:stu\[1\])  
> >>> student  
> \[('lady', 80), ('yu', 89), ('killer', 99), ('frank', 100)\]

对于这种有结构的数据，使用key也不错。

多字段排序

> >>> student = \[('frank',100),('yu',89),('lady',80),('killer',99),('yubo',89)\]  
> >>> student.sort(key = lambda s:(s\[1\],s\[0\]))  
> >>> student  
> \[('lady', 80), ('yu', 89), ('yubo', 89), ('killer', 99), ('frank', 100)\]

如果相同，就按另一个字段排序

# 相关内置函数 #

## 列表长度 ##

len()

> >>> l = \[1,2,'3',\[3,4\]\]  
> >>> len(l)  
> 4

不确定元素个数，又想使用索引访问时可先使用len判断。

## 排序与反转 ##

sorted(*iterable*, *\**, *key=None*, *reverse=False*)，与自带的方法sort不同，会返回一个新的已排序列表。不再展示，和sort用法一样。

reversed(seq)

返回一个反向的 [iterator][]。 *seq* 必须是一个具有 [`__reversed__()`][reversed] 方法的对象或者是支持该序列协议（具有从 `0` 开始的整数类型参数的 [`__len__()`][len] 方法和 [`__getitem__()`][getitem] 方法）。

> >>> r = \[s for s in reversed(l)\]  
> >>> r  
> \[\[3, 4\], '3', 2, 1\]

个人很少用，返回的是迭代器，不是反转后的列表。

## 求和 ##

`sum`(*iterable*, */*, *start=0*)

从 *start* 开始自左向右对 *iterable* 的项求和并返回总计值。 *iterable* 的项通常为数字，而 start 值则不允许为字符串

>  >>> l = \[1,2,3,4,5\]  
> >>> sum(l)  
> 15

## list() ##

接收可迭代对象，通过浅拷贝，返回列表。

> >>> list((3,6,'7',\[5,4\]))  
> \[3, 6, '7', \[5, 4\]\]

min()、max()、enumerate()、zip()很少用，再更新。

# 模拟数据结构 #

避免文章篇幅太长，不再黏贴代码，提供思路。

## 模拟栈 ##

列表低索引一端做栈底，另一端做栈顶。append函数进行栈顶元素添加，pop进行栈顶元素删除。len()判断栈是否为空。

## 模拟队列 ##

列表低索引一端做队头，另一端做队尾。append函数进行队尾元素添加，pop(0)进行队头元素删除。len()判断队列是否为空。

# **列表生成式**  #

这个为什么红色加粗呢？因为非常重要！！！

如果我们需要一个得到一个包含数字1-10的列表，我们可以怎么做呢？

首先想到的是for循环

L = []
    for i in range(1, 11):
        L.append(i)
    print(L)

这没有错，但是使用列表生成式更简洁。

L = [x for x in range(1, 11)]

对于上面这种，我们可以抽象为  \[x for x in S\]，只要S可迭代就好

> >>> \[x for x in (2,'4',True,\['lady','killer'\])\]  
> \[2, '4', True, \['lady', 'killer'\]\]

如果我们想要得到1-10的平方构成的列表呢？

> >>> \[x\*\*2 for x in range(1,11)\]  
> \[1, 4, 9, 16, 25, 36, 49, 64, 81, 100\]

我们再抽象为  \[F(x) for x in S\]， F(x)是关于x的表达式

如果我们想要得到1-10中偶数的平方构成的列表呢？

> >>> \[x\*\*2 for x in range(1,11) if x%2==0\]  
> \[4, 16, 36, 64, 100\]

我们再抽象为 **\[F(x) for x in S if P(x)\]**，P(x)是关于x的筛选条件（不包含x，直接写if True也是可以的，一般我们用到时是关于x的筛选）

再来，如果我们想要得到1-10中奇数与偶数分别做和的列表呢（5\*5=25个）？

> >>> \[x+y for x in range(1,11) for y in range(1,11) if x%2==0 and y%2!=0\]  
> \[3, 5, 7, 9, 11, 5, 7, 9, 11, 13, 7, 9, 11, 13, 15, 9, 11, 13, 15, 17, 11, 13, 15, 17, 19\]

这是不是一个全排列问题呀

> >>> \[x+y for x in 'abc' for y in 'ABC'\]  
> \['aA', 'aB', 'aC', 'bA', 'bB', 'bC', 'cA', 'cB', 'cC'\]

# 思考题 #

1.以下两种写法结果是否一样？

> 写法1
> 
> l.sort(reverse=True)
> 
> 写法2
> 
> l.sort()
> 
> l.reverse()

2.下面代码的结果是多少？

> >>> l = \[1,2,6,6,6\]  
> >>> sum(l,2)

3.使用列表生成式，得到字符串列表 l = \['lAdy','KILLER','laDy9','9','lady\_killer'\]中**仅包含字母的字符串**，并将大写字母转为小写字母存到列表中。即结果为\['lady','killer'\]， 'laDy9'、'9'不是仅包含字母的字符串,'lady\_killer'中包含下划线，也不是仅字母。提示：想一想字符串那篇文章的函数。

答案见：[Python-元组总结（操作符、方法、内置函数、相关模块）][Python- 2]

更多python相关内容：[【python总结】python学习框架梳理][python_python]

本人b站账号:[lady\_killer9][lady_killer9]

有问题请下方评论，转载请注明出处，并附有原文链接，谢谢！如有侵权，请及时联系。如果您感觉有所收获，自愿打赏，可选择支付宝18833895206（小于），您的支持是我不断更新的动力。

[Python-]: https://blog.csdn.net/lady_killer9/article/details/108407183
[Python- 1]: https://blog.csdn.net/lady_killer9/article/details/108939273
[iterator]: https://docs.python.org/zh-cn/3/glossary.html#term-iterator
[reversed]: https://docs.python.org/zh-cn/3/reference/datamodel.html#object.__reversed__
[len]: https://docs.python.org/zh-cn/3/reference/datamodel.html#object.__len__
[getitem]: https://docs.python.org/zh-cn/3/reference/datamodel.html#object.__getitem__
[Python- 2]: https://blog.csdn.net/lady_killer9/article/details/108741304
[python_python]: https://blog.csdn.net/lady_killer9/article/details/108763489
[lady_killer9]: https://space.bilibili.com/374432302