Python序列類型

Python序列類型

序列：字符、列表、元組

    全部序列都支持迭代
    序列表示索引爲非負整數的有序對象集合
    字符和元組屬於不可變序列，列表可變

1)字符

字符串字面量:把文本放入單引號、雙引號或三引號中；
    '    ''    '''
        >>> str1 = ' hello, fanison '
        >>> type(str1)
        str
    
    若是要使用unicode編碼，則在字符以前使用字符u進行標識
        >>> str2 = u'你好，fanison'
        >>> type(str2)
        unicode
        
    文檔字串：模塊、類或函數的第一條語句是一個字符的話，該 字符串就成爲文檔字符串，能夠使用__doc__屬性引用；
        例：
            >>> def printName():
                    "the function is print hello"
                    print 'hello'
            >>> printName.__doc__
            
    運算符：
        索引運算符          s[i]        返回一個序列的元素i
        切片運算符          s[i:j]      返回一個切片
        擴展切片運算符      s[i:j:stride]
      
        例：
            >>> str3 = 'hello,fanison'
            >>> str2[0:]
            'hello,fanison'      返回全部元素
            >>> str2[0:7]
            'hello,f'            返回索引7以前的全部元素
            >>> str2[0:7:2]
            'hlof'               返回從索引0到6內步徑爲2的元素，即隔一個取一個
            >>> str2[7:0:-2]        
            'a,le'               從索引7處倒着隔一個取一個取到索引1處
            >>> str2[-4:-1]
            'iso'                從索引-4處取到-2處       
            >>> str2[-4::-1]
            'inaf,olleh'         從-4處到開始處倒着取
        注意：
            步徑爲正表示  正着取，索引從小到大          i < j
            步徑爲負表示  倒着取，索引從大到小          i > j
        
    支持運算：
        索引、切片、min()、max()、len()等
        
            len(s)              s中的元素個數
            min(s)              s的最小值
            max(s)              s的最大值
            
   支持方法：
        S.index(sub [,start [,end]])            找到指定字符串sub首次出現的位置
        S.upper()                               將一個字符串轉換爲大寫形式
        S.lower()                               將一個字符串轉化爲小寫形式
        S.join(t)                               使用s做爲分隔符鏈接序列t中的字符串
                    >>> l1 = list(str1)
                    >>> l1
                    ['h', 'e', 'l', 'l', 'o', ',', 'f', 'a', 'n', 'i', 's', 'o', 'n']
                    >>> ''.join(l1)
                    'hello,fanison'             使用空字符做爲分隔符鏈接列表l1
       S.replace(old, new[, count])             替換一個字符串
                    >>> str1.replace('fan','FAN')
                    'hello,FANison'
    注意：
        使用 help()獲取其幫助
                >>> help(str.join)

2)列表

