str.方法的整理（字符串类型内置方法的具体使用）

<1>str.strip()、str.lstrip()和str.rstrip()

1' str.strip()（主要方法）

方法：str.strip(self,chars)

作用：移除字符串头与尾的指定字符。（核心是头与尾）,移除的结果作为一个返回值，原字符串仍不变。

chars参数：需要移除的字符串，如果省略或者为None，则默认移除空格。

要点

①：移除的字符串过程为从外向内，如果最外边没有要移除的字符串（假设里面却有的话），此时里面的那个字符串是不会被移除的。

s1='/a=abcd*/-a'
s2=s1.strip('a')
print(s1)
print(s2)

结果：
/a=abcd*/-a
/a=abcd*/-
需要移除的字符串是a，左边a在里面无法移除，右边最外边有一个a，可以移除

②：当要移除多个字符串（假设‘ab’）的时候，移除没有前后顺序，只有被移除对象两边最外面有b就移除b，移除后的最外边如果还有a则继续继续移除a。

#①
s1='b*a /abcd*/b a-'
s2=s1.strip('ab')
print(s1)
print(s2)

#结果：
b*a /abcd*/b a-
*a /abcd*/b a-
移除原则：由外向内，内部字符串只能等待外边全部移除完毕才能移除。

#②
s1='ba/abcd*/ a-ab'
s2=s1.strip('ab')
print(s1)
print(s2)

#结果：
ba/abcd*/ a-ab
/abcd*/ a-
先把b移除了，b移除完a就暴露到最外边了，这样就可以移除a。这里可以看到移除ab部分先后顺序，只要谁在外面谁先移除。

③：所以所strip移除字符串是有限制的，不是说有就移除，而是最外边有才移除，在里面不行，除非移除的多个字符串中的其他字符串被移除了，将这个字符串暴露到最外边了，才会开始移除。

s1='+/*-/=abcd*/*/+ -'
s2=s1.strip('/-*+= ')
print(s1)
print(s2)

结果：
+/*-/=abcd*/*/+ -
abcd
此时abcd两边都是一些特殊字符，想要去除就直接将所有字符放入需要移除的字符串中就可以全部移除了。不管怎么移除，肯定会依次将所有需移除的字符暴露在最外边。

 注：官方文档内容，供参考：

返回原字符串的副本，移除其中的前导和末尾字符。 chars 参数为指定要移除字符的字符串。 如果省略或为 None，则 chars 参数默认移除空格符。 实际上 chars 参数并非指定单个前缀或后缀；而是会移除参数值的所有组合:

>>>
>>> '   spacious   '.strip()
'spacious'
>>> 'www.example.com'.strip('cmowz.')
'example'
最外侧的前导和末尾 chars 参数值将从字符串中移除。 开头端的字符的移除将在遇到一个未包含于 chars 所指定字符集的字符时停止。 类似的操作也将在结尾端发生。 例如:

>>>
>>> comment_string = '#....... Section 3.2.1 Issue #32 .......'
>>> comment_string.strip('.#! ')
'Section 3.2.1 Issue #32'

 ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------

2' str.lstrip()和str.rstrip()

左移除和右移除（前移除和尾移除）

方法类似前面的str.strip()，只不过是只移除前面或者只移除尾部字符串。移除规则同上。

左移除：
s1='-*abc*-'
s2=s1.lstrip('-')
print(s1)
print(s2)

#结果：
-*abc*-
*abc*-
lstrip只移除左边的。右边的不管

右移除：
s1='-*abc*-'
s2=s1.rstrip('-')
print(s1)
print(s2)

#结果：
-*abc*-r
-*abc*
rstrip只移除右边的。左边的不管

 注：官方文档内容，供参考：

str.lstrip([chars])
返回原字符串的副本，移除其中的前导字符。 chars 参数为指定要移除字符的字符串。 如果省略或为 None，则 chars 参数默认移除空格符。 实际上 chars 参数并非指定单个前缀；而是会移除参数值的所有组合:

>>>
>>> '   spacious   '.lstrip()
'spacious   '
>>> 'www.example.com'.lstrip('cmowz.')
'example.com'


str.rstrip([chars])
返回原字符串的副本，移除其中的末尾字符。 chars 参数为指定要移除字符的字符串。 如果省略或为 None，则 chars 参数默认移除空格符。 实际上 chars 参数并非指定单个后缀；而是会移除参数值的所有组合:

>>>
>>> '   spacious   '.rstrip()
'   spacious'
>>> 'mississippi'.rstrip('ipz')
'mississ'

