【Python】list 列表增删改查详解、实现栈和队列、注意事项

超、凢脫俗 2022-10-10 12:50 112阅读 0赞

### list列表详解介绍 ###

*  概述
 *  Python创建列表（2种方式）
 *   *  使用 \[ \] 直接创建列表
     *  使用 list() 函数创建列表
 *  访问列表元素
 *  删除列表
 *  list 列表添加元素（3种方法）
 *   *  append() 方法添加元素
     *  extend() 方法添加元素
     *  insert() 方法插入元素
 *  list 列表删除元素（4种方法）
 *   *  del 根据索引值删除元素
     *  pop() 根据索引值删除元素
     *  remove() 根据元素值进行删除
     *  clear() 删除列表所有元素
 *  list 列表修改元素
 *   *  修改单个元素
     *  修改一组元素
 *  list 列表查找元素
 *   *  index() 方法
     *  count()方法
 *  list 列表使用技巧及注意事项
 *   *  list 添加元素的方法及区别
     *  list 删除操作
 *  list列表 实现栈和队列
 *   *  list 实现队列
     *  list 实现栈
     *  collections模块 实现栈和队列

# 概述 #

在实际开发中，经常需要将一组（不只一个）数据存储起来，以便后边的代码使用。说到这里，可能听说过数组（Array），它就可以把多个数据挨个存储到一起，通过数组下标可以访问数组中的每个元素。

需要明确的是，Python 中没有数组，但是加入了更加强大的列表。

如果把数组看做是一个集装箱，那么 Python 的列表就是一个工厂的仓库。

> 大部分编程语言都支持数组，比如C语言、C++、Java、PHP、JavaScript 等。

从形式上看，列表会将所有元素都放在一对中括号\[ \]里面，相邻元素之间用逗号`,`分隔，如下所示：

[element1, element2, element3, ..., elementn]

格式中，`element1 ~ elementn` 表示列表中的元素，个数没有限制，只要是 Python 支持的数据类型就可以。

从内容上看，列表可以存储整数、小数、字符串、列表、元组等任何类型的数据，并且同一个列表中元素的类型也可以不同。比如说：

["www.qinjl.com", 1, [2,3,4], 3.0]

可以看到，列表中同时包含字符串、整数、列表、浮点数这些数据类型。

> 注意，在使用列表时，虽然可以将不同类型的数据放入到同一个列表中，但通常情况下不这么做，同一列表中只放入同一类型的数据，这样可以提高程序的可读性。

另外，经常用 `list 代指列表`，这是因为列表的数据类型就是 `list`，通过 `type() 函数`就可以知道，例如：

>>> type( ["www.qinjl.com", 1, [2,3,4] , 3.0] )
    <class 'list'>

可以看到，它的数据类型为 `list`，就表示它是一个`列表`。

# Python创建列表（2种方式） #

在 Python 中，创建列表的方法可分为两种，下面分别进行介绍。

## 使用 \[ \] 直接创建列表 ##

使用`[ ]`创建列表后，一般使用`=`将它赋值给某个变量，具体格式如下：

listname = [element1 , element2 , element3 , ... , elementn]

其中，`listname` 表示变量名，`element1 ~ elementn` 表示列表元素。

例如，下面定义的列表都是合法的：

num = [1, 2, 3, 4, 5, 6, 7]
    name = ["www.qinjl.com"]
    program = ["C语言", "Python", "Java"]

另外，使用此方式创建列表时，列表中元素可以有多个，也可以一个都没有，例如：

emptylist = [ ]

这表明，`emptylist` 是一个空列表。

## 使用 list() 函数创建列表 ##

除了使用`[ ]`创建列表外，Python 还提供了一个内置的函数 `list()`，使用它可以将其它数据类型转换为列表类型。例如：

