您现在的位置是：首页 > Python

当前栏目

Python 学习之列表

Python

2023-03-02 11:11:49 时间

### 文章目录 ###

*   *  函数 list
     *  基本的列表操作
     *   *  修改列表：给元素赋值
         *  删除元素
         *  给切片赋值
     *  列表方法
     *   *  append
         *  clear
         *  copy
         *  count
         *  extend
         *  index
         *  insert
         *  pop
         *  remove
         *  reverse
         *  sort
     *  参考资料

列表是可变的，即可修改其内容。

## 函数 list ##

如果你想使用字符串来创建列表，那就用函数`list`（ 它实际上是一个类，而不是函数，但眼下，这种差别并不重要。），例如：

In [1]: a = list("hello")
    
    In [2]: a
    Out[2]: ['h', 'e', 'l', 'l', 'o']

要将字符列表（如前述代码第 3 行的 a）转换为字符串，可使用下面的表达式：  
`''.join(a)`

In [3]: ''.join(a)
    Out[3]: 'hello'

## 基本的列表操作 ##

可对列表执行所有的标准序列操作，如索引、切片、拼接和相乘，但列表的有趣之处在于它是可以修改的。本节将介绍一些修改列表的方式：给元素赋值、删除元素、给切片赋值以及使用列表的方法。（请注意，并非所有列表方法都会修改列表。）

### 修改列表：给元素赋值 ###

修改列表很容易，只需使用普通赋值语句即可——使用索引表示法给特定位置的元素赋值，如`x[1] = 2`。

例如：

In [7]: x = [1,1,1]
    
    In [8]: x[1] = 2
    
    In [9]: x
    Out[9]: [1, 2, 1]

注意：不能给不存在的元素赋值，因此如果列表的长度为2，你就不能写 “x\[2\]=…”

### 删除元素 ###

从列表中删除元素也很容易，只需使用del语句即可。

In [11]: names = ['Alice', 'Beth', 'Cecil', 'Dee-Dee', 'Earl'] 
    
    In [12]: del names[2]
    
    In [13]: names
    Out[13]: ['Alice', 'Beth', 'Dee-Dee', 'Earl']

注意到 Cecil 彻底消失了，而列表的长度也从5变成了4。

### 给切片赋值 ###

切片是一项极其强大的功能，而能够给切片赋值让这项功能显得更加强大。

In [14]: name = list('Perl') 
    
    In [15]: name
    Out[15]: ['P', 'e', 'r', 'l']
    
    In [16]: name[2:]=list('ar')
    
    In [17]: name
    Out[17]: ['P', 'e', 'a', 'r']

从上述代码可知，可同时给多个元素赋值。比较神奇的是，通过使用切片赋值，可将切片替换为长度与其不同的序列。

我们再看一个例子.

In [18]: name = list('Perl')
    
    In [19]: name[1:]=list('ython')
    
    In [20]: name
    Out[20]: ['P', 'y', 't', 'h', 'o', 'n']

可以看到，把原本长度为3的切片换成了长度为5的切片。

使用切片赋值还可在不替换原有元素的情况下插入新元素。

In [21]: nums = [1,5]
    
    In [22]: nums[1:1] = [2,3,4]
    
    In [23]: nums
    Out[23]: [1, 2, 3, 4, 5]

在这里，我们“替换”了一个空切片，相当于插入了一个序列。如果你要在位置 x 处插入一个序列，那么就可以用 somelist\[x:x\] = \[…\]

你可采取相反的措施来删除切片。

In [23]: nums
    Out[23]: [1, 2, 3, 4, 5]
    
    In [24]: nums[1:4] = []
    
    In [25]: nums
    Out[25]: [1, 5]

上述代码与`del numbers[1:4]`等效。

In [26]: nums = [1,2,3,4,5]
    
    In [27]: del nums[1:4]
    
    In [28]: nums
    Out[28]: [1, 5]

可以理解为删除切片 nums\[1:4\]

我们执行步长不为1（乃至为负）的切片赋值。