列表：容器類型
         任意對象的有序集合，經過索引訪問其中的元素，可變對象，長度可變，異構，任意嵌套
     
      支持在原處修改
            修改指定的索引元素，修改指定的分片，刪除語句，內置方法
            
         >>> list1 = [ 1,2,3,'x','n' ]
         >>> list1[1]=56
         >>> print list1
         [1, 56, 3, 'x', 'n']
         >>> list1[1:3]=[]              會刪除索引1到索引3以前的元素
         >>> print list1
         [1, 'x', 'n']   
         >>> del(list1[1])              使用del函數刪除list索引爲1的元素
         >>> print list1
         [1, 'n']
            注意：
                 由於支持原處修改，不會改變內存位置，可以使用  id() 查看其位置變化
       
       內置方法：
                 L.count(value)                     計算value值出現的次數
                 L.append(object)                   將一個新元素追加到L末端                    
                 L.extend(iterable)                 增長合併列表(第二個列表內容會以單個元素追加至末端)
                        >>> l1 = [ 1,2,3 ]
                        >>> l2 = [ 'x','y','z']
                        >>> l1.append(l2)
                        >>> l1
                        [1, 2, 3, ['x', 'y', 'z']]          使用append方法會以其原有存在形式追加
                        >>> l1 = [ 1,2,3 ]
                        >>> l1.extend(l2)
                        >>> l1
                        [1, 2, 3, 'x', 'y', 'z']            注意兩種增長的區別
                L.pop([index])                      返回元素index並從列表中移除它，若是省略則返回並移除列表最後一個元素
                L.remove(key)                       移除值爲key的元素
                        >>> l1 = [ 'x',2,'abc',16,75 ]
                        >>> l1.pop(2)                       pop方法是按索引移除
                        'abc'
                        >>> l1
                        ['x', 2, 16, 75]
                        >>> l1.remove(16)                   remove方法是按值移除
                        >>> l1
                        ['x', 2, 75]  
                L.index(value)                        指定值首次出現的位置
                L.insert(index, object)               在索引index處插入值
                        >>> l1.insert(1,'abc')
                        >>> l1
                        ['x', 'abc', 2, 75]
                L.sort()                              排序
                L.reverse()                           逆序
                        >>> l1.sort()
                        [2, 75, 'abc', 'x']
                        >>> l1.reverse()
                        ['x', 'abc', 75, 2]
                        
        l1 + l2: 合併兩個列表，返回一個新的列表；不會修改原列表；
                        >>> l1 = [ 1,2,3]
                        >>> l2 = [ 'x','y','z']
                        >>> l1 + l2
                        [1, 2, 3, 'x', 'y', 'z']
                        
        l1 * N: 把l1重複N次，返回一個新列表; 
                        >>> l1 * 3
                        [1, 2, 3, 1, 2, 3, 1, 2, 3]         使用id()查看是否生成新列表
        
        成員關係判斷字符：  
                        in              用法：   item in container
                        not in               item not in container
                            >>> l1 = [ 'x','y',3 ]
                            >>> 'y' in l1
                            True
                            >>> 'x' not in l1
                            False
                            
       列表解析：[]
       
       列表複製方式：
            淺複製:二者指向同一內存對象
                    >>> l1 = [ 1,2,3,4 ]
                    >>> l2 = l1
                    >>> id(l1) == id(l1)
                    True                            能夠看出二者內存地址相同
                    >>> l1.append('x')
                    >>> print l1
                    [ 1,2,3,4,'x' ]
                    >>> print l2
                     [ 1,2,3,4,'x' ]
            深複製：二者指向不一樣內存對象
                    1)導入copy模塊，使用deepcoop方法
                     >>> import copy
                     >>> l3 = copy.deepcopy(l1)
                     >>> id(l3) == id(l1)
                     False                          地址不一樣
                     
                    2)複製列表的全部元素，生成一個新列表
                    >>> l4 = l1[:]              
                    >>> print l4
                    [ 1,2,3,4,'x' ]
                    >>> l1.append(6)
                    >>> print l1
                    [ 1,2,3,4,'x',6 ]               l1改變
                    >>> print l4
                    [ 1,2,3,4,'x' ]                 l4不變

3)元組

表達式符號：()

    容器類型
        任意對象的有序集合，經過索引訪問其中的元素，不可變對象，長度固定，異構，嵌套
    
    常見操做：
        ()                      
                    >>> t1 = ( 1,2,3,'xyz','abc')
                    >>> type(t1)
                    tuple
                    >>> len(t1)
                    5
                    >>> t2 = ()                             定義一個空元組
                    >>> t3 = ( , )
                    SyntaxError: invalid syntax             報錯：使用逗號分隔的條件是最少要有一個元素
        
        (1,)
                    >>> t1[:]
                    ( 1,2,3,'xyz','abc' )
                    >>> t1[1:]
                    (2, 3, 'xyz', 'abc')
    
        (1,2)       
                    >>> t1[1:4]
                    (2, 3, 'xyz')
                    >>> t4 = 'x',1,'yz',45,[2,4,6]              注意!!!這樣也能夠生成元組
                    >>> t4  
                    ('x', 1, 'yz', 45, [2, 4, 6])

        t1 + t4: 合併兩個元組，返回一個新的元組；不會修改原元組；
                    >>> t1 + t4
                    (1, 2, 3, 'xyz', 'abc', 'x', 1, 'yz', 45, [2, 4, 6])
        
       
       t1 * N:  把l1重複N次，返回一個新元組; 
                    >>> t1 * 3
                    (1, 2, 3, 'xyz', 'abc', 1, 2, 3, 'xyz', 'abc', 1, 2, 3, 'xyz', 'abc')

        成員關係判斷
                in
                not in
     
        注意：
            雖然元組自己不可變，但若是元組內嵌套了可變類型的元素，那麼此類元素的修改不會返回新元組；
                例：
                    >>> t4 = ('x', 1, 'yz', 45, [2, 4, 6])
                    >>> id(t4)
                    44058448
                    >>> t4[4]                           
                    [2, 4, 6]
                    >>> t4[4].pop()                     彈出列表內一個元素
                    6
                    >>> print t4[4]
                    [2, 4]
                    >>> print t4
                    ('x', 1, 'yz', 45, [2, 4]) 
                    >>> id(t4)
                    44058448                            因而可知，對元組內列表內的修改也會使元組發生改變，沒有返回新元組

4)序列操做總結