05-03字符串与其常用操作

Posted cishi

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了05-03字符串与其常用操作相关的知识，希望对你有一定的参考价值。

目录

字符串及其操作

字符串是集合类型, 并不是一个基本类型

字符串对象操作

新建字符串

  • 方法1：s = ‘hello python‘
  • 方法2：s = "hello python"
  • 方法3：s = ‘‘‘hello python‘‘‘
  • 方法4：s = """hello python"""

前两种完全一样, 后两种完全一样
三引号可以定义多行字符串，单/双引号只能定义单行字符串

方法3或方法4与方法1或方法2的区别：
    In [42]: s = ‘‘‘hello python
        ...: i like python‘‘‘

    In [43]: s = ‘hello python
      File "<ipython-input-43-07b7eed529d4>", line 1
        s = ‘hello python
                         ^
    SyntaxError: EOL while scanning string literal

    三引号可以定义多行字符串
    单/双引号只能定义单行字符串

删除字符串对象

需要使用del方法删除
截至2020年5月23日，本人暂时还未发现其他的方法

字符串元素操作

转义

转义字符(这里的不全,可以互联网搜索)

  • ：换行
  • ：制表符
  • ：回车

回车与换行区别：老式打印机

换行是纸带往上移动一行。
回车是把针头回到开始位置。
window是 换行。unix是 。

python3中加r前缀代表此字符串是自然字符串

In [47]: s = ‘i like 
python‘

In [48]: print(s)
i like 
python

In [49]: s = ‘i‘m comyn‘    #‘有特殊作用，所以需要‘转义一下

In [50]: print(s)
i‘m comyn

三引号常用于：
sql = ‘‘‘select * from `table` where name=‘comyn‘ ‘‘‘


取消转义场景
In [52]: path = ‘c:windows
tsystem32‘    # 正常情况显示

In [53]: print(path)
c:windows
tsystem32

In [54]: path = ‘c:windows\ntsystem32‘    # 取消转义

In [55]: print(path)
c:windows
tsystem32

In [56]: path = ‘c:\windows\system32‘   # 也可以将所有的都转移,以防万一。

In [57]: path = r‘c:windows
tsystem32‘   # 加r前缀代表此字符串是自然字符串, 不会转义,python3中只有
前缀。python2中有u前缀。

In [58]: print(path)
c:windows
tsystem32

In [59]: ‘
‘ == ‘
‘    # 
和
是不相等的。
Out[59]: False

