Python中的数据类型常见方法

list() 方法
    1、cmp(list1, list2)：#比较两个列表的元素
    2、len(list)：#列表元素个数
    3、max(list)：#返回列表元素最大值
    4、min(list)：#返回列表元素最小值
    5、list(seq)：#将元组转换为列表
    6、list.append(obj)：#在列表末尾添加新的对象
    7、list.count(obj)： #统计某个元素在列表中出现的次数
    8、list.extend(seq)：#在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）
    9、list.index(obj)： #从列表中找出某个值第一个匹配项的索引位置
    10、list.insert(index, obj)：#将对象插入列表
    11、list.pop(obj=list[-1])： #移除列表中的一个元素（默认最后一个元素），并且返回该元素的值
    12、list.remove(obj)： #移除列表中某个值的第一个匹配项
    13、list.reverse()：   #反向列表中元素
    14、list.sort([func])：#对原列表进行排序

tuple()方法
    1、cmp(tuple1, tuple2)：#比较两个元组元素
    2、len(tuple)：#计算元组元素个数
    3、max(tuple)：#返回元组中元素最大值
    4、min(tuple)：#返回元组中元素最小值
    5、tuple(seq)：#将列表转换为元组
    6、index(obj): #从元组中找出某个值第一个匹配项的索引值
    7、count(obj): #统计某个元素在元组中出现的次数

dict()方法
    1、dict.clear() #删除字典中所有元素
    2、dict.copy()  #返回字典(浅复制)的一个副本
    3、dict.fromkeys(seq,val=None) #创建并返回一个新字典，以seq 中的元素做该字典的键，val做该字典中所有键对应的初始值(如果不提供此值，则默认为None)
    4、dict.get(key,default=None)  #对字典dict中的键key,返回它对应的值value，如果字典中不存在此键，则返回default的值(注意，参数default的默认值为None)
    5、dict.has_key(key)  #如果键(key)在字典中存在，返回True，否则返回False. 在Python2.2版本引入in 和not in 后，此方法几乎已废弃不用了，
　　　　　　　　　　　　　　　　但仍提供一个 可工作的接口
    6、dict.items()   #返回一个包含字典中(键, 值)对元组的列表
    7、dict.keys()    #返回一个包含字典中键的列表
    8、dict.values()  #返回一个包含字典中所有值的列表
    9、dict.iter()    #方法iteritems(),iterkeys(),itervalues()与它们对应的非迭代方法一样，不同的是它们返回一个迭代子，而不是一个列表
    10、dict.pop(key[, default])  #和方法get()相似，如果字典中key键存在，删除并返回dict[key]，如果key键不存在，且没有给出default的值，引发KeyError异常
    11、dict.setdefault(key,default=None) #和方法set()相似，如果字典中不存在key 键，由dict[key]=default为它赋值  

set()方法
    1、add(str) #向集合中添加元素
    2、clear()  #清空集合
    3、copy()   #返回集合的浅拷贝
    4、pop()    #删除并返回任意的集合元素（如果集合为空，会引发 KeyError）
    5、remove(index)  #删除集合中的一个元素（如果元素不存在，会引发 KeyError）
    6、discard(str)   #删除集合中的一个元素（如果元素不存在，则不执行任何操作）
    7、intersection() #将两个集合的交集作为一个新集合返回
    8、union()        #将集合的并集作为一个新集合返回
    9、difference()   #将两个或多个集合的差集作为一个新集合返回
    10、symmetric_difference() #将两个集合的对称差作为一个新集合返回(两个集合合并删除相同部分，其余保留)　
    11、update()      #用自己和另一个的并集来更新这个集合 　
    12、intersection_update()  #用自己和另一个的交集来更新这个集合
    13、isdisjoint() 　#如果两个集合有一个空交集，返回 True
    14、issubset()　   #如果另一个集合包含这个集合，返回 True
    15、issuperset() 　#如果这个集合包含另一个集合，返回 True
    16、difference_update() #从这个集合中删除另一个集合的所有元素
    17、symmetric_difference_update() #用自己和另一个的对称差来更新这个集合

