3.2　序列的操作

序列類型有很多共同的操作，如獲取長度、連接、重復、切片等等。本小節主要介紹序列的常用操作。

3.2.1　序列的創建

通過對變量直接賦值，即可創建該序列類型。如：

    >>> list_example =  [1, 2, 3]        ##創建了一個列表類型對象list_example
    >>> str_example = "hello world"      ##創建了一個字符串類型對象str_example
    >>> tuple_example = (10, 32, 20, 16) ##創建了一個元組類型對象tuple_example
    >>> list_example
    [1, 2, 3]
    >>> str_example
    'hello world'
    >>> tuple_example
    (10, 32, 20, 16)

3.2.2　獲取長度

可以通過len函數來返回序列中包含的成員個數。格式為：

    len (seq) 

其中seq為序列的名稱，如使用len函數獲取3.2.1定義的三個序列對象中的元素個數：

    >>> len (list_example) 
    3
    >>> len (str_example) 
    11
    >>> len (tuple_example) 
    4

3.2.3　索引與切片

序列中的每個元素都有其編號，被稱為下標，也作索引。序列的編號從左至右從0開始遞增。可以通過索引訪問各元素。格式如下：

    seq [i] 

其中seq為序列的名稱，可以通過索引i直接獲取對應元素。如：

    >>> L =  [10, 11, 12, 13, 14, 15, 16, 17, 18] 
    >>> L [0] 
    10

訪問序列時，也可以從序列右端開始。序列由右至左元素的索引也可以是-1、-2……如對上例中的L進行訪問：

    >>> L [-2] 
    17

切片是序列很常用的一種操作。使用切片可以訪問一定范圍內的元素。格式為：

    seq [startindex : remainindex : stepvalue] 

其中，seq為序列的名稱，startindex為提取元素的起始下標，remainindex為結束下標，即剩余元素的起始下標，stepvalue為步長值，即下標增量，缺省值為1。進行切片操作時從下標startindex取至下標remainindex-1，取出的結果序列中不包括下標為remainindex的元素。如對上例中的L繼續進行訪問：

    >>> L [1:5] 
    [11, 12, 13, 14]

起始下標和終止下標可以省略。若步長值為正，則省略起始下標表示從0開始，省略終止下標表示取至序列最后一個元素；若步長值為負，則省略初始下標表示從最后一個元素開始，省略終止下標表示取至下標為0的元素。如對上例中的L繼續進行訪問：

    >>> L [0:9:2]         ##獲取序列L中下標為0, 2, 4, 6, 8的元素構成的子序列
    [10, 12, 14, 16, 18]
    >>> L [:] 
    [10, 11, 12, 13, 14, 15, 16, 17, 18]
    >>> L [::-1]          ##等價于L [len (L) -1: :-1] 
    [18, 17, 16, 15, 14, 13, 12, 11, 10]

3.2.4　關系操作

in/not in 運算用于判斷某對象是否是序列的成員。格式為：

    elem in/not in seq

其中，elem為判斷是否在序列中的對象，seq為序列。

對于字符串而言，in/not in不僅可以判斷某字符是否是該序列的成員，還可以判斷字符串s1是否是字符串序列s2的子串；而對于列表或元組而言，該運算則無法判斷某列表或元組是否是該序列的子序列，只能用于判斷某對象是否是該序列的成員。如：

    >>> s = "hello world"
    >>> "h" in s        ##判斷“h”字符是否是字符串序列s的成員
    True                  
    >>> "world" in s    ##判斷“world”字符串是否是字符串序列s的子串。若為子串, 
    True                    則子串中的各字符的相對次序需與原字符串序列中各字符的
    >>> "ehllo" in s      相對次序一致。
    False
    >>> L =  [11, 13, 17, 19] 
    >>> 13 in L         ##判斷13是否是列表序列L的成員
    True
    >>>  [11, 13]  in L ##無法判斷 [11, 13] 是否是列表序列L的子序列
    False
    >>> t = (1, 2, 3) 
    >>> 3 in t          ##判斷3是否是元組序列t的成員
    True
    >>> (2, 3)  in t    ##無法判斷 (2, 3) 是否是元組序列t的子序列
    False
    >>> 5 not in t
    True

3.2.5　連接操作

連接操作是將多個相同類型的序列進行合并，并且保證其成員相對次序不變。格式為：

    seq1 + seq2

該操作的結果為由序列seq1的所有成員與序列seq2的所有成員構成的新序列?！?”操作適用于包括字符串、列表和元組的各種序列。字符串序列還可以通過join方法來實現連接，格式為：

    joinchar.join (stringlist) 