#将字符串转换成列表
    list1 = list("hello")
    print(list1)
    输出：['h', 'e', 'l', 'l', 'o']
    
    #将元组转换成列表
    tuple1 = ('Python', 'Java', 'C++', 'JavaScript')
    list2 = list(tuple1)
    print(list2)
    输出：['Python', 'Java', 'C++', 'JavaScript']
    
    #将字典转换成列表
    dict1 = {
        'a':100, 'b':42, 'c':9}
    list3 = list(dict1)
    print(list3)
    输出：['a', 'b', 'c']
    
    #将区间转换成列表
    range1 = range(1, 6)
    list4 = list(range1)
    print(list4)
    输出：[1, 2, 3, 4, 5]
    
    #创建空列表
    print(list())
    输出：[]

# 访问列表元素 #

列表是 Python 序列的一种，我们可以使用索引（Index）访问列表中的某个元素（得到的是一个元素的值），也可以使用切片访问列表中的一组元素（得到的是一个新的子列表）。

使用索引访问列表元素的格式为：

listname[i]

其中，`listname` 表示列表名字，`i` 表示索引值。列表的索引可以是正数，也可以是负数。

使用切片访问列表元素的格式为：

listname[start : end : step]

其中，listname 表示列表名字，start 表示起始索引，end 表示结束索引，step 表示步长。

以上两种方式在 Python序列 中进行了讲解，这里就不再赘述了，仅作示例演示，请看下面代码：

url = list("www.qinjl.com")
    #使用索引访问列表中的某个元素
    print(url[3])  #使用正数索引
    print(url[-4])  #使用负数索引
    #使用切片访问列表中的一组元素
    print(url[9: 13])  #使用正数切片
    print(url[9: 13: 3])  #指定步长
    print(url[-6: -1])  #使用负数切片
    
    输出：
    .
    .
    ['.', 'c', 'o', 'm']
    ['.', 'm']
    ['j', 'l', '.', 'c', 'o']

# 删除列表 #

对于已经创建的列表，如果不再使用，可以使用`del`关键字将其删除。

实际开发中并不经常使用 `del` 来删除列表，因为 Python 自带的垃圾回收机制会自动销毁无用的列表，即使开发者不手动删除，Python 也会自动将其回收。

del 关键字的语法格式为：

del listname

其中，`listname` 表示要删除列表的名称。

Python 删除列表实例演示：

intlist = [1, 45, 8, 34]
    print(intlist)
    del intlist
    print(intlist)
    
    输出：
    [1, 45, 8, 34]
    Traceback (most recent call last):
        File "C:\Users\qinjl\Desktop\demo.py", line 4, in <module>
            print(intlist)
    NameError: name 'intlist' is not defined

# list 列表添加元素（3种方法） #

Python序列一节告诉我们，使用`+`运算符可以将多个序列连接起来；

列表是序列的一种，所以也可以使用`+`进行连接，这样就相当于在第一个列表的末尾添加了另一个列表。

请看下面的演示：

language = ["Python", "C++", "Java"]
    birthday = [1991, 1998, 1995]
    info = language + birthday
    print("language =", language)
    print("birthday =", birthday)
    print("info =", info)
    
    输出：
    language = ['Python', 'C++', 'Java']
    birthday = [1991, 1998, 1995]
    info = ['Python', 'C++', 'Java', 1991, 1998, 1995]

从运行结果可以发现，使用`+`会生成一个新的列表，原有的列表不会被改变。

`+`更多的是用来拼接列表，而且执行效率并不高，如果想在列表中插入元素，应该使用下面几个专门的方法。

## append() 方法添加元素 ##

`append()` 方法用于在列表的末尾追加元素，该方法的语法格式如下：

listname.append(obj)

其中，listname 表示要添加元素的列表；obj 表示到添加到列表末尾的数据，它可以是单个元素，也可以是列表、元组等。

l = ['Python', 'C++', 'Java']
    #追加元素
    l.append('PHP')
    print(l)
    输出：['Python', 'C++', 'Java', 'PHP']
    
    #追加元组，整个元组被当成一个元素
    t = ('JavaScript', 'C#', 'Go')
    l.append(t)
    print(l)
    输出：['Python', 'C++', 'Java', 'PHP', ('JavaScript', 'C#', 'Go')]
    
    #追加列表，整个列表也被当成一个元素
    l.append(['Ruby', 'SQL'])
    print(l)
    输出：['Python', 'C++', 'Java', 'PHP', ('JavaScript', 'C#', 'Go'), ['Ruby', 'SQL']]

