python學習之「切片操做從入門到精通」

在python學習開發的過程當中，咱們老是不斷的要對List(列表),Tuple(元組)有取值操做：假如咱們有一個列表List1如今想取出1其中的前5個元素，改怎麼操做呢？

1 >>> List1 = ['zhangxueyou','liuyifei','liudehua','huyidao','haodada','wumengda','zhouxingchi','chenglong','Jack','linzhilin']
2 >>> List1
3 ['zhangxueyou', 'liuyifei', 'liudehua', 'huyidao', 'haodada', 'wumengda', 'zhouxingchi', 'chenglong', 'Jack', 'linzhilin']
4 >>> #比較笨的辦法是直接取值
5 ... 
6 >>> [List1[1],List1[2],List1[3],List1[4],List1[5]]
7 ['liuyifei', 'liudehua', 'huyidao', 'haodada', 'wumengda']
8 >>> 

以上的直接取值的方法是存在很大的侷限性的，假如如今想取前一百萬個值的話，是否是就沒有辦法了呢？可是你仍是能夠用循環完成：

 1 >>> List1
 2 ['zhangxueyou', 'liuyifei', 'liudehua', 'huyidao', 'haodada', 'wumengda', 'zhouxingchi', 'chenglong', 'Jack', 'linzhilin']
 3 >>> List2 = []
 4 >>> List2
 5 []
 6 >>> n = 5
 7 >>> for i in range(n):
 8 ...     List2.append(List1[i])
 9 ... 
10 >>> List2
11 ['zhangxueyou', 'liuyifei', 'liudehua', 'huyidao', 'haodada']
12 >>> 

可是，對這種常常取指定索引的範圍的操做，假如你使用循環的話使能夠解決的，可是相對更好的方法而言，此操做是至關繁瑣和費事的。所以python就提供了一個比較重量級的方法：切片(Slice)操做，能大大的簡化操做。

對於一樣的問題，只須要簡單的一個切片操做就能夠取得一樣的效果：

 1 >>> List1
 2 ['zhangxueyou', 'liuyifei', 'liudehua', 'huyidao', 'haodada', 'wumengda', 'zhouxingchi', 'chenglong', 'Jack', 'linzhilin']
 3 >>> #比較笨的辦法是直接取值
 4 ... 
 5 >>> [List1[1],List1[2],List1[3],List1[4],List1[5]]
 6 ['liuyifei', 'liudehua', 'huyidao', 'haodada', 'wumengda']
 7 >>> 
 8 >>> 
 9 >>> 
10 >>> 
11 #使用循環取值：比較繁瑣
12 >>> List1
13 ['zhangxueyou', 'liuyifei', 'liudehua', 'huyidao', 'haodada', 'wumengda', 'zhouxingchi', 'chenglong', 'Jack', 'linzhilin']
14 >>> List2 = []
15 >>> List2
16 []
17 >>> n = 5
18 >>> for i in range(n):
19 ...     List2.append(List1[i])
20 ... 
21 >>> List2
22 ['zhangxueyou', 'liuyifei', 'liudehua', 'huyidao', 'haodada']
23 >>> #切片操做的演示：
24 ... 
25 >>> List1[0:4]
26 ['zhangxueyou', 'liuyifei', 'liudehua', 'huyidao']
27 >>> List1[0:5]
28 ['zhangxueyou', 'liuyifei', 'liudehua', 'huyidao', 'haodada']
29 >>> 

注意：List1[0:5]表示的含義是，從索引0開始直到取到5個元素，所以，取到的元素索引爲：0,1,2,3,4可是不包含第六個數的索引5，這裏恰好取到了5個元素。故，記住切片的口訣就是：「顧頭不顧尾」。假如你的第一個索引是「0」，那麼你能夠省略不寫：

1 >>> List1
2 ['zhangxueyou', 'liuyifei', 'liudehua', 'huyidao', 'haodada', 'wumengda', 'zhouxingchi', 'chenglong', 'Jack', 'linzhilin']
3 >>> #索引爲0的狀況能夠省略
4 ... 
5 >>> List1[:5]
6 ['zhangxueyou', 'liuyifei', 'liudehua', 'huyidao', 'haodada']
7 >>> List1[0:5]
8 ['zhangxueyou', 'liuyifei', 'liudehua', 'huyidao', 'haodada']
9 >>> 

python是支持負索引的，即List1[-1],List1[-2],一樣，切片也是支持負索引的：

1 >>> List1
2 ['zhangxueyou', 'liuyifei', 'liudehua', 'huyidao', 'haodada', 'wumengda', 'zhouxingchi', 'chenglong', 'Jack', 'linzhilin']
3 >>> List1[-2:]
4 ['Jack', 'linzhilin']
5 >>> List1[-2:-1]
6 ['Jack']
7 >>> List1[:-1]
8 ['zhangxueyou', 'liuyifei', 'liudehua', 'huyidao', 'haodada', 'wumengda', 'zhouxingchi', 'chenglong', 'Jack']
9 >>> #記住：倒數第一個元素的索引採用負索引的話就是-1

切片在python開發過程當中是十分有用的，首先咱們建立一個0-199的數列：

1 >>> List3 = range(199)
2 >>> List3
3 [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198]
4 >>> 

而後，咱們就能夠在其中取出任意一段長度值：

1 >>> List3[:50]#取出前50個數
2 [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49]
3 >>> List3[:-100]#取出前50個數
4 [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98]

