python数据结构字符串

+ ->str   返回一个新的字符串
q+b
join连接，可以自定义连接符
string.join(iterable)-->str返回一个新的字符串
lst=['1','2','3']
print('/'.join(lst))   以/分割
打印结果‘1/2/3’

split系：从左自右，将字符串按照分隔符分割成若干字符串，并返回列表
    
    split(sep=None,maxsplit=-1)--->list of string，返回新的字符串列表
    sep字符分隔符，缺省的情况下空白字符做完分隔符
    maxsplit指定分割的次数，-1表示比那里整个字符串
    列如：
    s1="i,m \ta super studengt."
    s1.split()  #使用默认的
    打印结果：['i,m', 'a', 'super', 'studengt.']

rsplit：从右自左遍历，将字符串按照分隔符分割成若干字符串，并返回列表
    split(sep=None,maxsplit=-1)--->list of string，返回新的字符串列表
    从右自左遍历，但是返回的列表顺序还是正常的不会变换排序适合找路径的文件名
    切割后最后一个就是文件名
    sep字符分隔符，缺省的情况下空白字符做完分隔符
    maxsplit指定分割的次数，-1表示比那里整个字符串
    列如：
    s1="i,m \ta super studengt."
    s1.rsplit()  #使用默认的 
    打印结果：['i,m', 'a', 'super', 'studengt.']

splitlines: 按照行来切分字符串
    splitlines([keepends]) --> list of strings 返回新的字符串列表
    按照行来切分字符串
    keepends指的是是否保留行分隔符
    行分隔符包括\n  \r\n    \r等
    列如：
    'ab c\n\nde fg\rkl\r\n'.splitlines()
    'ab c\n\nde fg\rkl\r\n'.splitlines(True)
    s1 ='''I'm a super student'''
    print(s1)
    print(s1.splitlines())
    print(s1.splitlines(True))
  
partition系： 将字符串按照分隔符分割成2段，返回这2段和分隔符的元组

    partition(sep) --->(heade,sep,tail)
    从左至右，遇到分隔符就不字符串分割成两部分，返回头部、分隔符、尾部的分的三元组
    如果没有找到分割符，就返回头部（返回整个字符串）、2个空元素的三元组
    sep 分隔符，必须指定
    列如：
    s1 = '''I'm a super student'''
    s1.partition('s')
    s1.partition('stu')
    s1.partition('')
    s1.partition('abc')
    
    rpartition(sep) --->(heade,sep,tail)
    从右至左，遇到分隔符就不字符串分割成两部分，返回头部、分隔符、尾部的分的三元组
    如果没有找到分割符，就返回头部（返回整个字符串）、2个空元素的三元组
    sep 分隔符，必须指定

字符串大小写：常用于统一大小写，大小写做判断用
    upper()    #全部大写
    lower（）  #全部小写
    swapcase（） #交互大小写（大小便小写，小写变大写）

title() -->str   #标题的每个单词都大写
    列如：
    s = 'as  sa   s'
    print(s.title())
    结果为: 'As Sa S'
        
capitalize()   --->str #首个单词大写
    列如：
    s = 'as  sa   s'
    print(s.capitalize())
    结果为: 'As sa s'
 
填充的字符数都是以0开始计算，左开又必区间[0,n)       
    center(width[,fillchar])  -->str #居中打印，
        width：打印宽度     fillchar 填充的字符串，不指定默认空格
        列如：
        s = 'a'
        print(s.center(5,'#'))
        结果为: '##a##'
        
    zfill(width) -->str    #width 打印宽度，居右打印，以0填充
        列如：
        s = 'a'
        print(s.zfill(5))
        结果为: '0000a'
    ljust（width[,fillchar]）  --> str左对齐不指定字符串默认空格填充
        列如：
        s = 'a'
        print(s.ljust(5,'#'))
        结果为: 'a####'
    rjust（width[,fillchar]）  --> str右对齐不指定字符串默认空格填充
        列如：
        s = 'a'
        print(s.rjust(5,'#'))
        结果为: '####a'

#字符串修改1，替换，返回新的字符串
replace(old,new[,count]) -->str   #字符串修改1，替换，返回新的字符串
    字符串中找到匹配的替换为新字符串，返回新字符串
    count表示替换几次，不指定就是全部替换
    列如：
    a = 'ppp.www.com'
    print(a.replace('p','a',2))
    结果为：aap.www.com
    
#字符串修改2，去处，返回新的字符串
strip([chars])  --> str
    从字符串两端去除知道的字符集chars中的所有字符
    默认不指定chars，则去除两端的空白字符
    列如：
    s = '\r\n\t hello python \n \t'
    print(s.strip())
    结果为：'hello python'
     s = 'hello python'
    print(s.strip('he'))
    结果为：'elo python'
lstrip([chars])  --> str   从字符串左端去除，用法同上
rstrip([chars])  --> str  从字符串右端去除，用法同上

