列表及列表解析
發現要到2013了，這兩個月，離職入職，忙七忙八的，博文少了好多，筆記到是一大堆。
最近開始整理書籤，微博收藏以及筆記梳理
採用刪的方式，就是在evernote中新建一片，然後撈對應的筆記，一點點總結梳理，刪除原有的筆記，發現這樣效率高些（原來是在原有筆記之上直接修改總結，發現有用的資訊其實並不多，效率有點低）
相對而言比較全和有用，會持續優化。
2013，發完這個系列的部落格之後，將會整個部落格遷移到自己的部落格（剛開始寫…），後續將同步吧，不過csdn可能會慢一些，自己blog會更自由些。後續將會是python&框架,linux後臺開發，Go等等其他。
不扯了，看正題
以下是對列表筆記梳理的第一個版本，僅供參考
資料來源於書籍，網路，個人練習等等
|
1 2 3 4 5 |
#author:wklken #version: 1.0 #date: 2012-12-30 #history: 2012-12-30 created |
定義：
列表是Python中使用最頻繁的資料型別【可以說沒有之一】
關鍵詞：有序，可變
|
1 2 3 4 5 |
>一組有序專案的集合 >可變的資料型別【可進行增刪改查】 >列表中可以包含任何資料型別，也可包含另一個列表【可任意組合巢狀】 >列表是以方括號“ []”包圍的資料集合，不同成員以“ ,”分隔 >列表可通過序號訪問其中成員 |
檢視幫助 : help(list)
常見的列表操作
宣告&建立
|
1 2 3 4 5 6 |
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) 可以將一個序列轉為列表
通過下標訪問
|
1 2 |
>>>l = [1, 2, 3, 4] >>>l[0] #1 |
增加元素
A.新加入一個元素append
append方法新增。它在原列表末尾新增一個 item， item型別可以是任意的
|
1 2 3 |
l = [1, 2, 3] l.append('hello') #得到 [1, 2, 3, 'hello'] l.append(['hello']) #得到 [1, 2, 3, 'hello', ['hello']] |
B.插入一個元素insert
|
1 2 |
l1 = [1, 2, 3] l1.insert(1,9) #[1, 9, 2, 3] |
C.兩個列表相加
兩種方式
第一種
|
1 2 |
l1 = [1, 2, 3] l3 = l1 + [4, 5, 6] #這種方式,l1不變，二者返回新的列表，當列表很長時，會消耗大量記憶體 |
第二種(必須接收一個引數，且是另一個列表)
|
1 |
l1.extend([4, 5, 6]) #直接擴增l1 |
等價的做法
|
1 |
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的索引或切片刪除
|
1 2 3 |
l1 = [1, 2, 3, 4, 5, 6] del l1[0] #得到[2, 3, 4, 5, 6] del l1[0:2] #得到[4, 5, 6] |
B.按item的值進行刪除
|
1 2 |
l1 = [1,2,3,1,2] l1.remove(1) #得到[2,3,1,2] |
若是remove對應值查無，將跑ValueError
C.刪除某個位置並返回該位置值
pop若是不傳位置引數，預設刪除列表最後一個元素
|
1 2 3 |
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.某個元素
|
1 2 |
l1 = [1, 2, 3, 4] l1[0] = 0 #[0,2,3,4] |
B.某一段元素
|
1 2 3 4 |
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]
|
1 2 3 |
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
|
1 2 3 4 5 6 7 8 9 10 |
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()
|
1 2 |
l1 = [5,3,2,1,4,6] l1.sort() #得到[1,2,3,4,5,6] 預設升序 |
sort可接受引數
|
1 2 3 |
cmp，比較函式，接受兩個引數,小於時返回負，大於返回正，相等返回0 key，指定排序鍵 reverse，指定是否反序 |
列表的比較操作 , 隱式呼叫cmp 方法 , 比較規則是逐個掃描元素 , 進行比較, 如果可以比較 , 比較, 如果相等掃描下一個元素 , 如果不相等返回結果 , 如果兩個元素型別不可以比較 , 就比較兩個物件的 id()值 .. 如果一直相等 ,直到一個列表掃描結束 , 那麼返回較長的列表較大
|
1 2 3 4 5 6 7 |
>>> 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不變
|
1 |
sorted(l,key=str.lower,reverse=True) |
C.反序
|
1 |
l1.reverse() #l1反序 |
同樣
|
1 |
reversed(l1) #返回一個iterator |
l[::-1]可以達到一樣的效果，但是這個是返回一個新的列表
梳理：
sort sorted 區別
|
1 2 |
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
|
1 2 3 |
l1 = [1, 2, 3, 4] 1 in l1 #True 1 not in l1 #False |
B.查詢位置索引index
|
1 2 3 4 5 6 7 8 |
l1 = [1, 2, 3, 4] 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.統計一個元素的出現次數
|
1 2 |
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.直接
|
1 2 3 |
l1 = [1, 2, 3, 4, 5] for i in l1: print i |
B.需要索引位置
|
1 2 3 |
l1 = [1, 2, 3, 4, 5] for index,value in enumerate(l1): print index,value |
9.其他操作
|
1 2 3 4 |
len(l) #列表長度 l*3 重複 l1 = [1, 2] l1*3 #[1,2,1,2,1,2] |
清空列表
|
1 2 3 |
l1 = [] l1[:] = [] del l1[:] |
複製列表
|
1 |
l2 = l1[:] |
注意：在操作list時，如果是涉及原地修改的操作，例如append,insert等，返回值是None
要防止出現這種語法 l1 = l1.append(‘a’) ，如果這樣，你將得到None…….
列表解析
定義和說明
|
1 2 3 4 |
>Python 的強大特性之一是其對 list 的解析，它提供一種緊湊的方法，可以通過對 list 中的每個元素應用一個函式，從而將一個 list 對映為另一個 list。 >列表解析，又叫列表推導式( list comprehension) >列表解析比 for 更精簡，執行更快，特別是對於較大的資料集合 >列表解析可以替代絕大多數需要用到 map和 filter的場合 |
列表推導式提供了一個建立連結串列的簡單途徑，無需使用 map() ， filter() 以及 lambda 。以定義方式得到列表通常要比使用建構函式建立這些列表更清晰。每一個列表推導式包括在一個 for 語句之後的表示式，零或多個 for 或 if 語句。返回值是由 for 或 if 子句之後的表示式得到的元素組成的列表。如果想要得到一個元組，必須要加上括號。
基本列表解析
基本
|
1 2 3 |
>>> [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] |
多個值的
|
1 |
[ '%s = %s' for (k, v) in a_map.items()] |
兩次迴圈
|
1 2 3 4 |
>>> 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] |
可以呼叫函式
|
1 |
[ func(x) for x in l1] #等價於map |
注意，列表解析不會改變原有列表的值，會建立新的list
條件列表解析
|
1 |
[ x for x in range(100) if x%2 ==0 ] |
巢狀列表解析
|
1 |
mat = [ [1, 2, 3],[4, 5, 6], [7, 8, 9]] |
交換行列
|
1 |
[ [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合成一個
就是
|
1 |
['a','b',.....],['a','b'.....]['a','b'.....] |
變為
|
1 |
['a','b',.....,'a','b'.....'a','b'.....] |
處理
|
1 2 3 4 |
>>> 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 高效能容器資料型別
補充
2013-09-01 二維陣列初始化陷阱
對一維陣列，可以這麼做
|
1 |
lst =[0]*3 |
但是對二維陣列，不成立
|
1 2 3 4 5 6 |
>>> lst_2d =[[0]*3]*3 >>> lst_2d [[0,0,0],[0,0,0],[0,0,0]] >>> lst_2d[0][0]=5 >>> lst_2d [[5,0,0],[5,0,0],[5,0,0]] |
二維陣列，可以這麼做
|
1 2 3 4 5 6 |
>>> lst_2d = [[0] * 3 for i in xrange(3)] >>> lst_2d [[0, 0, 0], [0, 0, 0], [0, 0, 0]] >>> lst_2d[0][0] = 5 >>> lst_2d [[5, 0, 0], [0, 0, 0], [0, 0, 0]] |
The end!
wklken
Gighub: https://github.com/wklken
Blog: http://wklken.sinaapp.com/
2012-12-30
打賞支援我寫出更多好文章，謝謝！
打賞作者
打賞支援我寫出更多好文章，謝謝！
任選一種支付方式