operator模块
    在Python3.4以上版本才可以使用
    Python官方文档地址：https://docs.python.org/3.6/library/operator.html?highlight=operator

    import operator

    Operation(操作)                        Syntax(语法)              Function(功能)
    Addition(加法)                         a + b                    add(a, b)
    Concatenation(连接)                    seq1 + seq2              concat(seq1, seq2)
    Containment Test(包含测试)          　　obj in seq               contains(seq, obj)
    Division(除法)               　　　　   a / b                    truediv(a, b)
    Division(整除)               　　　　   a // b                   floordiv(a, b)
    Bitwise And(按位与)               　　　a & b                    and_(a, b)
    Bitwise Exclusive Or(按位异或)   　　   a ^ b                    xor(a, b)
    Bitwise Inversion(按位取反)            ~ a                      invert(a)
    Bitwise Or(按位或)                     a | b                    or_(a, b)
    Exponentiation(求幂)            　　   a ** b                   pow(a, b)
    Identity(身份测试)                     a is b                   is_(a, b)
    Identity(身份测试)                     a is not b               is_not(a, b)
    Indexed Assignment(索引分配)           obj[k] = v               setitem(obj, k, v)
    Indexed Deletion(索引删除)             del obj[k]               delitem(obj, k)
    Indexing(得出索引键值)        　　      obj[k]                   getitem(obj, k)
    Left Shift(左移)                      a << b                   lshift(a, b)
    Modulo(求模)                          a % b                    mod(a, b)
    Multiplication(乘法)                  a * b                    mul(a, b)
    Matrix Multiplication(矩阵乘法)        a @ b                    matmul(a, b)
    Negation (Arithmetic)(求负值数学)      - a                      neg(a)
    Negation (Logical)(求负值逻辑)         not a                    not_(a)
    Positive(求正值)                      + a                      pos(a)
    Right Shift(右移)            　　　　  a >> b                   rshift(a, b)
    Slice Assignment(片段分配)            seq[i:j] = values        setitem(seq, slice(i, j), values)
    Slice Deletion(片段删除)              del seq[i:j]             delitem(seq, slice(i, j))
    Slicing(得到片段)                     seq[i:j]                 getitem(seq, slice(i, j))
    String Formatting(字符串的格式化)　　 　s % obj                  mod(s, obj)
    Subtraction(减法)               　　  a - b                    sub(a, b)
    Truth Test(真值测试)      　　　　　　  obj                      truth(obj)
    Ordering(排序)                       a < b                    lt(a, b)
    Ordering(排序)                       a <= b                   le(a, b)
    Equality(相等)                       a == b                   eq(a, b)
    Difference(不等)                     a != b                   ne(a, b)
    Ordering(排序)                       a >= b                   ge(a, b)
    Ordering(排序)                       a > b                    gt(a, b)