可以看到，当给 `append()` 方法传递列表或者元组时，此方法会将它们视为一个整体，作为一个元素添加到列表中，从而形成包含列表和元组的新列表。

## extend() 方法添加元素 ##

`extend()` 和 `append()` 的不同之处在于：`extend()` 不会把列表或者元祖视为一个整体，而是把它们包含的元素逐个添加到列表中。

extend() 方法的语法格式如下：

listname.extend(obj)

其中，listname 指的是要添加元素的列表；obj 表示到添加到列表末尾的数据，它可以是单个元素，也可以是列表、元组等，但不能是单个的数字。

l = ['Python', 'C++', 'Java']
    #追加元素
    l.extend('C')
    print(l)
    输出：['Python', 'C++', 'Java', 'C']
    
    #追加元组，元祖被拆分成多个元素
    t = ('JavaScript', 'C#', 'Go')
    l.extend(t)
    print(l)
    输出：['Python', 'C++', 'Java', 'C', 'JavaScript', 'C#', 'Go']
    
    #追加列表，列表也被拆分成多个元素
    l.extend(['Ruby', 'SQL'])
    print(l)
    输出：['Python', 'C++', 'Java', 'C', 'JavaScript', 'C#', 'Go', 'Ruby', 'SQL']

## insert() 方法插入元素 ##

append() 和 extend() 方法只能在列表末尾插入元素，如果希望在列表中间某个位置插入元素，那么可以使用 `insert()` 方法。

insert() 的语法格式如下：

listname.insert(index , obj)

其中，index 表示指定位置的索引值。`insert()` 会将 `obj` 插入到 listname 列表`第 index 个`元素的位置。

当插入列表或者元祖时，`insert()` 也会将它们视为一个整体，作为一个元素插入到列表中，这一点和 `append()` 是一样的。

l = ['Python', 'C++', 'Java']
    #插入元素
    l.insert(1, 'C')
    print(l)
    输出：['Python', 'C', 'C++', 'Java']
    
    #插入元组，整个元祖被当成一个元素
    t = ('C#', 'Go')
    l.insert(2, t)
    print(l)
    输出：['Python', 'C', ('C#', 'Go'), 'C++', 'Java']
    
    #插入列表，整个列表被当成一个元素
    l.insert(3, ['Ruby', 'SQL'])
    print(l)
    输出：['Python', 'C', ('C#', 'Go'), ['Ruby', 'SQL'], 'C++', 'Java']
    
    #插入字符串，整个字符串被当成一个元素
    l.insert(0, "www.qinjl.com")
    print(l)
    输出：['www.qinjl.com', 'Python', 'C', ('C#', 'Go'), ['Ruby', 'SQL'], 'C++', 'Java']

提示，`insert()` 主要用来在列表的中间位置插入元素，如果你仅仅希望在列表的末尾追加元素，那更建议使用 `append() 和 extend()`。

# list 列表删除元素（4种方法） #

在列表中删除元素主要分为以下 3 种场景：

*  根据元素所在位置的`索引`进行删除，可以使用 `del` 关键字或者 `pop()` 方法；
 *  根据元素本身的值进行删除，可使用列表（list类型）提供的 `remove()` 方法；
 *  将列表中所有元素全部删除，可使用列表（list类型）提供的 `clear()` 方法。

## del 根据索引值删除元素 ##

`del` 是 Python 中的关键字，专门用来执行删除操作，它不仅可以删除整个列表，还可以删除列表中的某些元素。

del 可以删除列表中的单个元素，格式为：

del listname[index]

其中，`listname` 表示列表名称，`index` 表示元素的索引值。

del 也可以删除中间一段连续的元素，格式为：

del listname[start : end]

其中，`start` 表示起始索引，`end` 表示结束索引。`del` 会删除从索引 `start` 到 `end` 之间的元素，不包括 `end` 位置的元素（左闭右开）。