字符串查找方法一，常用，方便判断
    find(sub[,start[,end)])  -->int
        在知道区间[start,end),从左至右，查找字符串sub。找到返回索引，没找到返回-1
    rfind(sub[,start[,end)])  -->int
        在知道区间[start,end),从右至左，查找字符串sub。找到返回索引，没找到返回-1
    列如：
    a = 'veryveryaaaa'
    print(a.find('aa',1,3))
    结果为返回索引：-1     #在指定区间找不到aa
    a = 'veryveryaaaa'
    print(a.find('aa',1,12))
    结果为返回索引：8        #找到aa
    rfind   用法一样，只是从右往左找
    
字符串查找方法二，不常用，可以用来调试
    index(sub[,start[,end)])  -->int
        在知道区间[start,end),从左至右，查找字符串sub。找到返回索引，没找到抛出VaueError异常程序终止
    rindex(sub[,start[,end)])  -->int
        在知道区间[start,end),从右至左，查找字符串sub。找到返回索引，没找到没找到抛出VaueError异常程序终止
    列如：
    a = 'veryveryaaaa'
    print(a.index('aa',1,3))
    结果:抛出VaueError异常程序终止     #在指定区间找不到aa
    a = 'veryveryaaaa'
    print(a.index('aa',1,12))
    结果为返回索引：8        #找到aa
    rindex   用法一样，只是从右往左找

count(sub[,start[,end)])  -->int
    在知道区间[start,end],从左至右，统计字符串sub出现的次数，结果返回整型次数数字
    a = 'veryveryaaaa'
    print(a.count('aa',1,12))
    结果为：2
index与count方法的时间复杂度都是O(n)，随着列表规模数据的加大而效率下降
len(string)   #返回字符串的长度，即字符串的个数

endswith(suffix[,start[,end]])   --> bool  判断是否已某个字符结尾结果返回bool类型
    在指定的区间[start,end）,字符串是否是suffix结尾
    列如：
    a ='aaa ssss'
    print(a.endswith('aaa',0,10))
    结果为：False
       
startswith(suffix[,start[,end]])   --> bool  判断是否已某个字符开始结果返回bool类型
    在指定的区间[start,end）,字符串是否是suffix开始
    列如：
    a ='aaa ssss'
    print(a.startswith('aaa',0,10))
    结果为：True

isalnum()  --> bool 是否是字母和数字组成
isalpha()  --> 是否是字母
isdecimal()  --> 是否只包含十进制数字
isdigit()   --> 是否全部数字（0---9）
isidentifier()  是不是字母和下划线开头，其他都是字母、数字、下划线
islower()    是否全部小写
isupper()   是否全部大写
isspace()  是否只包含空白字符

字符串的格式化是一种拼接字符串输出样式的手段，更灵活方便
    join:拼接只能使用分隔符,且要求被拼接的是可迭代对象
    +   :拼接字符串方便，但是非字符串需要先转换为字符串才能拼接
    最常用的两种字符串格式化方式：
    1.C风格字符串格式化方式
        在2.5版本以前只能使用这种方式的格式化print输出
        格式要求：
        占位符：使用%和格式字符组成，列如 %s 、%d等
            s调用str（）、r会调用repr（）,所有对象都可以被这两个转换
        占位符中还可以插入修饰字符，列如%03d表示打印3个位置，不够前面补零
        format % values，格式字符串和被格式的值之间使用%分割
        values只能是一个对象，或者是一个合格式字符串占位符数目相等的元组，或是一个字典
        列如：
        print('I am %03d'%(20,))
        输出结果：'I am 020'
        print('I like %s' %'Python')
        输出结果：'I like Python'
        print('I am %-5d'%(20))
        输出结果：'I am  20'
        print('%3.2f%%,0x%x,0X%02X'%(89.7654,10,15))
        输出结果：'89.77%,0xa,0x0F'
    2.Python format（）函数风格字符串格式化方式推荐使用该方式
        format函数格式字符串语法-------Python鼓励使用
            '{} {xxx}'.format(*args,**kwargs)  --> str
            args是位置参数，是一个元组
            kwargs是关键字参数，是一个字典
            花括号表示占位符
            {}表示安装顺序匹配位置参数，{n}表示去位置参数索引值为n的值
            {xxx}表示在关键字参数中搜索名称一致的
            {{}}表示打印花括号
            使用format格式化对齐
               print('{0}*{1}={2:<2}'.format(3,2,2*3))   #左对齐
               输出为：2*3=6
               print('{0}*{1}={2:<02}'.format(3,2,2*3))  #左对齐以0填充
               输出为：2*3=60
               print('{0}*{1}={2:>02}'.format(3,2,2*3)) #右对齐以0填充
               输出为：2*3=06
               print('{:^30}'.format('centered'))   #居中默认空格填充
               输出为：'     centered        '
               print('{:*^30}'.format('centered'))
                输出为：'************centered************'  #居中*号填充
            使用format格式进制转换
                print('int:{0:d},hex:{0:x},oct:{0:o},bin:{0:b}'.format(42))
                输出为：int:42,hex:2a,oct:52,bin:101010
                print('int:{0:d},hex:{0:#x},oct:{0:#o},bin:{0:#b}'.format(42))
                输出为：int:42,hex:0x2a,oct:0o52,bin:0b101010
                octets = [192，168，0，1]
                print('{:02x}.{:02x}.{:02x}.{:02x}'.format(*octets))   #转换为十六进制
                输出为：c0.a8.00.01