str()方法
    1、去空格及特殊符号
        str.strip().lstrip().rstrip() 

    2、查找字符
        Str1 = 'strchra'
        Str2 = 'a'
        ret = Str1.index(Str2)
        print(ret)
        结果为：6

    3、扫描字符串是否包含指定的字符
        Str1 = '12345678'
        Str2 = '45678'
        print len(Str1 and Str2)
        结果为：5

    4、字符串长度
        sStr1 = 'strlen'
        print len(sStr1)

    5、将字符串中的大小写转换
        str.lower() #小写
        str.upper() #大写
        str.swapcase()   #大小写互换
        str.capitalize() #首字母大写
        String.capwords(S) #这是模块中的方法。它把S用split()函数分开，然后用capitalize()把首字母变成大写，最后用join()合并到一起
        str = ' s23567 qweasd234 a'
        from string import capwords
        print(len(str))
        print(capwords(str))
        print(len(capwords(str)))
        结果为： 　19
           　　   S23567 Qweasd234 A
     　　　　　　  18

    6、追加指定长度的字符串
        str1 = '12345'
        str2 = 'abcdef'
        str1 += str2[0:4]
        print(str1)
        结果为：12345abcd

    7、字符串指定长度比较
        #strncmp(sStr1,sStr2,n)
        sStr1 = '12345'
        sStr2 = '123bc'
        n = 3
        print cmp(sStr1[0:n],sStr2[0:n])

    8、复制指定长度的字符
        str1 = ''
        str2 = '12345'
        str1 = str2[0:8]
        print(str1)
        结果为：12345

    9、将字符串前n个字符替换为指定的字符
        str1 = '12345asfg'
        ch = 'r'
        str1 = 6 * ch + str1[3:]
        print(str1)

    10、扫描字符串
        str1 = 'ce11a1kjgdklab'
        str2 = 'gka'
        nPos = -1
        for c in str1:
            if c in str2:
                print(c)
                ret = str1.index(c)
                break
        print(ret)    

    11、翻转字符串
            str = 'abcdefg'
        1)切片翻转
          str1 = str[::-1]
          print(str1)
        2)先转为list，利用list的reverse，在join再转为字符串
          l = list(str)
          # print(l)
          l.reverse()
          result = "".join(l)
          print(result)
        3)使用reduce
          from functools import reduce
          result1 = reduce(lambda x,y:y+x,str)
          print(result1)
        4)模拟入栈和出栈
          str = 'abcdefg'
          def func(s):
             l = list(s) #模拟全部入栈
             result = ""
             while len(l)>0:
                 result += l.pop() #模拟出栈
              return result
          result = func(str)
          print(result) 

        5)使用for循环
          def func(s):
            result = ""
            max_index = len(s)-1
            for index,value in enumerate(s):
                print(index,value)
                result += s[max_index-index]
            return result
         result = func(str)
         print(result)
        6)使用递归函数
          def func(s):
              if len(s) < 1:
                  return s
              return func(s[1:])+s[0]
          result = func(str)
          print(result)

    12、查找字符串
        # 使用find函数只返回第一个匹配到的值，否则返回-1
        1)str1 = 'abcdefg'
          str2 = 'cde'
          print str1.find(str2)
          结果为：2
        2)str1 = 'abcdef123'
          s = 8
          print(ret1.find(s))
          结果为：-1

    13、分割字符串
        str1 = 'ab,cde,fgh,ijk'
        str2 = ','
        str1 = str1[str1.find(str2) + 1:]
        print str1
        结果为：cde,fgh,ijk

    14、连接字符串
        str = ''
        mylist = ['B', 'A', 'C', 'FF','2313']
        print(str.join(mylist))
        结果为：BACFF2313    

    15、截取字符串
        格式:   str[begin:end:step]
                str,字符串
                begin,起始位置
                end,结束位置
                step,间隔.s不等于0.默认为1
                注:
                    区间为左闭右开.
                    step>0,表示从左往右.
                    step<0,表示从右往左

       　　 aa = '01231456789'
       　　 print (aa[:])   #截取字符串的全部字符
       　　 print (aa[6:])  #截取第七个字符到结尾
        　　print (aa[0:3]) #截取第一位到第三位的字符
        　　print (aa[:-3]) #截取从头开始到倒数第三个字符之前
        　　print (aa[2])   #截取第三个字符
       　　 print (aa[::-1])  #创造一个与原字符串顺序相反的字符串
       　　 print (aa[-3:-1]) #截取倒数第三位与倒数第一位之前的字符
        　　print (aa[-3:])   #截取倒数第三位到结尾
       　　 print(aa[:-5:-3]) #逆序截取，
       　　 print(aa[:-3:-1]) #逆序截取，
       　　 print(aa[:-4:-2]) #逆序截取，
       　　     结果依次为：
         　　       96
        　　        98
         　　       97
        print(aa[-1:])

    16、字符串在输出时的对齐
        S.ljust(width,[fillchar])
        # 输出width个字符，S左对齐，不足部分用fillchar填充，默认的为空格。
        S.rjust(width,[fillchar]) #右对齐
        S.center(width, [fillchar]) #中间对齐
        S.zfill(width) #把S变成width长，并在右对齐，不足部分用0补足    

    17、字符串中的搜索和替换
        S.find(substr, [start, [end]])
        # 返回S中出现substr的第一个字母的标号，如果S中没有substr则返回-1。
        start和end作用就相当于在S[start:end]中搜索
        S.index(substr, [start, [end]])
        # 与find()相同，只是在S中没有substr时，会返回一个运行时错误
        S.rfind(substr, [start, [end]])
        # 返回S中最后出现的substr的第一个字母的标号，如果S中没有substr则返回-1，也就是说从右边算起的第一次出现的substr的首字母标号
        S.rindex(substr, [start, [end]])
        S.count(substr, [start, [end]]) #计算substr在S中出现的次数
        S.replace(oldstr, newstr, [count])
        # 把S中的oldstar替换为newstr，count为替换次数。这是替换的通用形式，还有一些函数进行特殊字符的替换
        S.strip([chars])
        # 把S中前后chars中有的字符全部去掉，可以理解为把S前后chars替换为None
        S.lstrip([chars])
        S.rstrip([chars])
        S.expandtabs([tabsize])
        # 把S中的tab字符替换没空格，每个tab替换为tabsize个空格，默认是8个

    18、字符串的分割和组合
        S.split([sep, [maxsplit]])
        # 以sep为分隔符，把S分成一个list。maxsplit表示分割的次数。默认的分割符为空白字符
        S.rsplit([sep, [maxsplit]])
        S.splitlines([keepends])
        # 把S按照行分割符分为一个list，keepends是一个bool值，如果为真每行后而会保留行分割符。
        S.join(seq) #把seq代表的序列──字符串序列，用S连接起来

    29、字符串的mapping，这一功能包含两个函数
        String.maketrans(from, to)
        # 返回一个256个字符组成的翻译表，其中from中的字符被一一对应地转换成to，所以from和to必须是等长的。
        S.translate(table[,deletechars])
        # 使用上面的函数产后的翻译表，把S进行翻译，并把deletechars中有的字符删掉。需要注意的是，如果S为unicode字符串，那么就不支持deletechars参数，