In [60]: print("123
45")    # 
回到起点,将12盖掉了
453
python3中所有字符串都是unixcode

查询操作

下标操作

  • 字符串也支持下表操作
  • 字符串是无法通过下标更改的
  • 字符串是可迭代对象，也就是说可以作为for循环的值
In [61]: s 
Out[61]: "i‘m comyn"

In [62]: s[3]
Out[62]: ‘ ‘

In [63]: s[4]
Out[63]: ‘c‘

In [64]: type(s[4])
Out[64]: str

In [65]: s[4] = C    # 字符串是不可变的
---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
<ipython-input-65-a888c3296699> in <module>()
----> 1 s[4] = C

NameError: name ‘C‘ is not defined

In [66]: s
Out[66]: "i‘m comyn"

字符串是可迭代对象：
    In [67]: for c in s:
        ...:     print(c)
        ...:
    i
    ‘
    m

    c
    o
    m
    y
    n

字符串的操作

连接

str.join连接，将可迭代对象转换为字符串
注意：此操作会返回一个新的字符串对象，但不会操作原有可迭代对象

In [73]: lst = [‘i‘, ‘am‘, ‘comyn‘]

In [74]: ‘ ‘.join(lst)   # join是字符串的方法,参数是可迭代对象,接收者是分隔符
Out[74]: ‘i am comyn‘

In [76]: ‘,‘.join(lst)
Out[76]: ‘i,am,comyn‘

In [77]: ‘‘.join(lst)
Out[77]: ‘iamcomyn‘

分割

分割：指定分隔符对字符串进行切片

split通过指定分隔符对字符串进行切片，返回一个list
  • split默认使用空格分割
  • 多个空格当成一个空格处理
  • 当指定了以空格为分割符时,每个空格都处理
  • s.split(maxsplit=1) # 只分割一次,maxsplit参数表示分割多少次，默认是-1, 表示分割所有分隔符
  • s.split(‘lo‘) # 分隔符可以是任意字符串
In [78]: s = ‘i love python‘

In [80]: s.split()    # split默认使用空格分割
Out[80]: [‘i‘, ‘love‘, ‘python‘]

In [81]: ‘i     love python‘.split()   # 多个空格当成一个空格处理
Out[81]: [‘i‘, ‘love‘, ‘python‘]

In [82]: ‘i     love python‘.split(‘ ‘)   # 当指定了以空格为分割符时,每个空格都处理
Out[82]: [‘i‘, ‘‘, ‘‘, ‘‘, ‘‘, ‘love‘, ‘python‘]

In [83]: s.split(maxsplit=1)   # 只分割一次
Out[83]: [‘i‘, ‘love python‘]

In [84]: ‘i i i i i i i i i‘.split(maxsplit=2)   # split从左往右分割字符串, maxsplit参数表示分割多少次, 默认为-1, 表示分割所有分隔符。
Out[84]: [‘i‘, ‘i‘, ‘i i i i i i i‘]

In [85]: s.split(‘o‘)   # 指定o为分割符
Out[85]: [‘i l‘, ‘ve pyth‘, ‘n‘]

In [86]: s.split(‘lo‘)   # 分隔符可以是任意字符串
Out[86]: [‘i ‘, ‘ve python‘]


split的实现：
In [90]: def split(s, sep, maxsplit):
    ...:     ret = []
    ...:     tmp = []
    ...:     i = ()
    ...:     for c in s:
    ...:         if c != sep:
    ...:             tmp.append(c)
    ...:         else:
    ...:             i += 1
    ...:             ret.append(‘‘.join(tmp))
    ...:             tmp.clear()
    ...:         if maxsplit > 0 and i >= maxsplit:
    ...:             ret.append()
    ...:             return ret
    ...:     return ret
rsplit

rsplit：是split从右往左的版本

In [87]: ‘i i i i ii i i‘.rsplit(maxsplit=1)
Out[87]: [‘i i i i ii i‘, ‘i‘]

In [88]: ‘i i i i ii i i‘.rsplit()
Out[88]: [‘i‘, ‘i‘, ‘i‘, ‘i‘, ‘ii‘, ‘i‘, ‘i‘]

In [89]: ‘i i i i ii i i‘.split()
Out[89]: [‘i‘, ‘i‘, ‘i‘, ‘i‘, ‘ii‘, ‘i‘, ‘i‘]
当不是用maxsplit参数时, split和rsplit表现形式一样,但是split效率高于rsplit


rsplit的实现：
In [91]: def rsplit(s, sep, maxsplit):
    ...:     ret = []
    ...:     tmp = []
    ...:     i = ()
    ...:     for c in reversed(s):
    ...:         if c != sep:
    ...:             tmp.append(c)
    ...:         else:
    ...:             i += 1
    ...:             ret.append(‘‘.join(reversed(tmp)))
    ...:             tmp.clear()
    ...:         if maxsplit > 0 and i >= maxsplit:
    ...:             ret.append()
    ...:             return reversed(ret)
    ...:     return reversed(ret)
splitlines：分割行
  • 返回结果不会带换行符
In [92]: s = ‘‘‘ i am comyn
    ...: i love python‘‘‘

In [93]: s.splitlines()   # 按行分割,并且返回结果不带换行符
Out[93]: [‘ i am comyn‘, ‘i love python‘]

In [94]: s.splitlines(True)   # 按行分割, 并且返回结果带换行符
Out[94]: [‘ i am comyn
‘, ‘i love python‘]
partition返回三元组
  • 当要分割的内容为空时,返回也为空
  • 当要分割的内容为要返回的内容时, 除了sep, 其他都为空
In [95]: ‘i am comyn‘.partition(‘ ‘)   # 总是返回一个三元组, 它按传入分割符分割一次,得到 head tail, 返回结果是head, sep, tail。(sep是指分隔符)
Out[95]: (‘i‘, ‘ ‘, ‘am comyn‘)


partition的实现：
In [103]: def partition(s, sep):
     ...:     if s == ‘‘:
     ...:         return ‘‘,‘‘,‘‘
     ...:     tmp = s.split(sep, mapsplit=1)
     ...:     if len(tmp) == 2:
     ...:         return tmp[0], sep, tmp[1]
     ...:     if len(tmp) == 1:
     ...:         return tmp[0], sep, ‘‘
     ...:     if len(tmp) == 0:
     ...:         return ‘‘, sep, ‘‘
rpartition

rpartition：是partition从右往左的版本

In [96]: cfg = ‘mysql.connect = mysql://user:password@127.0.0.1:3306/test‘

In [97]: cfg.partition(‘=‘)
Out[97]: (‘mysql.connect ‘, ‘=‘, ‘ mysql://user:password@127.0.0.1:3306/test‘)

In [98]: cfg = ‘env = PATH=/usr/bin:$PATH‘

In [99]: cfg.partition(‘=‘)
Out[99]: (‘env ‘, ‘=‘, ‘ PATH=/usr/bin:$PATH‘)

In [100]: ‘‘.partition(‘=‘)   # 当要分割的内容为空时,返回也为空
Out[100]: (‘‘, ‘‘, ‘‘)

In [101]: ‘=‘.partition(‘=‘)   # 当要分割的内容为要返回的内容时, 除了sep, 其他都为空
Out[101]: (‘‘, ‘=‘, ‘‘)

转换

经常用在英文书写格式上面，比如首字母大写。

In [104]: s = ‘test‘

In [105]: s.upper()   # 全部转换为大写
Out[105]: ‘TEST‘

In [106]: s.upper().lower()   # 先转换为大写,然后转换为小写
Out[106]: ‘test‘

In [107]: s.title()   # 首字母转换为大写
Out[107]: ‘Test‘

In [108]: s.capitalize()   # 首字母转换为大写
Out[108]: ‘Test

In [109]: ‘i love python‘.title()   # 与capitalize的区别, title常用于标题
Out[109]: ‘I Love Python‘

In [110]: ‘i love python‘.capitalize()   # 与title的区别, 常用于正文
Out[110]: ‘I love python‘

In [111]: s.center(80)    # 标题居中
Out[111]: ‘                                      test                                      ‘

In [112]: s.zfill(80)    # 居右,用0填充
Out[112]: ‘0000000000000000000000000000000000000000000000000000000000000000000000000000test‘

In [117]: s.casefold()   # 原地返回
Out[117]: ‘test‘

In [118]: ‘Test TTset‘.casefold()   # 使用大小写不同的测试, 全转换为大写或小写, 不同的平台有不同的表现形式, 但是同一个平台下, 表现形式相同, 通常用来忽略大小写的比较。忽略大小写。
Out[118]: ‘test ttset‘ 

In [119]: s.swapcase()   # 大小写互换
Out[119]: ‘TEST‘

In [120]: ‘Test‘.swapcase()   # 大小写互换
Out[120]: ‘tEST‘

In [121]: ‘	‘.expandtabs(4)   # 将table制表符转换为空格
Out[121]: ‘    ‘

In [123]: s.format()   # 单独讲,变化非常多,非常常用。
Out[123]: ‘test‘
upper：全部转换为大写
lower：全部转换为小写
title：标题,首字母大写
capitalize：首字母大写,常用于正文
center：标题居中
zfill：标题居右, 用0填充
casefold：忽略大小写
swapcase：大小写互换
expandtabs：将table制表符转换为空格

修改

In [124]: s = ‘i love python‘

In [125]: s.replace(‘love‘, ‘give up‘)  # 返回新字符串,使用new替换old
Out[125]: ‘i give up python‘

In [127]: s = ‘i very very love python‘

In [128]: s.replace(‘very‘, ‘not‘)   # 有多少个替换多少个
Out[128]: ‘i not not love python‘

In [129]: s.replace(‘very‘, ‘not‘, 1)   # 可选的count参数,指定替换多少次
Out[129]: ‘i not very love python‘

replace只能从前往后替换

In [130]: s = ‘     hahahahahah haha    ‘

In [131]: s.strip()   # strip移除字符串前后的空格
Out[131]: ‘hahahahahah haha‘

In [132]: s = ‘
 
 	 hahaha 	 
 
‘

In [133]: s.strip()   # strip移除前后的空白字符
Out[133]: ‘hahaha‘
注意：空格和空白是不一样的概念

In [135]: s = ‘######haha #### haha #####‘

In [136]: s.strip(‘#‘)   # 指定移除字符 
Out[136]: ‘haha #### haha ‘

In [138]: s = ‘{{ haha }}‘  

In [139]: s.strip(‘{}‘)    # 指定移除多个字符
Out[139]: ‘ haha ‘

In [140]: s.strip(‘{} ‘)   # 多加个空白,移除空白字符
Out[140]: ‘haha‘

In [141]: s.lstrip(‘{} ‘)   # lstrip表现和strip一样,但是只处理左端
Out[141]: ‘haha }}‘

In [142]: s.rstrip(‘{} ‘)   # rstrip表现和strip一样,但是只处理右端
Out[142]: ‘{{ haha‘

In [143]: s = ‘test‘   

In [144]: s.ljust(10)    # 原串在左边
Out[144]: ‘test      ‘

In [145]: s.rjust(10)    # 原串在右边
Out[145]: ‘      test‘

In [146]: s.center(10)   # 原串在中间
Out[146]: ‘   test   ‘

In [147]: s.center(10, ‘#‘)   # 原串在中间,使用指定字符填充
Out[147]: ‘###test###‘

In [148]: s.ljust(10, ‘#‘)   # 原串在右边,使用指定字符填充
Out[148]: ‘test######‘

In [149]: s.center(10, ‘##‘)   # 填充字符串长度只能为1
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-149-6e82a3cbddcf> in <module>()
----> 1 s.center(10, ‘##‘)

TypeError: The fill character must be exactly one character long

In [150]: s.center(3)   # 如果宽度小于等于原串长度,不做任何操作
Out[150]: ‘test‘

In [152]: s.center(11, ‘#‘)   # 优先填充左边
Out[152]: ‘####test###‘
replace：替换, 全替换
strip：移除字符串前后的空格
lstrip：移除左端的字符
rstrip：移除右端的字符
center：居中, 可以使用随意字符串填
ljust：原串在左边
rjust：原串在右边

查找

In [155]: s = ‘i love python‘

In [156]: s.find(‘love‘)   # 从左往右查找,找到第一个字串love,返回字串首字母的索引
Out[156]: 2 

In [157]: s.find(‘love1‘)   # 当字串不存在时,返回-1
Out[157]: -1

In [158]: s = ‘i very very love python‘

In [159]: s.find(‘very‘)    # 当有多个值的时候,返回第一个
Out[159]: 2

In [160]: s.find(‘very‘, 3)   # start参数指定从哪里开始查找
Out[160]: 7

In [161]: s.find(‘very‘, 3, 5)   # end参数指定到哪里结束查找, end不包含
Out[161]: -1

In [162]: s.rfind(‘very‘)   # rfind是find从右往左的版本
Out[162]: 7

In [163]: s.rfind(‘very‘, 3)  # start和stop意义一样,事实上, 是先根据start和stop截取字符串,再查找
Out[163]: 7

In [164]: s.rfind(‘very‘, 8)
Out[164]: -1

In [165]: s.index(‘very‘)   # 几乎与find一模一样
Out[165]: 2

In [166]: s.index(‘very‘, 3)
Out[166]: 7

In [167]: s.index(‘very‘, 8)    # 不存在的抛出ValueError, find查找不存在的时候返回-1, index和find惟一区别。
---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
<ipython-input-167-c5dce18db14c> in <module>()
----> 1 s.index(‘very‘, 8)

ValueError: substring not found

In [3]: s.rindex(‘very‘)    # rindex是index从右往左的版本
Out[3]: 7

In [5]: s.count(‘very‘)   # 存在
Out[5]: 2

In [6]: s.count(‘haha‘)   # 不存在返回0
Out[6]: 0

In [7]: s.count(‘very‘, 3)   # 从第三个开始统计
Out[7]: 1
s.find：查找, 从左至右
s.rfind：查找, 从右至左
s.index：根据值找出位置
s.rindex：是index的从右至左的版本
s.count：统计关键词出现的次数

判断

In [8]: s.startswith(‘i very‘)    # 判断字符串是否以某个前缀开始,返回结果是bool
Out[8]: True

In [9]: s.startswith(‘abc‘)
Out[9]: False

In [10]: s.startswith(‘very‘, 2)   # start参数表示的是从索引start处开始比较
Out[10]: True

In [11]: s.startswith(‘very‘, 2, 5)  # end参数表示从索引end处停止比较
Out[11]: False

In [12]: s.endswith(‘python‘)   # 判断字符串是否以某个后缀结尾, 返回bool
Out[12]: True

In [3]: s.endswith(‘python‘, 17)   # start参数表示从索引start处开始比较
Out[3]: True

In [5]: s.endswith(‘python‘, 0, 22)   # end参数表示到索引end为止, 不包含end
Out[5]: False

In [6]: ‘a‘.isalnum()   # 检测字符串是否由字母和数字组成;
Out[6]: True

In [81]: s.isalnum()   # 因为s含有空格, 所以返回False
Out[81]: False

In [82]: s.isidentifier()   # 字符是否是合法标示符
Out[82]: False

In [84]: ‘abc_123‘.isidentifier()
Out[84]: True

合法标示符：
    字母或者下划线开头
    仅包含字母数字和下划线

In [9]: ‘a‘.isidentifier()
Out[9]: True

string模块是补充自带字符方法不够的模块;
s.startswith：判断字符串是否以某个前缀开始,返回结果是bool
s.endswith：end参数表示从索引end处停止比较
s.isalnum：检测字符串是否由字母或数字，多个空格都不行
s.isdecimal：检查字符串是否只包含十进制字符，这种方法只存在于unicode对象。
s.islower：检测字符串是否由小写字母组成
s.isspace：检测字符串是否只由空格组成。
s.isalpha：检测字符串是否只由字母组成。
s.isdigit：检测字符串是否只由数字组成。
s.isnumeric：检测字符串是否只由数字组成，这种方法是只针对unicode对象。
s.istitle：检测字符串中所有的单词拼写首字母是否为大写，且其他字母为小写。
s.isascii：判断字符串是否只包含ASCII字符
s.isidentifier：用于判断字符串是否是有效的Python标识符，可用来判断变量名是否合法。
s.isprintable：如果所有字符都是可打印的，则isprintable()方法返回True，否则返回False。不可打印的字符可以是回车和换行符。
s.isupper：检测字符串中所有的字母是否都为大写





以上是关于05-03字符串与其常用操作的主要内容，如果未能解决你的问题，请参考以下文章

21个常用代码片段

记录C#常用的代码片段

BottomSheetDialogFragment 如何与其宿主片段通信？

那些你常用的JSP知识

提效小技巧——记录那些不常用的代码片段

C#程序员经常用到的10个实用代码片段 - 操作系统