Python序列

基本操作符
    in / not in:    obj [not] in sequence
    seq[index] :獲得下標為index的元素。index從0開始，不能超越下標
        反向index
            對于seq來說，可以使用負數下標。-1即為最后一個元素的index。
            對于第一個元素來說，其負數下標為：-len(seq)
    seq[ind1:ind2] :序列切片
    seq * expr :    把序列重復expr次
    seq1 + seq2:    連接序列seq1和seq2
    切片：
        seq[:] 或者 seq[::]
        seq[from:to]
            包含[from, to)的子序列
            eg:
                s = [a,b,c,d,e]
                s[0:3] --> [a,b,c]
                s[:3]  --> [a,b,c]
                s[2:]  --> [c,d,e]
                s[2:5] --> [c,d,e]
                s[2:100]-> [c,d,e] #可以用超過范圍的index值
        seq[from:to:step]
            可指定步長參數
            eg:
                s = [a,b,c,d,e]
                s[::-1]  --> [e,d,c,b,a]
                s[::2]   --> [a,c,e]
內建函數
    迭代的概念：
        所謂迭代，指的是能夠進行順序遍歷的對象，通常與迭代器模式相關。
        在Python中，for循環能夠遍歷所有的可迭代類型
        而序列是可迭代類型中的一種
        下面用iter表示可迭代類型，用seq特指序列
    類型轉換
        list(iter):        利用iter，創建一個序列
        str(obj):        把obj轉換成字符串
        unicode(obj):    把obj轉換成unicode字符串
        tuple(iter):    把iter轉換成一個元組
        特別的，對于list(iter)和tuple(iter)，創建的是iter的淺拷貝
    操作函數
        enumerate(iter)            返回一個enumerate對象，能生成(index, value)的元組
                                參考TestEnumerate.py
        len(seq)                返回seq的長度
        min(iter, key=None) or
        min(arg0, arg1 ... ,key=None)
                                返回iter里的最小值或者arg0,arg1...里的最小值
                                如果指定key的話，這個key必須是能傳遞給sort方法的回調函數
        reserved(iter)            返回一個逆序排列的迭代器
        sum(seq, init=0)        返回seq和可選參數init的總和
