精华内容
下载资源
问答
  • python3在指定字符串中找到子字符串的全部位置 def indexstr(str1,str2): '''查找指定字符串str1包含指定子字符串str2的全部位置, 以列表形式返回''' lenth2=len(str2) lenth1=len(str1) indexstr2=[] i=0 #...

    python3在指定字符串中找到子字符串的全部位置

    def indexstr(str1,str2):
        '''查找指定字符串str1包含指定子字符串str2的全部位置,
        以列表形式返回'''
        lenth2=len(str2)
        lenth1=len(str1)
        indexstr2=[]
        i=0
        while str2 in str1[i:]:
            indextmp = str1.index(str2, i, lenth1)
            indexstr2.append(indextmp)
            i = (indextmp + lenth2)
        return indexstr2
    
    if __name__ == '__main__':
        print()
        print(indexstr('aabceeabcddabcdabc','abc'))
    

    输出为:
    [1,6,11,15]

    Process finished with exit code 0

    展开全文
  • #find()、rfind()、index()、rindex()、count() s = "apple,peach,banana,peach,pear" #返回peach第一次出现的位置 s.find("peach") #从字符串尾部向前查找,返回第一次出现的...#在指定范围里查找,如果找到...
    #find()、rfind()、index()、rindex()、count()
    s = "apple,peach,banana,peach,pear"
    #返回peach第一次出现的位置
    s.find("peach")
    #从字符串尾部向前查找,返回第一次出现的位置
    s.rfind("p")
    #指定起始位置开始查找
    s.find("peach",6)
    #在指定范围里查找,如果找到了就返回出现的位置,若没找到,返回-1
    s.find("peach",6,20)
    
    #返回一个字符串在另一个字符串里面首次出现的位置
    s.index("peach")
    #返回一个字符串在另一个字符串里面最后一次出现的位置
    s.rindex("peach")
    
    #返回一个字符串在另一个字符串中出现的次数
    s.count("p")
    
    
    
    #split()、rsplit()、partition()、rpartition()
    str = "apple,peach,banana,pear"
    #从左往右或者从右往左按照指定的分隔符分割,返回列表,输出结果一样
    str.split(',')
    str.rsplit(',')
    ['apple','peach','banana','pear']
    #从左往右或者从右往左以指定的第一次出现的分隔符分割将字符串分割成三部分,分隔符前的字符串、分隔字符串、分隔符后的字符串,如果指定的分隔符不存在,则返回园字符串和两个空字符串
    str.partition('banana')
    ['apple,peach,','banana',pear']
    str.rpartition('banana')
    ['apple,peach,','banana',',pear']
    
    
    s = '\n\nhello\t\t world \n\n\n My name is Dong    '
    #指定最大分割次数,不指定分隔符,则任何空白符(包括空格、换行符、制表符等)都是分隔符
    s.split(None,1)
    ['hello','world \n\n\n My name is Dong    ']
    s.rsplit(None,1)
    ['\n\nhello\t\t world \n\n\n My name is','Dong']
    s.split(None,2)
    ['hello','world','My name is Dong    ']
    s.rsplit(None,2)
    [\n\nhello\t\t world \n\n\n My name','is','Dong']
    #最大分割次数如果大于可分割次数时无效,即全部分割
    s.split(maxsplit=6)
    ['hello','world','My','name','is','Dong']
    
    
    
    #字符串连接方法,不推荐使用+来连接,优先使用join()方法
    li = ['apple','peach','banana','pear']
    ','.join(li)
    'apple,peach,banana,pear'
    '-'.join(li)
    'apple-peach-banana-pear'
    
    
    #maketrans()用来生成字符映射表
    #translate()用来根据字符映射表中定义的对应关系转换字符串并替换其中的字符
    table = str.maketrans('abcdef','123456')
    s = 'python is a great programming language.'
    print(s.translate(table))
    'python is 1 gr51t progr1mming l1ngu1g5.'
    #注意,此时s的值并没有改变
    
    
    
    import string
    #小写字母
    lower = string.ascii_lowercase
    #大写字母
    upper = string.ascii_uppercase
    #所有字母
    letters =  string.ascii_letters
    #数字字符
    print(string.digits)
    #标点符号
    print(string.punctuation)
    
    
    #strip()、rstrip()、lstrip()
    #删除字符串两边的空白字符串,包括换行、空格、制表符
    '    abc        '.strip()#输出'abc'
    '\n\n hello word\t \t'.strip()#输出'hello word'
    #删除指定字符
    'aaaassssssssddf'.strip('a')#输出'ssssssssddf'
    'aaaassssssssddf'.strip('af')#输出'ssssssssdd'
    #删除字符串有段指定字符
    'aaaassssssssddfaaaaaa'.rstrip('a')#输出'ssssssssddfaaaaaa'
    #删除字符串左边指定字符
    'aaaassssssssddfaaaaaa'.lstrip('a')#输出''aaaassssssssddf'
    #字符串不在两侧,所以不删除
    'aaaasssssffffsssddfaaaaaa'.lstrip('af'),#输出'sssssffffsssdd'
    
    
    
    
    #replace(),代替目标字符
    '中国,中国'.replace('中国','中华人民共和国')#输出['中华人民共和国','中华人民共和国']
    #max(),最大字符
    max("hello world")#输出'w'
    #min(),最小字符
    min("hello world")#输出' ',最小字符是空格
    #zip(),打包
    list(zip('hello world','hello world'))#输出[('h', 'h'), ('e', 'e'), ('l', 'l'), ('l', 'l'), ('o', 'o'), (' ', ' '), ('w', 'w'), ('o', 'o'), ('r', 'r'), ('l', 'l'), ('d', 'd')]
    #由于zip()打包后的类型是“包”,所以直接输出不了,必须转换成list才能输出

     

    转载于:https://www.cnblogs.com/BASE64/p/11011782.html

    展开全文
  • 返回子串所在位置的最左端索引,如果没有找到则返回-1.如果指定 beg(开始) 和 end(结束) 范围,则检查是否包含在指定范围内,如果包含子字符串返回开始的索引值,否则返回-1。用法:string.find()实例:a = ' i ...

    本文实例讲述了python常见字符串处理函数与用法。分享给大家供大家参考,具体如下:

    1、find

    作用:在一个较长字符串中查找子串。返回子串所在位置的最左端索引,如果没有找到则返回-1.如果指定 beg(开始) 和 end(结束) 范围,则检查是否包含在指定范围内,如果包含子字符串返回开始的索引值,否则返回-1。

    用法:string.find()

    实例:

    a = ' i am a boy with no money '

    print a.find('a')

    输出结果:

    5

    print a.find('a',10,len(a))

    输出结果:

    -1

    2、join

    作用:Python中有join()和os.path.join()两个函数,具体作用如下:

    1) join(): 连接字符串数组。将字符串、元组、列表中的元素以指定的字符(分隔符)连接生成一个新的字符串

    2)os.path.join(): 将多个路径组合后返回

    用法:

    'sep'.join(seq)

    sep:分隔符。可以为空

    seq:要连接的元素序列、字符串、元组、字典

    上面的语法即:以sep作为分隔符,将seq所有的元素合并成一个新的字符串

    返回值:返回一个以分隔符sep连接各个元素后生成的字符串

    实例:

    seq = ['1','2','3','4','5']

    sep = '+'

    print sep.join(seq)

    输出:

    1+2+3+4+5

    dirs = '','usr','bin','env'

    print '/'.join(dirs)

    输出:

    /usr/bin/env

    print os.path.join('/hello/','good/boy/','doiido')

    输出:

    /hello/good/boy/doiido

    3、replace

    作用:Python replace() 方法把字符串中的 old(旧字符串) 替换成 new(新字符串),如果指定第三个参数max,则替换不超过 max 次。

    语法:str.replace(old, new[, max])

    参数:

    old �C 将被替换的子字符串。

    new �C 新字符串,用于替换old子字符串。

    max �C 可选字符串, 替换不超过 max 次

    实例:

    str = "this is string example....wow!!! this is really string";

    print str.replace("is", "was");

    print str.replace("is", "was", 3);

    输出:

    thwas was string example....wow!!! thwas was really string

    thwas was string example....wow!!! thwas is really string

    4、split函数

    描述

    Python split()通过指定分隔符对字符串进行切片,如果参数num 有指定值,则仅分隔 num 个子字符串

    语法

    split()方法语法:

    str.split(str="", num=string.count(str)).

    参数

    str �C 分隔符,默认为所有的空字符,包括空格、换行( )、制表符( )等。

    num �C 分割次数。

    返回值

    返回分割后的字符串列表。

    实例

    以下实例展示了split()函数的使用方法:

    实例:

    str = "Line1-abcdef Line2-abc Line4-abcd";

    print str.split( );

    print str.split(' ', 1 );

    以上实例输出结果如下:

    ['Line1-abcdef', 'Line2-abc', 'Line4-abcd']

    ['Line1-abcdef', ' Line2-abc Line4-abcd']

    希望本文所述对大家Python程序设计有所帮助。

    展开全文
  • Python3字符串方法

    2017-11-27 15:43:00
    Python字符串方法图示: 1、index() 重点 定义:查找并返回指定str的索引位置,如果没找到则会抛异常(查找的...例1:不指定范围默认是从左至右的顺序查询指定字符串“i”的索引位置 s = 'dark knigh...

    Python字符串方法图示:

     

    1、index()  重点

    定义:查找并返回指定str的索引位置,如果没找到则会抛异常(查找的顺序是从左至右)可以指定范围:开始位置和结束位置进行查找。

    格式:“字符串内容”.index('指定的字符串',指定范围)

     

     

    例1:不指定范围默认是从左至右的顺序查询指定字符串“i”的索引位置

    s = 'dark knight'
    s1 = s.index('i')
    print(s1)
    

     输出结果:

    7

    图示:

     

     

     

     

     

    例2:查找一串字符串时,返回这个被查找字符串的首个字符的索引位置

    s = 'dark knight'
    s1 = s.index('knight')
    # 查找一串字符串时,返回这个被查找字符串的首个字符的索引位置
    print(s1)
    

     输出结果:

    5

    图示:

     

     

     

     

     

     例3:查找并返回指定范围字符“k”的索引位置,查找方向以从左至右的顺序查找,且指定的范围顾首不顾尾

    s = 'dark knight'
    s1 = s.index('k',4,10)  
    # 表示从索引4到9的位置进行查找,顾首不顾尾
    # 如果有多个“k”字符串时则返回第一个“k”的索引位置
    print(s1)
    

    输出结果:

    5

    图示:

     

     

     

     

     

    例4:若未找到字符串则会抛出异常

    s = 'dark knight'
    s1 = s.index('x')  # 若未找到字符串则会抛出异常
    print(s1)
    

     输出结果:

    ValueError: substring not found

    图示:

     

     

     

     

     

     

     

     

     

     

    2、rindex()

    定义:查找并返回指定str的索引位置,如果没找到则会抛异常(查找的顺序是从右至左)可以指定范围:开始位置和结束位置进行查找

    格式:"字符串内容".rindex('指定的字符串',指定范围)

     

     

    例1:不指定范围默认是从右至左的顺序查询指定字符串的索引位置

    s = 'dark knight'
    s1 = s.rindex('k')
    # 不指定范围默认是从右至左的顺序查询指定字符串的索引位置
    print(s1) 

    输出结果:

    5

    图示:

     

     

     

     

     

    例2:若未找到字符串则会抛出异常

    s = 'dark knight'
    s1 = s.rindex('x') # 若未找到字符串则会抛出异常
    print(s1)

    输出结果:

    ValueError: substring not found

    图示:

     

     

     

     

     

    例3:查找并返回指定范围字符“k”的索引位置,查找方向在从右至左的顺序查找,且指定的范围顾首不顾尾

    s = 'dark knight'
    s1 = s.rindex('k',2,11) 
    # 表示从索引位置2到10的位置进行查找,顾首不顾尾
    # 如果有多个“k”字符串时则返回第一个“k”的索引位置
    print(s1)

    输出结果:

    5

    图示:

     

     

     

     

     

     

     

     

     

     

    3、find()  重点

    定义:查找并返回指定str的索引位置,如果没找到则返回:-1(查找的顺序是从左至右)可以指定范围:开始位置和结束位置进行查找

    格式:"字符串内容".find('指定的字符串',指定范围)

     

     

    例1:不指定范围默认是从左至右的顺序查询指定字符串“i”的索引位置

    s = 'dark knight'
    s1 = s.find('i')
    print(s1)

    输出结果:

    7

    图示:

     

     

     

     

     

    例2:查找一串字符串时,返回这个被查找字符串的首个字符的索引位置

    s = 'dark knight'
    s1 = s.find('dark')
    # 查找一串字符串时,返回这个被查找字符串的首个字符的索引位置
    print(s1)
    

     输出结果:

    0

    图示:

     

     

     

     

     

    例3:查找并返回指定范围字符“k”的索引位置,查找方向以从左至右的顺序查找,且指定的范围顾首不顾尾

    s = 'dark knight'
    s1 = s.find('k',3,13)
    # 查找并返回指定范围3到12之间的字符“k”的索引位置,从左至右的顺序查找,且指定的范围顾首不顾尾
    # 如果有多个“k”字符串时则返回第一个“k”的索引位置 print(s1)

    输出结果:

    3

    图示:

     

     

     

     

     

    例4:若未找到字符串则返回-1

    s = 'dark knight'
    s1 = s.find('x') # 没有找到字符串"x"时返回:-1
    print(s1)

    输出结果:

    -1

    图示:

     

     

     

     

     

     

     

     

     

     

    4、rfind()

    定义:查找并返回指定str的索引位置,如果没找到则返回:-1(查找的顺序是从右至左)可以指定范围:开始位置和结束位置进行查找

    格式:"字符串内容".rfind('指定的字符串',指定范围)

     

     

    例1:不指定范围默认是从右至左的顺序查询指定字符串的索引位置

    s = 'dark knight'
    s1 = s.rfind('k') # 从右至左的顺序查找并返回字符串'k'的索引位置
    print(s1)  

    输出结果:

    5

    图示:

     

     

     

     

     

    例2:查找并返回指定范围字符“k”的索引位置,查找方向在从右至左的顺序查找,且指定的范围顾首不顾尾

    s = 'dark knight'
    s1 = s.rfind('k',3,13)
    # 查找并返回指定范围3到12之间的字符“k”的索引位置,从右至左的顺序查找,且指定的范围顾首不顾尾
    # 如果有多个“k”字符串时则返回第一个“k”的索引位置
    print(s1)

    输出结果:

    5

    图示:

     

     

     

     

     

    例3:若未找到字符串则返回-1

    s = 'dark knight'
    s1 = s.rfind('x')
    print(s1)

    输出结果:

    -1

    图示:

     

     

     

     

     

     

     

     

     

     

     

    5、count()  重点

    定义:统计指定的str在字符串中出现的次数并返回这个数若没找到返回:0,可以指定范围:开始位置和结束位置进行统计

    格式:"字符串内容".count('指定的字符串',指定范围)

     

     

    例1:统计指定字符串“k”在字符串中出现的次数并返回这个数

    s = 'dark knight'
    s1 = s.count('k') # 得到字符串“k”的个数
    print(s1)

    输出结果:

    2

    图示:

     

     

     

     

     

    例2:统计指定范围内的字符串“k”的个数,且顾首不顾尾

    s = 'dark knight'
    s1 = s.count('k',5,13) # 统计5到12之间的字符串“k”的个数,顾首不顾尾
    print(s1)

    输出结果:

    1

    图示:

     

     

     

     

     

     

     

     

     

     

    6、strip()  重点 

    定义:移除字符串左右两侧指定的字符,并返回移除指定字符串后的字符串,括号内不指定字符串默认移除空格。

    格式:"字符串内容".strip(‘指定字符串’)

     

     

    例1:移除字符串左右两侧的空格

    s = '      dark knight    '
    s1 = s.strip() # 移除字符串左右两侧的空格
    print(s1)

    输出结果:

    dark knight

    图示:

     

     

     

     

     

     

    例2:移除字符串左右两侧的指定字符串

    s = '****dark knight**************'
    s1 = s.strip('*') # 移除字符串左右两侧的字符串“*”
    print(s1)

    输出结果:

    dark knight

    图示:

     

     

     

     

     

     

     

     

     

     

    7、lstrtip()

    定义:移除字符串左侧指定的字符,并返回移除指定字符串后的字符串,括号内不指定字符串默认移除空格。

    格式:“字符串内容”.lstrip(“指定字符串”)

     

     

    例1:移除字符串左侧的空格

    s = '      dark knight          '
    s1 = s.lstrip() # 去除字符串左侧的空格
    print(s1,'<—右侧空格并未去除')
    

    输出结果:

    dark knight           查看右侧的空格是去除

    图示:

    例2:移除字符串左侧的指定字符串

    s = '*****dark knight************'
    s1 = s.lstrip('*') # 去除字符串左侧的字符串“*”
    print(s1)

    输出结果:

    dark knight************

    图示:

     

     

     

     

     

     

     

     

     

     

    8、rstrip()

    定义:移除字符串右侧指定的字符,并返回移除指定字符串后的字符串,括号内不指定字符串默认移除空格。

    格式:“字符串内容”.rstrip(“指定字符串”)

     

     

    例1:移除字符串右侧的空格

    s = '       dark knight             '
    s1 = s.rstrip() # 去除字符串右侧的空格
    print(s1)

    输出结果:

    左侧的空格未去除—>        dark knight

    图示:

     

     

     

     

     

    例2:移除字符串右侧的指定字符串

    s = '*****dark knight************'
    s1 = s.rstrip('*') # 去除字符串右侧的字符串“*”
    print(s1)

    输出结果:

    *****dark knight

    图示:

     

     

     

     

     

     

     

     

     

     

     

    9、split()  重点

    定义:通过指定分隔符按从左到右的顺序对字符串进行切片,并以一个列表的形式返回。括号内不指定字符串表示默认以空格为分隔符。可以指定分隔符的个数

    格式:“字符串内容”.split(“指定分隔符”)

     

     

    例1:以空格为分隔符进行切片操作

    s = 'dark knight'
    s1 = s.split() # 以空格作为分隔符进行切片
    print(s1)

    输出结果:

    ['dark', 'knight']

    图示:

     

     

     

     

     

    例2:以指定字符作为分隔符进行切片操作

    s = 'dark knight'
    s1 = s.split('k') # 以字符“k”作为分隔符进行切片
    print(s1)

    输出结果:

    ['dar', ' ', 'night']

    图示:

     

     

     

     

     

    例3: 以指定字符作为分隔符进行切片操作且限定分隔符的个数

    s = 'dark knight'
    s1 = s.split('k',1)
    # 以字符“k”作为分隔符进行切片,
    # 且只限定1个"k"作为分隔符,字符串中如果有多个“k”则按从左至右的顺序来选定这个分隔符
    print(s1)

    输出结果:

    ['dar', ' knight']

    图示:

     

     

     

     

     

     

     

     

     

     

    10、rsplit()

    定义:通过指定分隔符按从右到左的顺序对字符串进行切片,并以一个列表的形式返回。括号内不指定字符串表示默认以空格为分隔符。可以指定分隔符的个数

    格式:“字符串内容”.rsplit(“指定分隔符”)

     

     

    例1:以空格作为分隔符进行切片

    s = 'dark knight'
    s1 = s.rsplit() # 以空格作为分隔符进行切片
    print(s1)

    输出结果:

    ['dark', 'knight']

    图示:

     

     

     

     

     

    例2:以指定字符作为分隔符进行切片操作

    s = 'dark knight'
    s1 = s.rsplit('k') # 以字符“k”作为分隔符进行切片
    print(s1)

    输出结果:

    ['dar', ' ', 'night']

    图示:

     

     

     

     

     

    例3: 以指定字符作为分隔符进行切片操作且限定分隔符的个数(这里就体现与split的区别了)

    s = 'dark knight'
    s1 = s.rsplit('k',1)
    # 以字符“k”作为分隔符进行切片,
    # 且只限定1个"k"作为分隔符,字符串中如果有多个“k”则按从右至左的顺序来选定这个分隔符
    print(s1)

    输出结果:

    ['dark ', 'night']

    图示:

     

     

     

     

     

     

     

     

     

     

    11、splitlines()

    定义:括号中不加参数默认为False,此时分隔符默认指定为“\n” 、“\n\r” 、“\r”对字符串进行分隔,以一个列表的形式返回;当括号中参数改为True时仍然会以“\n” 、“\n\r” 、“\r”进行分隔,但是在生成的元素中会保留分隔符。并以一个列表的形式返回。

    格式:“字符串内容”.splitlines(True/False)

     

     

    例1:括号中不加参数时默认为False,分隔符“\n”、“\r\n”、“\r”在生成元素时不会被保留

    s = '\ndar\rk kni\r\nght\r'
    s1 = s.splitlines() # 括号中不加参数默认为False,且以“\n”、"\n\r"、"\r"为分隔符
    print(s1)

    输出结果:

    ['', 'dar', 'k kni', '', 'ght']

    图示:

     

     

     

     

     

    例2:括号中为True时的操作,分隔符“\n”、“\r\n”、“\r”在生成元素时会被保留

    s = '\ndar\rk kni\r\nght\r'
    s1 = s.splitlines(True) # 括号中为True时,分隔符“\n”、“\r\n”、“\r”在生成元素时会被保留
    print(s1)

    输出结果:

    ['\n', 'dar\r', 'k kni\r\n', 'ght\r']

    图示:

     

     

     

     

     

     

     

     

     

     

    12、replace()  重点

    定义:将指定的字符串替换成新的字符串,并返回替换后的字符串。可以指定替换的次数,若不指定次数则默认替换全部。

    格式:“字符串内容”.replace(“要替换的内容”,“新的内容”,指定的替换的次数)

     

     

    例1:替换全部的指定的内容。

    s = 'dark knight dark sky'
    s1 = s.replace('dark','暗黑')
    print(s1)

    输出结果:

    暗黑 knight 暗黑 sky

    图示:

     

     

     

     

     

    例2:指定替换的次数,按从左到右的顺序进行替换

    s = 'dark knight dark sky'
    s1 = s.replace('dark','暗黑',1)
    print(s1)
    

     输出结果:

    暗黑 knight dark sky

    图示:

     

     

     

     

     

    例3:当要替换的内容不存在时也不会报错,直接返回字符串的原内容

    s = 'dark knight dark sky'
    s1 = s.replace('x','暗黑') # 要替换的内容不存在时,直接返回字符串的原内容
    print(s1)

     输出结果:

    dark knight dark sky

    图示:

     

     

     

     

     

     

     

     

     

     

    13、join()  重点

    定义:将序列中的元素以指定的字符拼接生成一个新的字符串,并返回这个字符串

    格式:“指定字符串内容”.join(一个序列)

     

     

    例1:将序列中的元素以空字符串拼接一个成一个新的字符串

    s = ''
    t = ('k','n','i','g','h','t')
    s1 = s.join(t) # 将序列中的元素以空字符串拼接一个成一个新的字符串
    print(s1)

    输出结果:

    knight

    图示:

     

     

     

     

     

    例2:将序列中的元素以“-”字符串拼接一个成一个新的字符串

    s = '-'
    t = ('k','n','i','g','h','t')
    s1 = s.join(t) # 将序列中的元素以“-”字符串拼接一个成一个新的字符串
    print(s1)
    

     输出结果:

    k-n-i-g-h-t

    图示:

     

     

     

     

     

     

     

     

     

     

    14、format()  重点

    定义:字符串格式化。有三种方法:1、按默认从左到右的默认顺序传值,2、按指定位置传值,3、按设置参数传值,返回格式化后的字符串

    格式1:“字符串-{}-字符串-{}”.format(“内容1”,“内容2”)       

       #  输出的结果为:字符串-内容1-字符串-内容2 

       #  格式化后的内容分别按从左到右的默认顺序分别对应到字符串中每个大括号里

     

    格式2:“字符串-{2}-字符串-{1}”.format(“内容1”,“内容2”)        

       #  输出的结果为:字符串-内容2-字符串-内容1 

       #  格式化后的内容分别按指定位置传值到字符串中对应的大括号里

     

    格式3:“字符串-{变量名1}-字符串-{变量名2}”.format(变量名1 = “内容 ”,变量名2 = “内容2”)   

          #  输出的结果为:字符串-内容1-字符串-内容12

       #  格式化后的内容分别按指定位置传值到字符串中对应的大括号里

     

     

    例1:按默认顺序对字符串进行格式化

    s = "I am dark {},I'm {} years old!"
    s1 = s.format('knight','28') 
    print(s1)

    输出结果:

    I am dark knight,I'm 28 years old!

    图示:

     

     

     

     

     

    例2:按位置对字符串进行格式化

    s = "I am dark {1},I'm {0} years old!"
    s1 = s.format('28','knight') 
    print(s1)

    输出结果:

    I am dark knight,I'm 28 years old!

    图示:

     

     

     

     

     

    例3:按位置对字符串进行格式化

    s = "I am dark {name},I'm {age} years old!"
    s1 = s.format(age = '28',name = 'knight')
    print(s1)

    输出结果:

    I am dark knight,I'm 28 years old!

    图示:

     

     

     

     

     

     

     

     

     

     

     

    15、format_map()

    定义:字符串格式化,与format不同的是括号中的mapping是一个字典对象,返回格式化后的字符串。

    格式:“字符串-{key1}-字符串-{key2}”.format_map({key1 : “value1 ”,key2 : “value2”})

          #  输出的结果为:字符串-value1-字符串-value2

     

     

    例:字符串的格式,传入一个字典对象

    people = {'name':'dark_knight','age':28}
    s = 'My name is {name},I am {age} years old'
    s1 = s.format_map(people)
    print(s1)

    输出结果:

    My name is dark_knight,I am 28 years old

    图示:

     

     

     

     

     

     

     

     

     

    16、encode()  重点

    定义:以指定的编码格式对字符串进行编码,并返回编码后的二进制

    格式:“字符串内容”.encode(“指定的字符编码”)

     

     

    例:以utf-8的方式进行编码并解码。

    s = '暗黑骑士'
    s1 = s.encode('utf-8')
    print(s1)  # 得到以"utf-8"编码后的二进制数
    s2 = s1.decode('utf-8')
    print(s2)  # 用decode解码,以什么编码就要以什么解码,否则乱码

    输出结果:

    b'\xe6\x9a\x97\xe9\xbb\x91\xe9\xaa\x91\xe5\xa3\xab'
    暗黑骑士

    图示:

     

     

     

     

     

     

     

     

     

     

    17、startswith()  重点

    定义:判断字符串是否是以指定字符串开头并返回布尔值,并可以指定范围。

    格式:“字符串内容”.startswith(“指定字符串”,指定范围)

     

     

    例1:判断字符串是否以指定字符串开头

    s = 'dark knight'
    s1 = s.startswith('dark')
    print(s1)

    输出结果:

    True

    图示:

     

     

     

     

     

    例2:判断字符串是否以指定字符串开头,并指定范围

    s = 'dark knight'
    s1 = s.startswith('k',5)
    print(s1)

    输出结果:

    True

    图示:

     

     

     

     

     

    例3:判断字符串是否以指定字符串开头

    s = 'dark knight'
    s1 = s.startswith('haha') # 在原字符串中没找到以指定内容开头的内容则返回False
    print(s1)

    输出结果:

    False

    图示:

     

     

     

     

     

     

     

     

     

     

    18、endswith()  重点

    定义:判断字符串是否是以指定字符串结尾并返回布尔值,并可以指定范围。

    格式:“字符串内容”.endswith(“指定字符串”,指定范围)

     

     

    例1:判断字符串是否以指定字符串结尾

    s = 'dark knight'
    s1 = s.endswith('knight')
    print(s1)

    输出结果:

    True

    图示:

     

     

     

     

     

    例2:判断字符串是否以指定字符串开头

    s = 'dark knight'
    s1 = s.endswith('x')
    print(s1)

    输出结果:

    False

    图示:

     

     

     

     

     

     

     

     

     

     

    19、upper()  重点

    定义:将字符串中的小写字母转换成大写字母,并返回转换成大写字母后的字符串

    格式:"小写字母的字符串".upper()

     

     

    例:将小写字母的字符串转换成大写字母。

    s = 'dark knight'
    s1 = s.upper()
    print(s1)

    输出结果:

    DARK KNIGHT

    图示:

     

     

     

     

     

     

     

     

     

     

    20、lower()  重点

    定义:将字符串中的大写字母转换成小写字母,并返回转换成小写字母后的字符串。

    格式:"大写字母的字符串".lower()

     

     

    例:将字符串中的大写字母转换成小写字母

    s = 'Dark Knight'
    s1 = s.lower()
    print(s1) 

    输出结果:

    dark knight

    图示:

     

     

     

     

     

     

     

     

     

     

    21、title()  重点

    定义:将字符串中的所有单词的首字母的替换成大写字母,并返回转换后的字符串

    格式:“字符串”.title()

     

     

    例:将字符串中的所有单词的首字母替换成大写字母

    s = 'my name is dark knight'
    s1 = s.title()
    print(s1)

    输出结果:

    My Name Is Dark Knight

    图示:

     

     

     

     

     

     

     

     

     

     

    22、swapcase()  重点

    定义:将字符串的大小写字母进行转换,并返回转换后的字符串

    格式:“字符串”.swapcase()

     

     

    例:将字符串的大小写字母进行转换

    s = 'Dark Knight'
    s1 = s.swapcase()
    print(s1)

    输出结果:

    dARK kNIGHT

    图示:

     

     

     

     

     

     

     

     

     

     

    23、ljust()

    定义:返回一个左对齐的字符串,并使用指定长度的填充符号,不指定填充符号默认使用空格作为填充符号。若指定的填充符号的长度小于字符串本身的长度,填充符号则不会显示。

    格式:“字符串”.ljust(填充的长度,“指定填充符号”)

     

     

    例1:返回一个以空格为填充的左对齐的字符串。

    s = 'dark knight'
    s1 = s.ljust(30)
    print(s1,'<-结束')

    输出结果:

    dark knight                    <-结束

    图示:

     

     

     

     

     

    例2:返回一个以指定字符串作为填充的左对齐的字符串。

    s = 'dark knight'
    s1 = s.ljust(30,'*')
    print(s1)

    输出结果:

    dark knight*******************

    图示:

     

     

     

     

     

    例3:指定的填充符号的长度小于字符串本身的长度,填充符号则不会显示

    s = 'dark knight'
    s1 = s.ljust(10,'*') # 指定填充符号的长度小于字符串的长度,则不会显示填充符号
    print(s1,'<-结束')

    输出结果:

    dark knight <-结束

    图示:

     

     

     

     

     

     

     

     

     

     

    24、rjust()

    定义:返回一个右对齐的字符串,并使用指定长度的填充符号,不指定填充符号默认使用空格作为填充符号。若指定的填充符号的长度小于字符串本身的长度,填充符号则不会显示。

    格式:“字符串”.rjust(填充的长度,“指定填充符号”)

     

     

    例1:返回一个以空格为填充的右对齐的字符串

    s = 'dark knight'
    s1 = s.rjust(30)
    print('开始->',s1)

    输出结果:

    开始->                    dark knight

    图示:

     

     

     

     

     

    例2:返回一个以指定字符串作为填充的右对齐的字符串。

    s = 'dark knight'
    s1 = s.rjust(30,'*')
    print(s1)

    输出结果:

    *******************dark knight

    图示:

     

     

     

     

     

    例3:指定的填充符号的长度小于字符串本身的长度,填充符号则不会显示

    s = 'dark knight'
    s1 = s.rjust(10,'*') # 指定填充符号的长度小于字符串的长度,则不会显示填充符号
    print('开始->',s1)

    输出结果:

    开始-> dark knight

    图示:

     

     

     

     

     

     

     

     

     

     

    25、center()  重点

    定义:返回一个居中对齐的字符串,并使用指定长度的填充符号,不指定填充符号默认使用空格作为填充符号。若指定的填充符号的长度小于字符串本身的长度,填充符号则不会显示。

    格式:“字符串”.center(填充的长度,“指定填充符号”)

     

     

    例1:返回一个以空格为填充的居中对齐的字符串

    s = 'dark knight'
    s1 = s.center(30)
    print('开始->',s1,'<-结束')

    输出结果:

    开始->          dark knight           <-结束

    图示:

     

     

     

     

     

    例2:返回一个以指定字符串作为填充的居中对齐的字符串。

    s = 'dark knight'
    s1 = s.center(30,'*')
    print('开始->',s1,'<-结束')

    输出结果:

    开始-> *********dark knight********** <-结束

    图示:

     

     

     

     

     

    例3:指定的填充符号的长度小于字符串本身的长度,填充符号则不会显示

    s = 'dark knight'
    s1 = s.center(10,'*') # 指定填充符号的长度小于字符串的长度,则不会显示填充符号
    print('开始->',s1,'<-结束')

    输出结果: 

    开始-> dark knight <-结束

    图示:

     

     

     

     

     

     

     

     

     

     

     

    26、capitalize()  重点

    定义:返回一个将字符串首字母大写、字符串中的其它字母变为小写的字符串

    格式:“字符串”.capitalize()

     

     

    例:返回一个将字符串首字母大写、字符串中的其它字母变为小写的字符串

    s = 'dARk kNigHt'
    s1 = s.capitalize()
    print(s1)

    输出结果:

    Dark knight

    图示:

     

     

     

     

     

     

     

     

     

     

    27、partition()

    定义:按从左到右的顺序,对字符串进行分割,返回一个包含3个元素的元组,这个元组中这3个元素分别为:指定分割符,以及以这个分隔符为中心的左右两侧的字符串。

    格式:“字符串”.partition("指定分隔符")

     

     

    例1:对字符串进行分割,返回一个包含3个元素的元组,按从左到右的顺序分割

    s = 'dark knight'
    s1 = s.partition('k')
    print(s1)

    输出结果:

    ('dar', 'k', ' knight')

    图示:

     

     

     

     

     

    例2:若在字符串中未找到指定的分隔符则返回一个包含3个元素的元组,这个元组元素包含字符串本身,以及两个空字符串

    s = 'dark knight'
    s1 = s.partition('x') # 指定一个不存在的字符串
    print(s1)

    输出结果:

    ('dark knight', '', '')

    图示:

     

     

     

     

     

     

     

     

     

     

    28、rpartition()

    定义:按从右到左的顺序,对字符串进行分割,返回一个包含3个元素的元组,这个元组中这3个元素分别为:指定分割符,以及以这个分隔符为中心的左右两侧的字符串。

    格式:“字符串”.rpartition("指定分隔符")

     

     

    例1:对字符串进行分割,返回一个包含3个元素的元组,按从右到左的顺序分割

    s = 'dark knight'
    s1 = s.rpartition('k')
    print(s1)

    输出结果:

    ('dark ', 'k', 'night')

    图示:

     

     

     

     

     

     

    例2:若在字符串中未找到指定的分隔符则返回一个包含3个元素的元组,这个元组元素包含两个空字符串,以及字符串本身

    s = 'dark knight'
    s1 = s.rpartition('x') # 指定一个不存在的字符串
    print(s1)

    输出结果:

    ('', '', 'dark knight')

    图示:

     

     

     

     

     

     

     

     

     

     

    29、translate()

    定义:根据参数table给出的表(包含 256 个字符)转换字符串的字符,要过滤掉的字符放到 deletechars 参数中。返回这替换后的字符串

    格式:“原字符串”.translate({映射表})

     

     

    例1:通过映射表替换s2字符串中的指定字符

    s1 = 'abcde'  # 原字符串中要替换的字符
    num = '12345' # 相应的映射字符的字符串。
    s2 = "aaxxbbxxccxxddxxee" # 原字符串
    
    form = s2.maketrans(s1,num) # 创建映射表,让s1字符串中的字母分别对应num中的字母并指向s2字符串。
    print(s2.translate(form)) # 使用上面映射表进行翻译,并把并把deletechars中有的字符删掉。

    输出结果:

    11xx22xx33xx44xx55

    图示:

     

     

     

     

     

     

     

     

     

     

    30、zfill()  重点

    定义:按指定长度在字符串的左侧填充"0"补齐,并返回这个补齐“0”后的字符串

    格式:“字符串”.zfill(指定长度)

     

     

    例1:按指定长度在字符串的左侧填充"0"补齐

    s = 'dark knight'
    s1 = s.zfill(20)
    print(s1)

    输出结果:

    000000000dark knight

    图示:

     

     

     

     

     

    例2:按指定长度在字符串的左侧填充"0"补齐,当填充“0”的个数小于字符串长度时,则不会显示。

    s = 'dark knight'
    s1 = s.zfill(10) # 填充的“0”的个数小于字符串的长度
    print(s1)

    输出结果:

    dark knight

    图示:

     

     

     

     

     

     

     

     

     

     

    31、maketrans()

    定义:用于创建字符映射的转换表,对于接受两个参数的最简单的调用方式,第一个参数是字符串,表示需要转换的字符,第二个参数也是字符串表示转换的目标。返回一个一一对应的字典

    格式:“原字符串”.maketrans("原字符串中要替换的字符",“相应的映射字符的字符串”)

     

     

    例:创建字符映射的转换表,并进行翻译

    s1 = 'abcde'  # 原字符串中要替换的字符
    num = '12345' # 相应的映射字符的字符串。
    s2 = "aaxxbbxxccxxddxxee" # 原字符串
    
    form = s2.maketrans(s1,num) # 创建映射表,让s1字符串中的字母分别对应num中的字母并指向s2字符串。
    print(form)   # 查看这个映射表
    print(s2.translate(form)) # 使用上面映射表进行翻译,并把并把deletechars中有的字符删掉。

    输出结果:

    {97: 49, 98: 50, 99: 51, 100: 52, 101: 53}
    11xx22xx33xx44xx55

    图示:

     

     

     

     

     

     

     

     

     

     

     

    32、expandtabs()

    定义:expandtabs() 方法把字符串中的“\t”转为空格,并返回替换空格后的字符串。(\t默认的空格数是 8)。

    格式:“字符串中的 \t ”.expandtabs(空格数)

     

     

    例1:将字符串中的“\t”替换成20个空格数

    s = 'dark\tknight'
    s1 = s.expandtabs(20)
    print(s1)

    输出结果:

    dark                knight

    图示:

     

     

     

     

     

    例2:括号中不加参数默认是8个空格

    s = 'dark\tknight'
    s1 = s.expandtabs()
    print(s1)

    输出结果:

    dark    knight

    图示:

     

     

     

     

     

     

     

     

     

     

    33、isdigit()  重点

    定义:判断字符串是否只由数字组成,并返回一个布尔值。

    格式:“字符串”.isdigit()

     

     

    例1:判断字符串是否只由数字组成

    s = 'dark knight'
    s1 = s.isdigit()
    print(s1)

    输出结果:

    False

    图示:

     

     

     

     

     

    例2:判断字符串是否只由数字组成

    s = '88888'
    s1 = s.isdigit()
    print(s1)

    输出结果:

    True

    图示:

     

     

     

     

     

     

     

     

     

     

     

    34、isalpha()  重点

    定义:判断字符串是否只由字母组成,并返回一个布尔值。

    格式:“字符串”.isalpha()

     

     

    例1:判断字符串是否只由字母组成

    s = 'dark knight'
    s1 = s.isalpha()
    print(s1) # 因为原字符串中有空格,所以返回False

    输出结果:

    False

    图示:

     

     

     

     

     

    例2:判断字符串是否只由字母组成

    s = 'darkknight'
    s1 = s.isalpha()
    print(s1)

    输出结果:

    True

    图示:

     

     

     

     

     

     

     

     

     

     

     

    35、isalnum()  重点

    定义:判断字符串是否只由字母或数字组成,并返回一个布尔值。

    格式:“字符串”.isalnum()

     

     

    例1:判断字符串是否只由字母或数字组成。

    s = 'darkknight888'
    s1 = s.isalnum()
    print(s1)

    输出结果:

    True

    图示:

     

     

     

     

     

    例2:判断字符串是否只由字母或数字组成。

    s = 'dark knight!@#'
    s1 = s.isalnum()
    print(s1)

    输出结果:

    False

    图示:

     

     

     

     

     

     

     

     

     

     

    36、isupper()  重点

    定义:判断字符串中所有的字母是否为大写。并返回一个布尔值。

    格式:“字符串”.isupper()

     

     

    例1:判断字符串中所有的字母是否为大写

    s = 'DARK KNIGHT!@#'
    s1 = s.isupper()
    print(s1)

    输出结果:

    True

    图示:

     

     

     

     

     

    例2:判断字符串中所有的字母是否为大写

    s = 'dark KNIGHT!@#'
    s1 = s.isupper()
    print(s1)

    输出结果:

    False

    图示:

     

     

     

     

     

     

     

     

     

     

     

     

    37、islower()  重点

    定义:判断字符串中所有的字母是否为小写。并返回一个布尔值。

    格式:“字符串”.islower()

     

     

    例1:判断字符串中所有的字母是否为小写

    s = 'dark knight!@#'
    s1 = s.islower()
    print(s1)

    输出结果:

    True

    图示:

     

     

     

     

     

    例2:判断字符串中所有的字母是否为小写

    s = 'DARK knight!@#'
    s1 = s.islower()
    print(s1)

    输出结果:

    False

    图示:

     

     

     

     

     

     

     

     

     

     

     

    38、isspace()  重点

    定义:判断字符串是否只由空白字符组成,并返回一个布尔值

    格式:“字符串”.isspace()

     

     

    例1:判断字符串是否只由空白字符组成

    s = 'dark knight'
    s1 = s.isspace()
    print(s1)

    输出结果:

    False

    图示:

     

     

     

     

     

    例2:判断字符串是否只由空白字符组成

    s = '        '
    s1 = s.isspace()
    print(s1)

    输出结果:

    True

    图示:

     

     

     

     

     

     

     

     

     

     

    39、istitle()  重点

    定义:判断字符串中所有的单词的首字母是否为大写且其他字母为小写。并返回一个布尔值。

    格式:“字符串”.istitle()

     

     

    例1:判断字符串中所有的单词的首字母是否为大写且其他字母为小写

    s = 'Dark Knight!@#$ 888'
    s1 = s.istitle()
    print(s1)

    输出结果:

    True

    图示:

     

     

     

     

     

    例2:判断字符串中所有的单词的首字母是否为大写且其他字母为小写

    s = 'Dark KNIGHT!@#$ 888'
    s1 = s.istitle()
    print(s1)

    输出结果:

    False

    图示:

     

     

     

     

     

     

     

     

     

     

    40、isdecimal()

    定义:判断字符串是否只包含十进制字符。这种方法只存在于unicode对象。并返回一个布尔值。(注意:定义一个十进制字符串,只需要在字符串前添加 'u' 前缀即可)

    格式:“字符串”.isdecimal()

     

     

    例1:判断字符串是否只包含十进制字符

    s = '8888888888'
    s1 = s.isdecimal()
    print(s1)

    输出结果:

    True

    图示:

     

     

     

     

     

    例2:判断字符串是否只包含十进制字符

    s = 'dark knight'
    s1 = s.isdecimal()
    print(s1)

    输出结果:

    False

    图示:

     

     

     

     

     

     

     

     

     

     

    41、isnumeric()

    定义:判断字符串是否只由数字组成。只针对unicode对象。并返回一个布尔值。

    格式:“字符串”.isnumeric()

     

     

    例1:判断字符串是否只由数字组成。

    s = '8888888888'
    s1 = s.isnumeric()
    print(s1)

    输出结果:

    True

    图示:

     

     

     

     

     

     

     

     

     

     

     

    42、isprintable()

    定义:判断字符串中的所有字符都是否为可打印的(或字符串为空)的则返回True,否则返回False

          (可打印字符:ASCII码中,第0~32号及第127号是控制字符;第33~126号是可打印字符,其中第48~57号为0~9十个阿拉伯数字;65~90号为26个大写英文字母,97~122号为26个小写英文字母,其余的是一些标点符号、运算符号等)

    格式:“字符串”.isprintable()

     

     

    例1:判断字符串中的所有字符都是否为可打印的

    s = '\t\n'
    s1 = s.isprintable()
    print(s1)

    输出结果:

    False

    图示:

     

     

     

     

     

    例2:判断字符串中的所有字符都是否为可打印的

    s = 'dark knight'
    s1 = s.isprintable()
    print(s1)

    输出结果:

    True

    图示:

     

     

     

     

     

    例3:判断字符串中的所有字符都是否为可打印的

    s = '暗黑骑士'
    s1 = s.isprintable()
    print(s1)
    

     输出结果:

    False

    图示:

     

     

     

     

     

     

     

     

     

     

    43、isidentifier()

    定义:判断是否是合法标识符,实际上是判断变量名是否合法,并返回一个布尔值

    格式:“字符串”.isidentifier()

     

     

    例1:判断是否是合法标识符

    s = '暗黑骑士'
    s1 = s.isidentifier()
    print(s1)

    输出结果:

    True

    图示:

     

     

     

     

     

    例2:判断是否是合法标识符

    s = '\t\n'
    s1 = s.isidentifier()
    print(s1)

    输出结果:

    False

    图示:

     

     

     

     

     

    例3:判断是否是合法标识符

    s = ' '
    s1 = s.isidentifier()
    print(s1)

    输出结果:

    False

    图示:

     

    转载于:https://www.cnblogs.com/fyknight/p/7895894.html

    展开全文
  • str.find(str, beg=0, end=len...Python find() 方法检测字符串中是否包含子字符串 str ,如果指定 beg(开始) 和 end(结束) 范围,则检查是否包含在指定范围内, 如果包含子字符串返回开始的索引值,否则返回-...
  • python字符串方法

    2021-05-29 19:50:29
    方法 描述 capitalize() 把首字符转换为大写。 casefold() 把字符串转换为小写。 center() 返回居中的字符串。... 返回指定值在字符串中... 在字符串中搜索指定的值并返回它被找到位置。 for
  • Python字符串切片

    2021-03-04 10:12:01
    字符串进行切片,有三个参数[start: end:step], start:开始位置索引,默认为字符串第一个字符 end:结束位置索引,默认为字符...print(a[:]) #截取整个字符串,开始位置为0,结束位置为6,根据位置找到的子串:abcd
  • Python字符串方法总结

    2017-06-23 15:57:00
    Python字符串方法图示: (温馨提示:对图片点右键——在新标签页中打开图片) 1、index() 定义:查找并返回指定str的索引位置,...例1:不指定范围默认是从左至右的顺序查询指定字符串“i”的索引位置 ...
  • Python——字符串学习

    2020-06-26 11:01:44
    一、字符串类型的表示 三引号可以表示多行字符串 二、字符串方法 方法 功能 ...将old换成new,可以指定替换次数...返回s的切片s[start:end]中子字符串sub出现的第1个位置,若没有找到,则返回-1 s.index() 与fin
  • Python字符串操作

    2017-12-05 20:18:59
    常用字符串方法: 1.string.find(str): 在字符串中查找字串,返回子串所在...String.find(str,start, end) 指定起始和终止位置end为检索范围内下一个索引 不包括end所指定字符 str = "aaa ffff adsff !!! aaa" p
  • 查找find 找到指定字符串出现第一个位置,第一个字符的下标,找不到返回-1 假设字符串string string.find(sub) 从下标1开始找 string.find(sub,1) 二、替换 假设字符串string string.replace(‘string1’, ...
  • 返回子串所在位置的最左端索引,如果没有找到则返回-1.如果指定 beg(开始) 和 end(结束) 范围,则检查是否包含在指定范围内,如果包含子字符串返回开始的索引值,否则返回-1。 用法:string.find() 实例: a = ...
  • python-字符串方法

    2018-03-02 23:57:44
    #find方法:查找子串,返回子串所在位置的最左端索引,如果没有找到则返回-1 s="agsa" print(s.find("gs")) print(s.find("agsaa")) #可以指定匹配的起始点和结束点参数,包含第一个索引,不包含第二个索引; print(s...
  • 字符串查找 vars = 'iloveyoutosimidaandilikeyou' ...# 从左向右 获取指定字符在字符串中第一次出现的索引位置,未找到则返回 -1 # str.find(sub[, start[, end]]) # res = vars.find('you') # res = vars.find('yo
  • python字符串处理函数汇总

    千次阅读 2017-09-21 10:51:52
    Python find() 方法检测字符串中是否包含子字符串 str ,如果指定 beg(开始) 和 end(结束) 范围,则检查是否包含在指定范围内,如果包含子字符串返回开始的索引值,否则返回-1。 用法:string.find()实例: a =...
  • Python 字符串魔法二

    2019-09-26 23:28:01
    #从开始往后找,找到第一个之后,获取未知,检测字符串中是否包含子字符串 str ,如果指定 beg(开始) 和 end(结束) 范围,则检查是否包含在指定范围内,找出第一个在哪个位置 如果包含子字符串返回开始的索引值...
  • 可以像其他语言一样通过指定下标找到对应元素,但Python中还有切片的方法取出字符串中的一部分,同理还可用切片的方法取出列表、元组 切片语法格式:[起始 : 结束 : 步长] 起始:对象中的起始位置,可以为空;...
  • 1. 使用 in 和 not in in 和 not in 在 Python 中是很常用...使用 字符串 对象的 find 方法,如果有找到子串,就可以返回指定子串在字符串中的出现位置,如果没有找到,就返回 -1 >>> hello, python.find(llo) != -1 T
  • find函数:默认是从前往后找,找到第一个字串(sub),获取其位置。 如果找不到,返回-1. test = 'alexalex' v = test.find('ex',5,8) print (v) 输出结果:6 默认格式为:左闭右开,即[开始,结束) format函数:...
  • 返回子串所在位置的最左端索引,如果没有找到则返回-1.如果指定 beg(开始) 和 end(结束) 范围,则检查是否包含在指定范围内,如果包含子字符串返回开始的索引值,否则返回-1。 用法:string.find() 实例: a =...
  • find 在字符串中查找子串,找到首次出现的位置,返回下标,找不到返回-1 rfind 从右边查找 join 连接字符串数组 replace 用指定内容替换指定内容,可以指定次数 split 切割字符串sep:指定按照什么进行切割,默认...
  • 字符串常用功能: # name.upper() #全部大写变小写 # name.lower() #全部小写变大写 # name.split() #分割 ...# name.find() #找到指定子序列的索引位置 # name.strip() #默认移除左右空白,可以传参数...
  • #find():查找字符位置并返回下标,没找到返回-1 s = "abc" print(s.find("b")) print(s.find("z")) #title():把字符串转换为第一个字符大写的格式,用于开头,返回字符串 print(s....
  • find():查找指定子串在字符串中出现的位置,如果没有找到指定子串,则返回 -1。 index():查找指定子串在字符串中出现的位置,如果没有找到指定子串,则引发 ValueError 错误。 replace():使...
  • python

    2020-09-06 14:00:52
    基本数据类型 (数字int 字符串str 列表list 元组tuple ... .count() 合区指定元素在元组中出现的次数(后面需要跟上参数) 2 index() 找到元素的索引位置 字典(dict) 创建字典对象 1基本结构 Info = {“k1”:”v1”
  • 添加到指定位置 extend 将序列中的每个元素追加到末尾 删 pop 不带参数弹出最后一个元素、带参数指定下标值 remove 移除指定的元素 clear 删除列表中的所有值 改 li[0] = ‘list’ 查 index 在列表...
  • Pythonic libsndfile包装器,用于读取和... 您可以在以下位置找到最新版本: : 愿望清单 智能格式选择器 如果未指定,则使用文件扩展名推断主要格式 如果未指定,则使用主格式推导子格式 格式列举 将格式范围分为格

空空如也

空空如也

1 2 3 4 5
收藏数 85
精华内容 34
关键字:

python找到指定字符位置

python 订阅