==================================================================================================

<2>str.center()

方法：str.center(self,width,fillchar)

作用：返回总长度为width的字符串，原字符串在正中，使用指定的fillchar填充两边的空余部分

参数：指定的fillchar给的话，默认使用ASCII空格符

fillchar为空时：用空格填充

s1='中国'
s2=s1.center(20)   #默认不传填充物
print(s2,'这是末尾')

#结果：
         中国          这是末尾
------------------------------------------------
fillchar不为空：填充指定字符串

s1='武汉'
s2=s1.center(20,'*')   #用*当做填充物
print(s2)

#结果：
*********武汉*********
------------------------------------------------
当width减去原字符串个数结果为奇数时候：左多右少

s1='高新'
s2=s1.center(7,'+')
print(s2)

#结果：
+++高新++

要点:

①：如果width小于等于原字符串的总长度，则返回原字符串。

s1='湖北武汉东湖高新'
s2=s1.center(7,'*')
print(s2)

#结果：
湖北武汉东湖高新

注：官方文档内容，供参考：

str.center(width[, fillchar])
返回长度为 width 的字符串，原字符串在其正中。 使用指定的 fillchar 填充两边的空位（默认使用 ASCII 空格符）。 如果 width 小于等于 len(s) 则返回原字符串的副本。

==================================================================================================

<3>str.join()

方法：str.join(self,interable)

作用：a.join(b),将a作为分隔符分隔b中的每一个元素，这里的b需要是一个可迭代对象。返回一个被a分隔了b的字符串

参数：可迭代对象

要点：①如果可迭代对象里面存在任何非字符串值（包括bytes对象）时候，会显示乱码(
)（在pycharm中）。

print('a'.join('大家好'))   #大a家a好
将a添加到‘大家好’中，相当于将a作为分隔符分隔了字符串‘大家好’

print('a'.join('大'))    #大
如果后面的参数是一个单字符，或者是包含单个元素的可迭代对象，就没a啥事了，直接返回这个参数（或者返回迭代对象中的字符串）

s=['abcd']
print('#'.join(s))

结果：
abcd

注：官方文档内容，供参考：

str.join(iterable)
返回一个由 iterable 中的字符串拼接而成的字符串。 如果 iterable 中存在任何非字符串值包括 bytes 对象则会引发 TypeError。 调用该方法的字符串将作为元素之间的分隔。

==================================================================================================

<4>str.count()

方法：str.count(self,x,__start,__end)

作用：返回字符串x,在[start,end]范围内非重叠出现的次数

参数：关键字符串x，开始 结束

要点：①[start,end]方法与切片方法一致，顾头不顾尾

　　　②start,end不写默认范围为全部

print('abcacd'.count('c'))  
print('abcaabcd'.count('abc'))
print('abcacd'.count('c',0,4))

#结果：
2
2
1

注：官方文档内容，供参考：

str.count(sub[, start[, end]])
返回子字符串 sub 在 [start, end] 范围内非重叠出现的次数。 可选参数 start 与 end 会被解读为切片表示法。

==================================================================================================

<5>、str.split()

一、默认拆分（从左往右）

方法：str.split(self,sep,maxsplit)

作用：找出字符串s中的sep字符，将sep当做分隔依据拆分该字符串s,返回一个拆分开来的列表

参数：sep：分隔依据 字符串，maxsplit：最大拆分次数，不写默认全部

 

要点：①如果有连续拆分依据的字符串，则连续拆分的字符串不会被组合在一起而是被视为分隔空字符串

print('1,,,,2'.split(','))  #['1', '', '', '', '2']
这里用逗号'，'来作为分隔拆分依据，有多个连续逗号，此时连续逗号之间有多少个空字符串，就拆分多少个空字符串加入列表

　　　②拆分依据字符串可能由多个字符组成，此时将多个字符当做整体作为拆分依据进行拆分就行

print('1ab2a3abbab5'.split('ab'))  #['1', '2a3', 'b', '5']
拆分依据为‘ab’,将‘ab’作为整体作为拆分依据

　　   ③使用指定的分隔符拆分空字符串将返回 ['']

print(''.split('ab'))   #['']

 　　   ④如果分隔依据字符串无的话，默认用空去拆分

print('1 2 3'.split())
print('1 2 3'.split(maxsplit=1))
print('   1   2   3   '.split())
结果
['1', '2', '3']
['1', '2 3']
['1', '2', '3']

注：官方文档内容，供参考：