In [29]: nums = [1,2,3,4,5,6,7,8,9,10]
    
    In [30]: nums[::2]=[0,0,0,0,0]
    
    In [31]: nums
    Out[31]: [0, 2, 0, 4, 0, 6, 0, 8, 0, 10]

In [31]: nums
    Out[31]: [0, 2, 0, 4, 0, 6, 0, 8, 0, 10]
    
    In [32]: nums[-1::-3]=[77,88,99]
    ---------------------------------------------------------------------------
    ValueError                                Traceback (most recent call last)
    <ipython-input-32-be8451000971> in <module>()
    ----> 1 nums[-1::-3]=[77,88,99]
    
    ValueError: attempt to assign sequence of size 3 to extended slice of size 4

为什么会出错呢？

因为 nums\[-1::-3\] 是一个长度为4的切片，而我们只提供了长度为3的序列 \[77,88,99\]，这样是不行的。我们修改一下：

In [33]: nums[-1::-3]=[77,88,99,66]
    
    In [34]: nums
    Out[34]: [66, 2, 0, 99, 0, 6, 88, 8, 0, 77]

## 列表方法 ##

方法是与对象联系紧密的函数。通常，像下面这样调用方法：  
`object.method(arguments)`

方法调用与函数调用很像，只是在方法名前加上了对象和点号。列表包含多个可用来查看或修改其内容的方法。

### append ###

方法 append 用于将一个对象附加到列表末尾。

In [35]: lst = [1,2,3]
    
    In [36]: lst.append(4)
    
    In [37]: lst
    Out[37]: [1, 2, 3, 4]

注意，如果你忘了方法名字也没有关系，当输入完`lst.`后，按tab键，就可以联想出来所有的方法.

In [38]: lst.
    lst.append   lst.copy     lst.extend   lst.insert   lst.remove   lst.sort     
    lst.clear    lst.count    lst.index    lst.pop      lst.reverse

你可能会问，为何给列表取lst这样糟糕的名字，而不称之为list呢？原因是 list 是一个内置函数（ 实际上，从Python 2.2起，list就是类型，而不是函数了），如果将前述列表命名为list，就无法调用这个函数。

另外请注意，与其他几个类似的方法一样，append 就地修改列表。这意味着它不会返回修改后的新列表，而是直接修改旧列表。

### clear ###

方法clear就地清空列表的内容。

In [40]: lst
    Out[40]: [1, 2, 3]
    
    In [41]: lst.clear()
    
    In [42]: lst
    Out[42]: []

这类似于切片赋值语句`lst[:] = []`。

### copy ###

方法 copy 复制列表。常规赋值只是将另一个名称关联到列表。

In [56]: a
    Out[56]: [1, 2, 3]
    
    In [57]: b = a
    
    In [58]: b[1]=4
    
    In [59]: a
    Out[59]: [1, 4, 3]
    
    In [60]: b
    Out[60]: [1, 4, 3]

可以看到，当执行`b = a`的时候，其实是把 b 关联到列表 a，也就是说 b 和 a 是同一个列表；

In [51]: a = [1,2,3]
    
    In [52]: b = a.copy()
    
    In [53]: b[1]=4
    
    In [54]: a
    Out[54]: [1, 2, 3]
    
    In [55]: b
    Out[55]: [1, 4, 3]

可以看到，b 是独立于 a 的一个列表，修改 b 并不会修改 a；

所以，要让a和b指向不同的列表，就必须将b关联到a的副本（`a.copy()`）。 这类似于使用`list(a)`或者`a[:]`，他们也都复制 a

In [61]: a = [1,2,3]
    
    In [62]: c = a[:]
    
    In [63]: b = list(a)
    
    In [64]: c[0] = 5
    
    In [65]: b[0] = 7
    
    In [66]: a
    Out[66]: [1, 2, 3]
    
    In [67]: b
    Out[67]: [7, 2, 3]
    
    In [68]: c
    Out[68]: [5, 2, 3]

### count ###

方法count计算指定的元素在列表中出现了多少次。

