[Python入门及进阶笔记]Python-基础-列表及列表解析小结 - Python - 运维网 - Powered by Discuz! Archiver

论坛 › Python › [Python入门及进阶笔记]Python-基础-列表及列表解析小结

uf123 发表于 2017-5-4 09:53:00

[Python入门及进阶笔记]Python-基础-列表及列表解析小结

<style>

</style>

博客迁往：新地址（点击直达）
新博客使用markdown维护，线下有版本库，自己写的所以会定时更新同步，同时提供更好的导航和阅读体验
csdn对markdown支持不好，所以旧版不会花时间进行同步修订，抱歉

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

列表及列表解析
　　发现要到2013了，这两个月，离职入职，忙七忙八的，博文少了好多，笔记到是一大堆。最近开始整理书签，微博收藏以及笔记梳理采用删的方式，就是在evernote中新建一片，然后捞对应的笔记，一点点总结梳理，删除原有的笔记，发现这样效率高些（原来是在原有笔记之上直接修改总结，发现有用的信息其实并不多，效率有点低）
　　相对而言比较全和有用，会持续优化。
　　2013，发完这个系列的博客之后，将会整个博客迁移到自己的博客（刚开始写...），后续将同步吧，不过csdn可能会慢一些，自己blog会更自由些。后续将会是python&框架,linux后台开发，Go等等其他。
　　不扯了，看正题以下是对列表笔记梳理的第一个版本，仅供参考
　　资料来源于书籍，网络，个人练习等等

#author:wklken
#version: 1.0
#date: 2012-12-30
#history:
2012-12-30created

定义：
　　列表是Python中使用最频繁的数据类型【可以说没有之一】
　　关键词：有序，可变

>一组有序项目的集合
>可变的数据类型【可进行增删改查】
>列表中可以包含任何数据类型，也可包含另一个列表【可任意组合嵌套】
>列表是以方括号“ []”包围的数据集合，不同成员以“ ,”分隔
>列表可通过序号访问其中成员

　　查看帮助 : help(list)

常见的列表操作

声明&创建

l = [] #空列表
l =
l = ]
l = list('hello') #得到 ['h', 'e', 'l', 'l', 'o']
l = list(range(4)) #
l = '1,2,3,4,5'.split(',')#['1', '2', '3', '4', '5']

　　内建函数list(a_sequence) 可以将一个序列转为列表
　　通过下标访问

>>>l =
>>>l#1

增加元素
　　A.新加入一个元素append
　　append方法添加。它在原列表末尾添加一个 item， item类型可以是任意的

l =
l.append('hello') #得到
l.append(['hello']) #得到 ]

　　B.插入一个元素insert

l1 =
l1.insert(1,9) #

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

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

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

l1.extend()#直接扩增l1

　　等价的做法

l1 +=

　　梳理：
　　s.append(x)
　　same as s = 在列表尾部追加单个对象x。使用多个参数会引起异常。
　　s.extend(x)
　　same as s = x将列表L中的表项添加到列表中。返回None。
　　s.insert(i, x)
　　same as s = 在索引为i的元素前插入对象x。如list.insert(0,x)在第一项前插入对象。返回None。

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

l1 =
del l1 #得到
del l1#得到

　　B.按item的值进行删除

l1 =
l1.remove(1)#得到

　　若是remove对应值查无，将跑ValueError
　　C.删除某个位置并返回该位置值
　　pop若是不传位置参数，默认删除列表最后一个元素

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

　　梳理:
　　s.pop()
　　same as x = s; del s; return x删除列表中索引为x的表项，并返回该表项的值。若未指定索引，pop返回列表最后一项。
　　s.remove(x)
　　same as del s 删除列表中匹配对象x的第一个元素。匹配元素时产生异常。返回None。
　　del s
　　same as s = []

修改元素
　　对指定索引进行赋值操作
　　A.某个元素

l1 =
l1 = 0 #

　　B.某一段元素