lang = ["Python", "C++", "Java", "PHP", "Ruby", "MATLAB"]
    #使用正数索引
    del lang[2]
    print(lang)
    输出：['Python', 'C++', 'PHP', 'Ruby', 'MATLAB']
    
    #使用负数索引
    del lang[-2]
    print(lang)
    输出：['Python', 'C++', 'PHP', 'MATLAB']
    
    del lang[1: 4]
    print(lang)
    输出：['Python', 'Ruby', 'MATLAB']
    
    lang.extend(["SQL", "C#", "Go"])
    del lang[-5: -2]
    print(lang)
    输出：['Python', 'C#', 'Go']

## pop() 根据索引值删除元素 ##

`pop()` 方法用来删除列表中指定索引处的元素，具体格式如下：

listname.pop(index)

其中，`listname` 表示列表名称，`index` 表示索引值。

注意：如果`不写 index 参数`，默认会删除列表中的最后一个元素，类似于数据结构中的`“出栈”`操作。

nums = [40, 36, 89, 2, 36, 100, 7]
    nums.pop(3)
    print(nums)
    输出：[40, 36, 89, 36, 100, 7]
    
    nums.pop()
    print(nums)
    输出：[40, 36, 89, 36, 100]

大部分编程语言都会提供和 `pop()` 相对应的方法，就是 `push()`，该方法用来将元素添加到列表的尾部，类似于数据结构中的“入栈”操作。

但是 Python 是个例外，Python 并没有提供 `push()` 方法，因为完全可以使用 `append()` 来代替 `push()` 的功能。

## remove() 根据元素值进行删除 ##

除了 del 关键字，Python 还提供了 remove() 方法，该方法会根据元素本身的值来进行删除操作。

需要注意的是，`remove()` 方法只会删除第一个和指定值相同的元素，而且必须保证该元素是存在的，否则会引发 `ValueError` 错误。

nums = [40, 36, 89, 2, 36, 100, 7]
    #第一次删除36
    nums.remove(36)
    print(nums)
    输出：[40, 89, 2, 36, 100, 7]
    
    #第二次删除36
    nums.remove(36)
    print(nums)
    输出：[40, 89, 2, 100, 7]
    
    #删除78
    nums.remove(78)
    print(nums)
    输出：
    Traceback (most recent call last):
        File "C:\Users\mozhiyan\Desktop\demo.py", line 9, in <module>
            nums.remove(78)
    ValueError: list.remove(x): x not in list

最后一次删除，因为 78 不存在导致报错，所以我们在使用 `remove()` 删除元素时最好提前判断一下。

## clear() 删除列表所有元素 ##

Python `clear()` 用来删除列表的所有元素，也即清空列表

url = list("www.qinjl.com")
    url.clear()
    print(url)
    输出：[]

# list 列表修改元素 #

## 修改单个元素 ##

修改单个元素非常简单，直接对元素赋值即可。

nums = [40, 36, 89, 2, 36, 100, 7]
    nums[2] = -26  #使用正数索引
    nums[-3] = -66.2  #使用负数索引
    print(nums)
    
    输出：
    [40, 36, -26, 2, -66.2, 100, 7]

使用索引得到列表元素后，通过`=`赋值就改变了元素的值。

## 修改一组元素 ##

Python 支持通过切片语法给一组元素赋值。

在进行这种操作时，如果不指定`步长`（step 参数），Python 就不要求新赋值的元素个数与原来的元素个数相同；

这意味，该操作既可以为列表添加元素，也可以为列表删除元素。

nums = [40, 36, 89, 2, 36, 100, 7]
    #修改第 1~4 个元素的值（不包括第4个元素）
    nums[1: 4] = [45.25, -77, -52.5]
    print(nums)
    输出：[40, 45.25, -77, -52.5, 36, 100, 7]

如果对==空切片（slice）==赋值，就相当于插入一组新的元素：

nums = [40, 36, 89, 2, 36, 100, 7]
    #在4个位置插入元素
    nums[4: 4] = [-77, -52.5, 999]
    print(nums)
    输出：[40, 36, 89, 2, -77, -52.5, 999, 36, 100, 7]

使用切片语法赋值时，Python 不支持单个值，例如下面的写法就是错误的：`nums[4: 4] = -77`

