Python中的序列操做

官方手冊：https://docs.python.org/3.7/library/stdtypes.html#sequence-types-list-tuple-range

序列簡介

序列是指按照位置順序來存儲數據的數據結構，也就是說能經過數值索引進行操做。實際上，python對序列的解釋是：只要類型對象中重載了__len__()和__getitem__()，且它們的整數參數從0開始，就表示這個類型知足序列協議，是一個序列類型。

python有三種基本的序列類型：列表、元組和range對象。固然，還有特別定製的序列類型：str和binary data。

序列類型又分爲可變序列和不可變序列。可變序列表示能夠原處修改的序列，不可變序列意味着不容許原處修改。例如，列表是可變序列，字符串是不可變序列。

可變對象和不可變對象的含義，參見python可變對象和不可變對象的解釋。

序列的通用操做

下面這些操做是序列通用的，不管是可變、不可變序列。但通用並不意味着全部序列都支持這些操做，有些特殊的序列由於某些緣由不支持某些操做也是合理的。

注意：python中序列操做在索引越界的時候都會報錯。

1.測試元素是否存在

x in S和x not in S，返回True或False。例如：

>>> 'a' in "abcd"
True
>>> 'aa' in "abcd"
False
>>> 'ab' in "abcd"
True
>>> 3 in [1,2,3,4]
True

2.加法和乘法符號

S1 + S2或S * N或N * S，其中S1和S2是同一種序列類型，N表示序列的重複次數。

例如：

>>> [1,2] + [3,4]
[1, 2, 3, 4]

>>> [1,2] * 3
[1, 2, 1, 2, 1, 2]
>>> 3 * [1, 2]
[1, 2, 1, 2, 1, 2]

注意，序列中保存的是元素的引用地址，因此對於序列中的可變元素，+ *時須要注意修改的影響範圍：

>>> L = [1,2,3,4]
>>> L1 = [['a'],['b']]

>>> L0 = L + L1
>>> L0
[1, 2, 3, 4, ['a'], ['b']]

>>> L1[0][0] = "aa"
>>> L0
[1, 2, 3, 4, ['aa'], ['b']]

上面修改"a"爲"aa"也會影響到+的結果L0，由於['a']是一個可變對象。一樣對於*的重複操做，也是拷貝引用：

>>> L = []
>>> L1 = [L] * 3
>>> L1
[[], [], []]

>>> L.append(3)
>>> L1
[[3], [3], [3]]

3.len()、max()和min()函數

len()返回序列的元素個數，也就是序列的長度。min()和max()分別返回序列中最小、最大的元素。

>>> len(L), min(L), max(L)
(4, 'a', 'd')

4.找出元素在序列中出現的次數count()

>>> s="hello world"
>>> s.count("h"),s.count("o")
(1, 2)

5.索引取元素

S[i]，i爲從0開始的數值，能夠取負數表示從尾部開始取。

例如：

>>> L
['a', 'b', 'c', 'd']
>>> L[0]
'a'
>>> L[1]
'b'
>>> L[-1]
'd'

負數的i等價於len(S)+i做爲索引。例如，len(S) = 3, i = -1，表示取最後一個元素，也就是index=2的元素。

6.分片

分片操做用於從序列中取出子序列，它會建立新的內存塊來保存取出來的序列對象。

• S[i:j]：從索引位i取到索引位j，不包括j
  
• S[i:]：從索引位i開始取到最結尾
  
• S[:j]：從最開頭取到索引位j，不包括j
  
• S[:]：從頭取到尾，至關於拷貝了序列，但獲得的是新序列
  
• S[i:j:k]：k表示取元素時的步進間隔，默認爲1，表示每一個元素都取，若是爲2，則表示取一個跳過一個

分片的區間是左閉右開的，因此不會包括j的索引位。i和j能夠是負數，負數表示從尾部開始計算索引位。例如，-1表示最後一個元素，-2表示倒數第二個元素。

特別地，若是i = j，則表示找到序列中的這個位置，但由於切片長度位0，因此返回空。

例如：

>>> s = "hello world"
>>> len(s)
11

>>> s[0:6]
'hello '
>>> s[:6]
'hello '

>>> s[6:10]   # 不包括index=10
'worl'
>>> s[6:11]   # 因此用大於10的結束位
'world'
>>> s[6:]
'world'
>>> s[6:-1]
'worl'

>>> s[:]      # 拷貝序列獲得副本
'hello world'

>>> s[::1]     # 步進爲1，默認的
'hello world'
>>> s[::2]     # 每次跳過一個元素
'hlowrd'

>>> s[1:1]    # 找到index=1的位置
''

7.找出第一個元素的位置index()

index(x,i,j)表示從序列中搜索元素x並返回第一次出現的x的位置，若是給定了i，則表示從索引位i開始搜索，給定了j則表示最多搜索到索引位爲j的位置。

若是找不到元素，將報錯。i和j能夠是負數，但不管它們是正數仍是負數，都是搜索的開始和結束位。

