LogoLogo
  • README
  • 前端编程
    • 01 Node JS
    • 02-ES6详解
    • 03-NPM详解
    • 04-Babel详解
    • 05-前端模块化开发
    • 06-WebPack详解
    • 07-Vue详解
    • 08-Git详解
    • 09-微信小程序
  • 人工智能
    • 机器学习
      • 二次分配问题
      • 非负矩阵
      • 概率潜在语义分析
      • 概率图模型
      • 集成学习
      • 降维
      • 距离度量
      • 决策树
      • 逻辑回归
      • 马尔可夫决策过程
      • 马尔可夫链蒙特卡洛法
      • 朴素贝叶斯法
      • 谱聚类
      • 奇异值分解
      • 潜在狄利克雷分配
      • 潜在语义分析
      • 强化学习
      • 社区算法
      • 时间序列模型
      • 特征工程
      • 条件随机场
      • 图论基础
      • 线性分类
      • 线性回归
      • 信息论中的熵
      • 隐马尔科夫模型
      • 支持向量机
      • 主成分分析
      • EM算法
      • Hermite 矩阵的特征值不等式
      • k-means聚类
      • k近邻法
      • PageRank算法
    • 深度学习
      • Pytorch篇
        • 01-线性模型
        • 02-梯度下降法
        • 03-反向传播
        • 04-pytorch入门
        • 05-用pytorch实现线性回归
        • 06-logistic回归
        • 07-处理多维特征的输入
        • 08-加载数据集
        • 09-多分类问题
        • 10-卷积神经网络
        • 11-循环神经网络
    • 图神经网络
      • 图神经网络笔记01
        • 01-图(Graphs)的结构
        • 02-网络的性质和随机图模型
        • 03-网络工具
        • 04-网络中的主题和结构角色
        • 05-网络中的社区结构
      • 图神经网络笔记02
        • 01-深度学习引言
        • 02-神经网络基础
        • 03-卷积神经网络
        • 04-图信号处理与图卷积神经网络
        • 05-GNN的变体与框架-
        • [06-Google PPRGo 两分钟分类千万节点的最快GNN](人工智能/图神经网络/图神经网络笔记02/06-Google%20PPRGo 两分钟分类千万节点的最快GNN.md)
        • 07-序列模型
        • 08-变分自编码器
        • 09-对抗生成网络
  • 日常记录
    • 健身日记
    • 面经记录
    • 自动生成Summary文件
  • 实战项目
    • 谷粒商城
      • 00-项目概述
      • 01-分布式基础-全栈开发篇
      • 02-分布式高级-微服务架构篇
      • 03-高可用集群-架构师提升篇
  • 数据库
    • MySQL笔记
      • 01-MySQL基础篇
      • 02-MySQL架构篇
      • 03-MySQL索引及调优篇
      • 04-MySQL事务篇
      • 05-MySQL日志与备份篇
    • Redis笔记
      • 01-Redis基础篇
      • 02-Redis高级篇
    • 02-Redis篇
  • 算法笔记
    • 01-算法基础篇
    • 02-算法刷题篇
  • 职能扩展
    • 产品运营篇
  • Go编程
    • 01-Go基础
      • 01-Go基础篇
  • Java编程
    • 01-Java基础
      • 01-Java基础篇
      • 02-多线程篇
      • 03-注射与反解篇
      • 04-JUC并发编程篇
      • 05-JUC并发编程与源码分析
      • 06-JVM原理篇
      • 07-Netty原理篇
      • 08-设计模式篇
    • 02 Java Web
      • 01-Mybatis篇
      • 01-Mybatis篇(新版)
      • 02-Spring篇
      • 02-Spring篇(新版)
      • 03-SpringMVC篇
      • 04-MybatisPlus篇
    • 03-Java微服务
      • 01-SpringBoot篇
      • 01-SpringBoot篇(新版)
      • 02-SpringSecurity篇
      • 03-Shiro篇
      • 04-Swagger篇
      • 05-Zookeeper篇
      • 06-Dubbo篇
      • 07-SpringCloud篇
      • 08-SpringAlibaba篇
      • 09-SpringCloud篇(新版)
    • 04-Java中间件
      • 数据库篇
        • 01-分库分表概述
        • 02-MyCat篇
        • 03-MyCat2篇
        • 04-Sharding-jdbc篇
        • 05-ElasticSearch篇
      • 消息中间件篇
        • 01-MQ概述
        • 02-RabbitMQ篇
        • 03-Kafka篇
        • 04-RocketMQ篇
        • 05-Pulsar篇
    • 05-扩展篇
      • Dubbo篇
      • SpringBoot篇
      • SpringCloud篇
    • 06-第三方技术
      • 01-CDN技术篇
      • 02-POI技术篇
      • 03-第三方支付技术篇
      • 04-第三方登录技术篇
      • 05-第三方短信接入篇
      • 06-视频点播技术篇
      • 07-视频直播技术篇
    • 07-云原生
      • 01-Docker篇
      • 02-Kubernetes篇
      • 03-Kubesphere篇
  • Linux运维
    • 01-Linux篇
    • 02-Nginx篇
  • Python编程
    • 01-Python基础
      • 01.配置环境
      • 02.流程控制
      • 03.数值
      • 04.操作符
      • 05.列表
      • 06.元祖
      • 07.集合
      • 08.字典
      • 09.复制
      • 10.字符串
      • 11.函数
      • 12.常见内置函数
      • 13.变量
      • 14.异常和语法错误
      • 15.时间和日期
      • 16.正则表达式
    • 02 Python Web
      • flask篇
        • 01.前言
        • 02.路由
        • 03.模板
        • 04.视图进阶
        • 05.flask-sqlalchemy
        • 06.表单WTForms
        • 07.session与cookie
        • 08.上下文
        • 09.钩子函数
        • 10.flask 信号
        • 11.RESTFUL
        • 13.flask-mail
        • 14.flask+celery
        • 15.部署
        • 16.flask-login
        • 17.flask-cache
        • 18.flask-babel
        • 19.flask-dashed
        • 20.flask-pjax
        • 21.flask上传文件到第三方
        • 22.flask-restless
        • 23.flask-redis
        • 24.flask-flash
        • 25.消息通知
        • 26.分页
    • 03-Python数据分析
      • Matplotlib
      • Numpy
      • Pandas
      • Seaborn
    • 04-Python爬虫
      • 1.准备工作
      • 2.请求模块的使用
      • 3.解析模块的使用
      • 4.数据存储
      • 5.识别验证码
      • 6.爬取APP
      • 7.爬虫框架
      • 8.分布式爬虫