但是如果使用字符串赋值，Python 会自动把字符串转换成序列，其中的每个字符都是一个元素，请看下面的代码：

s = list("Hello")
    s[2:4] = "XYZ"
    print(s)
    输出：['H', 'e', 'X', 'Y', 'Z', 'o']

使用切片语法时也可以指定步长（step 参数），但这个时候就要求所赋值的新元素的个数与原有元素的个数相同，例如：

nums = [40, 36, 89, 2, 36, 100, 7]
    #步长为2，为第1、3、5个元素赋值
    nums[1: 6: 2] = [0.025, -99, 20.5]
    print(nums)
    输出：[40, 0.025, 89, -99, 36, 20.5, 7]

# list 列表查找元素 #

Python 列表（list）提供了 `index()` 和 `count()` 方法，它们都可以用来查找元素。

## index() 方法 ##

`index()` 方法用来查找某个元素在列表中出现的位置（也就是索引），如果该元素不存在，则会导致 `ValueError` 错误，所以在查找之前最好使用 `count()` 方法判断一下。

`index()` 的语法格式为：

listname.index(obj, start, end)

其中，listname 表示列表名称，obj 表示要查找的元素，start 表示起始位置，end 表示结束位置。

`start` 和 `end` 参数用来指定检索范围：

*  start 和 end 可以都不写，此时会检索整个列表；
 *  如果只写 start 不写 end，那么表示检索从 start 到末尾的元素；
 *  如果 start 和 end 都写，那么表示检索 start 和 end 之间的元素。

index() 方法使用举例：

nums = [40, 36, 89, 2, 36, 100, 7, -20.5, -999]
    #检索列表中的所有元素
    print( nums.index(2) )
    输出：3
    
    #检索3~7之间的元素
    print( nums.index(100, 3, 7) )
    输出：5
    
    #检索4之后的元素
    print( nums.index(7, 4) )
    输出：6
    
    #检索一个不存在的元素
    print( nums.index(55) )
    输出：
    Traceback (most recent call last):
        File "C:\Users\qinjl\Desktop\demo.py", line 9, in <module>
            print( nums.index(55) )
    ValueError: 55 is not in list

## count()方法 ##

`count()` 方法用来统计某个元素在列表中出现的次数，基本语法格式为：

listname.count(obj)

其中，listname 代表列表名，obj 表示要统计的元素。

> 如果 `count()` 返回 0，就表示列表中不存在该元素，所以 `count()` 也可以用来判断列表中的某个元素是否存在。

count() 用法示例：

nums = [40, 36, 89, 2, 36, 100, 7, -20.5, 36]
    #统计元素出现的次数
    print("36出现了%d次" % nums.count(36))
    #判断一个元素是否存在
    if nums.count(100):
        print("列表中存在100这个元素")
    else:
        print("列表中不存在100这个元素")
    输出：
    36出现了3次
    列表中存在100这个元素

# list 列表使用技巧及注意事项 #

前面介绍了很多关于 `list 列表`的操作函数，有很多操作函数的功能非常相似。

例如，增加元素功能的函数有 `append()` 和 `extend()`，删除元素功能的有 `clear()`、 `remove()`、`pop()` 和 `del` 关键字。

通过实例演示的方式来明确各个函数的用法，以及某些函数之间的区别和在使用时的一些注意事项。

## list 添加元素的方法及区别 ##

定义两个列表（分别是 list\_1 和 list\_2），并分别使用 `+`、`extend()`、`append()` 对这两个 list 进行操作，其操作的结果赋值给 res。实例代码如下：