l1=
l1 = #
l1[:] = [] #清空了

　　梳理：
　　s = x
　　item i of s is replaced by x
　　s = t
　　slice of s from i to j is replaced by the contents of the iterable t
　　5.切片和索引
　　A.索引l

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

　　B.切片l

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

l1 =
l1 #, 取区间[i,j) ，左闭右开
l1[:2] #同上，可省略第一位
l1 #
l1 #
l1[:] #同l1，相当于复制一份
l1[::2] #步长2，
l1#
l1# 注意步长为负、理解起来相当于从7到1，倒序步长2

排序
　　A.原地排list.sort()

l1 =
l1.sort() #得到默认升序

　　sort可接受参数

cmp，比较函数，接受两个参数,小于时返回负，大于返回正，相等返回0
key，指定排序键
reverse，指定是否反序

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

>>> l1 = [(1,99),(3,97),(2,98),(4,96)]
>>> l1.sort(key=lambda x: x)
>>> l1
[(4, 96), (3, 97), (2, 98), (1, 99)]
>>> l1.sort(key=lambda x: x, 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]可以达到一样的效果，但是这个是返回一个新的列表
　　梳理：
　　sort sorted 区别

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

　　s.reverse()
　　reverses the items of s in place颠倒列表元素的顺序。
　　s.sort(]])
　　sort the items of s in place对列表排序，返回none。bisect模块可用于排序列表项的添加和删除。

查找和统计
　　A.包含判断in ,not in

l1=
1 in l1#True
1 not in l1 #False

　　B.查询位置索引index

l1 =
l1.index(1) #0
>>> l1.index(5) #特别注意，当值不存在于列表，用index将抛ValueError
Traceback (most recent call last):
File "<pyshell#44>", line 1, in <module>
l1.index(5)
ValueError: 5 is not in list

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

l1 =
l1.count(1) #2

　　梳理：
　　s.count(x)
　　return number of i's for which s == x返回对象x在列表中出现的次数。
　　s.index(x[, i[, j]])
　　return smallest k such that s == x and i <= k < j返回列表中匹配对象x的第一个列表项的索引。无匹配元素时产生异常。

遍历列表
　　A.直接

l1 =
for i in l1:
print i

　　B.需要索引位置

l1 =
for index,value in enumerate(l1):
print index,value

　　9.其他操作

len(l) #列表长度
l*3 重复
l1 =
l1*3 #

　　清空列表

l1 = []
l1[:] = []
del l1[:]

　　复制列表

l2 = l1[:]

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

列表解析

定义和说明

>Python 的强大特性之一是其对 list 的解析，它提供一种紧凑的方法，可以通过对 list 中的每个元素应用一个函数，从而将一个 list 映射为另一个 list。
>列表解析，又叫列表推导式( list comprehension)
>列表解析比 for 更精简，运行更快，特别是对于较大的数据集合
>列表解析可以替代绝大多数需要用到 map和 filter的场合

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

基本列表解析
　　基本

>>> #
l1 =
[ x*2 for x in l1] #

　　多个值的

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

　　两次循环

>>> l1 =
>>> l2 =
>>>

　　可以调用函数

[ func(x) for x in l1]#等价于map

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

条件列表解析

[ x for x in range(100) if x%2 ==0 ]

嵌套列表解析

mat = [ ,, ]

　　交换行列

[ for row in mat] for i in (0,1,2)] #[, , ]

其他：
　　1.根据索引取元素时，需要进行边界检查 IndexError 切片取，不需要，超过边界不会异常
　　2.在迭代中修改列表注意，不安全，不建议这么干但是可以 for i in l1[:]: 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 高性能容器数据类型

　　The end!
　　wklken
　　Gighub: https://github.com/wklken
　　Blog: http://wklken.sinaapp.com/
　　2012-12-30
　　转载请注明出处，谢谢!

页: [1]

查看完整版本: [Python入门及进阶笔记]Python-基础-列表及列表解析小结