总结：44个Python3字符串内置方法大全及示例

142.jpg

概述

Python中字符串是作为一种强大的处理工具集的存在，而不是类C中使用的那么难受。因为Python提供了一系列字符串操作的方法，从大小写转换、切片操作到查找等等应有尽有，几乎满足日常的使用场景，当然如果满足不了需求还可以得助于更加强大的第三方库比如string，re等。下面就介绍了Python3中44个字符串内置方法的基本概述及简单示例。

44个字符串内置方法概述

方法	描述
capitalize	返回S的大写版本，即创建第一个字符，为大写字母，其他为小写字母
casefold	返回全小写
center	使字符串产生居中效果，默认填充为空格，也可指定填充单个字符
count	返回子字符串sub的非重叠出现次数, string S [start：end]。 可选参数start和end为切片表示法。即在切片范围内统计指定字符串的出现次数，如果不指定即在整个字符串内统计指定字符串出现次数
encode	字符串编码转换，默认为encoding='utf-8'
endswith	测试字符串结尾是否为指定字符串，也可指定字符串结尾
expandtabs	将字符串中的tab制表符转换为空格，一个字表符默认为8个空格
find	在字符串中查找指定字符，找到则返回最小的索引，没有则返回-1，也可以加上分片指定字符串中索引范围
format	字符串格式化的一种方法，将需要格式化的地方填充{}
format_map	字符串格式化的一种方法，接收的参数为字典，通过映射的方式格式化
index	寻找字符串中出现指定的第一个索引
isalnum	字符串中是否全部为数字字符，并至少有一个字符，若是则返回Ttue，否则返回False
isalpha	字符串中是否全部为英文字母，并至少有一个字符，若是则返回True，否则返回False
isdecimal	判断字符串是否只有十进制字符，若是则返回True，否则返回False
isdigit	判断字符串中是否全部为数字，并至少有一个字符，若是则返回True,否则返回False
isidentifier	判断字符串是否为有效定义
islower	判断字符串是否全部为小写字符，若是则返回True，否则返回False
isnumeric	判断字符串中是否全部为数字，若是则返回True，否则返回False
isprintable	判断字符串中所有字符是否都是可打印字符(in repr())或字符串为空。
isspace	判断字符串是否全部为空格，若是则返回True，否则返回False
istitle	判断字符串是否为一个标题字符串，即每个单词首写字母都为大写，若是则返回True，否则返回False
isupper	判断字符串中是否全部为大写字符，若是则返回True，否则返回False
join	将序列中的元素以指定的字符拼接成新的字符串
ljust	使字符串左对齐，当len(s)<width时，多余的字符默认为空，也可以指定填充单个字符
lower	将字符串全部转为小写字符
lstrip	删除字符串最前面的空格，回车，制表符等
maketrans	返回一个用translate的转换表，示例中ste与abc为映射关系，每个字符相对应(s->a，t->b，e->c)，outtab用于替换intab出现在需要处理的字符串中，第三个参数为需要删除的字符
partition	搜索指定分隔符，并返回第一个分隔符之前的部分，第一个分隔符本身，和第一个分隔符之后的部分
replace	字符串替换，replace(self, old, new, count=None)，接受参数依次是需要替换的字符串，替换后的字符串，和可选参数替换次数，默认为全部替换
rfind	在字符串中查找指定字符，找到则返回最大的索引，没有则返回-1，也可以加上分片指定字符串中索引范围
rindex	在字符串中查找指定字符，找到则返回最大的索引，没有则返回-1，也可以加上分片指定字符串中索引范围
rjust	使字符串右对齐，当len(s)<width时，多余的字符默认为空，也可以指定填充单个字符
rpartition	搜索指定分隔符，并返回最后一个分隔符之前的部分，最后一个分隔符本身，和最后一个分隔符之后的部分
rsplit	从右向左寻找，以某个元素为中心将左右分割成两个元素并放入列表中，maxsplit参数默认为-1，表示根据指定分割字符全部分割，maxsplit=1即根据指定分割字符仅分割一次，使用效果和rpartition类似
rstrip	删除字符串最后面的空格，回车，制表符等
split	从左向右寻找，以某个元素为中心将左右分割成两个元素并放入列表中，maxsplit参数默认为-1，表示根据指定分割字符全部分割，maxsplit=1即根据指定分割字符仅分割一次，使用效果和partition类似
splitlines	以换行符('\r', '\r\n', \n')分割为列表，参数keepends默认False，不包含换行符，如果为True，则保留换行符
startswith	判断字符串开头是否为指定字符串，若是则返回True，否则返回False
strip	删除字符串左右两边的空格，回车，制表符等
swapcase	将字符串中大小写字符翻转为小大写字符
title	将字符串转为标题字符串，即每个单词首字母大写
translate	根据参数table给出的表(包含 256 个字符)转换字符串的字符, 要过滤掉的字符放到 del 参数中。table表是通过maketrans方法转换而来
upper	将字符串全部转为小写字符
zfill	当len(s)<width时，从左边开始用0填充

44种方法使用示例

# 示例
s = 'str_test'

print('s.capitalize'.center(40, '-'))
# 返回S的大写版本，即创建第一个字符，为大写字母，其他为小写字母
s_capitalize = s.capitalize()
print(s_capitalize)

print('s.casefold'.center(40, '-'))
# 返回全小写
s_casefold = s.casefold()
print(s_casefold)

print('s.center'.center(40, '-'))
# 使字符串产生居中效果，默认填充为空格，也可指定填充单个字符
s_center = s.center(20, '-')
print(s_center)

print('s.count'.center(40, '-'))
# 返回子字符串sub的非重叠出现次数, string S [start：end]。 可选参数start和end为切片表示法。即在切片范围内统计指定字符串的出现次数，如果不指定即在整个字符串内统计指定字符串出现次数
s_count = s.count('es', 0, 7)
print(s_count)

print('s.encode'.center(40, '-'))
# 字符串编码转换，默认为`encoding='utf-8'`
s_encode = s.encode('utf-8', 'strict')
print(s_encode)

print('s.endswith'.center(40, '-'))
# 测试字符串结尾是否为指定字符串，也可指定字符串结尾
s_endswith = s.endswith('st', 1, 8)
print(s_endswith)

print('s.expandtabs'.center(40, '-'))
# 将字符串中的tab制表符转换为空格，一个字表符默认为8个空格
s_tab = 'ss\tr'
s_tab_expandtabs = s_tab.expandtabs(tabsize=8)
print(s_tab_expandtabs)

print('s.find'.center(40, '-'))
# 在字符串中查找指定字符，找到则返回最小的索引，没有则返回-1，也可以加上分片指定字符串中索引范围
s_find = s.find('test', 0, 8)
print(s_find)

print('s.format'.center(40, '-'))
# 字符串格式化的一种方法，将需要格式化的地方填充`{}`
s_format = '{} string in python'.format('Powerful')
print(s_format)

print('s.format_map'.center(40, '-'))
# 字符串格式化的一种方法，接收的参数为字典，通过映射的方式格式化
a = {'x': 'Powerful'}
s_format_map = '{x} string in python'.format_map(a)
print(s_format_map)

print('s.index'.center(40, '-'))
# 寻找字符串中出现指定的第一个索引
s_index = s.index('test')
print(s_index)

print('s.isalnum'.center(40, '-'))
# 字符串中是否全部为数字字符，并至少有一个字符，若是则返回Ttue，否则返回False
s_num = '233'
s_num_isalnum = s_num.isalnum()
print(s_num_isalnum)

print('s.isalpha'.center(40, '-'))
# 字符串中是否全部为英文字母，并至少有一个字符，若是则返回True，否则返回False
s_alpha = 'will'
s_alpha_isalpha = s_alpha.isalpha()
print(s_alpha_isalpha)

print('s.isdecimal'.center(40, '-'))
# 判断字符串是否只有十进制字符，若是则返回True，否则返回False
s_deci = '333'
s_deci_isdecimal = s_deci.isdecimal()
print(s_deci_isdecimal)

print('s.isdigit'.center(40, '-'))
# 判断字符串中是否全部为数字，并至少有一个字符，若是则返回True,否则返回False
s_digi = '123456'
s_digi_isdigit = s_digi.isdigit()
print(s_digi_isdigit)

print('s.isidentifier'.center(40, '-'))
# 判断字符串是否为有效定义
s_iden = ''
s_iden_isidentifier = s_iden.isidentifier()
print(s_iden_isidentifier)

print('s.islower'.center(40, '-'))
# 判断字符串是否全部为小写字符，若是则返回True，否则返回False
s_islower = s.islower()
print(s_islower)


print('s.isnumeric'.center(40, '-'))
# 判断字符串中是否全部为数字，若是则返回True，否则返回False
s_nume = '123456'
s_nume_isnumeric = s_nume.isnumeric()
print(s_nume)

print('s.isprintable'.center(40, '-'))
# 判断字符串中所有字符是否都是可打印字符(in repr())或字符串为空。
s_prin = ''
s_prin_isprintable = s_prin.isprintable()
print(s_prin_isprintable)

print('s.isspace'.center(40, '-'))
# 判断字符串是否全部为空格，若是则返回True，否则返回False
s_spac = '      '
s_spac_isspace = s_spac.isspace()
print(s_spac_isspace)

print('s.istitle'.center(40, '-'))
# 判断字符串是否为一个标题字符串，即每个单词首写字母都为大写，若是则返回True，否则返回False
s_titl = 'String In Python.'
s_titl_istitle = s_titl.istitle()
print(s_titl_istitle)

print('s.isupper'.center(40, '-'))
# 判断字符串中是否全部为大写字符，若是则返回True，否则返回False
s_uppe = 'STR_TEST'
s_uppe_isupper = s_uppe.isupper()
print(s_uppe_isupper)

print('s.join'.center(40, '-'))
# 将序列中的元素以指定的字符拼接成新的字符串
strs = ['Powerful', 'strng', 'in', 'python']
strs_join = ' '.join(strs)  # 指定' '空格拼接列表中的元素
print(strs_join)

print('s.ljust'.center(40, '-'))
# 使字符串左对齐，当len(s)<width时，多余的字符默认为空，也可以指定填充单个字符
s_ljust = s.ljust(10, '*')
print(s_ljust)

print('s.lower'.center(40, '-'))
# 将字符串全部转为小写字符
s_lowe = 'I Like PYTHON'
s_lowe_lower = s_lowe.lower()
print(s_lowe_lower)

print('s.lstrip'.center(40, '-'))
# 删除字符串最前面的空格，回车，制表符等
s_lstr = ' \n\t\rstr_test'
s_lstr_lstrip = s_lstr.lstrip()
print(s_lstr_lstrip)

print('s.maketrans'.center(40, '-'))
# 返回一个用translate的转换表，示例中`ste`与`abc`为映射关系，每个字符相对应(s->a，t->b，e->c)，`outtab`用于替换`intab`出现在需要处理的字符串中，第三个参数为需要删除的字符
intab = "st"
outtab = "#$"
deltab = '_'
s_maketrans = s.maketrans(intab, outtab, deltab)
print(s_maketrans)

print('s.partition'.center(40, '-'))
# 搜索指定分隔符，并返回第一个分隔符之前的部分，第一个分隔符本身，和第一个分隔符之后的部分
s_part = 'I like Python'
s_part_partition = s_part.partition(' ')
print(s_part_partition)

print('s.replace'.center(40, '-'))
# 字符串替换，`replace(self, old, new, count=None)`，接受参数依次是需要替换的字符串，替换后的字符串，和可选参数替换次数，默认为全部替换
s_replace = s.replace('t', 'T', 1)
print(s_replace)

print('s.rfind'.center(40, '-'))
# 在字符串中查找指定字符，找到则返回最大的索引，没有则返回-1，也可以加上分片指定字符串中索引范围
s_rfind = s.rfind('t', 0, 8)
print(s_rfind)

print('s.rindex'.center(40, '-'))
# 在字符串中查找指定字符，找到则返回最大的索引，没有则返回-1，也可以加上分片指定字符串中索引范围
s_rindex = s.rindex('t', 0, 8)
print(s_rindex)

print('s.rjust'.center(40, '-'))
# 使字符串右对齐，当len(s)<width时，多余的字符默认为空，也可以指定填充单个字符
s_rjust = s.rjust(10, '*')
print(s_rjust)

print('s.rpartition'.center(40, '-'))
# 搜索指定分隔符，并返回最后一个分隔符之前的部分，最后一个分隔符本身，和最后一个分隔符之后的部分
s_part = 'I like Python'
s_part_rpartition = s_part.rpartition(' ')
print(s_part_rpartition)

print('s.rsplit'.center(40, '-'))
# 从右向左寻找，以某个元素为中心将左右分割成两个元素并放入列表中，maxsplit参数默认为-1，表示根据指定分割字符全部分割，`maxsplit=1`即根据指定分割字符仅分割一次，使用效果和rpartition类似
s_rspl = 'I like python'
s_rspl_rsplit = s_rspl.rsplit(' ', 1)
print(s_rspl_rsplit)


print('s.rstrip'.center(40, '-'))
# 删除字符串最后面的空格，回车，制表符等
s_rstr = ' str_test\n\t\r'
s_rstr_rstrip = s_rstr.rstrip()
print(s_rstr_rstrip)

print('s.split'.center(40, '-'))
# 从左向右寻找，以某个元素为中心将左右分割成两个元素并放入列表中，maxsplit参数默认为-1，表示根据指定分割字符全部分割，`maxsplit=1`即根据指定分割字符仅分割一次，使用效果和partition类似
s_spli = 'I like python'
s_spli_split = s_spli.split(' ', 1)
print(s_spli_split)

print('s.splitlines'.center(40, '-'))
# 以换行符('\r', '\r\n', \n')为分割列表，参数`keepends`默认False，不包含换行符，如果为True，则保留换行符
s_line = '''It's a nice day.
with beautiful mood.
and you
'''
s_line_splitlines = s_line.splitlines(True)
print(s_line_splitlines)

print('s.startswith'.center(40, '-'))
# 判断字符串开头是否为指定字符串，若是则返回True，否则返回False
s_startswith = s.startswith('str')
print(s_startswith)

print('s.strip'.center(40, '-'))
# 删除字符串左右两边的空格，回车，制表符等
s_stri = '\n\t\rstr_test\n\t\r'
s_stri_strip = s_stri.strip()
print(s_stri_strip)

print('s.swapcase'.center(40, '-'))
# 将字符串中大小写字符翻转为小大写字符
s_swap = 'STR_test'
s_swap_swapcase = s_swap.swapcase()
print(s_swap_swapcase)

print('s.title'.center(40, '-'))
# 将字符串转为标题字符串，即每个单词首字母大写
s_titl = 'poerful string in python'
s_titl_title = s_titl.title()
print(s_titl_title)

print('s.translate'.center(40, '-'))
# 根据参数table给出的表(包含 256 个字符)转换字符串的字符, 要过滤掉的字符放到 del 参数中。table表是通过maketrans方法转换而来
s_translate = s.translate(s_maketrans)
print(s_translate)

print('s.upper'.center(40, '-'))
# 将字符串全部转为小写字符
s_uppe = 'STR_Test'
s_uppe_upper = s_uppe.upper()
print(s_uppe_upper)

print('s.z_fill'.center(40, '-'))
# 当len(s)<width时，从左边开始用0填充
s_zfill = s.zfill(10)
print(s_zfill)

carbon.png

示例效果如下：

carbon (1).png