tt = 'hello'
    #定义一个包含多个类型的 list
    list_1 = [1,4,tt,3.4,"yes",[1,2]]
    print(list_1, id(list_1))
    输出：[1, 4, 'hello', 3.4, 'yes', [1, 2]] 2251638471496
    
    #比较 list 中添加元素的几种方法的用法和区别
    list_2 = [6,7]
    res = list_1 + list_2
    print(res,id(res))
    print(list_1, id(list_1))
    输出：
    [1, 4, 'hello', 3.4, 'yes', [1, 2], 6, 7] 2251645237064
    [1, 4, 'hello', 3.4, 'yes', [1, 2]] 2665205552136
    
    res = list_1.extend(list_2)
    print(res,id(res))
    print(list_1,id(list_1))
    输出：
    None 1792287952
    [1, 4, 'hello', 3.4, 'yes', [1, 2], 6, 7] 2251638471496
    
    res = list_1.append(list_2)
    print(res,id(res))
    print(list_1,id(list_1))
    输出：
    None 1792287952
    [1, 4, 'hello', 3.4, 'yes', [1, 2], 6, 7, [6, 7]] 2251638471496

根据输出结果，可以分析出以下几个结论：

1.  使用“`+`”号连接的列表，是将 `list_2` 中的元素放在 `list_1` 的后面得到的 `res`。并且 `res` 的内存地址值与 `list_1` 并不一样，这表明 `res` 是一个重新生成的列表，原来的`list_1`并不会改变。
2.  使用 `extend()` 处理后得到的 `res` 是 `none`。表明 `extend` 没有返回值，并不能使用链式表达式。即 `extend` 千万不能放在等式的右侧，一定要引起注意。
3.  `extend()` 处理之后， `list_1` 的内容与使用“`+`”号生成的 `res` 是一样的。但 `list_1` 的地址在操作前后并没有变化，这表明 `extend` 的处理仅仅是改变了 `list_1`，而没有重新创建一个 `list`。从这个角度来看，`extend` 的效率要高于“`+`”号。
4.  从 `append()` 的结果可以看出，`append` 的作用是将 `list_2` 整体当成一个元素追加到 `list_1` 后面，这与 `extend` 和“`+`”号的功能完全不同，这一点也需要注意。

## list 删除操作 ##

接下来演示有关 del 的基本用法，实例代码如下：

tt = 'hello'
    #定义一个包含多个类型的 list
    list1 = [1,4,tt,3.4,"yes",[1,2]]
    print(list1)
    输出：[1, 4, 'hello', 3.4, 'yes', [1, 2]]
    
    del list1[2:5]
    print(list1)
    输出：[1, 4, [1, 2]]
    
    del list1[2]
    print(list1)
    输出：[1, 4]

这 3 行输出分别是 list1 的原始内容、删除一部分切片内容、删除指定索引内容。可以看到，`del` 关键字按照指定的位置删掉了指定的内容。

需要注意的是，在使用 `del` 关键字时，一定要搞清楚，删除的到底是变量还是数据。例如，下面代码演示和删除变量的方法：

tt = 'hello'
    # 定义一个包含多个类型的 list
    list1 = [1, 4, tt, 3.4, "yes", [1, 2]]
    l2 = list1
    print(id(l2), id(list1))
    输出：1765451922248 1765451922248
    
    del list1
    print(l2)
    输出：[1, 4, 'hello', 3.4, 'yes', [1, 2]]
    
    print(list1)
    输出：
    Traceback (most recent call last):
      File "C:\Users\qinjl\Desktop\demo.py", line 8, in <module>
        print(list1)
    NameError: name 'list1' is not defined

第一行输出的内容是 `l2` 和 `list1` 的地址，可以看到它们是相同的，说明 `l2` 和 `list1` 之间的赋值仅仅是传递内存地址。

接下来将 `list1` 删掉，并打印 `l2`，可以看到，`l2` 所指向的内存数据还是存在的，这表明 `del` 删除 `list1` 时仅仅是销毁了`变量 list1`，并没有删除指定的数据。

除了删除变量，其他的删除都是删除数据，比如将列表中数据全部清空，实现代码如下：

tt = 'hello'
    #定义一个包含多个类型的 list
    list1 = [1,4,tt,3.4,"yes",[1,2]]
    l2 = list1
    l3 = l2
    del l2[:]
    print(l2)
    print(l3)
    
    输出：
    []
    []

可以看到，`l3` 和 `l2` 执行同样的内存地址，当 `l2` 被清空之后，`l3` 的内容也被清空了。这表明内存中的数据真正改变了。