In [69]: lst = [1,2,3,3,4,5,3]
    
    In [70]: lst.count(3)
    Out[70]: 3
    
    In [71]: lst.count(8)
    Out[71]: 0

### extend ###

方法extend让你能够同时将多个值附加到列表末尾，为此可将这些值组成的序列作为参数提供给方法extend。换言之，你可使用一个列表来扩展另一个列表。

In [72]: a = [1,2,3]
    
    In [73]: b = [4,5,6]
    
    In [74]: a.extend(b)
    
    In [75]: a
    Out[75]: [1, 2, 3, 4, 5, 6]
    
    In [76]: b
    Out[76]: [4, 5, 6]

这看起来类似于拼接，但存在一个重要差别，那就是将修改被扩展的序列（这里是a）。在常规拼接中，情况是返回一个全新的序列，并不会修改原来的序列。

In [77]: a = [1,2,3]
    
    In [78]: b = [4,5,6]
    
    In [79]: a + b
    Out[79]: [1, 2, 3, 4, 5, 6]
    
    In [80]: a
    Out[80]: [1, 2, 3]
    
    In [81]: b
    Out[81]: [4, 5, 6]

如你所见，拼接出来的列表（第6行）与前一个示例扩展得到的列表（第8行）完全相同，但在这里a并没有被修  
改。鉴于常规拼接必须使用a和b的副本创建一个新列表，因此如果你要获得exten的效果，可以这样写：

In [82]: a = a + b
    
    In [83]: a
    Out[83]: [1, 2, 3, 4, 5, 6]

虽然效果一样，但是效率低于 extend。

另外，拼接操作并非就地执行的，即它不会修改原来的列表。要获得与extend相同的效果，也可将列表赋给切片，如下所示：

In [84]: a = [1,2,3]
    
    In [85]: b = [4,5,6]
    
    In [86]: a[len(a):] = b
    
    In [87]: a
    Out[87]: [1, 2, 3, 4, 5, 6]

这虽然可行，但可读性不好。

### index ###

方法index在列表中查找指定值第一次出现的索引。

In [89]: lst = [1,2,3,4,5,1,2]
    
    In [90]: lst.index(1)
    Out[90]: 0
    
    In [91]: lst.index(6)
    ---------------------------------------------------------------------------
    ValueError                                Traceback (most recent call last)
    <ipython-input-91-1fe7e2916666> in <module>()
    ----> 1 lst.index(6)
    
    ValueError: 6 is not in list

然而，搜索 6 时引发了异常，因为根本就没有找到这个数。

### insert ###

方法insert用于将一个对象插入列表。

In [92]: nums = [1,2,3,5,6]
    
    In [93]: nums.insert(3,'four')
    
    In [94]: nums
    Out[94]: [1, 2, 3, 'four', 5, 6]

参数中的3指定了要插入的索引位置。

也可使用给空切片赋值来获得与insert一样的效果。

In [98]: nums = [1,2,3,5,6]
    
    In [99]: nums[3:3] = ['four']
    
    In [100]: nums
    Out[100]: [1, 2, 3, 'four', 5, 6]

这虽巧妙，但可读性根本无法与使用insert媲美。

注意，第3行不能写成`nums[3:3] = 'four'`

否则就成了：

In [95]: nums = [1,2,3,5,6]
    
    In [96]: nums[3:3] = 'four'
    
    In [97]: nums
    Out[97]: [1, 2, 3, 'f', 'o', 'u', 'r', 5, 6]

### pop ###

方法pop从列表中删除一个元素，并返回这一元素。

如果不指定参数，那么就删除最后一个元素；如果在参数中指定索引，那么就删除索引对应的元素。

In [101]: x = [1,2,3,4,5,6]
    
    In [102]: x.pop()
    Out[102]: 6
    
    In [103]: x.pop()
    Out[103]: 5
    
    In [104]: x
    Out[104]: [1, 2, 3, 4]
    
    In [105]: x.pop(1)
    Out[105]: 2
    
    In [106]: x
    Out[106]: [1, 3, 4]

