python字符串内置方法

2022-08-12 08:04:30

网上已经有很多，自己操作一遍，加深印象。

dir

dir会返回一个内置方法与属性列表，用字符串'a,b,cdefg'测试一下

dir('a,b,cdefg')

得到一个列表

['__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']

双下横向开头的字符串为内部方法或私有方法。剩下的就是能用到的字符串方法了。

str.capitalize()

首字母大写

In：'a,b,cdefg'.capitalize()

Out: 'A,b,cdefg'

str.casefold()

把所有字母变为小写，与lower类似，lower只支持英文字母A~Z，但是casefold可以把非英文变为小写。

In:'B,b,cdEfg'.casefold()

Out: 'b,b,cdefg'

In:'B,b,cdEfg'.lower()

Out: 'b,b,cdefg'

官方：

str.casefold()

Return a casefolded copy of the string. Casefolded strings may be used for caseless matching.

Casefolding is similar to lowercasing but more aggressive because it is intended to remove all case distinctions in a string. For example, the German lowercase letter 'ß' is equivalent to "ss". Since it is already lowercase, lower() would do nothing to 'ß'; casefold() converts it to "ss".

The casefolding algorithm is described in section 3.13 of the Unicode Standard.

New in version 3.3.

In：'ß'.lower()

Out: 'ß'

In：'ß'.casefold()

Out: 'ss'

**`str.center`(width[, fillchar])**

按照给定字符和总宽度居中显示。比如，宽度为5的字符串‘11111’按照给定字符‘r’和总宽度8，显示的是：5个原始字符居中，'r'填充，长度为8的字符串。

In:''.center(8,'r')

Out: 'r11111rr'

**`str.count`(sub, start, end)**

子字符串在原字符串中的个数。

sub -- 需要搜索的子字符串

start -- 字符串开始搜索的位置，不填默认0

end -- 字符串结束搜索的位置，不填为最后

In:'r11111rr'.count('',1,5)

Out[39]: 4

`str.encode`(encoding="utf-8", errors="strict")

encoding -- 编码方式

errors -- 错误的处理方案。默认为 'strict',是编码错误引起一个UnicodeError。其他可能得值有 'ignore'--‘ ’, 'replace'--‘？’, 'xmlcharrefreplace'-- 可扩展标记语言替换, 'backslashreplace'--反斜杠替代以及codecs.register_error() 注册的所有值。

'党'.encode('ascii')
Traceback (most recent call last):

File "<ipython-input-52-eb91b915d522>", line 1, in <module>
'党'.encode('ascii')

UnicodeEncodeError: 'ascii' codec can't encode character '\u515a' in position 0: ordinal not in range(128)


'党'.encode('ascii','replace')

Out[48]: b'?'

'党'.encode('ascii','ignore')

Out[49]: b''

'党'.encode('ascii','xmlcharrefreplace')

Out[50]: b'党'

'党'.encode('ascii','backslashreplace')

Out[51]: b'\\u515a'

**`str.endswith`(suffix, start, end)**

如果字符串含有指定的后缀返回True，否则返回False。

suffix -- 子字符串

start -- 长字符串中的开始位置，默认0

end -- 长字符中结束位置，默认最后

'B,b,cdEfg'.endswith('g')

Out[54]: True

'B,b,cdEfg'.endswith('Efg')

Out[55]: True

'B,b,cdEfg'.endswith('Ef')

Out[56]: False

'B,b,cdEfg'.endswith('Ef',1,8)

Out[57]: True

str.expandtabs(tabsize=8)

把Tab--‘\t’变为其他长度的空格符，'\t'默认为8，下面为官网的例子：

'01\t012\t0123\t01234'.expandtabs()

Out[101]: '01      012     0123    01234'

'01\t012\t0123\t01234'.expandtabs(16)

Out[102]: '01              012             0123            01234'

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

检测字符串中是否包含子字符串 str ，beg（开始）到end（结束）如果包含子字符串，则返回开始的（最小的）索引值，否则返回-1。默认为0和最后。

'B,b,cdEfcg'.find('c',6,9)

Out[106]: 8

'B,b,cdEfcg'.find('c')

Out[107]: 4

'B,b,cdEfcg'.find('h')

Out[108]: -1

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

用法与str.find一致，这个得到的是结束的（最大的）索引值。

`str.format`(*args, **kwargs)

字符串格式化，通过{}代替传统的%.*arg表示不可变参数--元组，**kwargs表示可变参数--字典

1.索引

{}里面为索引，0对应format中第一个元素。

'我{}好人，你{}好人！'.format('是','不是')

Out[111]: '我是好人，你不是好人！'

'我{1}好人，你{0}好人！'.format('是','不是')

Out[112]: '我不是好人，你是好人！'

l = ['是','不是']

'我{0[0]}好人，你{0[1]}好人！'.format(l)

