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()