由 GitBook 提供支持
在本页
  • 创建列表
  • 通过下标取得列表中的单个值
  • 负数下标
  • 如何使用切片
  • 格式
  • 参数
  • 实例
  • 用del语句从列表中删除值
  • 向列表添加元素
  • 删除列表中的元素
  • 查找列表中的值
  • 更新列表的值
  • 为列表进行排序
  • 复制列表
  • 列表之间的连接
  • 列表用于循环
  • 使用列表作为堆栈(先进后出)
  • 使用列表作为队列(先进先出)
  • 描述
  • 语法
  • 支持方法
  • 列表推导式

这有帮助吗?

在GitHub上编辑
  1. Python编程
  2. 01-Python基础

05.列表

接下来一起来学习下列表

什么是列表?

列表就是一个有序的数据集合,在里面可以随意的添加和删除其中的元素,元素可以为任意类型

创建列表

data1 = ['1',1] # 通过[]将数据放在一起

data2 = ['1',2,[1,2,3],4] # 列表中元素也可以为一个序列

empty = []

通过下标取得列表中的单个值

注意,列表中的元素的位置,是从0开始计数的

>>> a = [1,2,3,4]
>>> a
[1, 2, 3, 4]
>>> a[0]
1
>>> a[1]
2
>>> a[2]
3
>>> a[3]
4

注意,如果下标的大小超过了列表中的元素个数,会报错

>>> a[4]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
IndexError: list index out of range

负数下标

在python中,支持负数下标。

>>> a = [1,2,3,4]
>>> a
[1, 2, 3, 4]
>>> a[-1]
4
>>> a[-2]
3
>>> a[len(a)-1]
4
>>> a[len(a)-2]
3

负数下标中整数值-1指的是列表中的最后一个下标,-2指的是列表中倒数第二个下标,以此类推。另外a[-i] 等价于a[len(a)-1]

如何使用切片

如果想从列表提取多个值,该怎么办?使用下标的话,太麻烦了,这时可以使用切片,切片可以从列表中取得多个值,得到的结果是一个新的列表

格式

list[start,stop,step]

参数

  • start:表示切片开始的下标位置

  • stop:表示切片结束处的下标位置,不包括stop这个位置

  • step:步长

实例

