博客迁往:新地址(点击直达)
新博客使用markdown维护,线下有版本库,自己写的所以会定时更新同步,同时提供更好的导航和阅读体验
csdn对markdown支持不好,所以旧版不会花时间进行同步修订,抱歉
-----------------------------------------------发现要到2013了,这两个月,离职入职,忙七忙八的,博文少了好多,笔记到是一大堆。最近开始整理书签,微博收藏以及笔记梳理采用删的方式,就是在evernote中新建一片,然后捞对应的笔记,一点点总结梳理,删除原有的笔记,发现这样效率高些(原来是在原有笔记之上直接修改总结,发现有用的信息其实并不多,效率有点低)
相对而言比较全和有用,会持续优化。
2013,发完这个系列的博客之后,将会整个博客迁移到自己的博客(刚开始写...),后续将同步吧,不过csdn可能会慢一些,自己blog会更自由些。后续将会是python&框架,linux后台开发,Go等等其他。
不扯了,看正题以下是对列表笔记梳理的第一个版本,仅供参考
资料来源于书籍,网络,个人练习等等
#author:wklken
#version: 1.0
#date: 2012-12-30
#history:
2012-12-30 created
列表是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)
same as s[len(s):len(s)] = [x] 在列表尾部追加单个对象x。使用多个参数会引起异常。
s.extend(x)
same as s[len(s):len(s)] = x将列表L中的表项添加到列表中。返回None。
s.insert(i, x)
same as s[i:i] = [x] 在索引为i的元素前插入对象x。如list.insert(0,x)在第一项前插入对象。返回None。
A.按item的索引或切片删除
l1 = [1, 2, 3, 4, 5, 6]
del l1[0] #得到[2, 3, 4, 5, 6]
del l1[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])
same as x = s[i]; del s[i]; return x删除列表中索引为x的表项,并返回该表项的值。若未指定索引,pop返回列表最后一项。
s.remove(x)
same as del s[s.index(x)] 删除列表中匹配对象x的第一个元素。匹配元素时产生异常。返回None。
del s[i:j]
same as s[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
item i of s is replaced by x
s[i:j] = t
slice of s from i to j is replaced by the contents of the iterable t
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=lambda x: x[1])
>>> l1
[(4, 96), (3, 97), (2, 98), (1, 99)]
>>> l1.sort(key=lambda x: 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]可以达到一样的效果,但是这个是返回一个新的列表
梳理:
sort sorted 区别
sort: 在原 list 上排序,不返回排序后的 list
sorted: 不改变原 list ,返回排序后的 list
s.reverse()
reverses the items of s in place颠倒列表元素的顺序。
s.sort([cmp[, key[, reverse]]])
sort the items of s in place对列表排序,返回none。bisect模块可用于排序列表项的添加和删除。
A.包含判断in ,not in
l1 = [1, 2, 3, 4]
1 in l1 #True
1 not in l1 #False
B.查询位置索引index
l1 = [1, 2, 3, 4]
l1.index(1) #0
>>> l1.index(5) #特别注意,当值不存在于列表,用index将抛ValueError
Traceback (most recent call last):
File "", line 1, in
l1.index(5)
ValueError: 5 is not in list
C.统计一个元素的出现次数
l1 = [1, 2, 3, 4, 1]
l1.count(1) #2
梳理:
s.count(x)
return number of i's for which s[i] == x返回对象x在列表中出现的次数。
s.index(x[, i[, j]])
return smallest k such that s[k] == x and i <= k < j返回列表中匹配对象x的第一个列表项的索引。无匹配元素时产生异常。
A.直接
l1 = [1, 2, 3, 4, 5]
for i in l1:
print i
B.需要索引位置
l1 = [1, 2, 3, 4, 5]
for index,value in enumerate(l1):
print index,value
9.其他操作
len(l) #列表长度
l*3 重复
l1 = [1, 2]
l1*3 #[1,2,1,2,1,2]
清空列表
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 子句之后的表达式得到的元素组成的列表。如果想要得到一个元组,必须要加上括号。
基本
>>> [x for x in range(5)] # [0, 1, 2, 3, 4]
l1 = [1,2,3,4]
[ x*2 for x in l1] #[2,4,6,8]
多个值的
[ '%s = %s' for (k, v) in a_map.items()]
两次循环
>>> l1 = [1,2,3,4]
>>> l2 = [1,2,3,4]
>>> [x+y for x in l1 for y in l2]
[2, 3, 4, 5, 3, 4, 5, 6, 4, 5, 6, 7, 5, 6, 7, 8]
可以调用函数
[ func(x) for x in l1] #等价于map
注意,列表解析不会改变原有列表的值,会创建新的list
[ x for x in range(100) if x%2 ==0 ]
mat = [ [1, 2, 3],[4, 5, 6], [7, 8, 9]]
交换行列
[ [row[i] for row in mat] for i in (0,1,2)] #[[1, 4, 7], [2, 5, 8], [3, 6, 9]]
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
转载请注明出处,谢谢!