python列表解析：是一个让人欣喜的术语，你可以在一行使用一个for循环将所有的值放在一个列表之中。python列表解析属于python的迭代中的一种，相比pythonfor循环速度会快很多。example:a=[x+2forxinrange(10)]printa输出的结果：[2,3,4,5,6,7,8,9,10,11]这个例子的执行过程：python会在解释器里对range(10)进行迭代，依次把列表里的内容取出来，赋值给最左边的x,然后执行x+2的操作，并且把执行好的结果保存在列表里。等range(10)迭代完以后就新生成了一个列表，结果就是[2,3,4,5,6,7,8,9,10,11]，从上面可以看出，这也是建立python列表的一个方法。

转载于:https://www.cnblogs.com/paranoia/p/6178525.html

定义：

列表是Python中使用最频繁的数据类型【可以说没有之一】

关键词：有序，可变

>一组有序项目的集合

>可变的数据类型【可进行增删改查】

>列表中可以包含任何数据类型，也可包含另一个列表【可任意组合嵌套】

>列表是以方括号“[]”包围的数据集合，不同成员以“,”分隔

>列表可通过序号访问其中成员

查看帮助:help(list)

常见的列表操作

声明&创建

l=[]#空列表

l=[1,2,3,4]

l=[1,'a',[2,3]]

l=list('hello')#得到['h','e','l','l','o']

l=list(range(4))#[0,1,2,3]

l='1,2,3,4,5'.split(',')#['1','2','3','4','5']

内建函数list(a_sequence)可以将一个序列转为列表

通过下标访问

>>>l=[1,2,3,4]

>>>l[0]#1

增加元素

A.新加入一个元素append

append方法添加。它在原列表末尾添加一个item，item类型可以是任意的

l=[1,2,3]

l.append('hello')#得到[1,2,3,'hello']

l.append(['hello'])#得到[1,2,3,'hello',['hello']]

B.插入一个元素insert

l1=[1,2,3]

l1.insert(1,9)#[1,9,2,3]

C.两个列表相加两种方式第一种

l1=[1,2,3]

l3=l1+[4,5,6]#这种方式,l1不变，二者返回新的列表，当列表很长时，会消耗大量内存

第二种(必须接收一个参数，且是另一个列表)

l1.extend([4,5,6])#直接扩增l1

等价的做法

l1+=[4,5,6]

梳理：

s.append(x)

sameass[len(s):len(s)]=[x]在列表尾部追加单个对象x。使用多个参数会引起异常。

s.extend(x)

sameass[len(s):len(s)]=x将列表L中的表项添加到列表中。返回None。

s.insert(i,x)

sameass[i:i]=[x]在索引为i的元素前插入对象x。如list.insert(0,x)在第一项前插入对象。返回None。

删除元素

A.按item的索引或切片删除

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

dell1[0]#得到[2,3,4,5,6]

dell1[0:2]#得到[4,5,6]

B.按item的值进行删除

l1=[1,2,3,1,2]

l1.remove(1)#得到[2,3,1,2]

若是remove对应值查无，将跑ValueError

C.删除某个位置并返回该位置值

pop若是不传位置参数，默认删除列表最后一个元素

l1=[1,2,3,4,5]

a=l1.pop(1)#a=2

b=l1.pop()#a=5

梳理:

s.pop([i])

sameasx=s[i];dels[i];returnx删除列表中索引为x的表项，并返回该表项的值。若未指定索引，pop返回列表最后一项。

s.remove(x)

sameasdels[s.index(x)]删除列表中匹配对象x的第一个元素。匹配元素时产生异常。返回None。

dels[i:j]

sameass[i:j]=[]

修改元素

对指定索引进行赋值操作

A.某个元素

l1=[1,2,3,4]

l1[0]=0#[0,2,3,4]

B.某一段元素

l1=[1,2,3,4]

l1[0:2]=[7,8,9]#[7,8,9,3,4]

l1[:]=[]#清空了

梳理：

s[i]=x

itemiofsisreplacedbyx