另外，在实际过程中，即便使用 `del` 关键字删除了`指定变量`，且该变量所占用的内存再没有其他变量使用，此内存空间也不会真正地被系统回收并进行二次使用，它只是会被标记为无效内存。

如果想让系统回收这些可用的内存，需要借助 gc 库中的 collect() 函数。例如：

#引入gc库
    import gc
    tt = 'hello'
    #定义一个包含多个类型的 list
    list1 = [1,4,tt,3.4,"yes",[1,2]]
    del list1
    #回收内存地址
    gc.collect()

前面在[Python缓存机制][Python]一节提过，系统为了提升性能，会将一部分变量驻留在内存中。

这个机制对于，多线程并发时程序产生大量占用内存的变量无法得到释放，或者某些不再需要使用的全局变量占用着大的内存，导致后续运行中出现内存不足的情况，此时就可以使用 `del 关键字`来销毁变量，让GC回收内存，使系统的性能得以提升。

# list列表 实现栈和队列 #

`队列`和`栈`是两种数据结构，其内部都是按照固定顺序来存放变量的，二者的区别在于对数据的存取顺序：

*  队列：先存入的数据最先取出，即“先进先出”。
 *  栈是：最后存入的数据最先取出，即“后进先出”。

考虑到 `list 类型`数据本身的存放就是有顺序的，而且内部元素又可以是各不相同的类型，非常适合用于队列和栈的实现。

## list 实现队列 ##

使用 `list 列表`模拟队列功能的实现方法是，定义一个 list 变量，存入数据时使用 `insert()` 方法，设置其第一个参数为 `0`，即表示每次都从最前面插入数据；

读取数据时，使用 `pop()` 方法，即将队列的最后一个元素弹出。

如此 `list 列表`中数据的存取顺序就符合“先进先出”的特点。实现代码如下：

# 定义一个空列表，当做队列
    queue = []
    # 向列表中插入元素
    queue.insert(0, 1)
    queue.insert(0, 2)
    queue.insert(0, "hello")
    print(queue)
    print("取一个元素：", queue.pop())
    print("取一个元素：", queue.pop())
    print("取一个元素：", queue.pop())
    
    输出：
    ['hello', 2, 1]
    取一个元素： 1
    取一个元素： 2
    取一个元素： hello

## list 实现栈 ##

使用 `list 列表`模拟栈功能的实现方法是，使用 `append()` 方法存入数据；使用 `pop()` 方法读取数据。

`append()` 方法向 `list` 中存入数据时，每次都在最后面添加数据，这和前面程序中的 `insert()` 方法正好相反。

举个例子：

# 定义一个空 list 当做栈
    stack = []
    stack.append(1)
    stack.append(2)
    stack.append("hello")
    print(stack)
    print("取一个元素：", stack.pop())
    print("取一个元素：", stack.pop())
    print("取一个元素：", stack.pop())
    
    输出：
    [1, 2, 'hello']
    取一个元素： hello
    取一个元素： 2
    取一个元素： 1

## collections模块 实现栈和队列 ##

前面使用 `list` 实现队列的例子中，插入数据的部分是通过 `insert()` 方法实现的，这种方法效率并不高，因为每次从列表的开头插入一个数据，列表中所有元素都得向后移动一个位置。

这里介绍一个相对更高效的方法，即使用标准库的 `collections` 模块中的 `deque` 结构体，它被设计成在两端存入和读取都很快的特殊 `list`，可以用来实现栈和队列的功能。

from collections import deque
    
    queueAndStack = deque()
    queueAndStack.append(1)
    queueAndStack.append(2)
    queueAndStack.append("hello")
    print(list(queueAndStack))
    输出：[1, 2, 'hello']
    
    # 实现队列功能，从队列中取一个元素，根据先进先出原则，这里应输出 1
    print(queueAndStack.popleft())
    输出：1
    
    # 实现栈功能，从栈里取一个元素，根据后进先出原则，这里应输出 hello
    print(queueAndStack.pop())
    输出：hello
    
    # 再次打印列表
    print(list(queueAndStack))
    输出：[2]

[Python]: https://blog.csdn.net/qq_32727095/article/details/118110896