python 判断字符串为空_总结：44个Python3字符串内置方法大全及示例

# 示例
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 = 'sstr'
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 = ' ntrstr_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_testntr'
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', 'rn', 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 = 'ntrstr_testntr'
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)