s[i:j]=t

sliceofsfromitojisreplacedbythecontentsoftheiterablet

5.切片和索引

A.索引l[i]

l1=[1,2,3,4,5]

l1[0]#1

l1[-1]#5，负数的索引从尾部开始计数,最后一个元素为-1

B.切片l[i:j:k] 

i,j,k可选，冒号必须的i不指定默认0，j不指定默认序列尾，k不指定默认1

l1=[1,2,3,4,5,6,7,8,9,10,11]

l1[0:2]#[1,2],取区间[i,j)，左闭右开

l1[:2]#同上，可省略第一位

l1[2:]#[3,4,5,6,7,8,9,10,11]

l1[2:-1]#[3,4,5,6,7,8,9,10]

l1[:]#同l1，相当于复制一份

l1[::2]#步长2，[1,3,5,7,9,11]

l1[0:7:2]#[1,3,5,7]

l1[7:0:-2]#[8,6,4,2]注意步长为负、理解起来相当于从7到1，倒序步长2

排序

A.原地排list.sort()

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

l1.sort()#得到[1,2,3,4,5,6]默认升序

sort可接受参数

cmp，比较函数，接受两个参数,小于时返回负，大于返回正，相等返回0

key，指定排序键

reverse，指定是否反序

列表的比较操作,隐式调用cmp方法,比较规则是逐个扫描元素,进行比较,如果可以比较,比较,如果相等扫描下一个元素,如果不相等返回结果,如果两个元素类型不可以比较,就比较两个对象的id()值..如果一直相等,直到一个列表扫描结束,那么返回较长的列表较大

>>>l1=[(1,99),(3,97),(2,98),(4,96)]

>>>l1.sort(key=lambdax:x[1])

>>>l1

[(4,96),(3,97),(2,98),(1,99)]

>>>l1.sort(key=lambdax:x[1],reverse=True)

>>>l1

[(1,99),(2,98),(3,97),(4,96)]

B.sorted函数

sorted(l1)#返回l1的有序序列，l1不变

sorted(l,key=str.lower,reverse=True)

C.反序

l1.reverse()#l1反序

同样

reversed(l1)#返回一个iterator

l[::-1]可以达到一样的效果，但是这个是返回一个新的列表

梳理：

sortsorted区别

sort:在原list上排序，不返回排序后的list

sorted:不改变原list，返回排序后的list

s.reverse()

reversestheitemsofsinplace颠倒列表元素的顺序。

s.sort([cmp[,key[,reverse]]])

sorttheitemsofsinplace对列表排序，返回none。bisect模块可用于排序列表项的添加和删除。

查找和统计

A.包含判断in,notin

l1=[1,2,3,4]

1inl1#True

1notinl1#False

B.查询位置索引index

l1=[1,2,3,4]

l1.index(1)#0

>>>l1.index(5)#特别注意，当值不存在于列表，用index将抛ValueError

Traceback(mostrecentcalllast):

File"",line1,in

l1.index(5)

ValueError:5isnotinlist

C.统计一个元素的出现次数

l1=[1,2,3,4,1]

l1.count(1)#2

梳理：

s.count(x)

returnnumberofi'sforwhichs[i]==x返回对象x在列表中出现的次数。

s.index(x[,i[,j]])

returnsmallestksuchthats[k]==xandi<=k

遍历列表

A.直接

l1=[1,2,3,4,5]

foriinl1:

printi

B.需要索引位置

l1=[1,2,3,4,5]

forindex,valueinenumerate(l1):

printindex,value

9.其他操作

len(l)#列表长度

l*3重复

l1=[1,2]

l1*3#[1,2,1,2,1,2]

清空列表

l1=[]

l1[:]=[]

dell1[:]

复制列表

l2=l1[:]

注意：在操作list时，如果是涉及原地修改的操作，例如append,insert等，返回值是None要防止出现这种语法l1=l1.append('a')，如果这样，你将得到None.......

列表解析

定义和说明

