字符串方法详解总结

字符串方法详解

字符串

……

字符串

python当中提供了很多操作字符的方法，接下来一起来认识一下
首先来看一下，操作字符串都有哪些方法

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'
'''

列出来的一共有44个方法
各个方法的英文解释：
https://docs.python.org/3/library/stdtypes.html#string-methods

1.1 大小写转换

字符串是不可更改的，在此基础做的操作都是新生成的字符串
lower、upper 一个单词全小写，全大写

str1 = "Abc"
print(str1.lower()) #字母小写
print(str1.upper()) #字母大写

title、captialize多个单词
title:将多个单词的所有首字母大写，其他字母小写
captialize:将字符串的第一个字符转换成大写，其它都转化成小写

str2 = "Aa bb ccC"
print(str2.title()) #Aa Bb Ccc     各个单词的首字母都大写,并且其他字母小写
print(str2.capitalize()) #Aa bb ccc  只有第一个单词的首字母大写，在它后面的其他单词都是小写

swapcase反转，大小写反转

str3 = "AAaaaAbBBb"
print(str3.swapcase()) #aaAAAaBbbB原来大写的变成小写，原来小写的变成大写

1.2 isXXX判断

isalpha,isdecimal,isdigit,isnumeric,isalnum

这几个函数的解释：
isalpha() 所有的字符都是字母
isdecimal()
isdigit() 这三个都是判断字符串是不是纯阿拉伯数字
isnumeric()
isalnum() 所有字符都是数字或者字母

isdeciaml、isdigit、isnumeric三者的区别
isdigit()
True: Unicode数字，byte数字（单字节），全角数字（双字节），罗马数字
False: 汉字数字
Error: 无

isdecimal()
True: Unicode数字，，全角数字（双字节）
False: 罗马数字，汉字数字
Error: byte数字（单字节）

isnumeric()
True: Unicode数字，全角数字（双字节），罗马数字，汉字数字
False: 无
Error: byte数字（单字节）
‘’’

s1 = "abcd"
s2 = "1234"
s3 = "abcd1234"
print(s1.isdigit()) #False
print(s1.isalpha()) #True
print(s1.isalnum()) #True
print("-----------------")
print(s2.isdigit()) #True
print(s2.isalpha()) #False
print(s2.isalnum()) #True
print("-----------------")
print(s3.isdigit()) #False
print(s3.isalpha()) #False
print(s3.isalnum()) #True

islower、isupper、istitle判断是否是小写，大写，首字母大写

str4 = "1Word1"#要求字符串中至少要包含一个字符串字符，否则直接返回false
print(str4.islower()) # False  字符是否全部是小写
print(str4.isupper()) # False 这个字符串中的字符是否全部是大写
print(str4.istitle()) # True 判断这个字符串中是否包含只有首字母是大写的情况。比如：str4="Word BooK"则返回的结果就是False,因为除了首字母还有非首字母是大写的情况

isspace,isprintable,isidentifier

isspace：判断字符串是否为空格没有其他任何元素，只有空格
isprintable：判断字符串是否为可打印（一般情况下都是可以打印的）"\t" ,"\r"这些都是不可以打印的
isidentifier：判断字符串是否为python当中的标识符，标识符：就是只能是包含数字、字母、下划线组成的而且数字不开头的都是标识符（关键字和保留关键字也不能作为标识符）

s1 = " "
s2 = "12 34 "
s3 = "if"

print(s1.isspace()) #True
print(s1.isprintable())#True
print(s1.isidentifier())#False
print("---------")
print(s2.isspace())#False
print(s2.isprintable())#True
print(s2.isidentifier())#False
print("---------")
print(s3.isspace())#False
print(s3.isprintable())#True
print(s3.isidentifier())#False

print("\t".isprintable())#False
print("2name".isidentifier()) #False

1.3 填充

center()、ljust()、rjust()、zfill()
center()：
具体用法：
s.center(width [,fillchar])
将字符串居中，左右两边使用fillchar进行填充，使得整个字符串的长度为width。fillchar默认为空格。如果width小于字符串的长度，则无法填充直接返回字符串本身(不会创建新字符串对象)。

x = "abc"
print(x.center(2,"-"))#总位数小于等于字符串的长度，则返回原先的字符串
print(x.center(5,"-"))#
print(x.center(8,"-"))#字符串的长度为3，给定的长度为8，需要填充“-”字符5个，5/2=2.5,取整，从第三个开始写字符  --abc---

ljust()、rjust()
ljust()使用fillchar填充在字符串S的右边，使得整体长度为width。
rjust()则是填充在左边。如果不指定fillchar，则默认使用空格填充。
如果width小于或等于字符串S的长度，则无法填充，直接返回字符串S(不会创建新字符串对象)。

x = "abc"
print(x.rjust(5,"-"))#--abc
print(x.ljust(5,"-"))#abc--

zfill(width)
用0填充在字符串S的左边使其长度为width。如果S前有正负号+/-，则0填充在这两个符号的后面，且符号也算入长度。
如果width小于或等于S的长度，则无法填充，直接返回S本身(不会创建新字符串对象)。

print('abc'.zfill(5))#00abc
print('-abc'.zfill(5))#-0abc
print('+abc'.zfill(5))#+0abc

1.4 子串搜索

count()、startsWith()、endsWith()、find()、rfind()、index()、rindex()
count():
count(sub[, start[, end]])
返回字符串S中子串sub出现的次数，可以指定从哪里开始计算(start)以及计算到哪里结束(end)，索引从0开始计算，不包括end边界。

x = "abccbaaaa"
print(x.count("a"))
print(x.count("a",6))#表示的从索引为6的位置开始找，所以一共是3个
print(x.count("a",6,8))#因为不包括索引为8的a,(包前不包后)，所以一共是2个

startsWith()、endsWith()
endswith(suffix[, start[, end]])
startswith(prefix[, start[, end]])

endswith()检查字符串S是否以suffix结尾，返回布尔值的True和False。suffix可以是一个元组(tuple)。可以指定起始start和结尾end的搜索边界。
startswith()用来判断字符串S是否是以prefix开头。

x = "abccbaaaa"
print(x.startswith("a")) #True
print(x.startswith("cb",2))#False 因为索引为2的位置为c,
print(x.startswith("cc",2)) #True

find()、rfind()
find(sub[, start[, end]])
rfind(sub[, start[, end]])

find()搜索字符串S中是否包含子串sub，如果包含，则返回sub的索引位置，否则返回"-1"。可以指定起始start和结束end的搜索位置。
rfind()则是返回搜索到的最右边子串的位置，如果只搜索到一个或没有搜索到子串，则和find()是等价的。

x = "abccbaaaa"
print(x.find("a"))
print(x.rfind("a"))

index()、rindex()
index(sub[, start[, end]])
index()和find()一样，唯一不同点在于当找不到子串时，抛出ValueError错误

1.5 替换

replace()、expandtabs()
replace()
replace(old, new[, count])
将字符串中的子串old替换为new字符串，如果给定count，则表示只替换前count个old子串。如果S中搜索不到子串old，则无法替换，直接返回字符串S(不创建新字符串对象)。

x = "abccbaaaa"
print(x.replace("a","A"))#把所有的小写a大写的A
print(x.replace("a","A",3))#只替换前3个小写的a

expandtabs()
将字符串S中的\t替换为一定数量的空格。默认N=8。
注意，expandtabs(8)不是将\t直接替换为8个空格。例如’xyz\tab’.expandtabs()会将\t替换为5个空格，因为"xyz"占用了3个字符位。
所以，在替换"\t"为空格时，会减掉"\t"前面的字符数量。如果"\t"的前面正好没有字符，则直接将"\t"替换为N个空格。
另外，它不会替换换行符(\n或\r)。

x = "abcc\tbaaaa"
x2 = "\tabccbaaaa"
print(x.expandtabs(1))
print(x.expandtabs(2))
print(x.expandtabs(3))
print(x.expandtabs(4))
print(x.expandtabs(5))
print(x.expandtabs(6))
print(x.expandtabs(7))
print(x.expandtabs(8))
#\t前面有字母，如果写入到expandtabs()里面的数字小于\t前面的字母的长度，则会空出来相应数量的空格
#如果写入到expandtabs()里面的数字大于\t前面的字母长度，则需要减去\t前面的字母长度，剩下的就是空格数
print(x2.expandtabs(1))
print(x2.expandtabs(2))
print(x2.expandtabs(3))
#\t前面没有字母，则expandtabs()里面的数字是多少就会空出来多少个空格

translate()、maketrans()
str.maketrans()生成一个字符一 一映射的table，然后使用translate(table)对字符串S中的每个字符进行映射。

#做一个简单的加密，将里面的字符替换成相应的数字
in_str = "eiloyuv "
out_str = "12345678"

#maketrans()建立映射表
map_table = str.maketrans(in_str,out_str)
#translate()进行映射
input_str = "i love you"
output_str = input_str.translate(map_table)

print(output_str) #2834718546

1.6分割

partition()、rpartition()、split()、rsplit()、splitlines()
partition()、rpartition()
搜索字符串S中的子串sep，并从sep处对S进行分割，最后返回一个包含3元素的元组：sep左边的部分是元组的第一个元素，sep自身是元组的二个元素，sep右边是元组的第三个元素。
partition(sep)从左边第一个sep进行分割，rpartition(sep)从右边第一个sep进行分割。
如果搜索不到sep，则返回的3元素元组中，有两个元素为空。partition()是后两个元素为空，rpartition()是前两个元素为空。

x = "abccbaaaa"
print(x.partition("a"))#('', 'a', 'bccbaaaa')
print(x.partition("c"))#('ab', 'c', 'cbaaaa')
#可以得出结论从左向右开始找，找到的第一个符合条件的字符开始分割，字符左边是第一部分，字符本身是第二部分，字符右边是第三部分
print(x.rpartition("a"))#('abccbaaa', 'a', '')
print(x.rpartition("c"))#('abc', 'c', 'baaaa')

split()、rsplit()、splitlines()
都是用来分割字符串，并生成一个列表。
split(sep=None, maxsplit=-1)
split()根据sep对S进行分割，maxsplit用于指定分割次数，如果不指定maxsplit或者给定值为"-1"，则会从左向右搜索并且每遇到sep一次就分割直到搜索完字符串。如果不指定sep或者指定为None，则改变分割算法：以空格为分隔符，且将连续的空白压缩为一个空格。
rsplit()和split()是一样的，只不过是从右边向左边搜索。
splitlines()用来专门用来分割换行符。虽然它有点像split(’\n’)或split(’\r\n’)，但它们有些区别
#分割单个字符

string1 = "a,b,c,d"
string2 = "a,b,,c,d"
string3 = "a b c d"
print(string1.split(',')) #['a', 'b', 'c', 'd']
print(string1.split(",",1)) #['a', 'b,c,d'] 只分割了一次
print(string1.split(",",2)) #['a', 'b', 'c,d'] 分割了两次
print(string2.split(","))

print(' 1 2 3 \n'.split())#['1', '2', '3']
print(' 1 2 3 \n'.split(" "))#['', '1', '2', '3', '\n']

下面的博客写的非常好，可以借鉴一下
https://www.cnblogs.com/f-ck-need-u/archive/2018/06/03/9127699.html

1.7拼接

join()
将可迭代对象(iterable)中的元素使用S连接起来。注意，iterable中必须全部是字符串类型，否则报错。
如果你还是python的初学者，还不知道iterable是什么，却想来看看join的具体语法，那么你可以暂时将它理解为：字符串string、列表list、元组tuple、字典dict、集合set。

#1.字符串
string = "hellopython"
print('_'.join(string)) #h_e_l_l_o_p_y_t_h_o_n
#2元组
tup = ("1","2","3") #里面必须是字符串
print('+'.join(tup)) #1+2+3

#集合
first_set = {'a','c','b','2'}
print("_".join(first_set)) #集合是无序的，每次运行出来的记过都是不一样的

#list
list_first = ["a","b","c","1"]
print("_".join(list_first)) #a_b_c_1

#字典
LiMing = {"name":"liming","age":18,"gender":"M"}
print("_".join(LiMing)) #name_age_gender仅仅是字典的键
#将连接符设定为空字符串''时，则会将可迭代对象的每个元素组成一个连接起来的字符串。
#此时我们可以把列表变成字符串了
list_second = ["a","b","c","d"]
a = "".join(list_second)
print(a,type(a)) #abcd  <class 'str'>

1.8修剪

strip()、rstrip()、lstrip()
strip([chars])
分别是移除左右两边、左边、右边的字符char。如果不指定chars或者指定为None，则默认移除空白(空格、制表符、换行符)。
唯一需要注意的是，chars可以是多个字符序列。在移除时，只要是这个序列中的字符，都会被移除。

str1 = "   ab cd ef gh "
print(str1.strip()) #ab cd ef gh

#移除字符串中的字符
websit_str = "www.baidu.com"
print(websit_str.strip('.cmowz')) #baidu