列表序列還可以通過extend方法來實現兩個列表的合并。格式為：

    list1.extend (list2) 

列表序列的extend方法是將列表list2合并至列表list1中，該方法本身并不返回任何結果，因此合并后查看列表list1的內容才可以看到合并結果。如：

    >>> "Hello" + "World"
    'HelloWorld'
    >>> "".join ( ["Hello", "World"] ) 
    'HelloWorld'
    >>> ", ".join ( ["Happy", "New", "Year"] ) 
    'Happy, New, Year'
    >>>  [1, 2, 3]  +  [2, 3, 4] 
    [1, 2, 3, 2, 3, 4]
    >>> L1 =  [1, 2, 3] 
    >>> L1.extend ( [2, 3, 4] ) 
    >>> L1
    [1, 2, 3, 2, 3, 4]
    >>> (1, "a")  + (2, "b") 
     (1, 'a', 2, 'b')

3.2.6　重復操作

重復操作是將某序列重復多次，生成新的序列。格式為：

    seq * n

該操作返回將序列seq重復n次后的結果序列，如：

    >>> s = "hello"
    >>> s * 3
    'hellohellohello'
    >>> L =  [1, 2] 
    >>> L * 4
    [1, 2, 1, 2, 1, 2, 1, 2]

3.2.7　常用函數及方法

1．最大值函數max、最小值函數min

通過max函數可以獲取給定序列的最大值，若有多個元素相等并且同為最大值，則返回第一個最大值，格式為：

    max (seq, key = func) 

其中seq為序列的名稱，key參數缺省時，序列元素必須是可比較類型。

若序列元素為數值，則直接比較大小，如：

    >>> max ( [10, 39, 34, 26, 30] ) 
    39

若序列元素為字符，則比較其編碼，西文字符比較其ASCII碼；中文漢字比較其機內碼，如：

    >>> s = "hello world"
    >>> max (s) 
    'w'
    >>> max ("Hello World") 
    'r'
    >>> ord ("我") 
    25105
    >>> ord ("們") 
    20204
    >>> max ("我們") 
    '我'

若序列元素又為序列，則首先比較每個序列元素的第一個元素，若相等再比較每個序列元素的第二個元素，直到分辨出大小為止。如：

    >>> max ( [ [10, 23] ,  [10, 32] ,  [10, 10, 40] ] ) 
    [10, 32]

若序列元素為數值或邏輯型，則按照邏輯型轉換為數值類型的值進行比較大?。═rue轉換為數值類型為1，False轉換為數值類型為0），若最大值有多個，則返回第一個最大值。如：

    >>> max (1, True) 
    1
    >>> max (True, 1) 
    True

還可以通過key參數指定比較依據。經常使用lambda函數來制定排序依據（lambda匿名函數可參見7.4章節）。如：

    >>> L =  [ [1, 2] , "abcdef", (10, 20, 30) ] 
    >>> max (L, key = lambda item: len (item) )   ##按L中的每個序列元素中的元素個數排序
    'abcdef'
    >>> L =  [ ("a", 20) , ("b", 30) , ("c", 15) ] 
    >>> max (L, key = lambda item: item [1] ) 
    ('b', 30)

通過min函數可以獲取給定序列的最小值，若有多個元素相等并且同為最小值，則返回第一個最小值，格式為：

    min (seq, key = func) 

min函數的使用方法與max函數的使用方法相同。如：

    >>> L= [ ("a", 20) , ("b", 30) , ("c", 15) ] 
    >>> min (L, key = lambda item: item [1] )       ##按L中的每個序列元素中下標為1的元素值排列
     ('c', 15)

2．求和函數sum

通過sum函數可以獲取給定序列的元素之和，格式為：

    sum (seq) 

其中seq為序列的名稱。

需注意：使用sum函數獲取給定序列的元素之和時，序列元素只能是可求和類型，如數值型和邏輯型。例：

    >>> sum ( [1.0, 2.5, 3.0] ) 
    6.5
    >>> sum ( (1, True) ) 
    2

3．匹配方法index和find

通過序列的index方法可以返回某元素或子序列在源序列中的位置（下標），格式為：

    seq.index (elem, startindex, remainindex) 

即在序列seq的下標startindex至remainindex-1之間查找elem元素，并返回其下標。

若缺省startindex，則默認從下標0開始查找；若缺省remainindex，則默認為查找到序列的最后一個元素。如：

    >>> s = "hello world"
    >>> s.index ("o") 
    4
    >>> s.index ("o", 5) 
    7

對于字符串，它的index方法還可以獲取子串在源字符串中的位置。如：

    >>> s = "hello world"
    >>> s.index ("ld") 
    9