>Python的强大特性之一是其对list的解析，它提供一种紧凑的方法，可以通过对list中的每个元素应用一个函数，从而将一个list映射为另一个list。

>列表解析，又叫列表推导式(listcomprehension)

>列表解析比for更精简，运行更快，特别是对于较大的数据集合

>列表解析可以替代绝大多数需要用到map和filter的场合

列表推导式提供了一个创建链表的简单途径，无需使用map()，filter()以及lambda。以定义方式得到列表通常要比使用构造函数创建这些列表更清晰。每一个列表推导式包括在一个for语句之后的表达式，零或多个for或if语句。返回值是由for或if子句之后的表达式得到的元素组成的列表。如果想要得到一个元组，必须要加上括号。

基本列表解析

基本

>>>[xforxinrange(5)]#[0,1,2,3,4]

l1=[1,2,3,4]

[x*2forxinl1]#[2,4,6,8]

多个值的

['%s=%s'for(k,v)ina_map.items()]

两次循环

>>>l1=[1,2,3,4]

>>>l2=[1,2,3,4]

>>>[x+yforxinl1foryinl2]

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

可以调用函数

[func(x)forxinl1]#等价于map

注意，列表解析不会改变原有列表的值，会创建新的list

条件列表解析

[xforxinrange(100)ifx%2==0]

嵌套列表解析

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

交换行列

[[row[i]forrowinmat]foriin(0,1,2)]#[[1,4,7],[2,5,8],[3,6,9]]

其他：

1. 根据索引取元素时，需要进行边界检查IndexError切片取，不需要，超过边界不会异常

2.在迭代中修改列表注意，不安全，不建议这么干但是可以foriinl1[:]:l1.insert()......

3.多个list合成一个就是

['a','b',.....],['a','b'.....]['a','b'.....]

变为['a','b',.....,'a','b'.....'a','b'.....]

>>>sum([['a','b'],['a','b'],['a','b']],[])

['a','b','a','b','a','b']

>>>list(itertools.chain(['a','b'],['a','b'],['a','b']))

['a','b','a','b','a','b']

4.关于堆栈和队列

通过上面的操作，可以发现，很轻易可以拿列表当做堆栈或者队列使用

当然，他们有自己的模块，可以查相关库

5.序列相关模块

array一种受限制可变序列类型，要求所有元素必须是相同类型

copy提供浅拷贝和深拷贝的能力

operator包含函数调用形式的序列操作符，如operator.concat(m,n)相当于m+n

re正则表达式

types包含Python支持的所有类型

collections高性能容器数据类型

1. 介绍

列表解析是最常应用迭代协议的环境之一，与for循环一起使用。先看一个简单的例子：

#for循环L=[1,2,3,4,5]for i in range(len(L)):L[i]+=10           #result:L=[11,12,13,14,15]#等效于#列表解析L=[1,2,3,4,5]L=[x+10 for x in L]     #result:[11,12,13,14,15]

从技术上来讲，列表解析并非真的是必需的，因为我们总可以用一个for循环手动构建一个表达是结果的列表。但是，列表解析编写更加精简，运行速度更快（快一倍）。

2.在文件上使用列表解析

f=open('salary.txt')lines=f.readlines()print(lines)#result:['lastName hoursWorked hourlyWage\n', 'Bob 4 80\n', 'Ann 8 160\n']#利用列表解析去掉每行末尾的换行符(\n)#rstrip方法：移除右端空白，或采用line[:-1]分片也可以lines=[line.rstrip() for line in lines]print(lines)#result:['lastName hoursWorked hourlyWage', 'Bob 4 80', 'Ann 8 160']

3.扩展的列表解析语法

一个非常有用的扩展：表达式中的嵌套的for循环可以有一个相关的if子句，来过滤那些测试不为真的结果项。

