您的位置:新葡亰496net > 奥门新萄京娱乐场 > 新葡亰496net:python字符串操作,字符串常用操作

新葡亰496net:python字符串操作,字符串常用操作

发布时间:2019-12-10 13:48编辑:奥门新萄京娱乐场浏览(165)

    文:铁乐与猫
    2018-3-20

    [terry笔记]Python字符串,terrypython

    正如学习python的字符串用法。

    print(dir(str))

    ['__add__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__gt__', '__hash__', '__init__', '__iter__', '__le__', '__len__', '__lt__', '__mod__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmod__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'capitalize', 'casefold', 'center', 'count', 'encode', 'endswith', 'expandtabs', 'find', 'format', 'format_map', 'index', 'isalnum', 'isalpha', 'isdecimal', 'isdigit', 'isidentifier', 'islower', 'isnumeric', 'isprintable', 'isspace', 'istitle', 'isupper', 'join', 'ljust', 'lower', 'lstrip', 'maketrans', 'partition', 'replace', 'rfind', 'rindex', 'rjust', 'rpartition', 'rsplit', 'rstrip', 'split', 'splitlines', 'startswith', 'strip', 'swapcase', 'title', 'translate', 'upper', 'zfill']

    如上是字符串的有着办法,贰个叁个看,共43个

     

    1.赶回第3个字母大写

       capitalize(...)

          capitalize() -> string

    1 2 3 4 >>>a = 'hello world' >>> b = a.capitalize() >>> print (b) Hello world

    2.按钦赐长度填充特定字符

        center(...)

          S.center(width[, fillchar]) -> string

    1 2 3 4 5 6 7 >>> a = 'linux' >>> print a.center(7,'h') hlinuxh >>> print a.center(8,'h') hlinuxhh >>> print a.center(9,'h') hhlinuxhh

    3.查找某字符串现身的次数

        count(...)

          S.count(sub[, start[, end]]) -> int

    1 2 3 4 5 6 7 8 9 >>> a = "this is my dog, i love this dog and it's a good dog!" >>> print a.count('dog') 3 >>> print a.count('dog',15) 2 >>> print a.count('dog',15,30) 0 >>> print a.count('dog',15,32) 1

    4.以内定的编码格式解码字符串。暗许编码为字符串编码(切合python第22中学管理普通话)

        decode(...)

          S.decode([encoding[,errors]]) ->object

    1 2 3 b = 'strid' >>> b.decode('utf-8') u'strid'

    5.用来判定字符串是还是不是以钦赐后缀结尾,假诺以钦赐后缀结尾重临True,不然重返False。可选参数"start"与"end"为寻觅字符串的起来与截至地方

        endswith(...)

        S.endswith(suffix[,start[, end]]) ->bool

    1 2 3 4 5 6 7 >>> shaw = 'I am shaw,what's your name ?' >>> shaw.endswith('?') True >>> shaw.endswith('w',7,9) True >>> shaw.endswith('w',7,8) False

    6.把字符串中的 tab 符号('t'卡塔尔转为空格,tab 符号('t'卡塔尔默许的空格数是8,tabsize -- 内定调换字符串中的 tab 符号('t'卡塔尔(قطر‎转为空格的字符数。

        expandtabs(...)

        S.expandtabs([tabsize])-> string

    1 2 3 4 5 6 7 >>> info = 'today is a good dtay' >>> print info.expandtabs() today is a good d       ay >>> print info.expandtabs(4)   # 把tab装换成4个空格 today is a good d   ay         >>> printinfo.expandtabs(1) today is a good d ay          # 把tab装换成1个空格

    7.检验字符串中是或不是带有子字符串 str ,假使钦定 beg(初始)和 end(停止)范围,则检查是不是满含在钦定范围内,即使带有子字符串,则赶回早先的索引值,不然再次回到-1。

        find(...)

        S.find(sub [,start [,end]])-> int

    1 2 3 4 5 6 7 >>> a = 'stivenwang' >>> a.find('w') 6 >>> a.find('w',9) -1 >>> a.find('w',9,11) -1

    8.格式换字符串输出(方法与%经常,但足以钦命顺序)

        format(...)

        S.format(*args, **kwargs)-> string

    1 2 3 4 5 6 7 8 >>> name = 'StivenWang' >>> fruit = 'apple' >>> print 'my name is {},I like {}'.format(name,fruit) my name is StivenWang,I like apple >>> print 'my name is {1},I like {0}'.format(fruit,name) my name is StivenWang,I like apple >>> print 'my name is {mingzi},I like{shuiguo}'.format(shuiguo=fruit,mingzi=name) my name is StivenWang,I like apple

    9.检查实验字符串string中是还是不是含有子字符串 str ,假设存在,则赶回str在string中的索引值,假设钦命beg(初始)和 end(截止)范围,则检查是不是含有在钦点范围内,该格局与 python find(卡塔尔(英语:State of Qatar)方法相近,只但是倘诺str不在 string中会报三个不胜(ValueError: substring not found)。

       index(...)

        S.index(sub [,start [,end]])-> int

    1 2 3 4 5 6 7 8 >>> str1 = "this is string example....wow!!!" >>> str2 = "exam" >>> print str1.index(str2) 15 >>> print str1.index(str2,20) Traceback (most recent call last):   File "<input>",line 1, in <module> ValueError: substringnot found报错

    10.检查实验字符串是还是不是由字母或数字组成。

        isalnum(...)

        S.isalnum() -> bool

    1 2 3 4 5 6 7 8 9 10 11 12 >>> a = '123' >>> a.isalnum() True >>> b = 'shaw' >>> b.isalnum() True >>> c = 'shaw123' >>> c.isalnum() True >>> d = 'th 123' >>> d.isalnum() False

    11.质量评定字符串是还是不是只由字母组成

        isalpha(...)

        S.isalpha() -> bool

    1 2 3 4 5 6 7 8 9 10 11 12 >> a = '123' >>> a.isalpha() False >>> b = '123shaw' >>> b.isalpha() False >>> c = 'shaw' >>> c.isalpha() True >>> d = 'sha w' >>> d.isalpha() False

    12.检查实验字符串是不是只由数字构成。

        isdigit(...)

        S.isdigit() -> bool

    1 2 3 4 5 6 7 8 9 >>> a = '123' >>> a.isdigit() True >>> b = 'shaw' >>> b.isdigit() False >>> c = '123shaw' >>> c.isdigit() False

    13.检验字符串是不是由小写字母组成。

        islower(...)

        S.islower() -> bool

    1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 >>> a = 'shaw' >>> a.islower() True >>> b = '123' >>> a.islower() True >>> c = '123shaw' >>> c.islower() True >>> d = 'SHAW' >>> d.islower() False >>> e = '123SHAW' >>> e.islower() False

    14.检测字符串是或不是只由空格组成。

        isspace(...)

        S.isspace() -> bool

    1 2 3 4 5 6 7 8 9 >>> a = ' ' >>> a.isspace() True >>> a = '123' >>> a.isspace() False >>> a = 'shaw' >>> a.isspace() False

    15.检查测量检验字符串中享有的单词拼写首字母是还是不是为大写,且别的字母为小写。

        istitle(...) 

        S.istitle() -> bool

    1 2 3 4 5 6 7 8 9 >>> a = 'Shaw' >>> a.istitle() True >>> a = 'Shaw123' >>> a.istitle() True >>> a = '123' >>> a.istitle() False

    16.检查测量检验字符串中有所的字母是还是不是都为题写

        isupper(...)

          S.isupper() -> bool

    1 2 3 4 5 6 7 8 9 10 11 12 >>> a = '123' >>> a.isupper() False >>> a = 'Shaw' >>> a.isupper() False >>> a = 'Shaw123' >>> a.isupper() False >>> a = 'SHAW123' >>> a.isupper() True

    17.用来将种类中的元素以钦赐的字符连接生成二个新的字符串。

    join(...)

        S.join(iterable) ->string

    1 2 3 4 >>> a = '-' >>> b = 'shaw' >>> print a.join(b) s-h-a-w

    18.重临八个原字符串左对齐,并利用空格填充至内定长度的新字符串。假设钦点的尺寸小于原字符串的长短则赶回原字符串。

        ljust(...)

        S.ljust(width[, fillchar])-> string

        width -- 钦赐字符串长度

        fillchar -- 填充字符,私下认可为空格

    1 2 3 4 5 >>> s = 'shaw' >>> s.ljust(10) 'shaw      ' >>> s.ljust(10,'8') 'shaw888888'

    19.转移字符串中颇有大写字符为小写。

        Lower(...)

        S.lower() -> string

    1 2 3 4 5 6 >>> s = 'PYTHON' >>> s.lower() 'python' >>> s = 'PYTHON123' >>> s.lower() 'python123'

    20.用于截掉字符串左侧包车型客车空格或钦赐字符。

        lstrip(...)

        S.lstrip([chars]) ->string or unicode

    1 2 3 4 5 6 >>> s = '%%%shaw' >>> s.lstrip('%') 'shaw' >>> s = '   shaw' >>> s.lstrip() 'shaw'

    21.遵照钦命的相间符将字符串进行剪切(重返多个3元的元组,第二个为分隔符左边的子串,第叁个为分隔符本人,第四个为分隔符左侧的子串)

        partition(...)

        S.partition(sep) ->(head, sep, tail)

    1 2 3 >>> S = 'are you know:lilin is lowser' >>> S.partition('lilin') ('are you know:', 'lilin', ' is lowser')

    22.把字符串中的 old(旧字符串)替换到 new(新字符串卡塔尔国,如果钦点第多少个参数max,则替换不当先 max 次。

        replace(...)

        S.replace(old, new[,count]) -> string

    1 2 3 >>> S = 'shaw' >>> S.replace('sh','LI') 'LIaw'

    23.重临字符串最终三遍面世的职分,若无相配项则赶回-1。

        rfind(...)

        S.rfind(sub [,start[,end]]) -> int

        str -- 查找的字符串

        beg -- 开首查找之处,默认为0

        end -- 结束查找地点,默感觉字符串的长短。

    1 2 3 4 5 >>> s = 'lilin is good li lao ban' >>> s.rfind('li') 14 >>> s.rfind('li',0,8) 2

    24.重返子字符串 str 在字符串中最后现身的职分,若无相称的字符串会报万分,你能够指定可选参数[beg:end]设置查找的间隔。

        rindex(...)

        S.rindex(sub [,start[,end]]) -> int

        语法:

          str.rindex(str,beg=0 end=len(string))

    1 2 3 4 5 6 7 8 9 >>> s = 'my name is shaw' >>> s.rindex('s') 11 >>> s.rindex('s',5,10) 9 >>> s.rindex('s',2,8) Traceback (most recent call last):   File "<input>",line 1, in <module> ValueError: substring not found

    25.重临的原/新字符串右对齐,且暗许使用空格填充至钦定长度(width)的新字符串。假使钦定的长度(width)小于原字符串的长度则赶回原字符串

        rjust(...)

        S.rjust(width[, fillchar])-> string

        语法:

          str.rjust(width[,fillchar])

           width -- 钦命填充钦命字符后新字符串的路程度.

           fillchar– 要填写的字符,暗许为空格。

    1 2 3 4 5 6 7 >>> s = 'sch' >>> s.rjust(20) '                 sch' >>> s.rjust(20,'0') '00000000000000000sch' >>> s.rjust(20,'H') 'HHHHHHHHHHHHHHHHHsch'

    26.删减 string 字符串末尾的钦赐字符(默感觉空格).

        rstrip(...)

        S.rstrip([chars]) ->string or unicode

        语法:

          str.rstrip([chars])

    1 2 3 >>> s = 'shawn' >>> s.rstrip('n') 'shaw'

    27.透过点名分隔符对字符串进行切开,即便参数num有钦定值,则仅相隔 num 个子字符串

        split(...)

        S.split([sep [,maxsplit]])-> list ofstrings

        语法:

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

    1 2 3 4 5 >>> s = 'shawnlinuxnmac' >>> s.split('n') ['shaw', 'linux', 'mac'] >>> s.split('n',1) ['shaw', 'linuxnmac']

    28.依据行分隔,重返八个满含各行作为成分的列表,假设 num 钦点则仅切成丝 num 个行.

        splitlines(...)

        S.splitlines(keepends=False)-> list ofstrings

        语法:

          str.splitlines( num=string.count('n'))

           num -- 分割行的次数。

    1 2 3 4 5 6 >>> s = 'what's your name?n my name is shawn how old areyou?' >>> s.splitlines() ["what's your name?", ' my name is shaw', ' how old areyou?'] >>> s.splitlines(1) ["what's your name?n", ' my name is shawn', ' how old areyou?'] >>> s.splitlines(3)

    29.用来检查字符串是还是不是是以钦赐子字符串早先,假诺是则赶回 True,不然重临 False。假设参数 beg 和 end钦命值,则在内定范围内检查。

        startswith(...)

        S.startswith(prefix[,start[, end]]) ->bool

        语法:

        str.startswith(str,beg=0,end=len(string))

        str -- 检查测量检验的字符串。

        strbeg -- 可选参数用于安装字符串检查测试的发端地方。

        strend -- 可选参数用于安装字符串检查评定的扫尾地方。

    1 2 3 4 5 >>> s = 'my name is shaw' >>> s.startswith('my') True >>> s.startswith('my',10,15) False

    30.用来移除字符串头尾钦点的字符(默感到空格)。

        strip(...)

        S.strip([chars]) ->string or unicode

    1 2 3 >>> s = 'my name is sam' >>> s.strip('m') 'y name is sa'

    31.用来对字符串的尺寸写字母进行转移(小写转大写,大写转小写卡塔尔国

        swapcase(...)

        S.swapcase() -> string

    1 2 3 4 5 6 >>> s = 'stiven' >>> s.swapcase() 'STIVEN' >>> s = 'SHAW' >>> s.swapcase() 'shaw'

    32.重临"标题化"的字符串,正是说全体单词都以以大写开首,其他字母均为小写。

        title(...)

        S.title() -> string

    1 2 3 >>> s = 'my name is shaw' >>> s.title() 'My Name Is Shaw'

    33.基于参数table给出的表(包罗 256 个字符卡塔尔(قطر‎转变字符串的字符, 并重回翻译后的字符串。要过滤掉的字符放到del 参数中

        translate(...)

        S.translate(table [,deletechars])->string

        语法:

          str.translate(table[, deletechars])

           table -- 翻译表,翻译表是通过maketrans方法调换而来。

          deletechars -- 字符串中要过滤的字符列表。

    1 2 3 4 5 6 7 8 9 >>> from string import maketrans suchas = maketrans('sm','@$') >>> s = 'this is sam's dog' >>> s "this is sam's dog" >>> s.translate(suchas) "[email protected] [email protected] @a$'@ dog" >>> s.translate(suchas,'dog') 去除d,o,g字符 "[email protected] [email protected] @a$'@ "

    34.将字符串中的小写字母转为大写字母

        upper(...)

        S.upper() -> string

    1 2 3 4 5 6 7 8 9 >>> s = 'sam' >>> s.upper() 'SAM' >>> s = '23sam' >>> s.upper() '23SAM' >>> s = '23s am' >>> s.upper() '23S AM'

    如下学习python的字符串用法。 print(dir(str卡塔尔卡塔尔 ['__add__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__...

    前言

    本篇文章将介绍python的字符串操作,越多内容请参照他事他说加以考查:python学习指南

    1)字符串第三个字母大写,其它字母也会转变来小写:

    S.capitalize() -> str
    记念方法:capital(大写字母)

    def capitalize(self): # real signature unknown; restored from __doc__
        """
        S.capitalize() -> str
    
        Return a capitalized version of S, i.e. make the first character
        have upper case and the rest lower case.
        """
        return ""
    

    示例:

    s = 'tieleyumao'
    #首字母大写,其它字母变小写(不管有没有非字母隔开)
    s1 = s.capitalize()
    print(s1)
    s18 = 'yun tie Yumo'
    s19 = s18.capitalize()
    print(s19)
    
    返回的结果是:
    Tielemao
    Yun tie yumo
    

    python中字符串对象提供了累累主意来操作字符串,作用十三分丰富。

    生机勃勃、查看帮助文书档案

    在上学编制程序语言进程中,不管是python语言还是别的语言时我们都应当学会查看API文书档案,查看扶持新闻,以便大家举行支付使用。
    读书python查看文档有三种办法:

    1. 下载官方的API文书档案实行查看,官方地址:新葡亰496net,python官方地址
    2. 能够在地头搭建好的蒙受中,进入命令窗口并切换成python情状,使用dir(卡塔尔(英语:State of Qatar)和help(卡塔尔方法函数实行查看,比如,笔者想查看str字符串中有何属性和方法,使用dir(str卡塔尔命令能够查阅,若是想查看具体的某部方法的行使,如index(卡塔尔国方法,能够动用help(str.index卡塔尔(英语:State of Qatar)的章程查看方法的采用。

    2)全体转变到大写字母 and 全体调换到小写字母:

    注:那生机勃勃对建议放一块纪念。另那个平日用在验证码功用上。
    输入验证码不区分朗朗上口写可信赖它去贯彻。

    S.upper() -> str
    记得方法:up,向上,能够了然为小写的上进提高都变大写了。

    def upper(self): # real signature unknown; restored from __doc__
        """
        S.upper() -> str
    
        Return a copy of S converted to uppercase.
        """
        return ""
    

    示例:

    s = 'tieleyumao'
    #全部转换成大写字母
    s2 = s.upper()
    print(s2)
    
    返回的结果是:TIELEYUMAO
    

    S.lower() -> str
    纪念方法:lower,收缩,大写裁减就能成为小写了。

    def lower(self): # real signature unknown; restored from __doc__
        """
        S.lower() -> str
    
        Return a copy of the string S converted to lowercase.
        """
        return ""
    

    示例:

    s2 = 'TIELEYUMAO'
    #全部转换成小写字母
    s3 = s2.lower()
    print(s3)
    
    返回的结果是:tieleyumao
    
    print(dir(str))
    
    [..........'capitalize', 'casefold', 'center', 'count', 'encode', 'endswith', 'expandtabs', 'find', 'format', 'format_map', 'index', 'isalnum', 'isalpha', 'isdecimal', 'isdigit', 'isidentifier', 'islower', 'isnumeric', 'isprintable', 'isspace', 'istitle', 'isupper', 'join', 'ljust', 'lower', 'lstrip', 'maketrans', 'partition', 'replace', 'rfind', 'rindex', 'rjust', 'rpartition', 'rsplit', 'rstrip', 'split', 'splitlines', 'startswith', 'strip', 'swapcase', 'title', 'translate', 'upper', 'zfill']
    

    二、字符串习感到常函数

    lower():将字符串全形成小写;upper():将字符串全改成大写;原字符串保持不变

    #定义一个字符串变量
    str1 = "AbCd"
    #将str1变成小写,赋值给str2
    str2 = str1.lower()
    #将str1变成大写,赋值给str3
    str3 = str1.upper()
    

    find()函数:函数原型:SttringObject.find(sub, [end]卡塔尔国,效用是回来字符串中第多少个冒出sub的第一个假名的下标,若无找到sub子串,则赶回-1。start和end是可选参数,从start地方下标初叶,到end地点下标截止,在[start, end]中展开搜索

    str1 = "abcdefghijklmn"
    index1 = str1.find("mn", 0, 13)
    

    rfind(),函数原型:StringObject.rfind(sub, [start, [end]]卡塔尔国,再次回到字符串中最后现身sub的第多少个字母的阐明,假诺字符串中平昔不sub,则赶回-1

    >>>str1 = 'abcabcabcabc'
    >>>index1 = str1.rfind('ab')
    >>>index1
    6
    

    index()函数,函数原型StringObject.index(sub, [start,[end]]卡塔尔国,成效跟find函数同样

    >>>str1 = 'hello world'
    >>>index = str1.index('ll')
    >>>index
    2
    >>>index1 = str1.index('xx')
    Traceback (most recent call last):
      File "<stdin>", line 1, in <module>
    ValueError: substring not found
    

    注意:find(卡塔尔国函数和index(卡塔尔国函数的效果是同样的,在三个字符串中查找子串的岗位下标。差异在于,在未曾找到子串的情事下,find函数的重回值是-1;而index(卡塔尔(قطر‎函数就能产出四个ValueError的不胜。

    count()函数,函数原型:StringObject.count(sub, [start, [end]]卡塔尔(قطر‎,总括sub在字符串中冒出的次数

    #定义一个字符串变量
    str1 = "hello,world! hello.python!"
    #计算子串'he'在str1字符串中出现的总次数
    countNum = str1.count('he')
    

    replace()函数,函数原型:StringObject.replace(oldstr, newstr, [, count]卡塔尔(英语:State of Qatar),在那之中count参数为轮番的次数(不输入为一切替换卡塔尔

    #定义一个字符串变量
    >>>str1 = "xyzxyzxyzxxxx"
    #使用replace()函数,将'xyz'替换成'abc'
    >>>str2 = str1.replace('xyz', 'abc')
    >>>str2
    

    strip()函数,函数原型:StringObject.strip([char]卡塔尔(英语:State of Qatar),把字符串前后有char的字符全体去掉,默许去掉空格。lstrip([char]卡塔尔(英语:State of Qatar):去掉字符串左侧有char的字符;rstrip([char]卡塔尔(英语:State of Qatar):去掉字符串侧边有char的字符。

    >>>str1 = '    my name is ...   '
    >>>str2 = str1.strip()
    >>>str2
    my name is ...
    >>>str3 = '******hello evenyone!*****'
    >>>str4 = str3.strip('*')
    >>>str4
    'hello everyone!'
    

    join()方法,函数原型:StringObject.join(iterable卡塔尔国,个中iterable是可迭代类型如列表。效用是用来在队列中添日币素,但需要添加的队列元素都必须是字符串。重回值是一个字符串类型。

    >>>seq = [1, 2, 3, 4]
    >>>sep = ' '
    >>>str1 = sep.join(seq)
    Traceback (most recent call last):
      File "<stdin>", line 1, in <module>
    TypeError: sequence item 0: expected str instance, int found
    

    split()方法,函数原型:StringObject.split(sep=None, maxsplit=-1卡塔尔国,功能是将字符串分割成序列。sep暗许景况下是以空格作为分隔符。

    >>>dirs = "/usr/bin/env"
    >>>dirList = dirs.split("/")
    >>>dirList
    ['', 'user', 'bin', 'env']
    

    3)对字符串操作居中(center):

    S.center(width[, fillchar]) -> str
    回忆方法:center,中央。

    注:需求填参数width宽度的数值进去,假若填的上升的幅度小于字符串宽度,并不会挑起退换。
    除此以外fillchar表示可用你填的字符填充两侧空白处。

    def center(self, width, fillchar=None): # real signature unknown; restored from __doc__
        """
        S.center(width[, fillchar]) -> str
    
        Return S centered in a string of length width. Padding is
        done using the specified fill character (default is a space)
        """
        return ""
    

    示例:

    s = 'tieleyumao'
    #宽度32,字符串居中
    s4 = s.center(32)
    print(s4)
    #宽度32,字符串居中后,两边的空白以*填充
    s5 = s.center(32, '*')
    print(s5)
    
    效果:
               tieleyumao           
    ***********tieleyumao***********
    

    这个方法的使用验证见法定文档:string methods,本文对它们进行详尽分解,各位今后可将本文当做手册。

    三、此外函数

    1. capitalize(卡塔尔(英语:State of Qatar)函数:再次回到三个首字母大写的字符串。
    2. center()函数:S.center(width, [fillchar]卡塔尔(英语:State of Qatar)->string,再次来到一个把原字符串移到中间,默许把两侧加多空格的字符串,也能够和谐拟订填充物
    3. decode()函数:S.decode([新葡亰496net:python字符串操作,字符串常用操作方法。encoding[, errors]])->object,编码
    4. encode()函数:S.encode([encoding[, errors]])->object,解码
    5. endswith()函数,S.endswith(suffix[,start[, end]]卡塔尔国->bool,检查是否以suffix结尾,能够钦定位置,做巡回的论断条件很有用,免去==!
    6. isalnum(卡塔尔国函数,S.isalnum(卡塔尔(英语:State of Qatar)->bool,判别S中是不是全为数字恐怕字母[并至少有二个字符],是则赶回True,未有字符重返False
    7. is阿尔法(卡塔尔国函数,S.is阿尔法(卡塔尔->bool函数,推断是或不是全为字母【并且至稀有叁个字符】
    8. isdigit(卡塔尔(قطر‎函数,S.isdigit(卡塔尔国->bool,判别是还是不是全为数字【并且至稀有三个数字】
    9. islower()函数,S.islower(卡塔尔国->bool,判别字母是或不是全为小写(有数字不影响)【并至稀有三个字符】

    4)对字符串实行高低写翻转:

    S.swapcase() -> str
    回忆方法:swap 调换,case 包围。
    沟通包围,像围棋中的黑白子情形顿然转头黑包白,白包黑,大小写翻转。

    def swapcase(self): # real signature unknown; restored from __doc__
        """
        S.swapcase() -> str
    
        Return a copy of S with uppercase characters converted to lowercase
        and vice versa.
        """
        return ""
    

    示例:

    s6 = 'TieLeYuMao'
    #对s6字符串进行大小写反转
    s7 = s6.swapcase()
    print(s6, s7)
    
    效果:
    TieLeYuMao tIElEyUmAO
    

    此间未有形式相配(正则卡塔尔(英语:State of Qatar)相关的效益。python中要选用方式匹配相关的主意操作字符串,必要import re导入re模块。关刘頔则情势相配,参见:re Module Contents。

    四、Python字符串运算符

    操作符 描述 实例
    字符串连接 a = 'hello' 'python',运行结果:a=‘hellopython’
    * 重复输出字符串 a = '-'*5,运行结果:a = '-----'
    [] 通过索引获取字符串中的字符 a = 'hello' ,b = a[0],运行结果为:b = 'h'
    [:] 截取字符串中一部分字符 a = 'hello world' ,b = a[1:4],运行结果:b='ell'
    in 成员运算符,如果字符串中包含给定的字符返回True,不包含返回False 'h' in a,其中a = ‘hello’,运行结果:True
    not in 成员运算符,如果字符串中包含给定的字符返回False,不包含返回True 'h' in a,其中a = ‘hello’,运行结果:False
    r/R 原始字符串 - 原始字符串:所有的字符串都是直接按照字面的意思来使用,没有转义特殊或不能打印的字符。 原始字符串除在字符串的第一个引号前加上字母"r"(可以大小写)以外,与普通字符串有着几乎完全相同的语法。 print r'n',运行结果为:n

    注意点:1、list、str、dict都以可迭代,可用for循环。
    2、计算字符串的长度使用len(str卡塔尔(قطر‎,恐怕str.len()

    5)以非字母隔断的每一个单词的首字母转变来大写:

    S.title() -> str
    记得方法:title,标题,头衔,季军。能够想像成加冕成大写。
    不过在不体面用之处下要慎用。

    def title(self): # real signature unknown; restored from __doc__
        """
        S.title() -> str
    
        Return a titlecased version of S, i.e. words start with title case
        characters, all remaining cased characters have lower case.
        """
        return ""
    

    示例:

    s8 = 'tiele mao*yu3catdog'
    s9 = s8.title()
    #title对每个非字母隔开的英文视为一个单词进行操作
    print(s9)
    
    效果:
    Tiele Mao*Yu3Catdog
    

    注意,python中字符串是不可变对象,所以具备更改和生成字符串的操作的贯彻况势都以另三个内部存款和储蓄器片段中新生成一个字符串对象。例如,'abc'.upper(卡塔尔将会在划分另三个内部存款和储蓄器片段,并将回来的ABC保存在这里内部存款和储蓄器中。

    6)判定以什么样为(前缀)开端,以怎么着为(后缀)结尾,重临布尔值;

    (成组方便回想,作为评定尺度,重返的是布尔值。
    别的能够切块钦点推断在第肆个人以什么样为发端之类。)

    S.startswith(prefix[, start[, end]]) -> bool
    S.endswith(suffix[, start[, end]]) -> bool
    记得方法:start,初始;end 结尾;swith 快速地;

    判定字符串是或不是以钦定前缀开端/后缀结尾,
    若是以内定前缀开头/后缀结尾重临True,不然重返False。
    可选参数"start"与"end"为搜索字符串的开首与结束地点。

    def startswith(self, prefix, start=None, end=None): # real signature unknown; restored from __doc__
        """
        S.startswith(prefix[, start[, end]]) -> bool
    
        Return True if S starts with the specified prefix, False otherwise.
        With optional start, test S beginning at that position.
        With optional end, stop comparing S at that position.
        prefix can also be a tuple of strings to try.
        """
        return False
    
     def endswith(self, suffix, start=None, end=None): # real signature unknown; restored from __doc__
        """
        S.endswith(suffix[, start[, end]]) -> bool
    
        Return True if S ends with the specified suffix, False otherwise.
        With optional start, test S beginning at that position.
        With optional end, stop comparing S at that position.
        suffix can also be a tuple of strings to try.
        """
        return False
    

    #见到方法的认证参数中含start=None,end=None的意味支持对字符串进行加参数切成块管理。

    示例:

    s10 = 'tieleYumaoCatDog'
    s11 = s10.startswith('ti')
    print(s11)
    s12 = s10.startswith('Yu')
    print(s12)
    #切片判断从左起数第5位开头是Y前缀为真还是假
    s13 = s10.startswith('Y', 5)
    print(s13)
    s14 = s10.endswith('Dog')
    print(s14)
    #判断从第五位开始至第十位结束,后缀结尾是mao是否为真
    s15 = s10.endswith('mao', 5, 10)
    print(s15)
    返回的结果:s11 = True , s12 = False ,s13 = True s14 = True s15 = True。
    

    下文现身的"S"表示待操作的字符串。本文未有对casefold,encode,format,format_map举办介绍,前两方和unicode有关,后两个内容有一点点太多。

    7)去除首尾的空格,换行符,tab(制表符,日常为七个空格);

    S.strip([chars]) -> str
    chars -- 移除字符串头尾内定的字符。迭代,可冬天排列。

    回忆方法:strip,剥除服装……;空,天子的新衣。
    除此外,还有lstrip和rstrip的方法,
    各自对应剥除左(left)和右(right)起头计数的字符
    (填入钦命要剥除的参数,可无序)

    def strip(self, chars=None): # real signature unknown; restored from __doc__
        """
        S.strip([chars]) -> str
    
        Return a copy of the string S with leading and trailing
        whitespace removed.
        If chars is given and not None, remove characters in chars instead.
        """
        return ""
    

    示例1:

    s16 = '  tab    '
    #去除s16首尾的空格,换行符,tab制表符等
    s17 = s16.strip()
    print(s16)
    print(s17)
    
    效果:
      tab  
    tab
    

    示例2:

    name = 'aleX leNb'
    n2 = name.lstrip('al')
    print(n2)
    n3 = name.rstrip('Nb')
    print(n3)
    n4 = name.strip('ab')
    print(n4)
    
    效果为:
    eX leNb
    aleX le
    leX leN
    

    1.尺寸写转变

    8)通过成分查找索引(下标);

    find和index一同记念

    S.find(sub[, start[, end]]卡塔尔国 -> int (再次回到索引值,找不到的回到-1)
    S.index(sub[, start[, end]]卡塔尔 -> int (重临索引值,找不到的报那么些)
    记得方法:find,查找;index,索引。
    要专一的是一次只好回到最早找到的字符索引,和office中的查找有一点类似。

    find(卡塔尔国 方法检验字符串中是不是满含子(sub)字符串 str ,假如钦命beg(先导) 和 end(甘休) 范围,则检查是或不是含有在钦命范围内,借使带有子字符串再次回到早先的索引值,否则重临-1。

    def find(self, sub, start=None, end=None): # real signature unknown; restored from __doc__
        """
        S.find(sub[, start[, end]]) -> int
    
        Return the lowest index in S where substring sub is found,
        such that sub is contained within S[start:end].  Optional
        arguments start and end are interpreted as in slice notation.
    
        Return -1 on failure.
        """
        return 0
    

    index(卡塔尔 方法检验字符串中是还是不是富含子字符串 str ,假使钦定 beg(开头) 和 end(截至) 范围,则检查是或不是含有在钦点范围内,该格局与 python find(卡塔尔(قطر‎方法相符,只然而若是str不在string中会报三个十一分。

    def index(self, sub, start=None, end=None): # real signature unknown; restored from __doc__
        """
        S.index(sub[, start[, end]]) -> int
    
        Like S.find() but raise ValueError when the substring is not found.
        """
        return 0
    

    示例:

    s18 = 'yun tie Yumo'
    print(s18.find('ao'))
    print(s18.find('mo'))
    print(s18.find('i'))
    print(s18.index('tie', 3, -1))
    print(s18.index('i', 2))
    
    结果:
    -1
    10
    5
    4
    5
    

    1.1 lower、upper

    9)count 计数,寻找成分现身的个数;

    S.count(sub[, start[, end]]) -> int
    回想方法:count,流量计;常用变量名,常用函数方法。

    count(卡塔尔国 方法用于计算字符串里有个别字符现身的次数。
    可选参数为在字符串寻觅的发端与截至地方。

     def count(self, sub, start=None, end=None): # real signature unknown; restored from __doc__
        """
        S.count(sub[, start[, end]]) -> int
    
        Return the number of non-overlapping occurrences of substring sub in
        string S[start:end].  Optional arguments start and end are
        interpreted as in slice notation.
        """
        return 0
    

    示例:

    s18 = 'yun tie Yumo'
    print(s18.count('u'))
    
    结果:2
    

    S.lower()
    S.upper()

    10)replace 替换sub str;

    (很有用,比如一些情境下循环遍历非数字的字符替换成空格,再split分割就做出了整套纯数字的列表了。)

    S.replace(old, new[, count]) -> str
    记得方法:replace,替代

    replace(卡塔尔(英语:State of Qatar) 方法把字符串中的 old(旧字符串) 替换成new(新字符串卡塔尔,倘诺钦定第多少个参数max,则替换不当先 max 次。

    def replace(self, old, new, count=None): # real signature unknown; restored from __doc__
        """
        S.replace(old, new[, count]) -> str
    
        Return a copy of S with all occurrences of substring
        old replaced by new.  If the optional argument count is
        given, only the first count occurrences are replaced.
        """
        return ""
    

    示例:

    s18 = 'yun tie Yumo'
    s20 = s18.replace('Yu', 'M', 1)
    print(s20)
    
    结果:yun tie Mmo
    

    再次回到S字符串的小写、大写格式。(注意,那是新生成的字符串,在另一片内部存款和储蓄器片段中,后文将不再解释这种表现卡塔尔

    11)split 分割,首要程度5颗星。因为split比任何字符串操作方法都要美妙,别的是生成新的字符串,它是直接将字符串生成List(列表)了。並且运转操作日志方面也许有常用到它的。

    S.split(sep=None, maxsplit=-1卡塔尔 -> list of strings (生成的是全部是字符串成分结合的列表)
    回想方法:split,分离。

    split(卡塔尔(英语:State of Qatar)通过点名分隔符对字符串实行切开,即便参数num 有钦定值,则仅相隔 num 个子字符串(可钦赐实行剪切的次数)。暗许以空格作为分隔符实行切开。此外要细心的是它以什么字符为分隔符,那钦定的相间符字符就能同一时间也被裁撤掉。此外若分隔符适逢其会在首先位,左侧的远非字符了,依旧会转移空字符串。其它从右往左分割使用rsplit。

    def split(self, sep=None, maxsplit=-1): # real signature unknown; restored from __doc__
        """
        S.split(sep=None, maxsplit=-1) -> list of strings
    
        Return a list of the words in S, using sep as the
        delimiter string.  If maxsplit is given, at most maxsplit
        splits are done. If sep is not specified or is None, any
        whitespace string is a separator and empty strings are
        removed from the result.
        """
        return []
    

    示例:

    s18 = 'yun tie Yumo'
    s21 = s18.split()
    print(s21,type(s21))
    s22 = s18.split('u')
    print(s22)
    print(s18.split('y',1))
    
    效果:
    ['yun', 'tie', 'Yumo'] <class 'list'>
    ['y', 'n tie Y', 'mo']
    ['', 'un tie Yumo']
    

    例如:

    12)join 到场、连接字符串;(建议和split成对记。)

    S.join(iterable) -> str
    记得方法:join,连接(符);能够想像成它正是大器晚成座桥。

    join(卡塔尔国 方法用于将系列中的成分以内定的字符连接生成三个新的字符串。
    它的源码表达文书档案中有iterable(可迭代的,可重复的)表示可对可迭代的靶子开展操作;
    (self对象是'自己')

    别的在对四个列表中的众多字符串成分做拼接操作时,join 是豆蔻梢头种更高效的字符串连接情势,使用 操作时,每实施一回 操作就能以致在内存中生成叁个新的字符串对象,遍历8次有8个字符串生成,形成无谓的内存浪费。而用 join 方法漫天进度只会生出三个字符串对象。

    join不止能对字符串实行操作,还可对元祖/列表等操作,只不超过实际行操作时最棒要确定保障列表中的全数因素都以字符串,不然有个别列表操作会不成功。
    用某字符串做三个连接符,连接可迭代对象中的每三个因素,产生贰个新的字符串。

    #迭代:对Computer特定程序中供给频仍施行的子程序*(少年老成组命令卡塔尔(قطر‎,进行二回重复,即重复试行顺序中的循环,直到满意某条件截止,亦称作迭代。

    def join(self, iterable): # real signature unknown; restored from __doc__
        """
        S.join(iterable) -> str
    
        Return a string which is the concatenation of the strings in the
        iterable.  The separator between elements is S.
        """
        return ""
    

    示例:

    s18 = 'yun tie Yumo'
    s21 = s18.split()
    print(s21,type(s21))
    s23 = '*'.join(s21)
    print(s23,type(s23))
    
    效果:
    (可以看到list转换成str了,且每个元素之间加上了自定义的*号连接符。)
    ['yun', 'tie', 'Yumo'] <class 'list'>
    yun*tie*Yumo <class 'str'>
    
    >>> print('ab XY'.lower())
    ab xy
    >>> print('ab XY'.upper())
    AB XY
    

    13)format 格式化函数,这里唯有记录一下对字符串的格式化操作方法。

    S.format(*args, **kwargs) -> str
    记得方法:format,格式化。

    它加强了字符串格式化的功力。
    基本语法是透过 {} 和 : 来代替原先的 % 。
    format 函数能够承担不限个参数,地方能够不按顺序。

    def format(self, *args, **kwargs): # known special case of str.format
        """
        S.format(*args, **kwargs) -> str
    
        Return a formatted version of S, using substitutions from args and kwargs.
        The substitutions are identified by braces ('{' and '}').
        """
        pass
    

    示例1:

    s = "{} {}".format("hello", "tiele")  #不设置指定位置,按默认顺序
    print(s)  #显示hello tiele
    print("{0} {1}".format("hello", "tiele")) #指定索引位置输出
    
    print("我叫{0},我今年{1}岁,我热爱{2}。
    明年{1},我仍然是{0},我依然热爱{2}。".format("铁乐", "18", "运维开发"))
    # 多个位置对应一个索引位置格式化
    # 输出结果:
    我叫铁乐,我今年18岁,我热爱运维开发。明年18,我仍然是铁乐,我依然热爱运维开发。
    

    示例2:

    # 也可指定参数,下面是通过字典(键值对)指定参数的例子
    site = {"name": "铁乐与猫梦境之森", "url": "www.tielemao.com"}
    print("我的网站:{name}, 网址:{url}".format(**site))
    
    效果:
    我的网站:铁乐与猫梦境之森, 网址:www.tielemao.com
    
    # 通过列表索引设置参数
    my_list = ['铁乐与猫','www.tielemao.com', '运维人生']
    print("我的网站:{0[0]},网址:{0[1]}, 主题是:{0[2]}".format(my_list))
    #注:此处0不可省略,后面[]接的是列表中的索引位置。
    
    效果:
    我的网站:铁乐与猫,网址:www.tielemao.com, 主题是:运维人生
    

    1.2 title、capitalize

    14)推断字符串操作(重返布尔值)

    (很有用,在总括器,验证码之类的输入框中测度都能用到)

    以下多个一块记:
    isalnum(卡塔尔国 方法检验字符串是不是由字母和数字组成。
    is阿尔法(卡塔尔 方法检查测量检验字符串是或不是只由字母组成。
    isdigit(卡塔尔(英语:State of Qatar) 方法检查实验字符串是不是只由数字组成。

    纪念方法:阿尔法,阿尔法,字雄性黑狗;al num,字母 数字;digit,数字,数脚趾。

    动用才具:
    譬喻说,if no str.isdigit()则是判别除数字外的(包蕴特殊符号等情事)都在内了。
    而if str.isdigit(卡塔尔 则条件就是满意是数字。

    实例1:

    # 计算用户输入的内容中有几个整数(以个位数为单位)。
    num = 0
    content = input('请输入由字母和数字组成的内容:').strip()
    for i in content:
        if i.isdigit():
             num  = 1
    print(num)
    
    实例2:
    # 计算用户输入的内容中有几个整数(以相连的数字为一个整数计数)。
    content = input('请输入:').strip()
    for i in content:
         # 判断i不为数字类型就用空格进行替换填充,
         # 注意这里最初我是用了判断是字母类型就进行空格填充,然后就出现了测试时输入特殊符号时计算错误
         # 所以有个原则是尽量用(not 真)的方式来包含不是你所求的范围。
         if not i.isdigit():
            content = content.replace(i, ' ', 1)
    # print(content)
    # 替换空格之后就可以利用split进行对空切割成列表,然后用len求出列表中的元素个数就得出整数个数结果了。
    print('你输入的内容中共有%s个整数。' % len(content.split()))
    

    End

    S.title()
    S.capitalize()

    前面八个重返S字符串中具备单词首字母大写且其余字母小写的格式,后面一个再次回到首字母大写、其余字母全体大写的新字符串。

    例如:

    >>> print('ab XY'.title())
    Ab Xy
    >>> print('abc DE'.capitalize())
    Abc de
    

    1.3 swapcase

    S.swapcase()

    swapcase(卡塔尔(قطر‎对S中的全数字符串做大小写转变(大写-->小写,小写-->大写卡塔尔(英语:State of Qatar)。

    >>> print('abc XYZ'.swapcase())
    ABC xyz
    

    2.isXXX判断

    2.1 isalpha,isdecimal,isdigit,isnumeric,isalnum

    S.isdecimal()
    S.isdigit()
    S.isnumeric()
    S.isalpha()
    S.isalnum()

    测量试验字符串S是不是是数字、字母、字母或数字。对于非Unicode字符串,前3个章程是等价的。

    例如:

    >>> print('34'.isdigit())
    True
    >>> print('abc'.isalpha())
    True
    >>> print('a34'.isalnum())
    True
    

    2.2 islower,isupper,istitle

    S.islower()
    S.isupper()
    S.istitle()

    判别是或不是小写、大写、首字母大写。要求S中起码要含有叁个字符串字符,不然直接回到False。举个例子不可能是纯数字。
    只顾,istitle(卡塔尔剖断时会对各种单词的首字母边界判定。比如,word1 Word2、word1_Word2、word1(卡塔尔(英语:State of Qatar)Word2中都带有八个单词,它们的首字母都以"w"和"W"。由此,倘若用istitle(卡塔尔国去看清它们,将重临False,因为w是小写。

    例如:

    >>> print('a34'.islower())
    True
    >>> print('AB'.isupper())
    True
    >>> print('Aa'.isupper())
    False
    >>> print('Aa Bc'.istitle())
    True
    >>> print('Aa_Bc'.istitle())
    True
    >>> print('Aa bc'.istitle())
    False
    >>> print('Aa_bc'.istitle())
    False
    
    # 下面的返回False,因为非首字母C不是小写
    >>> print('Aa BC'.istitle())
    False
    

    2.3 isspace,isprintable,isidentifier

    S.isspace()
    S.isprintable()
    S.isidentifier()

    各自推断字符串是或不是是空白(空格、制表符、换行符等卡塔尔(英语:State of Qatar)字符、是还是不是是可打字与印刷字符(举例制表符、换行符就不是可打字与印刷字符,但空格是卡塔尔、是不是知足标记符定义准绳。

    例如:

    认清是不是为空白。未有任何字符是不算是空荡荡。

    >>> print(' '.isspace())
    True
    >>> print(' t'.isspace())
    True
    >>> print('n'.isspace())
    True
    >>> print(''.isspace())
    False
    >>> print('Aa BC'.isspace())
    False
    

    认清是还是不是是可打字与印刷字符。

    >>> print('n'.isprintable())
    False
    >>> print('t'.isprintable())
    False
    >>> print('acd'.isprintable())
    True
    >>> print(' '.isprintable())
    True
    >>> print(''.isprintable())
    True
    

    推断是不是知足标记符定义法则。

    标记符定义法则为:只可以是字母或下划线起始、不可能包罗除数字、字母和下划线以外的即兴字符。

    >>> print('abc'.isidentifier())
    True
    >>> print('2abc'.isidentifier())
    False
    >>> print('abc2'.isidentifier())
    True
    >>> print('_abc2'.isidentifier())
    True
    >>> print('_abc_2'.isidentifier())
    True
    >>> print('_Abc_2'.isidentifier())
    True
    >>> print('Abc_2'.isidentifier())
    True
    

    3.填充

    3.1 center

    S.center(width[, fillchar])

    将字符串居中,左右两侧使用fillchar实行填充,使得整个字符串的长短为width。fillchar默以为空格。借使width小于字符串的尺寸,则无从填充直接回到字符串自身(不会创立新字符串对象卡塔尔国。

    例如:

    应用下划线填充并居中字符串

    >>> print('ab'.center(4,'_'))
    _ab_
    >>> print('ab'.center(5,'_'))
    __ab_
    

    运用默许的空格填充并居中字符串

    >>> print('ab'.center(4))
     ab 
    >>> print(len('ab'.center(4)))
    4
    

    width小于字符串长度

    >>> print('abcde'.center(3))
    abcde
    

    3.2 ljust和rjust

    S.ljust(width[, fillchar])
    S.rjust(width[, fillchar])

    ljust(卡塔尔(英语:State of Qatar)使用fillchar填充在字符串S的动手,使得全体尺寸为width。rjust(卡塔尔国则是填充在左臂。如若不点名fillchar,则暗中认可使用空格填充。

    要是width小于或等于字符串S的长度,则无从填充,直接重返字符串S(不会成立新字符串对象卡塔尔。

    例如:

    >>> print('xyz'.ljust(5,'_'))
    xyz__
    >>> print('xyz'.rjust(5,'_'))
    __xyz
    

    3.3 zfill

    S.zfill(width)

    用0填充在字符串S的左边使其尺寸为width。要是S前右正负号 /-,则0填充在此八个暗号的末尾,且符号也算入长度。
    后生可畏经width小于或等于S的长短,则无从填充,间接再次来到S自个儿(不会创设新字符串对象卡塔尔(英语:State of Qatar)。

    >>> print('abc'.zfill(5))
    00abc
    
    >>> print('-abc'.zfill(5))
    -0abc
    
    >>> print(' abc'.zfill(5))
     0abc
    
    >>> print('42'.zfill(5))
    00042
    
    >>> print('-42'.zfill(5))
    -0042
    
    >>> print(' 42'.zfill(5))
     0042
    

    4.子串寻找

    4.1 count

    S.count(sub[, start[, end]])

    归来字符串S中子串sub现身的次数,能够钦点从哪个地方早先估量(start卡塔尔甚至计算到何地结束(end卡塔尔(英语:State of Qatar),索引从0开头思量,不包蕴end边界。

    例如:

    >>> print('xyabxyxy'.count('xy'))
    3
    
    # 次数2,因为从index=1算起,即从'y'开始查找,查找的范围为'yabxyxy'
    >>> print('xyabxyxy'.count('xy',1))
    2
    
    # 次数1,因为不包括end,所以查找的范围为'yabxyx'
    >>> print('xyabxyxy'.count('xy',1,7))
    1
    
    # 次数2,因为查找的范围为'yabxyxy'
    >>> print('xyabxyxy'.count('xy',1,8))
    2
    

    4.2 endswith和startswith

    S.endswith(suffix[, start[, end]])
    S.startswith(prefix[, start[, end]])

    endswith(卡塔尔(英语:State of Qatar)检查字符串S是还是不是已suffix结尾,再次来到布尔值的True和False。suffix可以是叁个元组(tuple卡塔尔(قطر‎。能够钦定起先start和结尾end的查究边界。

    同理startswith(卡塔尔用来剖断字符串S是还是不是是以prefix开始。

    例如:

    suffix是平凡的字符串时。

    >>> print('abcxyz'.endswith('xyz'))
    True
     
    # False,因为搜索范围为'yz'
    >>> print('abcxyz'.endswith('xyz',4))
    False
     
    # False,因为搜索范围为'abcxy'
    >>> print('abcxyz'.endswith('xyz',0,5))
    False
    >>> print('abcxyz'.endswith('xyz',0,6))
    True
    

    suffix是元组(tuple卡塔尔国时,只要tuple中随意一个成分满足endswith的标准化,就回来True。

    # tuple中的'xyz'满足条件
    >>> print('abcxyz'.endswith(('ab','xyz')))
    True
     
    # tuple中'ab'和'xy'都不满足条件
    >>> print('abcxyz'.endswith(('ab','xy')))
    False
     
    # tuple中的'z'满足条件
    >>> print('abcxyz'.endswith(('ab','xy','z')))
    True
    

    4.3 find,rfind和index,rindex

    S.find(sub[, start[, end]])
    S.rfind(sub[, start[, end]])¶
    S.index(sub[, start[, end]])
    S.rindex(sub[, start[, end]])

    find(卡塔尔(英语:State of Qatar)搜索字符串S中是还是不是带有子串sub,即便带有,则赶回sub的目录地点,不然再次来到"-1"。能够钦定起头start和甘休end的寻觅地方。

    index(卡塔尔(قطر‎和find(卡塔尔(英语:State of Qatar)同样,独一区别点在于当找不到子串时,抛出ValueError错误。

    rfind(卡塔尔则是回到搜索到的最侧边子串的职位,借使只找寻到二个或从不搜索到子串,则和find(卡塔尔是等价的。

    同理rindex()。

    例如:

    >>> print('abcxyzXY'.find('xy'))
    3
    >>> print('abcxyzXY'.find('Xy'))
    -1
    >>> print('abcxyzXY'.find('xy',4))
    -1
    
    >>> print('xyzabcabc'.find('bc'))
    4
    >>> print('xyzabcabc'.rfind('bc'))
    7
    
    >>> print('xyzabcabc'.rindex('bcd'))
    Traceback (most recent call last):
     File "<stdin>", line 1, in <module>
    ValueError: substring not found
    

    能够运用in操作符来剖断字符串S是还是不是满含子串sub,它回到的不是索引位置,而是布尔值。

    >>> 'xy' in 'abxycd'
    True
    >>> 'xyz' in 'abxycd'
    False
    

    5.替换

    5.1 replace

    S.replace(old, new[, count])

    将字符串中的子串old替换为new字符串,借使给定count,则代表只替换前count个old子串。借使S中探索不到子串old,则不可能轮番,直接重回字符串S(不创立新字符串对象卡塔尔国。

    >>> print('abcxyzoxy'.replace('xy','XY'))
    abcXYzoXY
    >>> print('abcxyzoxy'.replace('xy','XY',1))
    abcXYzoxy
    >>> print('abcxyzoxy'.replace('mn','XY',1))
    abcxyzoxy
    

    5.2 expandtabs

    S.expandtabs(N)

    将字符串S中的t替换为自然数量的空格。暗中同意N=8。

    注意,expandtabs(8)不是将t直接替换为8个空格。比方'xyztab'.expandtabs()会将t替换为5个空格,因为"xyz"占用了3个字符位。

    别的,它不会轮流换行符(n或r)时。

    例如:

    >>> '01t012t0123t01234'.expandtabs(4)
    '01 012 0123 01234'
    
    >>> '01t012t0123t01234'.expandtabs(8)
    '01  012  0123 01234'
    
    >>> '01t012t0123t01234'.expandtabs(7)
    '01  012 0123 01234'
    
    >>> print('012t0123n01234'.expandtabs(7))
    012 0123
    01234
    

    5.3 translate和maketrans

    S.translate(table)
    static str.maketrans(x[, y[, z]])

    str.maketrans(卡塔尔(قطر‎生成二个字符生机勃勃风流倜傥映射的table,然后利用translate(table卡塔尔(英语:State of Qatar)对字符串S中的每一个字符举行映射。

    假定您熟练Linux,就知道tr命令,translate(卡塔尔(قطر‎实现的效果与利益和tr是看似的。

    举个例子,未来想要对"I love fairy"做叁个简易的加密,将中间某些字符都替换为数字,这样外人就不晓得转变后的那句话是什么样看头。

    >>> in_str='abcxyz'
    >>> out_str='123456'
    
    # maketrans()生成映射表
    >>> map_table=str.maketrans(in_str,out_str)
    
    # 使用translate()进行映射
    >>> my_love='I love fairy'
    >>> result=my_love.translate(map_table)
    >>> print(result)
    I love f1ir5
    

    注意,maketrans(x[, y[, z]]卡塔尔中的x和y都以字符串,且长度必需相等。

    如果maketrans(x[, y[, z]]卡塔尔国给定了第两个参数z,那这么些参数字符串中的每个字符都会被映射为None。

    例如,不替换"o"和"y"。

    >>> in_str='abcxyz'
    >>> out_str='123456'
    >>> map_table=str.maketrans(in_str,out_str,'ay')
    >>> my_love='I love fairy'
    >>> result=my_love.translate(map_table)
    >>> print(result)
    I love fir
    

    6.分割

    6.1 partition和rpartition

    S.partition(sep)
    S.rpartition(sep)

    招来字符串S中的子串sep,并从sep处对S进行划分,最终回到三个包含3成分的元组:sep左边包车型地铁有的是元组的第一个成分,sep本身是元组的三个因素,sep左边是元组的首个要素。

    partition(sep卡塔尔国从侧面第二个sep进行划分,rpartition(sep卡塔尔(英语:State of Qatar)从侧边第叁个sep进行分割。

    假设搜索不到sep,则赶回的3成分元组中,有八个成分为空。partition(卡塔尔(英语:State of Qatar)是后多个因素为空,rpartition(卡塔尔(英语:State of Qatar)是前多少个要素为空。

    例如:

    # 只搜索到一个sep时,两者结果相同
    >>> print('abcxyzopq'.partition('xy'))
    ('abc', 'xy', 'zopq')
    >>> print('abcxyzopq'.rpartition('xy'))
    ('abc', 'xy', 'zopq')
    
    # 搜索到多个sep时,分别从左第一个、右第一个sep分割
    >>> print('abcxyzxyopq'.partition('xy'))
    ('abc', 'xy', 'zxyopq')
    >>> print('abcxyzxyopq'.rpartition('xy'))
    ('abcxyz', 'xy', 'opq')
    
    # 搜索不到sep
    >>> print('abcxyzxyopq'.partition('xyc'))
    ('abcxyzxyopq', '', '')
    >>> print('abcxyzxyopq'.rpartition('xyc'))
    ('', '', 'abcxyzxyopq')
    

    6.2 split、rsplit和splitlines

    S.split(sep=None, maxsplit=-1)
    S.rsplit(sep=None, maxsplit=-1)
    S.splitlines([keepends=True])

    都是用来分割字符串,并转移一个列表。

    split(卡塔尔(قطر‎依照sep对S进行分割,maxsplit用于钦定分割次数,倘使不点名maxsplit或然给定值为"-1",则会从做向右寻觅何况每遇到sep一遍就分开直到寻觅完字符串。假设不内定sep或许内定为None,则变动分割算法:以空格为分隔符,且将接连的空域压缩为三个空格。

    rsplit(卡塔尔国和split(卡塔尔(قطر‎是均等的,只不过是从左边向左边寻找。

    splitlines(卡塔尔国用来特意用来划分换行符。固然它有一些像split('n')或split('rn'卡塔尔(英语:State of Qatar),但它们有些分裂,见下文解释。

    率先是split(卡塔尔(英语:State of Qatar)的现身说法剖判(rsplit(卡塔尔示例略卡塔尔(قطر‎。

    # sep为单个字符时
    >>> '1,2,3'.split(',')
    ['1', '2', '3']
    
    >>> '1,2,3'.split(',',1)
    ['1', '2,3']  # 只分割了一次
    
    >>> '1,2,,3'.split(',')
    ['1', '2', '', '3'] # 不会压缩连续的分隔符
    
    >>> '<hello><><world>'.split('<')
    ['', 'hello>', '>', 'world>']
    
    # sep为多个字符时
    >>> '<hello><><world>'.split('<>')
    ['<hello>', '<world>']
    
    # 不指定sep时
    >>> '1 2 3'.split()
    ['1', '2', '3']
    
    >>> '1 2 3'.split(maxsplit=1)
    ['1', '2 3']
    
    >>> '  1  2  3  '.split()
    ['1', '2', '3']
    
    >>> '  1  2  3 n'.split()
    ['1', '2', '3']
    
    # 显式指定sep为空格、制表符、换行符时
    >>> ' 1 2 3 n'.split(' ')
    ['', '1', '', '2', '', '3', '', 'n']
    
    >>> ' 1 2 3 n'.split('t')
    [' 1 2 3 n']
    
    >>> ' 1 2n3 n'.split('n')
    [' 1 2', '3 ', ''] # 注意列表的最后一项''
    
    >>> ''.split('n')
    ['']
    

    再是splitlines(卡塔尔国的亲自过问解析。

    splitlines(卡塔尔中得以钦点各个换行符,经常见到的是n、r、rn。若是内定keepends为True,则保留全部的换行符。

    >>> 'ab cnnde fgrklrn'.splitlines()
    ['ab c', '', 'de fg', 'kl']
    
    >>> 'ab cnnde fgrklrn'.splitlines(keepends=True)
    ['ab cn', 'n', 'de fgr', 'klrn']
    

    将split(卡塔尔(قطر‎和splitlines(卡塔尔(قطر‎绝相比一下:

    #### split()
    >>> ''.split('n')
    ['']      # 因为没换行符可分割
    
    >>> 'One linen'.split('n')
    ['One line', '']
    
    #### splitlines()
    >>> "".splitlines()
    []       # 因为没有换行符可分割
    
    >>> 'Two linesn'.splitlines()
    ['Two lines']
    

    7.join

    S.join(iterable)

    将可迭代对象(iterable卡塔尔中的字符串使用S连接起来。注意,iterable中必需全都以字符串类型,不然报错。

    万意气风发你还是python的初读书人,还不知情iterable是怎么着,却想来拜望join的实际语法,那么你能够偶尔将它精晓为:字符串string、列表list、元组tuple、字典dict、集结set。

    例如:

    字符串

    >>> L='python'
    >>> '_'.join(L)
    'p_y_t_h_o_n'
    

    元组

    >>> L1=('1','2','3')
    >>> '_'.join(L1)
    '1_2_3'
    

    会面。注意,集结严节。

    >>> L2={'p','y','t','h','o','n'}
    >>> '_'.join(L2)
    'n_o_p_h_y_t'
    

    列表

    >>> L2=['py','th','o','n']
    >>> '_'.join(L2)
    'py_th_o_n'
    

    字典

    >>> L3={'name':"malongshuai",'gender':'male','from':'China','age':18}
    >>> '_'.join(L3)
    'name_gender_from_age'
    

    iterable参预迭代的后生可畏对必需是字符串类型,无法包涵数字或别的种类。

    >>> L1=(1,2,3)
    >>> '_'.join(L1)
    Traceback (most recent call last):
     File "<stdin>", line 1, in <module>
    TypeError: sequence item 0: expected str instance, int found
    

    以下两种也不能够join。

    >>> L1=('ab',2)
    >>> L2=('AB',{'a','cd'})
    

    8.修剪:strip、lstrip和rstrip

    S.strip([chars])
    S.lstrip([chars])
    S.rstrip([chars])

    独家是移除左右两侧、侧面、右侧的字符char。假如不点名chars大概钦赐为None,则暗许移除空白(空格、制表符、换行符卡塔尔(قطر‎。

    唯黄金时代必要注意的是,chars能够是多少个字符系列。在移除时,只假若那么些队列中的字符,都会被移除。

    例如:

    移除单个字符或空白。

    >>> '  spacious  '.lstrip()
    'spacious  '
     
    >>> '  spacious  '.rstrip()
    '  spacious'
     
    >>> 'spacious  '.lstrip('s')
    'pacious  '
     
    >>> 'spacious'.rstrip('s')
    'spaciou'
    

    2.移除字符中的字符。

    >>> print('www.example.com'.lstrip('cmowz.'))
    example.com
    >>> print('wwwz.example.com'.lstrip('cmowz.'))
    example.com
    >>> print('wwaw.example.com'.lstrip('cmowz.'))
    aw.example.com
    >>> print('www.example.com'.strip('cmowz.'))
    'example'
    

    出于www.example.com的前4个字符都是字符系列cmowz.中的字符,所以都被移除,而第四个字符e不在字符体系中,所以修剪到此甘休。同理wwwz.example.com。

    wwaw.example.com中第一个字符a不是字符体系中的字符,所以修剪到此甘休。

    总结

    如上就是那篇小说的全体内容了,希望本文的源委对大家的读书恐怕干活有所自然的参阅学习价值,若是有疑难我们能够留言沟通,多谢大家对剧本之家的援救。

    您大概感兴趣的文章:

    • Python 字符串操作方法大全
    • 在Python中操作字符串之replace(卡塔尔方法的运用
    • Python 字符串操作实现代码(截取/替换/查找/分割卡塔尔
    • Python中常用操作字符串的函数与方式计算
    • Python字符串切成丝操作知识详细解释
    • Python中的字符串查找操作方法总计
    • python字符串的常用操作方法小结
    • 在Python中操作字符串之startswith(卡塔尔(قطر‎方法的施用
    • Python列表(list卡塔尔国、字典(dict卡塔尔(英语:State of Qatar)、字符串(string卡塔尔(قطر‎基本操作小结
    • 在Python中操作字符串之rstrip(卡塔尔(英语:State of Qatar)方法的利用

    本文由新葡亰496net发布于奥门新萄京娱乐场,转载请注明出处:新葡亰496net:python字符串操作,字符串常用操作

    关键词:

上一篇:新葡亰496net四线程编制程序

下一篇:没有了