str.split(sep=None, maxsplit=-1)
返回一个由字符串内单词组成的列表，使用 sep 作为分隔字符串。 如果给出了 maxsplit，则最多进行 maxsplit 次拆分（因此，列表最多会有 maxsplit+1 个元素）。 如果 maxsplit 未指定或为 -1，则不限制拆分次数（进行所有可能的拆分）。

如果给出了 sep，则连续的分隔符不会被组合在一起而是被视为分隔空字符串 (例如 '1,,2'.split(',') 将返回 ['1', '', '2'])。 sep 参数可能由多个字符组成 (例如 '1<>2<>3'.split('<>') 将返回 ['1', '2', '3'])。 使用指定的分隔符拆分空字符串将返回 ['']。

例如:

>>>
>>> '1,2,3'.split(',')
['1', '2', '3']
>>> '1,2,3'.split(',', maxsplit=1)
['1', '2,3']
>>> '1,2,,3,'.split(',')
['1', '2', '', '3', '']
如果 sep 未指定或为 None，则会应用另一种拆分算法：连续的空格会被视为单个分隔符，其结果将不包含开头或末尾的空字符串，如果字符串包含前缀或后缀空格的话。 因此，使用 None 拆分空字符串或仅包含空格的字符串将返回 []。

例如:

>>>
>>> '1 2 3'.split()
['1', '2', '3']
>>> '1 2 3'.split(maxsplit=1)
['1', '2 3']
>>> '   1   2   3   '.split()
['1', '2', '3']

二、str.rsplit(从右往左拆分)

方法：str.rsplit(sep=None, maxsplit=-1)

用法同上，只是拆分顺序变了而已。

注：官方文档内容，供参考：

str.rsplit(sep=None, maxsplit=-1)
返回一个由字符串内单词组成的列表，使用 sep 作为分隔字符串。 如果给出了 maxsplit，则最多进行 maxsplit 次拆分，从 最右边 开始。 如果 sep 未指定或为 None，任何空白字符串都会被作为分隔符。 除了从右边开始拆分，rsplit() 的其他行为都类似于下文所述的 split()。

 ==================================================================================================

<6>、str.replace()

方法：str.replace(self,old,new,count)

作用：用new的字符串替换old的字符串，count不写默认全部替换完，count有的话，代表最大替换次数。

参数：old 被替换的字符     new  替换的字符     count 最大替换次数（如果实际只有3个可以替换，而替换count为100，肯定只替换3个啦）

要点：无要点，主要要搞清楚替换和被替换在方法中的位置。

print('aaabc'.replace('a', '$'))
print('aaabc'.replace('a', '@', 0))
print('aaabc'.replace('a', '#', 2))
print('aaabc'.replace('a', '&', 100))

结果：
$$$bc
aaabc
##abc
&&&bc

注：官方文档内容，供参考：

str.replace(old, new[, count])
返回字符串的副本，其中出现的所有子字符串 old 都将被替换为 new。 如果给出了可选参数 count，则只替换前 count 次出现。

 ==================================================================================================

<7>、str.isdigit()   str.isdecimal()   str.isnumeric()

方法：str.isdigit(self)      str.isdecimal(self)    str.isnumeric(self)

作用：判断是否为数字，如果是返回值为True，否则为False

参数：无参数

要点：三个都是判断数字的但是有所不同（注意，罗马数字用搜狗v方法貌似打出来的字符有问题，最后倒入特殊字符更正确）

print('123'.isdigit())
print(b'123'.isdigit())
print('Ⅵ'.isdigit())
print('陆'.isdigit())

结果
True
True
False
False
-------------------------------------------------------------------------
print('123'.isdecimal())
print(b'123'.isdecimal())
print('Ⅵ'.isdecimal())
print('陆'.isdecimal())

结果
True
会报错
False
False
-------------------------------------------------------------------------
print('123'.isnumeric())
print(b'123'.isnumeric())
print('Ⅵ'.isnumeric())
print('陆'.isnumeric())

结果
True
会报错
True
True

字符串三种判断数字的方法区别

	isdigit（）	isdecimal()	isnumeric()
Unicode数字	True	True	True
byte数字	True	报错	报错
罗马数字	False	False	True
汉字数字	False	False	True

 

 

 

 总结：其实最常用的是isdigit（），因为它可以判断Unicode和b类型的数字字符串，这两种字符串我们用的比较常见，而罗马数字和汉字比较少见，罗马数字和汉字数字只能isnumeric（）判断

 

 

 

注：官方文档内容，供参考：