>>> a = [1,2,3,4,5,6,7,8,9]
>>> a
[1, 2, 3, 4, 5, 6, 7, 8, 9]

>>> a[1:]
[2, 3, 4, 5, 6, 7, 8, 9]
>>> a[1:len(a)]
[2, 3, 4, 5, 6, 7, 8, 9]

>>> a[:5]
[1, 2, 3, 4, 5]
>>> a[0:5]
[1, 2, 3, 4, 5]

>>> a[0:5:2]
[1, 3, 5]

>>> a[::2]
[1, 3, 5, 7, 9]
>>> a[0:len(a):2]
[1, 3, 5, 7, 9]

用del语句从列表中删除值

del语句将删除列表中下标处的值,列表中被删除值后面的所有值,都将向前移动一个下标

>>> a = [1,2,3,4,5,6,7,8,9]

>>> a[1:5]
[2, 3, 4, 5]
>>> del a[1:5]
>>> a
[1, 6, 7, 8, 9]

>>> a[0]
1
>>> del a[0]
>>> a
[6, 7, 8, 9]

向列表添加元素

  • list.append(x)

    • 将项添加到列表的末尾。相当于。a[len(a):] = [x]

>>> a = [1,2,3,4,'angle']
>>> a
[1, 2, 3, 4, 'angle']
>>> a.append(2)
>>> a
[1, 2, 3, 4, 'angle', 2]
>>> a.append("name")
>>> a
[1, 2, 3, 4, 'angle', 2, 'name']
>>> a[len(a):] = ["123"]
>>> a
[1, 2, 3, 4, 'angle', 2, 'name', '123']
  • list.extend(iterable)

    • 通过附加iterable中的所有项来扩展列表。相当于 。a[len(a):] = iterable

>>> a = [1,2,3]
>>> a
[1, 2, 3]
>>> b = [4,5,6]
>>> a.extend(b)  # 将一个列表的元素追加到另一列表的末尾中
>>> a
[1, 2, 3, 4, 5, 6]
  • list.insert(i,x)

    • 在给定位置插入项目,第一个参数是要插入的元素的索引,第二个参数是即将要插入的元素

>>> a = [1,3,5,7]
>>> a
[1, 3, 5, 7]
>>> a.insert(1,2) # 插入到第一个位置,也就是原来的3位置,插入后,3以及3以后的元素,都往后退一位
>>> a
[1, 2, 3, 5, 7]
>>> a.insert(3,4)
>>> a
[1, 2, 3, 4, 5, 7]

删除列表中的元素

  • list.remove(x )

    • 从列表中删除值等于x的第一个项目。ValueError如果没有这样的项目,它会引发一个

>>> a = [1,2,3,4,5,6]
>>> a
[1, 2, 3, 4, 5, 6]
>>> a.remove(1)  # 删除指定值相同的元素
>>> a
[2, 3, 4, 5, 6]
>>> a.remove(5)
>>> a
[2, 3, 4, 6]
  • list.pop([ i ] )

    • 删除列表中给定位置的项目,然后将其返回。如果未指定索引,则a.pop()删除并返回列表中的最后一项。(方法签名中i周围的方括号表示该参数是可选的,而不是您应该在该位置键入方括号。您将在Python Library Reference中经常看到这种表示法)

>>> a
[1, 2, 3, 4, 5, 6]
>>> a.pop() # 默认删除最好一个元素,相当于a.pop(len(a)-1)
6
>>> a.pop(4) # 删除指定位置在第4个的元素
5
>>> a.pop(1)
2
>>> a
[1, 3, 4]
>>> a.pop(0)
1
>>> a
[3, 4]
  • list.clear()

    • 从列表中删除所有项目,相当于del a[:]

>>> a = [1,2,3,4,5,6]
>>> a
[1, 2, 3, 4, 5, 6]
>>> a.clear()  # 清除列表中的元素,但不会删除列表对象
>>> a
[]


>>> a = [1,2,3,4,5,6]
>>> del a  # 删除列表对象
>>> a
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'a' is not defined

查找列表中的值

  • list.index(x [,start [,end ] ] )

    • 在值等于x的第一个项的列表中返回从零开始的索引。ValueError如果没有这样的项目,则提高a 。

    • 可选参数start和end被解释为切片表示法,并用于将搜索限制为列表的特定子序列。返回的索引是相对于完整序列的开头而不是start参数计算的。