字符串
    字符串對象是不可變的，一旦創建，不能改變
    但字符串引用可以指向新字符串。
    字符串的表示：
        eg:
        'abc' #單引號
        "ccc" #雙引號，單引號和雙引號表示字符串沒有區別。
        r'mamamiya\n' #用r表示不轉義
        """abcdef""" #三引號可以用來做WYSIWYG格式的字符串。
    字符串操作符
        比較操作符 ：>, <, !=  字符串比較按照ascii序列
        序列操作
            [index]
            [::]切片操作
            in / not in
        連接符
            + ： 可以連接多個字符串。
            eg:
                'hello' + ' world' + ' moyun'
            Note：由于字符串不可變，使用連接符會產生多個子字符串，從而導致一定的性能問題
            如果注重性能的問題，則應當使用string類型函數join
            eg:
                ''.join( ('hello', ' world', ' moyun') )
            編譯時字符串連接
                Python中允許把字符串分開寫。例如：
                'hello ' "World"
                這種方法可以用來連接字符串的時候進行注釋。例如：
                    "http://"        #protocol
                    "localhost"     #address
                    ":80"             #port
                    "/index.html"    #file
        重復操作符
            * ： 可以讓字符串重復出現多次
    只適用于字符串的操作符：
        格式化字符串
            格式化字符            轉換方式
            %c                     轉換成字符(ASCII 碼值，或者長度為一的字符串)
            %r                     優先用repr()函數進行字符串轉換
            %s                     優先用str()函數進行字符串轉換
            %d / %i             轉成有符號十進制數
            %u                     轉成無符號十進制數
            %o                     轉成無符號八進制數
            %x/%X (Unsigned)    轉成無符號十六進制數(x/X 代表轉換后的十六進制字符的大小寫)
            %e/%E                 轉成科學計數法(e/E 控制輸出e/E)
            %f/%F                 轉成浮點數(小數部分自然截斷)
            %g/%G                %e和%f / %E 和%F 的簡寫
            %%                    輸出%
            符號                    作用
            *                     定義寬度或者小數點精度
            -                    用做左對齊
            +                     在正數前面顯示加號( + )
            <sp>                 在正數前面顯示空格
            #                     在八進制數前面顯示零('0')，在十六進制前面顯示'0x'或者'0X'(取決于用的是'x'還是'X')
            0                     顯示的數字前面填充‘0’而不是默認的空格
            %                     '%%'輸出一個單一的'%'
            (var)                 映射變量(字典參數)
            m.n                 m 是顯示的最小總寬度,n 是小數點后的位數(如果可用的話)
        字符串模板
            參考TestStringTemplate
    字符串內建函數
        字符串的處理，可以使用string模塊，也可以使用字符串內建函數以及標準操作符
        但是，基于性能的考慮，在可以的情況下，應當盡量使用字符串的內建函數
        方法                            描述
        string.capitalize()        把字符串的第一個字符大寫
        string.center(width)    返回一個原字符串居中,并使用空格填充至長度width的新字符串
        string.count(str, beg=0,end=len(string))
                                返回str 在string 里面出現的次數，如果beg 或者end 指定則返回指定范圍內str 出現的次數
        string.decode(encoding='UTF-8',errors='strict')
                                以encoding 指定的編碼格式解碼string，如果出錯默認報一個ValueError 的異常，
                                除非errors 指定的是'ignore' 或者'replace'
        string.encode(encoding='UTF-8',errors='strict')
                                以encoding 指定的編碼格式編碼string，如果出錯默認報一個ValueError 的異常，
                                除非errors 指定的是'ignore'或者'replace'
        string.endswith(obj, beg=0,end=len(string))
                                檢查字符串是否以obj 結束，如果beg 或者end 指定則檢查指定的范圍內是否以obj 結束，
                                如果是，返回True,否則返回False.
        string.expandtabs(tabsize=8)
                                把字符串string 中的tab 符號轉為空格，默認的空格數tabsize 是8.
        string.find(str, beg=0,end=len(string))
                                檢測str 是否包含在string 中，如果beg 和end 指定范圍，則檢查是否包含在指定范圍內，
                                如果是返回開始的索引值，否則返回-1
        string.index(str, beg=0,end=len(string))
                                跟find()方法一樣，只不過如果str 不在string 中會報一個異常.
        string.isalnum()        如果string 至少有一個字符并且所有字符都是字母或數字則返回True,否則返回False
        string.isalpha()        如果string 至少有一個字符并且所有字符都是字母則返回True,否則返回False
        string.isdecimal()        如果string 只包含十進制數字則返回True 否則返回False.
        string.isdigit()        如果string 只包含數字則返回True 否則返回False.
        string.islower()        如果string 中包含至少一個區分大小寫的字符，并且所有這些(區分大小寫的)字符都是小寫，
                                則返回True，否則返回False
        string.isnumeric()        如果string 中只包含數字字符，則返回True，否則返回False
        string.isspace()        如果string 中只包含空格，則返回True，否則返回False.
        string.istitle()        如果string 是標題化的(見title())則返回True，否則返回False
        string.isupper()        如果string 中包含至少一個區分大小寫的字符，并且所有這些(區分大小寫的)字符都是大寫，
                                則返回True，否則返回False
        string.join(seq)         以string 作為分隔符，將seq 中所有的元素(的字符串表示)合并為一個新的字符串
        string.ljust(width)        返回一個原字符串左對齊,并使用空格填充至長度width 的新字符串
        string.lower()            轉換string 中所有大寫字符為小寫.
        string.lstrip()            截掉string 左邊的空格
        string.partition(str)    有點像find()和split()的結合體,從str 出現的第一個位置起,把字符串string
                                分成一個3 元素的元組(string_pre_str,str,string_post_str),如果string 中不包含
                                str 則string_pre_str == string.
        string.replace(str1, str2,num=string.count(str1))
                                把string 中的str1 替換成str2,如果num 指定，則替換不超過num 次.
        string.rfind(str, beg=0,end=len(string))
                                類似于find()函數，不過是從右邊開始查找.
        string.rindex( str, beg=0,end=len(string))
                                類似于index()，不過是從右邊開始.
        string.rjust(width)        返回一個原字符串右對齊,并使用空格填充至長度width 的新字符串
        string.rpartition(str)    類似于partition()函數,不過是從右邊開始查找.
        string.rstrip()         刪除string 字符串末尾的空格.
        string.split(str="", num=string.count(str))
                                以str 為分隔符切片string，如果num有指定值，則僅分隔num 個子字符串
        string.splitlines(num=string.count('\n'))
                                按照行分隔，返回一個包含各行作為元素的列表，如果num 指定則僅切片num 個行.
        string.startswith(obj, beg=0,end=len(string))
                                檢查字符串是否是以obj 開頭，是則返回True，否則返回False。
                                如果beg 和end 指定值，則在指定范圍內檢查
        string.strip([obj])        在string 上執行lstrip()和rstrip()
        string.swapcase()         翻轉string 中的大小寫
        string.title()            返回"標題化"的string,就是說所有單詞都是以大寫開始，其余字母均為小寫(見istitle())
        string.translate(str, del="")
                                根據str 給出的表(包含256 個字符)轉換string 的字符,要過濾掉的字符放到del 參數中
        string.upper()             轉換string 中的小寫字母為大寫
        string.zfill(width)     返回長度為width 的字符串，原字符串string 右對齊，前面填充0
    Unicode
        兼容性問題
            Python在早期的版本中不支持unicode。所以，對于python早期停止更新的模塊，很有可能對unicode支持會有問題
            例如，string模塊已經停止了更新，并且不支持unicode。
            此外，內建函數str()和chr()不支持unicode，應該用unicode()和unichar()代替
        Unicode字符串
            使用unicode字符串時，只要在原來的字符串前面加一個u前綴即可。例如：u"Hello World"
        Unicode數據流
            文件 --> 二進制數據流 --解碼--> unicode字符串對象
            unicode字符串對象 --編碼--> 二進制數據流 --> 文件
        Unicode使用提示
            1. 程序中的字符串前盡量加上u
            2. 不要使用str()函數，使用unicode()代替
            3. 不要使用過時的string模塊
            4. 減少在程序中encode和decode的次數。
            5. pickle模塊不兼容unicode，所以盡量編碼為BLOB字段保存字符信息
        使用中文（回顧）
            1. 配置源文件的編碼格式為utf-8
            2. 在源文件的第一行加上：
                # -*- coding:utf-8 -*-
            3. 確保運行時的環境也為utf-8
            eg : TestChinese.py

