目錄

序列

序列是一類基本資料型別(字串/列表/元組)的統稱，這些資料型別都含有一些共同的特性。例如：資料型別物件可以包含有若干個元素，這些元素有序排列，並且可以通過下標索引來訪問到其中的一個或幾個元素。

序列型別包含了：

• String 字串
• Tuple 元組
• List 列表

序列的標準操作符

適用於所有序列型別

注意：使用連線操作符( + )來講兩個序列的內容合併，並不是一個最快、最有效的方法。

• 合併字串型別物件時，建議呼叫join()函式，會更加節省記憶體。
• 合併列表型別物件時，建議使用列表型別的內建的extend()函式，但是注意這個函式會將原來的列表物件改變，而且可變型別物件的extend()函式沒有返回值。

當然，用什麼方法最好還得看具體情況了。

切片操作符[]/[:]/[::]

序列允許通過下標的方式來獲得某一個元素，或者通過指定下標範圍來獲得一組序列的元素，這種訪問序列的方式被稱之為切片。

方式一：[] 獲取序列的某個元素

• 索引偏移量為正值：範圍為0 <= index <= len(seqName)-1
• 索引偏移量為負值：範圍為-len(seqName) <= index <= -1
  正負索引的區別在於：正索引以序列的開始為起點，負索引以序列的結束為起點。

NOTE：len() 是序列型別的內建函式，可以獲取序列的長度，即元素的個數。
注意：
1. 使用 [] 方式時，index的取值不能超出範圍，否則會報錯IndexError
2. 索引值是從0開始的

方式二：[:] 獲取序列的某一組元素

seqName[starting_index:ending_index-1] #獲取由starting_index開始至ending_index結束之間的元素

注意：
1. 使用 [:] 方式時，index的取值可以超出範圍而不會報錯。
2. 索引值是從0開始的

In [23]: alist = [1,2,3,4,5]

In [24]: alist[:100]         #ending_index超出了範圍，但仍然沒有報錯；start_index的預設值 == 0，ending_index的預設值為len(seqName)
Out[24]: [1, 2, 3, 4, 5]

方式三：[::] 步長索引
序列的最後一個切片操作是擴充套件的步長切片操作，即，第三個索引值。
步長：在獲取的切片子序列的基礎上，按照一定的步進來獲取元素。
EXAMPLE1：每隔一位獲取一個元素

In [48]: aStr = 'abcdefghijk'

In [49]: aStr[::2]
Out[49]: 'acegik'

EXAMPLE2：將序列內容反轉

In [50]: aStr[::-1]
Out[50]: 'kjihgfedcba'

一個例子

有一個字串，我們想通過一個迴圈的形式去顯示，並且每顯示一次我們就把位於最後的一個字元砍掉。

In [53]: aStr = 'abcdefghijk'

In [54]: range(-1,-len(aStr),-1)    
Out[54]: [-1, -2, -3, -4, -5, -6, -7, -8, -9, -10]

In [56]: for i in [None]+range(-1,-len(aStr),-1):
    ...:     print aStr[:i]
    ...:     
abcdefghijk
abcdefghij
abcdefghi
abcdefgh
abcdefg
abcdef
abcde
abcd
abc
ab
a

當然，如果我們把上例中的 String 變成 List 或 Tuple 之後，這個小技巧將會非常實用。
NOTE：
1. range() 是數字列表生成器，也支援步進操作 。
2. 為了第一次 Print 能夠將 String 完全列印，需要使用aStr[:None]
3. 倒序刪除元素aStr[:-index]
4. Python 中的 for 迴圈可以遍歷所有的可迭代型別物件

range() 用法: range() 函式常用於生成一個 List 資料型別物件， EG.

In [1]: range(1,10)
Out[1]: [1, 2, 3, 4, 5, 6, 7, 8, 9]

一些使用技巧：
range(1,10,2) 當引數是全正數時，按從小到大排列

range(-1,-10,-2) 當引數全是負數時，按從大到小排列

In [3]: range(-1,-10,-2)
Out[3]: [-1, -3, -5, -7, -9]

List[:-1] 從後往前刪除元素

In [5]: range(-1,-10,-2)[:-1]
Out[5]: [-1, -3, -5, -7]

In [7]: range(1,10,2)[:-1]
Out[7]: [1, 3, 5, 7]

字串的連線

字串可以使用 “+” 號來進行連線，但實際上還有一種更加快、更省記憶體的連線方式 —— join()
EXAMPLE:

In [10]: ''.join(['my name',' is jmilk'])
Out[10]: 'my name is jmilk'

序列的功能函式

注意：下列函式中的len()/reversed()/sum()只能接受序列型別引數，其他的功能函式除了可以接收序列型別引數外，還能夠接收所有的可迭代物件。我們在學習一個函式時，先使用 help() 來檢視函式的幫助文件，幫助文件中會明確的指出該函式能夠接收的引數型別。

可迭代物件包含下面4種：
1. 序列型別 List、String 、Tuple。
2. 非序列型別dict、file。
3. 自定義的任何包含__iter__()或__getitem__()方法的類迭代器。
4. Iterable(迭代器)，函式形參中包含iterable，表示可以傳遞迭代器型別實參。