Out[118]: '我是好人，你不是好人！'

2.关键字

'我{我}好人，你{你}好人！'.format(我='是',你='不是')

Out[121]: '我是好人，你不是好人！'

3.填充

'{0:*<10}'.format('党')  #总长度为10，字符串在左面

Out[127]: '党*********'

'{0:*>10}'.format('党')  #总长度为10，字符串在右面

Out[128]: '*********党'  

'{0:*^10}'.format('党')  #总长度为10，字符串居中

Out[129]: '****党*****'

4.精度与进制

'{0:.2f}'.format(1/3)

Out[132]: '0.33'

'{0:b}'.format(8)    #二进制

Out[133]: ''

'{0:o}'.format(8)     #八进制

Out[134]: ''

'{:,}'.format(111111111111111)  #千分位格式化

Out[135]: '111,111,111,111,111'

`str.format_map`(mapping)

与str.format(**mapping)类似，区别在于format_map直接用字典，而不是复制一个。下面是官方例子，其中Default是dict的一个子类。

class Default(dict):

    def __missing__(self, key):

        return key

'{name} was born in {country}'.format_map(Default(name='Guide'))

Out[]: 'Guide was born in country'

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

与str.find类似，区别在于，index如果找不到要寻到的字符，会得到ValueError，而find则返回-1。

'asdfghjkhl'.find('i')

Out[]: -

'asdfghjkhl'.index('i')

Traceback (most recent call last):

  File "<ipython-input-25-af5de9246bb5>", line , in <module>

    'asdfghjkhl'.index('i')

ValueError: substring not found

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

用法与str.rindex一致，这个得到的是结束的（最大的）索引值。

str.isalum()

如果字符串至少有一个字符，并且所有字符都是字母或数字则返回 True,否则返回 False。

'asdfghjkhl'.isalnum()

Out[26]: True

'asdfg.. hjkhl'.isalnum()

Out[27]: False

str.isalpha()

如果字符串至少有一个字符，并且所有字符都是字母或汉字则返回 True,否则返回 False。

str.isdecimal() str.isdigit() str.isnumeric()

3个都是判断字符串是不是数字字符

差别：

str.isdecimal() 表面上就是: str 是阿拉伯数字123456这样的为True，是汉字数字，罗马数字为False，显示的‘’不是‘’数字的b" "为Error。

str.isdigit() 除了汉字数字为False，其他数字都为True，包括单字节数字b" "。

str.isnumeric() 除了单字节数字b" "是Error，所有的数字都为True。

str.isidentifier()

检测字符串是否是字母开头。

'asdfghjkhl'.isidentifier()

Out[33]: True

'1asdfghjkhl'.isidentifier()

Out[34]: False

str.islower()

如果字符串中的所有字符都是小写，并且至少有一个字符，则返回True，否则返回False。

'asdfghjkhl'.islower()

Out[37]: True

'asdfghjkHl'.islower()

Out[38]: False

str.isprintable()

判断是不是都为可见/可打印字符

'asdf\nghjkHl'.isprintable()

Out[42]: False

'asdfghjkHl'.isprintable()

Out[43]: True

str.isspace()

判断是否为空格字符（注意不是空）

''.isspace()

Out[44]: False

' '.isspace()

Out[45]: True

'ss'.isspace()

Out[46]: False

str.istitle()

字面上意思是：判断字符串能不能做标题

'Wo Shi Hao Ren 1'.istitle()

Out[50]: True

'Wo Shi Hao Ren 党'.istitle()

Out[51]: True

'Wo Shi Hao ren'.istitle()

Out[52]: False

'Wo Shi Hao Ren'.istitle()

Out[53]: True

str.title()

把字符串变为标题格式。

'wo shi hao ren'.title()

Out[140]: 'Wo Shi Hao Ren'

str.isupper()

与str.islower()对应，如果字符串中的所有字符都是大写，并且至少有一个字符，则返回True，否则返回False。

str.join(string)

以str作为分隔符，将string所有的元素合并成一个新的字符串。若string为空，则TypeError。

''.join('asdfghjkl')

Out[55]: 'a111s111d111f111g111h111j111k111l'

''.join()

Traceback (most recent call last):

  File "<ipython-input-56-5fa735339586>", line 1, in <module>

    ''.join()

TypeError: join() takes exactly one argument (0 given)

str.ljust(width,fillchar)

得到一个原始字符串左对齐,并使用fiichar填充至指定长度的新字符串。若指定的长度小于原字符串的长度则返回原始字符串。与format的填充用法相似。

width--指定长度

fillchar--填充字符串，默认空格字符。

''.ljust(50)

Out[57]: '111                                               '

''.ljust(50,'*')

Out[58]: '111***********************************************'

'{0:*<50}'.format('')

Out[62]: '111***********************************************'

str.rjust(width,fillchar)