　　　　　　可以使用把某个字符翻译为None的方式实现相同的功能。此外还可以使用codecs模块的功能来创建更加功能强大的翻译表。

    20、字符串还有一对编码和解码的函数
        S.encode([encoding,[errors]])
        # 其中encoding可以有多种值，比如gb2312 gbk gb18030 bz2 zlib big5 bzse64等都支持。errors默认值为"strict"，意思是UnicodeError。
　　　　　　可能的值还有'ignore', 'replace','xmlcharrefreplace','backslashreplace'和所有的通过codecs.register_error注册的值。
　　　　　　这一部分内容涉及codecs模块，不是特明白
        S.decode([encoding,[errors]])    

    21、字符串的测试、判断函数，这一类函数在string模块中没有，这些函数返回的都是bool值
        S.startswith(prefix[,start[,end]]) #是否以prefix开头
        S.endswith(suffix[,start[,end]])   #以suffix结尾
        S.isalnum() #是否全是字母和数字，并至少有一个字符
        S.isalpha() #是否全是字母，并至少有一个字符
        S.isdigit() #是否全是数字，并至少有一个字符
        S.isspace() #是否全是空白字符，并至少有一个字符
        S.islower() #S中的字母是否全是小写
        S.isupper() #S中的字母是否便是大写
        S.istitle() #S是否是首字母大写的    

    22、字符串类型转换函数，这几个函数只在string模块中有
        string.atoi(s[,base])
        #base默认为10，如果为0,那么s就可以是012或0x23这种形式的字符串，如果是16那么s就只能是0x23或0X12这种形式的字符串
        string.atol(s[,base]) #转成long
        string.atof(s[,base]) #转成float