>>> s="hello world"
>>> s.index("o")
4
>>> s.index("o",1,-1)
4
>>> s.index("o",-5)    # 從倒數第5個元素開始搜索
7
>>> s.index("a")       # 搜索不到時報錯
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: substring not found

不可變序列的操做

相比可變序列，不可變序列的惟一操做是能夠支持內置的hash()操做。可變序列沒法hash()。

>>> hash("asd")
-2014632507

>>> hash((1,23))
1320437575

>>> hash([1,23])
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unhashable type: 'list'

可以hash的不可變序列，意味着能做爲dict的key，能保存到set或frozenset中。

可變序列的操做

1. s[i] = x、s[i:j] = t將序列中的元素替換成x或可迭代對象t
   
2. s[i:j:K] = t將序列中的元素替換成可迭代對象t，t的長度必須和s[i:j:k]的長度同樣
   
3. del s[i]、del s[i:j]刪除序列中的元素，等價於s[i] = []、s[i:j] = []
   
4. del s[i:j:k]刪除序列中的某些元素，k爲步進值
   
5. s.remove(x)：移除第一次出現的元素x
   
6. s.clear()表示清空序列中的全部元素，等價於del s[:]
   
7. s.pop([i])表示移除序列s中的第i個元素並返回這個元素，中括號表示可選，若是沒有參數，默認移除最後一個元素
   
8. s.append(x)向序列的尾部追加元素x，等價於s[len(s):len(s)] = [x]
   
9. s.extend(t)或s += t表示將t擴展到序列s的尾部，等價於s[len(s):len(s)] = t
   
10. s.insert(i,x)表示將x插入到序列中的i索引位置處，等價於s[i:i] = [x]
    
11. s *= n表示將序列n的元素重複n次追加到s的尾部
    
12. s.copy()表示拷貝序列獲得一個新的序列副本，等價於s[:]
    
13. s.reverse()原地反轉序列s，爲了節約內存空間，因此是原地反轉，不會返回反轉後的序列

對於序列，還有一個內置函數reversed(SEQ)。與之對應的，還有一個內置函數sorted()，但它操做的對象是可迭代對象，並不必定老是序列。

示例1：序列元素賦值

>>> L = ['aa','bb','cc','dd','ee','ff']
>>> L1 = [1,2,3,4]

>>> L[0] = "a"
>>> L
['a', 'bb', 'cc', 'dd', 'ee', 'ff']

>>> L[1:2] = L1
>>> L
['a', 1, 2, 3, 4, 'cc', 'dd', 'ee', 'ff']

>>> L[::2] = [1,2,3,4,5]
>>> L
[1, 1, 2, 3, 3, 'cc', 4, 'ee', 5]

示例2：刪除元素

刪除相關操做有del、remove()、pop()、clear()。

例如：

>>> L = ['aa','bb','cc','dd','ee','ff']
>>> del L[1]
>>> L
['aa', 'cc', 'dd', 'ee', 'ff']
>>> del L[1:2]
>>> L
['aa', 'dd', 'ee', 'ff']
>>> del L[::2]
>>> L
['dd', 'ff']

>>> L = ['aa','bb','cc','dd','ee','ff']
>>> L.remove('aa')
>>> L
['bb', 'cc', 'dd', 'ee', 'ff']

>>> L.pop()
'ff'
>>> L
['bb', 'cc', 'dd', 'ee']

>>> L.pop(2)
'dd'
>>> L
['bb', 'cc', 'ee']

>>> L.clear()
>>> L
[]

示例3：添加元素

相關操做有append()、extend()、insert()、s *= n。

例如：

>>> L = ['aa', 'bb', 'cc', 'dd', 'ee']
>>> L1 = [1,2,3,4]

>>> L.append("ff")
>>> L
['aa', 'bb', 'cc', 'dd', 'ee', 'ff']

>>> L.insert(1,"a")
>>> L
['aa', 'a', 'bb', 'cc', 'dd', 'ee', 'ff']

>>> L.extend(L1)
>>> L
['aa', 'a', 'bb', 'cc', 'dd', 'ee', 'ff', 1, 2, 3, 4]

>>> L1 * 2
[1, 2, 3, 4, 1, 2, 3, 4]

示例4：其它操做

拷貝序列copy()、反轉序列reverse()。

>>> L = ['aa', 'bb', 'cc', 'dd', 'ee']

>>> L1 = L.copy()
>>> L1
['aa', 'bb', 'cc', 'dd', 'ee']

>>> L.reverse()
>>> L
['ee', 'dd', 'cc', 'bb', 'aa']

還有一個可用於序列的內置函數reversed()，它反轉序列，並返回可迭代對象。因此，若是要將它展示出來，須要構建容器。例如:

>>> L = ['aa', 'bb', 'cc', 'dd', 'ee']

>>> list(reversed(L))
['ee', 'dd', 'cc', 'bb', 'aa']

>>> set(reversed(L))
{'aa', 'bb', 'ee', 'cc', 'dd'}