Python中除了index方法可以實現元素的查找，find方法也可以，其參數與index相同。但要注意，列表類型和元組類型的序列沒有find方法，因此若對這兩類序列進行查找某元素，則需使用index方法。如：

    >>> L =  [1, 2, 3, 4] 
    >>> L.index (2) 
    1
    >>> L.find (2) 
    Traceback (most recent call last) :
      File "<pyshell#12>", line 1, in <module>
        L.find (2) 
    AttributeError: 'list' object has no attribute 'find'

在字符串中找出某子串所在位置，既可以使用index方法，也可以使用find方法。但若找不到子串，則兩個方法的處理方式是不一樣的。如：

    >>> s = "hello world"
    >>> s.index ("o") 
    4
    >>> s.find ("o") 
    4
    >>> s.index ("t")
    Traceback (most recent call last) :
      File "<pyshell#17>", line 1, in <module>
        s.index ("t")
    ValueError: substring not found
    >>> s.find ("t") 
    -1

若源字符串中無待查找之子串，使用index方法，則拋出異常，并給出錯誤提示；使用find方法，則返回-1，表示找不到子串。

4．統計次數方法count

通過序列的count方法可以獲取某元素在序列中出現的次數，格式為：

    seq.count (elem, startindex, remainindex) 

即在序列seq中下標startindex至remainindex-1之間進行統計elem出現的次數。若缺省startindex，則默認從下標0開始統計；若缺省remainindex，則默認為統計到序列的最后一個元素。如：

    >>> s = "hello world. hello everyone."
    >>> s.count ("o") 
    4
    >>> s.count("o",12)
    2
    >>> L =  [1, 2, 3, 2, 2, 3] 
    >>> L.count (2) 
    3

對于字符串，它的count方法還可以獲取子串在源字符串中出現的次數。如：

    >>> s = "hello world. hello everyone."
    >>> s.count ("hello") 
    2

5．排序函數sorted、排序方法sort

通過sorted函數或列表的sort方法可以對序列進行排序。sorted函數返回排序后的序列，而原序列元素次序保持不變；列表調用sort方法進行排序，則在原序列上進行排序。

sorted函數的格式為：

    sorted (seq, key = func, reverse = False) 

其中seq為序列的名稱。

reverse參數可省略，若省略，按升序排；若reverse=True，則按降序排。

key可以缺省，缺省時，若原序列元素為數值，則按數值大小進行排序；若原序列元素是西文字符或漢字，則按字符ASCII碼或漢字的機內碼進行排序；若原序列元素還是序列，則按元素序列下標為0的元素進行排序，若下標為0的元素相等，則繼續按下標為1的元素排序……如：

    >>> L =  [12, 34, 20, 19] 
    >>> sorted (L) 
    [12, 19, 20, 34]
    >>> sorted (L, reverse = True) 
    [34, 20, 19, 12]
    >>> s = "hello"
    >>> sorted (s) 
    ['e', 'h', 'l', 'l', 'o']
    >>> L =  [ (12, 34) , (20, 12)  , (1, 10) , (12, 30) , (12, 37) ] 
    >>> sorted (L) 
    [ (1, 10) , (12, 30) , (12, 34) , (12, 37) , (20, 12) ]

通過key參數，可以指定排序依據，通常會指定一個函數，序列根據該函數返回的結果進行排序（lambda匿名函數可參見7.4章節，split方法可參見3.3.2小節）。如：

    >>> L =  [ ("a", 20) , ("b", 32) , ("c", 24) ] 
    >>> sorted (L, key = lambda item: item [1] ) 
    [ ('a', 20) , ('c', 24) , ('b', 32) ]
    >>> s="Python is a programming language"
    >>> sorted (s.split (" ") )   ##通過分隔符" "將s分離成若干子串構成的序列, 并對序列進行排序
    ['Python', 'a', 'is', 'language', 'programming']
    >>> sorted (s.split (" ") , key = lambda item: item.lower ( ) ) 
    ['a', 'is', 'language', 'programming', 'Python']

sort方法的格式為：

    seq.sort (key = func, reverse = False) 

其中seq為序列的名稱，key和reverse參數的使用方法同sorted函數。通過調用該方法，可以根據key指定的排序依據對原列表進行排序。但由于字符串和元組是不可變序列，不可以直接對原序列進行修改，所以字符串和元組無sort方法。如：

    >>> L =  [ ("a", 20) , ("b", 32) , ("c", 24) ] 
    >>> L.sort (key = lambda item: item [1] ) 
    >>> L
    [ ('a', 20) , ('c', 24) , ('b', 32) ]