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