得到一个原始字符串右对齐,并使用fiichar填充至指定长度的新字符串。若指定的长度小于原字符串的长度则返回原始字符串。与format的填充用法相似。（用法与ljust一致）

str.lower()

把所有字母转化为小写，与str.upper()相对，与str.casefold()区别。

str.upper()

把所有字母转化为大写。

str.lstrip(chars)

删除str左边所有出现在chars子字符串，chars为空时默认空格字符。

'     Wo Shi Hao ren   '.lstrip()

Out[67]: 'Wo Shi Hao ren   '

'Wo Shi Hao ren'.lstrip('fdsfsfW')

Out[68]: 'o Shi Hao ren'

'Wo Shi Hao ren'.lstrip('fdsfsfw')

Out[69]: 'Wo Shi Hao ren'

str.rstrip(chars)

与str.lstrip(chars)对应且方法一致，删除str右边所有出现在chars子字符串，chars为空时默认空格字符。

str.strip(chars)

与str.lstrip(chars)和str.rstrip(chars)用法一致，这个是删除两边所有出现在chars子字符串，chars为空时默认空格字符。

'asdas'.strip('as')

Out[124]: 'd'

str.maketrans(intab,outtab)

得到一个用于str.translate()的映射，其实就是一个字典。

intab--是原始字符

outtab--翻译后的字符，长度与in相等

intab = "abcde"

outtab = ""

name = "asdwgwegb"

x = ''.maketrans(intab, outtab)

name.translate(x)

Out[103]: '1s4wgw5g2'

ord('a')  #a的Unicode编码

Out[104]: 97

x

Out[105]: {97: 49, 98: 50, 99: 51, 100: 52, 101: 53}

x就是maketrans得到的字典，字典中的映射是字符对应的Unicode编码。

str.translate()

根据str.maketrans得到的字典翻译str

str.partition(char) str.split(char，count)

作用都是字符串分割

str.partition(char)根据字符串char分割str得到一个3元素元组（只识别第一次出现的字符串）。char不能为空

'asdsawoainiasdaswoainid'.partition('woaini')

Out[111]: ('asdsa', 'woaini', 'asdaswoainid')

'asdsawoainiasdaswoainid'.partition('woainid')

Out[112]: ('asdsawoainiasdas', 'woainid', '')

str.split(char,count) 根据字符串char分割str得到一个列表（识别所有的char，并且char不包含在列表内），char默认为空格符。

char--子字符串

count--切割次数，默认全部。

'asdsawoainiasdaswoainid'.split('woaini')

Out[113]: ['asdsa', 'asdas', 'd']

'asdsawoainiasdaswoainid'.split()

Out[114]: ['asdsawoainiasdaswoainid']

'asdsawoainiasdaswo ainid'.split()

Out[115]: ['asdsawoainiasdaswo', 'ainid']

str.rpartition(char)

用法与str.partition(char)一致，str.rpartition(char)根据字符串char分割str得到一个3元素元组（只识别最后一次出现的字符串）。char不能为空

str.rsplit(char，count)

与str.split用法一致，但是str.rsplit是从后往前工作，str.split是签到后工作。

'basdasa'.rsplit('as',1)

Out[131]: ['basd', 'a']

'basdasa'.split('as',1)

Out[132]: ['b', 'dasa']

str.splitlines(keepends)

str.splitlines(keepends) 按照行('\r', '\r\n', \n')分隔，得到各行元素的列表，如果keepends为 False，不包含换行符，如果为 True，则保留换行符。默认为False。

'asdsa\r\nwo\rainia\r\nsdas\nw\roainid'.splitlines()

Out[116]: ['asdsa', 'wo', 'ainia', 'sdas', 'w', 'oainid']

'asdsa\r\nwo\rainia\r\nsdas\nw\roainid'.splitlines(False)

Out[117]: ['asdsa', 'wo', 'ainia', 'sdas', 'w', 'oainid']

'asdsa\r\nwo\rainia\r\nsdas\nw\roainid'.splitlines(True)

Out[118]: ['asdsa\r\n', 'wo\r', 'ainia\r\n', 'sdas\n', 'w\r', 'oainid']

str.replace(old,new,count)

把字符串中的 old（旧字符串）替换成 new(新字符串)，替换不超过count 次，count为空时不限次数。

'asdas'.replace('as','sa',1)

Out[121]: 'sadas'

'asdas'.replace('as','sa')

Out[122]: 'sadsa'

str.startswith(start,end)

startswith() 方法用于检查字符串是否是以指定字符串开头，如果是返回True，否则返回False。start，end未指定范围，默认0，len(str)-1

'basdasa'.startswith('ba')

Out[135]: True

'basdasa'.startswith('ba',1,5)

Out[136]: False

str.swapcase()

大写变小写，小写变大写

'basdasaDASDA'.swapcase()

Out[138]: 'BASDASAdasda'

str.zfill(width)