列表
    特點：線性表，非常靈活
        1. 元素值可以改變
        2. 可以包含不同類型的元素
        3. 表的長度可以改變
        4. 可以非常方便的進行插入、刪除等操作
    列表的創建
        類似于變量的創建，可以使用方括號和逗號來創建列表并賦值。
        eg.
            aList = [123, 'abc', 4.5, ['inner', 'list'], 7-9j]
            anotherList = [None, 'something else']
            emptyList = []
    列表中元素的訪問
        用[]或者切片。支持多維[]
    更新列表
        列表可變，因此能夠更新
        1. 使用[]并賦值
        2. 對list調用append方法，追加到列表尾部
    刪除列表
        刪除列表中的某個元素
            1. del list[index]
            2. remove(obj)
            eg.
                >>> a = ['abc', 'def','abc','def']
                >>> del a[1]
                >>> print a
                ['abc', 'abc', 'def']
                >>> a.remove('abc')
                >>> print a
                ['abc', 'def']
            說明：remove是刪掉第一個遇到的obj, 如果list中不存在obj，則會拋出異常
    列表操作符
        > , <
        聯接操作符+, += 與extend
            +可以用來聯接兩個列表，例如：a = [1,2]; b=[2,3]; c=a+b
            而extend也可以得到兩個列表的聯接，方法是：a.extend(b)
            不同的是，+實際上創建了一個新列表，并沒有修改原有的兩個操作數a和b
            而extend實際上直接修改了a列表，并沒有創建新列表
            因此，從表現上說，a.extend(b) 類似于 a+=b
            從性能上說，extend要比+更優一點
            注： a + 5會報錯。必須使用a.append(5)來增加元素，或者a + [5]
        重復操作符*
    列表內建函數
        List Method                Operation
        list.append(obj)         向列表中添加一個對象obj
        list.count(obj)         返回一個對象obj 在列表中出現的次數
        list.extend(seq)        把序列seq 的內容添加到列表中
        list.index(obj, i=0,
        j=len(list))             返回list[k] == obj 的k 值,并且k 的范圍在 i<=k<j;否則引發ValueError異常.
        list.insert(index, obj)    在索引量為index 的位置插入對象obj.
        list.pop(index=-1)         刪除并返回指定位置的對象,默認是最后一個對象
        list.remove(obj)        從列表中刪除對象obj
        list.reverse()            原地翻轉列表
        list.sort(func=None,key=None,
        reverse=False)             以指定的方式排序列表中的成員,如果func 和key 參數指定,則按照指定的方式比較
                                各個元素,如果reverse 標志被置為True,則列表以反序排列.
元組(Tuple)
    特點：元組是不可變對象
    創建元組
        eg.
            a = (1,2,3)
            b = 4,5,6  #在沒有歧義的情況下，括號可以省略
            c = (7,)   #創建一個對象的元組時，需要加上括號和逗號
    訪問元組： 使用[]
    元組支持+， *， 比較操作符
    元組的不可變性
        元組的不可變性表現在以下幾個方面：
        1. 元組的長度和大小不能改變
        2. 元組中包含的不可變對象不能改變
        3. 元組中包含的可變對象（引用），可以利用引用改變可變對象的內容，但不能改變引用的指向
        注意，雖然元組不能改變，但是元組變量能夠指向新的元組。即
        a = (1,2,3)
        a = (1,2)
        所以，可以有
        a = (1,2) + (3,4) #reminder : +創建了新元組，但是沒有改變原有元組
    元組使用示例
        a = (1,2,[3,4])
        #! a[0] = 10 Error! 元組包含的不可變對象不能改變
        #! a[2] = [5,6]        元組包含的可變對象，不能改變其指向
        a[2][1] = 6 #元組包含的可變對象可以改變內容
        等效于：
        b = a[2];b[1] = 6

淺拷貝和深拷貝
    1. 對于不可變的非容器類型（數值、字符串。。。），淺拷貝和深拷貝沒有差別
    2. 如果一個元組中僅包含原子類型，則淺拷貝和深拷貝沒有差別
    淺拷貝方式：
        [:] 切片拷貝
        list() 工廠方法拷貝
        copy.copy()
    深拷貝方式：
        copy.deepcopy()