注意：pop是唯一既修改列表又返回一个非None值的列表方法。

使用pop可实现一种常见的数据结构——栈（stack）。

push和pop是两种最基本的栈操作。Python没有提供push，但可使用append来替代。

### remove ###

方法remove用于删除第一个为指定值的元素。

In [4]: x = [1,2,3,1,4,5]
    
    In [5]: x.remove(1)
    
    In [6]: x
    Out[6]: [2, 3, 1, 4, 5]

请注意，remove是就地修改且不返回值的方法之一。不同于pop的是，它修改列表，但不返回任何值。

### reverse ###

方法reverse按相反的顺序排列列表中的元素。

In [7]: x = [1,2,3,4,5]
    
    In [8]: x.reverse()
    
    In [9]: x
    Out[9]: [5, 4, 3, 2, 1]

注意到reverse修改列表，但不返回任何值。

### sort ###

方法sort用于对列表就地排序 。就地排序意味着对原来的列表进行修改，使其元素按顺序排列，而不是返回排序后的列表的副本。

In [10]: x = [2,3,9,1,4,5,5]
    
    In [11]: x.sort()
    
    In [12]: x
    Out[12]: [1, 2, 3, 4, 5, 5, 9]

前面介绍了多个修改列表而不返回任何值的方法，在大多数情况下，这种行为都相当自然（例如，对append来说就如此）。需要强调sort的行为也是这样的，但是这种行为给很多人都带来了困惑。在需要排序后的列表副本并保留原始列表不变时，通常会遭遇这种困惑。为实现这种目标，一种直观（但错误）的方式是像下面这样做：

In [19]: x = [3,5,2,1,8]
    
    In [20]: y = x.sort()
    
    In [21]: print(y)
    None

鉴于sort修改x且不返回任何值，最终的结果是x是经过排序的，而y包含None。为实现前述目标，正确的方式之一是先将y关联到x的副本，再对y进行排序，如下所示：

In [22]: x = [3,5,2,1,8]
    
    In [23]: y = x.copy()
    
    In [24]: y.sort()
    
    In [25]: y
    Out[25]: [1, 2, 3, 5, 8]
    
    In [26]: x
    Out[26]: [3, 5, 2, 1, 8]

为获取排序后的列表的副本，另一种方式是使用函数sorted。

In [27]: x = [3,5,2,1,8]
    
    In [28]: y = sorted(x)
    
    In [29]: y
    Out[29]: [1, 2, 3, 5, 8]
    
    In [30]: x
    Out[30]: [3, 5, 2, 1, 8]

实际上，sorted 这个函数可用于任何序列，但总是返回一个列表 。

In [31]: sorted('BACW')
    Out[31]: ['A', 'B', 'C', 'W']

## 参考资料 ##

《Python基础教程（第三版）》，人民邮电出版社

猜你喜欢

前端测试一共有哪几种？
OHOS标准系统的SAMGR代码解读（v3.1）--1--Safwk
Golang用Proto文件同时生成gRPC和HTTP
你需要知道的内核总线架构
浅谈前端开发规范，你学会了吗？
ArkUI Service Ability开发实战详解
如何在 Linux Mint 中创建和切换工作区
微软警告：夏令时可能引发 Windows 7-Windows 11 出现问题
如何用 Kubernetes 自定义资源？一文聊聊 CRD
OpenHarmony设备开发之基于TCP遥控小车
使用FeatureAbility模块启动其他Ability
面试官：讲讲SpringAOP的底层代理模式
V8 堆外内存 ArrayBuffer 垃圾回收的实现
V8 新生代垃圾回收的实现
在 Spring MVC 中处理域对象
用了 TS 映射类型，同事直呼内行！
TypeScript 你还只会用 Any？
JS基本搜索算法实现与170万条数据下的性能测试
这些CSS提效技巧，你需要知道！
深度解析 Go 泛型版排序比 sort 包更快吗？

zl程序教程

当前栏目

Python 学习之列表

相关文章