>>> a = [3,5,6,4,1,9]
>>> a
[3, 5, 6, 4, 1, 9]
>>> a.index(5)
1
>>> a.index(1)
4
>>> a.index(1,4)
4
>>> a.index(1,5)  # 为什么报错,因为索引是从第5个位置开始索引的
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: 1 is not in list
>>> a.index(1,2,5)
4
>>> a.index(3,2,5)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: 3 is not in list

更新列表的值

可以对列表的数据项进行修改或更新

>>> a = [1,2,3,4]
>>> a[0] = 'angle'
>>> a
['angle', 2, 3, 4]

为列表进行排序

  • list.sort(key = None,reverse = False )

    • 对列表中的项目进行排序(参数可用于排序自定义,请参阅sorted()其说明)

>>> a = [9,6,3,4,7,]
>>> a
[9, 6, 3, 4, 7]

>>> a.sort()
>>> a
[3, 4, 6, 7, 9]

# 利用key进行倒序排序
>>> a = [9,6,3,4,7,]
>>> a.sort(key=lambda x:-x)
>>> a
[9, 7, 6, 4, 3]

# 反向排序
>>> a = [9,6,3,4,7,]
>>> a.sort(reverse=True)
>>> a
[9, 7, 6, 4, 3]
  • list.reverse()

    • 反转列表中的元素

>>> a
[9, 7, 6, 4, 3]
>>> a = [9,6,3,4,7,]

>>> a.reverse() # 这是反转列表,注意没有进行排序
>>> a
[7, 4, 3, 6, 9]

复制列表

  • list.copy()

    • 返回列表的浅表副本。相当于a[:]

浅复制仅仅复制了容器中元素的地址

>>> a = [1,2,[3,4]]
>>> b = a.copy()    # 浅拷贝:深拷贝父对象(一级目录),子对象(二级目录)不拷贝,还是引用
>>> c = a           # 浅拷贝: 引用对象
>>> b
[1, 2, [3, 4]]
>>> a
[1, 2, [3, 4]]
>>> a[2]
[3, 4]

# 注意
>>> a[2].append(2)
>>> b
[1, 2, [3, 4, 2]]
>>> a.append(1)

# b[2]有新元素添加了,其余没变动
>>> b
[1, 2, [3, 4, 2]]
>>> a
[1, 2, [3, 4, 2], 1]
>>> c
[1, 2, [3, 4, 2], 1]

有时候一个一个输出相同的列表,很麻烦,这时候可以这样输出

>>> a = [1,2,3,4]
>>> a * 3 #这样就可以快速输出三个相同的列表,并且自动连接在一起
[1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4]

列表之间的连接

列表之间的连接通过‘+’连接在一起

>>> a = [1,2,3,4]
>>> b = [5,6,7]
>>> a+b
[1, 2, 3, 4, 5, 6, 7]

列表用于循环

>>> for i in range(4):
...     print(i)
...
0
1
2
3

range(4)的返回值是类似于列表的值,python认为类似于[0,1,2,3]

>>> for i in [0,1,2,3]:
...     print(i)
...
0
1
2
3

前面的for循环实际上是在循环执行它的子句,在每次迭代中,让变量依次设置列表中的值

常见的python技巧,是在for循环中使用range(len(someList)),迭代列表中的每一个下标

>>> word = ["a","b","c","d"]
>>> word
['a', 'b', 'c', 'd']
>>> for i in range(len(word)):
...     print(word[i])
...
a
b
c
d

使用列表作为堆栈(先进后出)

list方法可以很容易地将列表用作堆栈,其中添加的最后一个元素是检索到的第一个元素(“last-in,first-out”)。要将项添加到堆栈顶部,请使用append()。要从堆栈顶部检索项目,请在pop()没有显式索引的情况下使用

>>> stack = [1,2,3,]
>>> stack
[1, 2, 3]
>>> stack.append(4)
>>> stack
[1, 2, 3, 4]
>>> stack.pop()
4
>>> stack
[1, 2, 3]

使用列表作为队列(先进先出)

要实现队列,请使用collections.deque设计为具有快速追加和从两端弹出的队列

描述

返回一个从左到右(使用append())初始化的新deque对象,其中包含来自iterable的数据。如果未指定iterable,则新的deque为空。

Deques是堆栈和队列的概括(名称发音为“deck”,是“双端队列”的缩写)。Deques支持线程安全,内存有效的附加和从双端队列的弹出,在任一方向上具有大致相同的O(1)性能。