還能夠添加「步長「取值：

1 >>> List3
2 [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198]
3 >>> List3[:100:5]#步長爲5
4 [0, 5, 10, 15, 20, 25, 30, 35, 40, 45, 50, 55, 60, 65, 70, 75, 80, 85, 90, 95]
5 >>> 

甚至什麼都不寫，只寫[:]就能夠原樣複製一個list：

1 >>> List1[:]
2 ['zhangxueyou', 'liuyifei', 'liudehua', 'huyidao', 'haodada', 'wumengda', 'zhouxingchi', 'chenglong', 'Jack', 'linzhilin']
3 >>> List2[:]
4 ['zhangxueyou', 'liuyifei', 'liudehua', 'huyidao', 'haodada']
5 >>> List3[:]
6 [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198]
7 >>> 

tuple也是一種list，惟一區別是tuple不可變。所以，tuple也能夠用切片操做，只是操做的結果還是tuple:

1 >>> tuple1 = (1,2,3,4,5,6,7,8,9,10,11,12,13,14,15)
2 >>> tuple1[:10]
3 (1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
4 >>> tuple1[:-8]
5 (1, 2, 3, 4, 5, 6, 7)
6 >>> 

字符串'xxx'或Unicode字符串u'xxx'也能夠當作是一種list，每一個元素就是一個字符。所以，字符串也能夠用切片操做，只是操做結果還是字符串：

1 >>> "ABCDEFGHIJKLMNOPQRST"[:5]
2 'ABCDE'
3 >>> "ABCDEFGHIJKLMNOPQRST"[:-6]
4 'ABCDEFGHIJKLMN'
5 >>> 

在不少編程語言中，針對字符串提供了不少各類截取函數，其實目的就是對字符串切片。Python沒有針對字符串的截取函數，只須要切片一個操做就能夠完成，很是簡單。

注意：當你的索引超出你要索引的元組或者列表的範圍的時候是不會報任何錯誤的，只會按照列表或者元組的的、最大長度來顯示：

1 >>> List3
2 [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198]
3 >>> List3[:231] #這裏明顯已經超出了列表的範圍
4 [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198]

python切片中的高級操做：

1. 切片的原理分析：

list的切片，內部是調用__getitem__，__setitem__,__delitem__和slice函數。而slice函數又是和range()函數相關的。

給切片傳遞的鍵是一個特殊的slice對象。該對象擁有可描述所請求切片方位的屬性，切片的含義和演示：

1 >>> List4 = [1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20]
2 >>> List4
3 [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20]
4 >>> x = List4[1:10] #x = List4.__getitem__(slice(1,10,None))
5 >>> List4[1:5]=[100,111,122] #List4.setitem__(slice(1,3,None),[100,111,122])
6 >>> del List4[1:4] #List4.del__delitem__(slice(1,4,None))
7 >>> List4
8 [1, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20]
9 >>> 

帶步長的python切片：

1 >>> List4
2 [1, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20]
3 >>> List4[0:20:2] #其中2爲步長值
4 [1, 7, 9, 11, 13, 15, 17, 19]
5 >>> 

注意：步進值爲step

當step > 0 時

切片從 start(含start)處開始，到end（不含end）處結束，**從左往右**，每隔（step-1）（索引之間的差仍爲step，但相隔的元素是step-1個）個元素進行一次截取。

這時，start 指向的位置應該在end指向的位置的左邊，不然返回值爲空

當step < 0 時

切片從 start(含start)處開始，到end（不含end）處結束，**從右往左**，每隔（step-1）（索引之間的差仍爲step，但相隔的元素是step-1個）個元素進行一次截取。

這時，start 指向的位置應該在end指向的位置的右邊，不然返回值爲空

這裏有一個比較經典的字符串反向的例子：

1 >>> strin = "Hello World!"
2 >>> strin[::-1]
3 '!dlroW olleH'
4 >>> 

切片的邊界問題：

1 s=[1,2,3,4]       # S 上界爲 0 下界爲 4
2 s[-100:100]       #返回 [1,2,3,4] -100超出了上界，100超出了下界：等價於 s[0:4]
3 s[-100:-200]      #返回 [] -100,-200均超出了上界，自動取上界：等價於s[0:0]
4 s[100:200]        #返回 [] 100,200均超出了下界，自動取下界值：等價於s[4:4]
5 s[:100]           #返回 [1,2,3,4] 開始值省略表示從第0個開始
6 s[0:]             #返回 [1,2,3,4] 結束值爲空表示到最後一個結束

2. 切片的擴展知識：

 1 >>> id(List4)
 2 140115516658320
 3 #直接經過列表來賦值 List5 = List4，指向的內存地址空間是不變的，都是（140115516658320），不管刪除List4仍是List5這個列表都會被刪除，即List4和List5都沒有元素了。
 4 >>> List5 = List4
 5 >>> List5
 6 [1, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20]
 7 >>> List4
 8 [1, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20]
 9 >>> id(List5)
10 140115516658320
11 #可是，經過切片來命名的兩個列表他們指向的內存地址編號是不一樣的，140115516658320 ！=  140115516604784
12 >>> List6 = List5
13 >>> id(List6)
14 140115516658320
15 >>> List6 = List4[:]
16 >>> id(List6)
17 140115516604784
18 >>> #地址改變
19 ... 
20 >>>