#找出1~9的三次方中的偶数项#方法1：列表解析+if判断even=[x**3 for x in range(1,10) if x%2==0]print(even)  #result: [8, 64, 216, 512]#方法2：列表解析+filter+lambda函数even=list(filter((lambda x:x%2==0),[x**3 for x in range(1,10)]))print(even)  #result: [8, 64, 216, 512]#方法3：map+filter+lambda函数（列表解析比map函数运行要快一点，map函数对for循环要快2倍）even=list(filter(lambda x:x%2==0,map((lambda x:x**3),range(1,10))))print(even)  #result: [8, 64, 216, 512]

构建一个x+y连接的列表

#将一个字符串中的每一个x和另一个字符串中的每个y连接起来lst=[x+y for x in 'abc' for y in 'lmn']print(lst)    #result:['al', 'am', 'an', 'bl', 'bm', 'bn', 'cl', 'cm', 'cn']

4.列表解析和矩阵（又称多维数组）

创建多维矩阵（注意行列值的位置）：

#创建一个row行col列的零矩阵,其中row和col需要提前定义row=5col=6#方法1：列表解析arr1=[[0 for c in range(col)] for r in range(row)]#方法2：最不建议使用！！！因为当对其中某一个值赋值时，会导致该值所在列皆发生改变arr2=[[0]*col]*row#方法3：numpy中的zeros函数,dtype默认float64,若为整型，需自定义import numpy as nparr3=np.zeros((row,col),dtype=int)

常见操作：

M=[[1,2,3],[4,5,6],[7,8,9]]N=[[2,2,2],[3,3,3],[4,4,4]]#提取行M[1]    #return:[4,5,6]#提取列,其中row是自定义变量，没有特殊含义，不是固定的，且只能行遍历#方法1：第一轮循环：row=[1,2,3]；第二轮循环：row=[4,5,6]；第三轮循环：row=[7,8,9][row[1] for row in M]   #return:[2,5,8]#方法2：[M[row][1] for row in range(3)]    #return:[2,5,8]#提取对角线（假设矩阵有相同的数目的行和列）   [M[i][i] for i in range(len(M))]    #return:[1, 5, 9]#两个矩阵对应元素的乘积，注意第二个的col和row的位置[M[row][col]*N[row][col] for row in range(3) for col in range(3)]#return:[2, 4, 6, 12, 15, 18, 28, 32, 36][[M[row][col]*N[row][col] for col in range(3)] for row in range(3)]#return:[[2, 4, 6], [12, 15, 18], [28, 32, 36]]

5.集合解析和字典解析

#集合解析{x*x for x in range(10)}      #result:{0, 1, 4, 9, 16, 25, 36, 49, 64, 81}#等效于：set(x*x for x in range(10))   #result:{0, 1, 4, 9, 16, 25, 36, 49, 64, 81}#集合解析拓展{x*x for x in range(10) if x%2==0}   #result:{0, 4, 16, 36, 64}#注意：这里有个项（12）被合并了，因为12出现了两次{x*y for x in [1,2,3] for y in [4,5,6]} #result:{4, 5, 6, 8, 10, 12, 15, 18}#字典解析{x:x*x for x in range(10)}#result:{0: 0, 1: 1, 2: 4, 3: 9, 4: 16, 5: 25, 6: 36, 7: 49, 8: 64, 9: 81}#等效于：dict((x,x*x) for x in range(10))#result:{0: 0, 1: 1, 2: 4, 3: 9, 4: 16, 5: 25, 6: 36, 7: 49, 8: 64, 9: 81}#字典解析拓展{x:x*x for x in range(10) if x%2==0}  #result:{0: 0, 2: 4, 4: 16, 6: 36, 8: 64}#正常应该为{1:4,1:5,1:6,2:4,2:5,2:6,3:4,3:5,3:6},但由于一个key只能对应一个value,因此保留最晚更新的那个{x:y for x in [1,2,3] for y in [4,5,6]}  #result:{1: 6, 2: 6, 3: 6}

列表解析

　　根据已有列表，高效创建新列表的方式。

　　列表解析是Python迭代机制的一种应用，它常用于实现创建新的列表，因此用在[]中。

语法：

　　[expression for iter_val in iterable]

　　[expression for iter_val in iterable if cond_expr]