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

新葡亰496net字符串常见操作,常见操作

发布时间:2019-09-08 01:21编辑:奥门新萄京娱乐场浏览(64)

    (1)find

    01-python中字符串的宽广操作,01-python字符串

    (1)find

    检查测量试验str是或不是带有在myStr中,假如存在则赶回开头的索引值,不然重回-1。

    In [1]: myStr = "hello world tairan and tairanCity."
    
    In [2]: str = "tairan"
    
    In [3]: myStr.find(str)
    Out[3]: 12
    
    In [7]: str = "helo"
    
    In [8]: myStr.find(str)
    Out[8]: -1
    

    (2)index

    搜寻索引。

    In [9]: myStr = "hello world tairan and tairanCity"
    
    In [10]: myStr.find("world")
    Out[10]: 6
    
    In [11]: myStr.find("tairan")
    Out[11]: 12
    
    In [12]: myStr.rfind("tairan")
    Out[12]: 23    #rfind代表从有右往左查
    

    (3)count

    归来str在start和end之间在myStr内部现身的次数。

    In [13]: myStr
    Out[13]: 'hello world tairan and tairanCity'
    
    In [14]: myStr.count("hello")
    Out[14]: 1
    
    In [15]: myStr.count("tairan")
    Out[15]: 2
    

    (4)replace

    把myStr中的str替换成new_str,借使count钦赐,则替换不超过count次。

    In [16]: myStr
    Out[16]: 'hello world tairan and tairanCity'
    
    In [17]: myStr.replace("hello","nihao")
    Out[17]: 'nihao world tairan and tairanCity'
    
    In [18]: myStr.replace("tairan","TaiRan")
    Out[18]: 'hello world TaiRan and TaiRanCity'
    
    In [20]: myStr.replace("tairan","Tairan",1)    #如果指定了count,则替换不能超过count次
    Out[20]: 'hello world Tairan and tairanCity'
    

    (5)split

    切割,以str为分隔符,假如maxsplit有钦定值,则仅分割maxaplit个字符串。

    In [21]: myStr
    Out[21]: 'hello world tairan and tairanCity'
    
    In [22]: str = " "
    
    In [23]: myStr.split(str)
    Out[23]: ['hello', 'world', 'tairan', 'and', 'tairanCity']
    
    In [24]: myStr.split(str,2)  #指定count为2
    Out[24]: ['hello', 'world', 'tairan and tairanCity']
    

    (6)capitalize

    把字符串的率先个字符大写。

    In [25]: myStr
    Out[25]: 'hello world tairan and tairanCity'
    
    In [26]: myStr.capitalize()
    Out[26]: 'Hello world tairan and tairancity'
    

    (7)title

    把字符串的各样单词的首字母大写。

    In [27]: myStr
    Out[27]: 'hello world tairan and tairanCity'
    
    In [28]: myStr.title()
    Out[28]: 'Hello World Tairan And Tairancity'
    

    (8)startswith

    检验字符串是还是不是已obj起首,是则赶回True,,否则再次回到False。

    In [29]: myStr
    Out[29]: 'hello world tairan and tairanCity'
    
    In [30]: myStr.startswith("hello")
    Out[30]: True
    
    In [32]: myStr.startswith("helo")
    Out[32]: False
    

    (9)enddswith

    反省字符串是还是不是已obj结尾,是则赶回True,不然再次来到False。

    In [33]: myStr
    Out[33]: 'hello world tairan and tairanCity'
    
    In [34]: myStr.endswith("ty")
    Out[34]: True
    
    In [35]: myStr.endswith("txt")
    Out[35]: False
    

    (10)lower

    调换myStr第11中学存有大写字符为小写。

    In [36]: myStr1 = "HELLO WORLD TAIRAN AND TAIRANCITY"
    
    In [37]: myStr1.lower()
    Out[37]: 'hello world tairan and tairancity'
    

    (11)upeer

    改变myStr中保有小写字符为大写。

    In [38]: myStr
    Out[38]: 'hello world tairan and tairanCity'
    
    In [39]: myStr.upper()
    Out[39]: 'HELLO WORLD TAIRAN AND TAIRANCITY'
    

    (12)ljust

    回到一个原字符串左对齐,并应用空格填充至长度width的新字符串。

    In [40]: str = "hello"
    
    In [41]: str.ljust(10)
    Out[41]: 'hello     '
    

    (13)rjust

    回来一个原字符串右

    In [42]: str
    Out[42]: 'hello'
    
    In [43]: str.rjust(10)
    Out[43]: '     hello'
    

    (14)center

    回到多个原字符居中,并动用空格填充至长度width的新字符串。

    In [45]: str.center(10)
    Out[45]: '  hello   '
    

    (15)lstrip

    除去myStr左侧的空白字符。

    In [47]: myStr = "       hello"
    
    In [48]: myStr.lstrip()
    Out[48]: 'hello'
    

    (16)rstrip

    删除myStr侧面的空白字符。

    In [49]: myStr = "hello         "
    
    In [50]: myStr.rstrip()
    Out[50]: 'hello'
    

    (17)strip

    去除myStr字符串两端的空白字符。

    In [51]: myStr = "    hello       "
    
    In [52]: myStr.strip()
    Out[52]: 'hello'
    

    (18)partition

    把myStr以str分割成三片段:str前,str,str后。

    In [53]: myStr = "hello world tairan and tairanCity."
    
    In [54]: str = "tairan"
    
    In [55]: myStr.partition(str)
    Out[55]: ('hello world ', 'tairan', ' and tairanCity.')  #返回的是元组,而且包含空格
    
    In [56]: myStr.rpartition(str)
    Out[56]: ('hello world tairan and ', 'tairan', 'City.')  #rpartition表示从右往左查找
    

    (19)splitlines

    根据行分割,再次回到叁个带有各行作为元素的列表。

    In [57]: myStr = "hellonworld"
    
    In [58]: print(myStr)
    hello
    world
    
    In [59]: myStr.splitlines()
    Out[59]: ['hello', 'world']
    

    (20)isalpha

    设若myStr的保有字符都以字母,则赶回True,不然再次来到False。

    In [61]: myStr
    Out[61]: 'danjk'
    
    In [62]: myStr.isalpha()
    Out[62]: True
    
    In [63]: myStr1 = "1244"
    
    In [64]: myStr1.isalpha()
    Out[64]: False
    

    (21)isdigit

    假定myStr只含有数字则赶回True,不然再次回到False。

    In [66]: myStr = "213131"
    
    In [67]: myStr.isdigit()
    Out[67]: True
    
    In [68]: myStr = "dmakd"
    
    In [69]: myStr.isdigit()
    Out[69]: False
    

    (22)isalnum

    固然字符串都以字符也许数字则赶回True,不然重回False。

    In [70]: myStr = "21da2"
    
    In [71]: myStr.isalnum()
    Out[71]: True
    
    In [72]: myStr = "2112123"
    
    In [73]: myStr.isalnum()
    Out[73]: True
    

    (23)isspace

    一旦字符串至少有叁个字母,并且具有字符都以空格,则赶回True,不然重回False。

    In [74]: myStr = "       "
    
    In [75]: myStr.isspace()
    Out[75]: True
    
    In [76]: myStr = "   dad       "
    
    In [77]: myStr.isspace()
    Out[77]: False
    

    (23)join

    myStr中各类字符后边插入str,构形成一个新的字符串。

    In [78]: str = " "
    
    In [79]: myStr = ["my","name","is","xiaoyafei"]
    
    In [80]: str.join(myStr)
    Out[80]: 'my name is xiaoyafei'
    
    In [81]: str = "_"
    
    In [82]: str.join(myStr)
    Out[82]: 'my_name_is_xiaoyafei'
    

     

    (1)find 检查评定str是或不是含有在myStr中,假使存在则赶回初始的索引值,不然重回-1。 In [1]: myStr =...

    长见的操作查找

    <1>find

    检查测验 str 是不是含有在 mystr中,假诺是回去起始的索引值,不然重临-1

    mystr.find(str, start=0, end=len(mystr))
    

    mystr = 'hello jianshu , This is Python demo '

    检查评定str是不是包罗在myStr中,即便存在则赶回伊始的索引值,不然重回-1。

    1.string.find(str, beg=0, end=len(string))

    <2>index

    跟find()方法一样,只然则倘使str不在 mystr中会报多少个极度.

    mystr.index(str, start=0, end=len(mystr)) 
    

    以下是广阔的操作

    In [1]: myStr = "hello world tairan and tairanCity."
    
    In [2]: str = "tairan"
    
    In [3]: myStr.find(str)
    Out[3]: 12
    
    In [7]: str = "helo"
    
    In [8]: myStr.find(str)
    Out[8]: -1
    

    检查评定 str 是还是不是带有在 string 中,借使 beg 和 end 钦赐范围,则检查是不是含有在钦定范围内,假若是回去起首的索引值,不然重临-1

    <3>count

    回到 str在start和end之间 在 mystr里面出现的次数

    mystr.count(str, start=0, end=len(mystr))
    

    <1>find

    检测 str 是或不是包括在 mystr 中,如若是回去开始的索引值,不然再次来到 -1

    # 记住,返回的是所在位置索引值,没找到就返回-1
    mystr.find(str, start=0, end=len(mystr)) 
    

    (2)index

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

    <4>replace

    把 mystr 中的 str1 替换到 str2,假如 count 内定,则替换不抢先 count 次.

    mystr.replace(str1, str2,  mystr.count(str1))
    

    <2> index

    跟find()方法同样,只可是假若str不在 mystr中会报三个非凡.

    # 如果没有找到,会抛出异常'substring not found'
    mystr.index(str, start=0, end=len(mystr)) 
    

    搜寻索引。

    类似于 find()函数,但是是从侧边开头查找.

    <5>split

    以 str 为分隔符切块 mystr,要是 maxsplit有钦定值,则仅相隔 maxsplit 个子字符串

    mystr.split(str=" ", 2)    
    

    <3>count

    回去 str在start和end之间 在 mystr里面现身的次数

    mystr.count(str, start=0, end=len(mystr))
    
    In [9]: myStr = "hello world tairan and tairanCity"
    
    In [10]: myStr.find("world")
    Out[10]: 6
    
    In [11]: myStr.find("tairan")
    Out[11]: 12
    
    In [12]: myStr.rfind("tairan")
    Out[12]: 23    #rfind代表从有右往左查
    

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

    <6>capitalize

    把字符串的首先个字符大写

    mystr.capitalize()
    

    <4>replace

    把 mystr 中的 str1 替换到 str2,假使 count 钦命,则替换不当先 count 次.

    # 记住这里替换之后会返回一个新的字符串
    mystr.replace(str1, str2,  mystr.count(str1))
    

    (3)count

    临近于 find()函数,然则找不到报至极.

    新葡亰496net字符串常见操作,常见操作。<7>title

    把字符串的各种单词首字母大写

    >>> a = "hello itcast"
    >>> a.title()
    'Hello Itcast'
    

    <5>split

    以 str 为分隔符切成丝 mystr,纵然 maxsplit有钦命值,则仅相隔 maxsplit 个子字符串

    # 按照空格字符串拆分,参数2为最大拆分数
    mystr.split(str=" ", 2)    
    

    归来str在start和end之间在myStr当中出现的次数。

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

    <8>startswith

    检查字符串是不是是以 hello 初始, 是则赶回 True,不然重回 False

    mystr.startswith(hello)
    

    <6>capitalize

    把字符串的率先个字符大写

    mystr.capitalize()
    
    In [13]: myStr
    Out[13]: 'hello world tairan and tairanCity'
    
    In [14]: myStr.count("hello")
    Out[14]: 1
    
    In [15]: myStr.count("tairan")
    Out[15]: 2
    

    相近于 rfind()函数,可是找不到报非凡.

    <9>endswith

    检查字符串是或不是以obj甘休,要是是回到True,不然重回 False.

    mystr.endswith(obj)
    

    <7>title

    把字符串的各种单词首字母大写

    >>> a = "hello jianshu"
    >>> a.title()
    >>> 'Hello Jianshu'
    

    (4)replace

    2.统计string.count(str, beg=0, end=len(string))

    <10>lower

    退换 mystr 中全数大写字符为题写

    mystr.lower()        
    

    <8>startswith

    自己争论字符串是不是是以 obj 发轫, 是则赶回 True,不然重回 False

    mystr.startswith(obj)
    

    把myStr中的str替换成new_str,借使count内定,则替换不当先count次。

    检查实验 str 是或不是含有在 string 中冒出的次数,假若 beg 和 end 内定范围,则检查是还是不是带有在钦赐范围内

    <11>upper

    改变 mystr 中的小写字母为题写

    mystr.upper()    
    

    <9>endswith

    检查字符串是或不是以obj甘休,若是是再次回到True,不然重临 False.

    mystr.endswith(obj)
    
    In [16]: myStr
    Out[16]: 'hello world tairan and tairanCity'
    
    In [17]: myStr.replace("hello","nihao")
    Out[17]: 'nihao world tairan and tairanCity'
    
    In [18]: myStr.replace("tairan","TaiRan")
    Out[18]: 'hello world TaiRan and TaiRanCity'
    
    In [20]: myStr.replace("tairan","Tairan",1)    #如果指定了count,则替换不能超过count次
    Out[20]: 'hello world Tairan and tairanCity'
    

    3.分割string.split(str="", num=string.count(str))

    <12>ljust

    归来多少个原字符串左对齐,并运用空格填充至长度 width 的新字符串

    mystr.ljust(width) 
    

    <10>lower

    调换 mystr 中保有大写字符为题写

    mystr.lower()       
    

    (5)split

    以 str 为分隔符切成片 string,借使 num有钦命值,则仅相隔 num 个子字符串

    <13>rjust

    归来一个原字符串右对齐,并动用空格填充至长度 width 的新字符串

    mystr.rjust(width)    
    

    <11>upper

    更动 mystr 中的小写字母为题写

    mystr.upper()    
    

    切割,以str为分隔符,纵然maxsplit有钦命值,则仅分割maxaplit个字符串。

    string.splitlines([keepends])

    <14>center

    归来八个原字符串居中,并选取空格填充至长度 width 的新字符串

    mystr.center(width)   
    

    <12>ljust

    回到贰个原字符串左对齐,并选拔空格填充至长度 width 的新字符串

    mystr.ljust(width) 
    
    In [21]: myStr
    Out[21]: 'hello world tairan and tairanCity'
    
    In [22]: str = " "
    
    In [23]: myStr.split(str)
    Out[23]: ['hello', 'world', 'tairan', 'and', 'tairanCity']
    
    In [24]: myStr.split(str,2)  #指定count为2
    Out[24]: ['hello', 'world', 'tairan and tairanCity']
    

    按照行('r', 'rn', n')分隔,重返贰个分包各行作为元素的列表,假若参数 keepends 为 False,不带有换行符,假如为 True,则保留换行符。

    <15>lstrip

    删去 mystr 左侧的空白字符

    mystr.lstrip()
    

    <13>rjust

    归来三个原字符串右对齐,并接纳空格填充至长度 width 的新字符串

    mystr.rjust(width)    
    

    (6)capitalize

    string.partition(str)

    <16>rstrip

    删去 mystr 字符串末尾的空白字符

    mystr.rstrip()    
    

    <14>center

    回来三个原字符串居中,并运用空格填充至长度 width 的新字符串

    mystr.center(width)   
    

    把字符串的首先个字符大写。

    有一点点像 find()和 split()的结合体,从 str 现身的率先个职务起,把 字 符 串 string 分 成 一 个 3 元 素 的 元 组 (string_pre_str,str,string_post_str),如若 string 中不富含str 则 string_pre_str == string.

    <17>strip

    剔除mystr字符串两端的空白字符

    >>> a = "nt itcast tn"
    >>> a.strip()
    'itcast'
    

    <15>lstrip

    除去 mystr 左边的空白字符

    mystr.lstrip()
    
    In [25]: myStr
    Out[25]: 'hello world tairan and tairanCity'
    
    In [26]: myStr.capitalize()
    Out[26]: 'Hello world tairan and tairancity'
    

    string.rpartition(str)

    <18>rfind

    左近于 find()函数,不过是从左边初叶查找.

    mystr.rfind(str, start=0,end=len(mystr) )
    

    <16>rstrip

    除去 mystr 字符串末尾的空白字符

    mystr.rstrip()    
    

    (7)title

    看似于 partition()函数,不过是从左边开首.

    <19>rindex

    就像于 index(),可是是从左边开始.

    mystr.rindex( str, start=0,end=len(mystr))
    

    <17>strip

    删除mystr字符串两端的空白字符

    # 只是去除两端字符串,如果 'jian shu', 中间存在空格,则不去除中间的
    >>> a = "nt jianshu tn"
    >>> a.strip()
    >>> 'jianshu'
    

    把字符串的各样单词的首字母大写。

    4.判断string.startswith(obj, beg=0,end=len(string))

    <20>partition

    把mystr以str分割成三部分,str前,str和str后

    mystr.partition(str)
    

    <18>rfind

    左近于 find()函数,然而是从右侧伊始查找.

    mystr.rfind(str, start=0,end=len(mystr) )
    
    In [27]: myStr
    Out[27]: 'hello world tairan and tairanCity'
    
    In [28]: myStr.title()
    Out[28]: 'Hello World Tairan And Tairancity'
    

    检查字符串是不是是以 obj 最早,是则赶回 True,不然再次回到 False。假诺beg 和 end 钦命值,则在钦赐范围内检查.

    <21>rpartition

    类似于 partition()函数,可是是从左侧最早.

    mystr.rpartition(str)
    

    <19>rindex

    看似于 index(),可是是从左侧初步.

    mystr.rindex( str, start=0,end=len(mystr))
    

    (8)startswith

    string.endswith(obj, beg=0,end=len(string))

    <22>splitlines

    依据行分隔,重临一个分包各行作为成分的列表

    mystr.splitlines()  
    

    <20>partition(分区, 分成3段)

    把mystr以str分割成三有些,str前,str

    # 返回一个元祖, 参数是按照那个字符串去拆分
    mystr.partition(str)
    

    检查实验字符串是不是已obj最初,是则赶回True,,不然再次回到False。

    检查字符串是或不是是以 obj 结尾,是则赶回 True,不然再次回到 False。假使beg 和 end 钦点值,则在钦定范围内检查.

    <23>isalpha

    一经 mystr 全部字符都以字母 则赶回 True,不然重临 False

    mystr.isalpha()  
    

    <21>rpartition

    类似于 partition()函数,可是是从左边起头.

    # 从右到左,分三段
    mystr.rpartition(str)
    
    In [29]: myStr
    Out[29]: 'hello world tairan and tairanCity'
    
    In [30]: myStr.startswith("hello")
    Out[30]: True
    
    In [32]: myStr.startswith("helo")
    Out[32]: False
    

    string.isalnum() 全数字符都是字母或数字则赶回 True,否则重回 False

    24>isdigit

    假定 mystr 只含有数字则赶回 True 不然重回 False.

    mystr.isdigit() 
    

    <22>splitlines

    依照行分隔,再次来到贰个包蕴各行作为成分的列表

    # 分割的字符串,按照n  分割
    mystr.splitlines()  
    

    (9)enddswith

    string.is阿尔法() 全数字符都是字母则赶回 True,不然重返 False

    <25>isalnum

    假设 mystr 全部字符都以字母或数字则赶回 True,不然再次来到 False

    mystr.isalnum()  
    

    <23>isalpha

    设若 mystr 全数字符都以字母 则赶回 True,不然重临 False

    # 必须为存字符, 空格都属于其他字符,
    mystr.isalpha()  
    

    反省字符串是还是不是已obj结尾,是则赶回True,不然重回False。

    string.isdigit() 全部字符都以数字则赶回 True,不然再次回到 False

    <26>isspace

    一旦 mystr 中只包罗空格,则赶回 True,不然重临 False.

    mystr.isspace()   
    

    <24>isdigit

    只要 mystr 只包罗数字则赶回 True 不然再次回到 False.

    # 必须为纯数字, 空格都属于其他字符,
    mystr.isdigit() 
    
    In [33]: myStr
    Out[33]: 'hello world tairan and tairanCity'
    
    In [34]: myStr.endswith("ty")
    Out[34]: True
    
    In [35]: myStr.endswith("txt")
    Out[35]: False
    

    string.isupper() 全部字符都是大写则赶回 True,不然重回 False

    <27>join

    mystr 中各样成分后边插入str,构造出多个新的字符串

    mystr.join(str)
    

    <25>isalnum

    假设 mystr 全数字符都是字母或数字则赶回 True,否则重回 False

    mystr.isalnum()  
    

    (10)lower

    string.islower() 全部字符都以小写则赶回 True,否则重回 False

    <26>isspace

    只要 mystr 中只好分包空格,则赶回 True,不然重返 False.

    mystr.isspace()   
    

    改动myStr第11中学习用具备大写字符为小写。

    string.isspace() 只含有空格则赶回 True,否则再次回到 False

    <27>join

    mystr 中各类字符前边插入str,构造出三个新的字符串

    # 用法 : mystr.join(str)
    >>> strs = ['my','name','is', 'hai']
    >>> strSpace = ' '
    >>> strSpace.join(strs)
    # 以下是输出结果
    >>> 'my name is hai'
    
    In [36]: myStr1 = "HELLO WORLD TAIRAN AND TAIRANCITY"
    
    In [37]: myStr1.lower()
    Out[37]: 'hello world tairan and tairancity'
    

    5大小写string.capitalize()

    问题:

    1. 给定三个字符串aStr,重临使用空格只怕't'分割后的尾数第2个子串

       testStr = 'haha nihao a t heihei t woshi nide t hao nnnn'
      
       # 即可以去除以上字符串中的所有转义和空格符号
      
       # 1. 去除t n 空格
       strList = testStr.strip()
       # 2. 得到新的字符串,拼接起来
       newStr = ''.join(strList)
      

    (11)upeer

    把字符串的率先个字符大写

    转变myStr中有所小写字符为大写。

    string.upper()

    In [38]: myStr
    Out[38]: 'hello world tairan and tairanCity'
    
    In [39]: myStr.upper()
    Out[39]: 'HELLO WORLD TAIRAN AND TAIRANCITY'
    

    退换 string 中的小写字母为题写

    (12)ljust

    string.lower()

    重返三个原字符串左对齐,并运用空格填充至长度width的新字符串。

    调换 string 中的小写字母为题写

    In [40]: str = "hello"
    
    In [41]: str.ljust(10)
    Out[41]: 'hello     '
    

    6string.ljust(width)

    (13)rjust

    归来一个原字符串左对齐,并利用空格填充至长度 width 的新字符串

    回到贰个原字符串右

    string.rjust(width)

    In [42]: str
    Out[42]: 'hello'
    
    In [43]: str.rjust(10)
    Out[43]: '     hello'
    

    归来三个原字符串右对齐,并选择空格填充至长度 width 的新字符串

    (14)center

    string.center(width)

    再次来到多少个原字符居中,并利用空格填充至长度width的新字符串。

    回去多个原字符串居中,并动用空格填充至长度 widt串h 的新字符

    In [45]: str.center(10)
    Out[45]: '  hello   '
    

    7.string.strip([obj])

    (15)lstrip

    去除 string 字符串前后的的obj,借使不传参数,删除前后空格

    删除myStr左侧的空白字符。

    新葡亰496net,string.lstrip([obj])

    In [47]: myStr = "       hello"
    
    In [48]: myStr.lstrip()
    Out[48]: 'hello'
    

    除去 string 字符串左面的obj,如若不传参数,删除左面空格

    (16)rstrip

    string.rstrip([obj])

    剔除myStr右侧的空白字符。

    除去 string 字符串右面包车型大巴obj,如若不传参数,删除右面空格

    In [49]: myStr = "hello         "
    
    In [50]: myStr.rstrip()
    Out[50]: 'hello'
    

    新葡亰496net 1

    (17)strip

    新葡亰496net 2

    剔除myStr字符串两端的空白字符。

    In [51]: myStr = "    hello       "
    
    In [52]: myStr.strip()
    Out[52]: 'hello'
    

    (18)partition

    把myStr以str分割成三片段:str前,str,str后。

    In [53]: myStr = "hello world tairan and tairanCity."
    
    In [54]: str = "tairan"
    
    In [55]: myStr.partition(str)
    Out[55]: ('hello world ', 'tairan', ' and tairanCity.')  #返回的是元组,而且包含空格
    
    In [56]: myStr.rpartition(str)
    Out[56]: ('hello world tairan and ', 'tairan', 'City.')  #rpartition表示从右往左查找
    

    (19)splitlines

    依照行分割,重临贰个分包各行作为元素的列表。

    In [57]: myStr = "hellonworld"
    
    In [58]: print(myStr)
    hello
    world
    
    In [59]: myStr.splitlines()
    Out[59]: ['hello', 'world']
    

    (20)isalpha

    就算myStr的有所字符都是字母,则赶回True,不然重临False。

    In [61]: myStr
    Out[61]: 'danjk'
    
    In [62]: myStr.isalpha()
    Out[62]: True
    
    In [63]: myStr1 = "1244"
    
    In [64]: myStr1.isalpha()
    Out[64]: False
    

    (21)isdigit

    借使myStr只含有数字则赶回True,不然再次来到False。

    In [66]: myStr = "213131"
    
    In [67]: myStr.isdigit()
    Out[67]: True
    
    In [68]: myStr = "dmakd"
    
    In [69]: myStr.isdigit()
    Out[69]: False
    

    (22)isalnum

    假定字符串都以字符或然数字则赶回True,不然重临False。

    In [70]: myStr = "21da2"
    
    In [71]: myStr.isalnum()
    Out[71]: True
    
    In [72]: myStr = "2112123"
    
    In [73]: myStr.isalnum()
    Out[73]: True
    

    (23)isspace

    比如字符串至少有叁个字母,并且具有字符都是空格,则赶回True,不然重回False。

    In [74]: myStr = "       "
    
    In [75]: myStr.isspace()
    Out[75]: True
    
    In [76]: myStr = "   dad       "
    
    In [77]: myStr.isspace()
    Out[77]: False
    

    (23)join

    myStr中各种字符后边插入str,构形成一个新的字符串。

    In [78]: str = " "
    
    In [79]: myStr = ["my","name","is","xiaoyafei"]
    
    In [80]: str.join(myStr)
    Out[80]: 'my name is xiaoyafei'
    
    In [81]: str = "_"
    
    In [82]: str.join(myStr)
    Out[82]: 'my_name_is_xiaoyafei'
    

     

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

    关键词:

上一篇:1源码阅读,学习之安装

下一篇:没有了