str.isdigit()
如果字符串中至少有一个字符且所有字符均为数字字符则返回真值，否则返回假值。 数字字符包括十进制数字符和需要特别处理的数字，例如兼容性上标数字。 这也涵盖了不能被用来组成以 10 为基数的数值的数字，例如 Kharosthi 数字。 正式的定义为：数字字符就是特征属性值 Numeric_Type=Digit 或 Numeric_Type=Decimal 的字符。

str.isnumeric()
如果字符串中至少有一个字符且所有字符均为数值字符则返回真值，否则返回假值。 数值字符包括数字字符，以及所有在 Unicode 中设置了数值特性属性的字符，例如 U+2155, VULGAR FRACTION ONE FIFTH。 正式的定义为：数值字符就是具有特征属性值 Numeric_Type=Digit, Numeric_Type=Decimal 或 Numeric_Type=Numeric 的字符。

str.isdecimal()
如果字符串中至少有一个字符且所有字符均为十进制数字符则返回真值，否则返回假值。 十进制数字符是以 10 为基数的计数制会用来组成数值的字符，例如 U+0660, ARABIC-INDIC DIGIT ZERO。 正式的定义为：十进制数字符就是 Unicode 一般分类 "Nd" 中的字符。

==================================================================================================

<8>、str.endswith()   str.startswith()

方法：str.endswith(self,suffix,,start,end) 

　　　str.startswith(self,prefix,start,end)

作用：判断字符串是否以某字符串开头或者结尾，如果是的，返回True，否则返回False

参数：suffix，prefix代表开头或者结尾的判断字符串，start和end代表判断的开始索引和结尾索引。

要点：无

s='hello world'
res=s.startswith('hel')
res1=s.endswith('rld')
print(res,res1)

# 结果为：
True True

注：官方文档内容，供参考：

str.startswith(prefix[, start[, end]])
如果字符串以指定的 prefix 开始则返回 True，否则返回 False。 prefix 也可以为由多个供查找的前缀构成的元组。 如果有可选项 start，将从所指定位置开始检查。 如果有可选项 end，将在所指定位置停止比较。

str.endswith(suffix[, start[, end]])
如果字符串以指定的 suffix 结束返回 True，否则返回 False。 suffix 也可以为由多个供查找的后缀构成的元组。 如果有可选项 start，将从所指定位置开始检查。 如果有可选项 end，将在所指定位置停止比较。

==================================================================================================

<9>、str.isalpha() str.isalnum()

方法：str.isalpha(self) 

　　    str.isalnum(self)

作用：判断是否是字母，判断是否为字母或数字，返回True 或者False

参数：无

要点：isalpha(self)判断是否为字母，而isalnum(self)判断的是字母和数字，判断范围包含isalpha，更大。

print('abc'.isalpha())      
print('abc123'.isalpha())    
print('abc'.isalnum())      
print('abc123'.isalnum())    

# 结果为：
True
False
True
True

注：官方文档内容，供参考：

str.isalpha()
如果字符串中至少有一个字符且所有字符均为字母则返回真值，否则返回假值。 字母类字符是在 Unicode 字符数据库中被定义为 "Letter" 的字符，即一般分类特征属性为 "Lm", "Lt", "Lu", "Ll" 或 "Lo" 其中之一。 请注意这不同于 Unicode 标准所定义的 "Alphabetic" 特征属性。

str.isalnum()
如果字符串中至少有一个字符且所有字符均为字母或数字则返回真值，否则返回假值。 如果以下方法中的一个返回 True 则字符 c 为字母或数字: c.isalpha(), c.isdecimal(), c.isdigit(), or c.isnumeric()。

==================================================================================================

<10>、str.capitalize()  str.lower()  str.upper()

　　　　   str.islower() str.isupper()

方法：str.capitalize(self)  str.lower(self)  str.upper(self) str.islower(self) str.isupper(self)

作用：str.capitalize  将字符串首字母大写，返回一个首字母大写的字符串

　　   str.lower 将字符串包含字母的字符全部转换成小写

          str.upper 将字符串包含字母的字符全部转换成大写

          str.islower 判断字符串里面至少有一个字母，且这些字母全部是小写，则返回True，否则返回False

          str.isupper 判断字符串里面至少有一个字母，且这些字母全部是大写，则返回True，否则返回False

参数：无

要点：方法很简单，需要简单区分一下