虽然list对象支持类似的操作,但它们针对快速固定长度操作进行了优化,并且导致O(n)内存移动成本 pop(0)和操作,这些操作改变了底层数据表示的大小和位置。insert(0, v)

如果未指定maxlenNone,则deques可能会增长到任意长度。否则,双端队列限制为指定的最大长度。一旦有界长度双端队列已满,当添加新项目时,从对方端丢弃相应数量的项目。有界长度deques提供类似于tailUnix中的过滤器的功能。它们还可用于跟踪仅涉及最近活动的事务和其他数据池。

语法

collections.deque([ iterable [,maxlen ] ] )

支持方法

  • append(x )

    • 将x添加到双端队列的右侧。

  • appendleft(x )

    • 将x添加到双端队列的左侧。

  • clear()

    • 从双端队列中删除所有元素,使其长度为0。

  • copy()

    • 创建deque的浅表副本。

  • count(x )

    • 计算deque元素的数量等于x。

  • extend(可迭代的)

    • 通过附加可迭代参数中的元素来扩展双端队列的右侧。

  • extendleft(可迭代的)

    • 通过附加来自iterable的元素来扩展双端队列的左侧。注意,左边的序列会导致反转迭代参数中元素的顺序。

  • index(x [,start [,stop ] ] )

    • 返回deque中的x位置(在索引开始时或 索引停止之前)。返回第一个匹配或ValueError如果未找到则引发 。

  • insert(i,x )

    • 将x插入位置i的双端队列中。

    • 如果插入会导致有界双端超过maxlen,IndexError则会引发a。

  • pop()

    • 从双端队列的右侧移除并返回一个元素。如果没有元素,则提出一个IndexError。

  • popleft()

    • 从双端队列的左侧移除并返回一个元素。如果没有元素,则提出一个IndexError。

  • remove(值)

    • 删除第一次出现的值。如果没有找到,提出一个 ValueError。

  • reverse()

    • 在原地反转deque的元素然后返回None。

  • rotate(n = 1 )

    • 向右旋转deque n步。如果n为负数,则向左旋转。

    • 当双端队列不为空时,向右d.appendleft(d.pop())旋转一步相当于,向左旋转一步相当于d.append(d.popleft())。

  • maxlen*(只读属性)*

    • 一个双端队列的最大大小或None无边界。

>>> from collections import deque
>>> d = deque('ghi')                 # make a new deque with three items
>>> for elem in d:                   # iterate over the deque's elements
...     print(elem.upper())
G
H
I

>>> d.append('j')                    # add a new entry to the right side
>>> d.appendleft('f')                # add a new entry to the left side
>>> d                                # show the representation of the deque
deque(['f', 'g', 'h', 'i', 'j'])

>>> d.pop()                          # return and remove the rightmost item
'j'
>>> d.popleft()                      # return and remove the leftmost item
'f'
>>> list(d)                          # list the contents of the deque
['g', 'h', 'i']
>>> d[0]                             # peek at leftmost item
'g'
>>> d[-1]                            # peek at rightmost item
'i'

>>> list(reversed(d))                # list the contents of a deque in reverse
['i', 'h', 'g']
>>> 'h' in d                         # search the deque
True
>>> d.extend('jkl')                  # add multiple elements at once
>>> d
deque(['g', 'h', 'i', 'j', 'k', 'l'])
>>> d.rotate(1)                      # right rotation
>>> d
deque(['l', 'g', 'h', 'i', 'j', 'k'])
>>> d.rotate(-1)                     # left rotation
>>> d
deque(['g', 'h', 'i', 'j', 'k', 'l'])

>>> deque(reversed(d))               # make a new deque in reverse order
deque(['l', 'k', 'j', 'i', 'h', 'g'])
>>> d.clear()                        # empty the deque
>>> d.pop()                          # cannot pop from an empty deque
Traceback (most recent call last):
    File "<pyshell#6>", line 1, in -toplevel-
        d.pop()
IndexError: pop from an empty deque

>>> d.extendleft('abc')              # extendleft() reverses the input order
>>> d
deque(['c', 'b', 'a'])

列表推导式

列表推导式(又称列表解析式)提供了一种简明扼要的方法来创建列表

举个栗子

a = []
for i in range(1,10):
    a.append(i)
print(a)

运行结果:

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

是不是看起来代码太多了,这时可以使用列表推倒式

b = [i for i in range(1,10)]
print(b)

运行结果:

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

这样写起来是不是方便很多了

上一页04.操作符下一页06.元祖

最后更新于3年前

这有帮助吗?