迭代：迭代是重複反饋過程的活動，每一次對過程的重複稱為一次”迭代”，而每一次迭代得到的結果會作為下一次迭代的初始值。Python 中迭代的概念是由序列、迭代器、其他支援迭代操作的物件中泛化而來的。

enumerate() 枚舉出序列物件的元素

enumerate(sequence[,start = 0]) 接收一個可迭代物件作為引數，返回一個enumerate物件(是一個迭代器，由索引號和元素合併為一個元素而組成的元組)。[,start = 0]引數可以指定索引的起始位置。

In [22]: aStr = 'jmilkfan'

In [23]: enumerate(aStr)
Out[23]: <enumerate at 0x35d1550>     #返回一個enumerate物件，是一個迭代器

In [25]: for i,j in enumerate(aStr):
    ...:     print "%s : %s" % (i,j)
    ...:     
0 : j
1 : m
2 : i
3 : l
4 : k
5 : f
6 : a
7 : n

len() 獲取序列物件的長度

只接受序列型別引數
序列物件的長度，即序列物件元素的個數

In [39]: name = 'Jmilk'

In [40]: len(name)
Out[40]: 5

min() 取出sequence中的最小值

In [28]: aStr
Out[28]: 'jmilkfan'

In [29]: min(aStr)
Out[29]: 'a'

若元素是String型別的化會轉換為ASCII碼計算後再比較。

max() 取出sequence中的最大值

類似min()函式

In [30]: max(aStr)
Out[30]: 'n'

reversed() 返回一個逆序訪問的迭代器

只接受序列型別物件引數
reversed(sequence) -> reverse iterator over values of the sequence

In [31]: aStr
Out[31]: 'jmilkfan'

In [32]: reversed(aStr)
Out[32]: <reversed at 0x36d4ed0>

In [34]: for i in reversed(aStr):
    ...:     print i,
    ...:        
n a f k l i m j

sorted() 序列的排序

接收一個可迭代物件，返回一個有序的列表。
sorted(iterable, cmp=None, key=None, reverse=False) –> new sorted list

• iterable：接收一個可迭代物件
• cmp(x,y)：指定一個定製的，能夠比較兩個接收引數 x, y 的函式，預設為None。
• key(x)：指定一個接收一個引數的函式，用作在每個元素中提取一個關鍵值作為比較值，預設為 None 表示比較每個元素。
• reverse：False 為預設值表示正序排列，True 為逆序排列。

注意1：沒有__getitem__()的物件，如：Int型別是不能呼叫 key 和 cmp 函式的。
注意2：在Python中有許多內建的函式能夠接受指定一個定製的函式，如：map()、filter()、reduce()、包括sorted等，這種時候使用 lambda 匿名函式將會非常的方便。

排序效率：key /reverse > cmp 。因為 cmp 函式會進行多次的兩兩比較，而 key/reverse 對每個輸入記錄只會被呼叫一次。

Key函式：以第二個關鍵字為比較值排序

In [205]: li = [('a',3),('b',2),('c',1)]

In [208]: sorted(li,key = lambda keyword:keyword[1]) #選擇li[][1] ==> (3,2,1)作為比較的關鍵詞
Out[208]: [('c', 1), ('b', 2), ('a', 3)]

cmp函式：以第二個關鍵字為比較值排序

In [213]: sorted(li,cmp = lambda x,y:cmp(x[1],y[1]))   #會進入多次的兩兩(1,2)/(1,3)/(2,3)比較
Out[213]: [('c', 1), ('b', 2), ('a', 3)]

reverse：逆序排列

In [216]: sorted(li,lambda z,x:cmp(z[1],x[1]),reverse=True)
Out[216]: [('a', 3), ('b', 2), ('c', 1)]

sum() 計算序列中的各項元素和

sum() 只接受序列型別物件，但是不支援元素為String或Char型別的序列。
sum(sequence[, start]) -> value
[, start]：可以指定累加的starting index。

In [59]: num = [1,2,3,4]

In [60]: str = 'My name is Jmilk'

In [61]: sum(num)
Out[61]: 10

In [62]: sum(str)
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-62-3a5f0824550a> in <module>()
----> 1 sum(str)

TypeError: unsupported operand type(s) for +: 'int' and 'str'

zip 混合兩個序列物件

將兩個序列物件中索引相同的兩個元素結合成元組，並以這些元組作為返回的新列表的一個元素。

In [54]: aList
Out[54]: ['my', 'name', 'is', 'Jmilk']

In [55]: name
Out[55]: 'Jmilk'

In [56]: zip(name,aList)
Out[56]: [('J', 'my'), ('m', 'name'), ('i', 'is'), ('l', 'Jmilk')]

all() 檢測sequence中各項元素是否均為True

全 True 則 True，反正為 False 。

In [63]: num = [1,2,3,'']

In [64]: all(num)
Out[64]: False

In [65]: num = [1,2,3,True]

In [66]: all(num)
Out[66]: True

注意：所以的空值序列物件都是False

any() 檢測序列中的任意元素是否為True

有 True 則 True 。

In [67]: num = [1,2,3,'']

In [68]: any(num)
Out[68]: True