print('abc'.capitalize())   #Abc
print('123abc'.capitalize())   #123abc
print('123aBc'.lower())   #123abc
print('123aBc'.upper())   #123ABC
print('123'.isupper())   #False
print('aBc'.isupper())   #False
print('ABC'.isupper())   #True
print('123ABC'.isupper())   #True
print('123'.islower())   #False
print('aBc'.islower())   #False
print('abc'.islower())   #True
print('123abc'.islower())   #True

注：官方文档内容，供参考：

str.capitalize()
返回原字符串的副本，其首个字符大写，其余为小写。

str.lower()
返回原字符串的副本，其所有区分大小写的字符 [4] 均转换为小写。

str.upper()
返回原字符串的副本，其中所有区分大小写的字符 [4] 均转换为大写。 请注意如果 s 包含不区分大小写的字符或者如果结果字符的 Unicode 类别不是 "Lu" (Letter, uppercase) 而是 "Lt" (Letter, titlecase) 则 s.upper().isupper() 有可能为 False。
所用转换大写算法的描述请参见 Unicode 标准的 3.13 节。

str.isupper()
如果字符串中至少有一个区分大小写的字符 [4] 具此类字符均为大写则返回真值，否则返回假值。

str.islower()
如果字符串中至少有一个区分大小写的字符 [4] 且此类字符均为小写则返回真值，否则返回假值。

==================================================================================================

<11>、str.find() str.index()       str.rfind() str.rindex()

方法：str.find(self,sub,_start,_end)   str.index(self,sub,_start,_end)

　　　str.rfind(self,sub,_start,_end)   str.rindex(self,sub,_start,_end)

作用：前两者都是查找功能，返回找到的索引值最小数  后面的加了个r，代表找到的索引值最大数

参数：sub为查找的字符串 ，start查找开始索引   end查找结束索引

要点：find找不到返回-1，index找不到会报错ValueError

print('abcb'.find('b'))   #1
print('abc'.find('d'))   #-1
print('abcdedfg'.find('d',1,6))   #3
print('abcdefg'.find('d',4,5))   #-1
print('abcb'.index('b'))   #1
# print('abc'.index('d'))   #报错ValueError: substring not found
print('abcdefg'.index('d',1,5))   #3
# print('abcdefg'.index('d',4,5))   #报错ValueError: substring not found

print('ababc'.rfind('b'))   #3
# print('abc'.rfind('d'))   #-1
print('abcdefg'.rfind('d',1,5))   #3
# print('abcdefg'.rfind('d',4,5))   #-1
print('abc'.rindex('b'))   #1
# print('abc'.rindex('d'))   #ValueError: substring not found
print('abcdefg'.rindex('d',1,5))   #3
# print('abcdefg'.rindex('d',4,5))   #ValueError: substring not found

注：官方文档内容，供参考：

str.find(sub[, start[, end]])
返回子字符串 sub 在 s[start:end] 切片内被找到的最小索引。 可选参数 start 与 end 会被解读为切片表示法。 如果 sub 未被找到则返回 -1。

注解 find() 方法应该只在你需要知道 sub 所在位置时使用。 要检查 sub 是否为子字符串，请使用 in 操作符:
>>>
>>> 'Py' in 'Python'
True

str.index(sub[, start[, end]])
类似于 find()，但在找不到子类时会引发 ValueError。

str.rfind(sub[, start[, end]])
返回子字符串 sub 在字符串内被找到的最大（最右）索引，这样 sub 将包含在 s[start:end] 当中。 可选参数 start 与 end 会被解读为切片表示法。 如果未找到则返回 -1。

str.rindex(sub[, start[, end]])
类似于 rfind()，但在子字符串 sub 未找到时会引发 ValueError。

==================================================================================================

<12>、str.()

方法：

作用：

参数：

要点：

注：官方文档内容，供参考：

 

 

 

 

 

 

 

 

 

 

 str.isidentifier()
如果字符串根据语言定义属于有效的标识符则返回真值，参见 标识符和关键字。

str.translate(table)
返回原字符串的副本，其中每个字符按给定的转换表进行映射。 转换表必须是一个使用 __getitem__() 来实现索引操作的对象，通常为 mapping 或 sequence。 当以 Unicode 码位序号（整数）为索引时，转换表对象可以做以下任何一种操作：返回 Unicode 序号或字符串，将字符映射为一个或多个字符；返回 None，将字符从结果字符串中删除；或引发 LookupError 异常，将字符映射为其自身。

 

 

未完待续......

(以下为添加模板） 

==================================================================================================

<n>、str.()

方法：

作用：

参数：

要点：

注：官方文档内容，供参考：