Python字符串操作完全指南：内置方法与示例

何川

发布时间：2026-10-14 | 6人浏览过

原创

本文详细解析Python中字符串对象的常用操作方法。涵盖大小写转换、类型判断、填充对齐、子串搜索、替换、分割连接及修剪等核心功能。通过具体代码示例，解释lower、upper、find、split、join等方法的参数用法与返回值特性，帮助开发者高效处理文本数据。

Python字符串操作完全指南：内置方法与示例

前言

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

这些方法的详细使用说明可参考官方文档：string methods。本文将对它们进行逐一详解，建议读者将其作为日常开发的手册查阅。

本文不涉及正则表达式（模式匹配）相关的功能。若需在Python中使用正则表达式操作字符串，需导入re模块。关于正则模式匹配的具体内容，请参阅：re Module Contents。

需要注意的是，Python中的字符串是不可变对象。因此，所有对字符串进行修改或生成的操作，其实现方式都是在新的内存片段中创建一个新的字符串对象。例如，执行'abc'.upper()时，系统会在另一块内存中生成并返回'ABC'。

下文中的"S"代表待操作的字符串。本文未介绍casefold、encode、format和format_map方法，前两者与Unicode编码相关，后两者内容较为复杂且篇幅较长。

大小写转换方法

1. 大小写转换

1.1 lower、upper

S.lower() S.upper()

这两个方法分别返回字符串S的小写和大写格式。请注意，它们返回的是新生成的字符串，存储在另一片内存区域中，后文不再重复说明这一机制。

例如：


>>> print('ab XY'.lower())
ab xy
>>> print('ab XY'.upper())
AB XY

1.2 title、capitalize

S.title() S.capitalize()

title()方法返回字符串中所有单词首字母大写、其余字母小写的格式；capitalize()方法则仅将首字母大写，其余字母全部转为小写，并返回新字符串。

例如：


>>> print('ab XY'.title())
Ab Xy
>>> print('abc DE'.capitalize())
Abc de

1.3 swapcase

S.swapcase()

swapcase()方法对字符串S中的所有字符进行大小写互换（大写转小写，小写转大写）。


>>> print('abc XYZ'.swapcase())
ABC xyz

字符串类型判断方法

2. isXXX判断

2.1 isalpha,isdecimal,isdigit,isnumeric,isalnum

S.isdecimal() S.isdigit() S.isnumeric() S.isalpha() S.isalnum()

这些方法用于测试字符串S是否由数字、字母或字母数字组成。对于非Unicode字符串，前三个方法的功能是等价的。

例如：


>>> print('34'.isdigit())
True
>>> print('abc'.isalpha())
True
>>> print('a34'.isalnum())
True

2.2 islower,isupper,istitle

S.islower() S.isupper() S.istitle()

这些方法分别判断字符串是否全为小写、全为大写或符合标题格式（首字母大写）。要求字符串S中至少包含一个字符类字符，否则直接返回False（例如纯数字字符串会返回False）。注意，istitle()在判断时会识别每个单词的首字母边界。例如，'word1 Word2'、'word1_Word2'、'word1()Word2'均被视为包含两个单词，其首字母分别为'w'和'W'。由于'w'是小写，因此使用istitle()判断这些字符串将返回False。

例如：


>>> print('a34'.islower())
True
>>> print('AB'.isupper())
True
>>> print('Aa'.isupper())
False
>>> print('Aa Bc'.istitle())
True
>>> print('Aa_Bc'.istitle())
True
>>> print('Aa bc'.istitle())
False
>>> print('Aa_bc'.istitle())
False

# 下面的返回False，因为非首字母C不是小写
>>> print('Aa BC'.istitle())
False

2.3 isspace,isprintable,isidentifier

S.isspace() S.isprintable() S.isidentifier()

这些方法分别判断字符串是否仅由空白字符（空格、制表符、换行符等）组成、是否可打印（制表符和换行符不可打印，但空格可打印），以及是否符合标识符定义规则。

例如：

判断是否为空白字符串。空字符串不被视为空白。


>>> print(' '.isspace())
True
>>> print(' \t'.isspace())
True
>>> print('\n'.isspace())
True
>>> print(''.isspace())
False
>>> print('Aa BC'.isspace())
False

判断是否包含可打印字符。


>>> print('\n'.isprintable())
False
>>> print('\t'.isprintable())
False
>>> print('acd'.isprintable())
True
>>> print(' '.isprintable())
True
>>> print(''.isprintable())
True

判断是否符合标识符定义规则。

标识符定义规则为：必须以字母或下划线开头，且只能包含数字、字母和下划线，不能包含其他任意字符。


>>> print('abc'.isidentifier())
True
>>> print('2abc'.isidentifier())
False
>>> print('abc2'.isidentifier())
True
>>> print('_abc2'.isidentifier())
True
>>> print('_abc_2'.isidentifier())
True
>>> print('_Abc_2'.isidentifier())
True
>>> print('Abc_2'.isidentifier())
True

字符串填充与对齐

3. 填充

3.1 center

S.center(width[, fillchar])

该方法将字符串居中，并在左右两侧使用fillchar字符进行填充，使总长度达到width。fillchar默认为空格。如果width小于字符串本身的长度，则无法填充，直接返回原字符串（不会创建新对象）。

例如：

使用下划线填充并居中字符串


>>> print('ab'.center(4,'_'))
_ab_
>>> print('ab'.center(5,'_'))
__ab_

使用默认的空格填充并居中字符串


>>> print('ab'.center(4))
 ab 
>>> print(len('ab'.center(4)))
4

width小于字符串长度


>>> print('abcde'.center(3))
abcde

3.2 ljust和rjust

S.ljust(width[, fillchar]) S.rjust(width[, fillchar])

ljust()方法在字符串S的右侧使用fillchar进行填充，使总长度达到width；rjust()则在左侧填充。若不指定fillchar，默认使用空格填充。

如果width小于或等于字符串S的长度，则无法填充，直接返回原字符串S（不会创建新对象）。

例如：


>>> print('xyz'.ljust(5,'_'))
xyz__
>>> print('xyz'.rjust(5,'_'))
__xyz

3.3 zfill

S.zfill(width)

该方法在字符串S的左侧用0进行填充，使总长度达到width。如果S以正负号（+/-）开头，则0填充在符号之后，且符号计入总长度。如果width小于或等于S的长度，则无法填充，直接返回S本身（不会创建新对象）。


>>> print('abc'.zfill(5))
00abc

>>> print('-abc'.zfill(5))
-0abc

>>> print('+abc'.zfill(5))
+0abc

>>> print('42'.zfill(5))
00042

>>> print('-42'.zfill(5))
-0042

>>> print('+42'.zfill(5))
+0042

子串搜索与定位

4. 子串搜索

4.1 count

S.count(sub[, start[, end]])

该方法返回字符串S中子串sub出现的次数。可以指定起始位置start和结束位置end（索引从0开始，不包括end边界）。

例如：


>>> print('xyabxyxy'.count('xy'))
3

# 次数2，因为从index=1算起，即从'y'开始查找，查找的范围为'yabxyxy'
>>> print('xyabxyxy'.count('xy',1))
2

# 次数1，因为不包括end，所以查找的范围为'yabxyx'
>>> print('xyabxyxy'.count('xy',1,7))
1

# 次数2，因为查找的范围为'yabxyxy'
>>> print('xyabxyxy'.count('xy',1,8))
2

4.2 endswith和startswith

S.endswith(suffix[, start[, end]]) S.startswith(prefix[, start[, end]])

endswith()方法检查字符串S是否以suffix结尾，返回布尔值True或False。suffix可以是一个元组（tuple）。可以指定起始start和结尾end的搜索边界。

同理，startswith()方法用于判断字符串S是否以prefix开头。

例如：

suffix是普通字符串时。


>>> print('abcxyz'.endswith('xyz'))
True
　
# False，因为搜索范围为'yz'
>>> print('abcxyz'.endswith('xyz',4))
False
　
# False，因为搜索范围为'abcxy'
>>> print('abcxyz'.endswith('xyz',0,5))
False
>>> print('abcxyz'.endswith('xyz',0,6))
True

suffix是元组（tuple）时，只要tuple中任意一个元素满足endswith的条件，就返回True。


# tuple中的'xyz'满足条件
>>> print('abcxyz'.endswith(('ab','xyz')))
True
　
# tuple中'ab'和'xy'都不满足条件
>>> print('abcxyz'.endswith(('ab','xy')))
False
　
# tuple中的'z'满足条件
>>> print('abcxyz'.endswith(('ab','xy','z')))
True

4.3 find,rfind和index,rindex

S.find(sub[, start[, end]]) S.rfind(sub[, start[, end]])¶ S.index(sub[, start[, end]]) S.rindex(sub[, start[, end]])

find()方法搜索字符串S中是否包含子串sub。如果包含，返回sub的索引位置；否则返回-1。可以指定起始start和结束end的搜索范围。

index()方法与find()类似，唯一区别在于当找不到子串时，会抛出ValueError错误。

rfind()方法返回搜索到的最右侧子串的位置。如果只找到一个或未找到子串，则与find()等价。

同理，rindex()方法的行为与rfind()类似。

例如：


>>> print('abcxyzXY'.find('xy'))
3
>>> print('abcxyzXY'.find('Xy'))
-1
>>> print('abcxyzXY'.find('xy',4))
-1

>>> print('xyzabcabc'.find('bc'))
4
>>> print('xyzabcabc'.rfind('bc'))
7

>>> print('xyzabcabc'.rindex('bcd'))
Traceback (most recent call last):
 File "<stdin>", line 1, in <module>
ValueError: substring not found

可以使用in操作符来判断字符串S是否包含子串sub，它返回的是布尔值而非索引位置。


>>> 'xy' in 'abxycd'
True
>>> 'xyz' in 'abxycd'
False

字符串替换与格式化

5. 替换

5.1 replace

S.replace(old, new[, count])

该方法将字符串中的子串old替换为new。如果指定了count参数，则仅替换前count个old子串。如果在S中未搜索到子串old，则无法替换，直接返回原字符串S（不创建新对象）。


>>> print('abcxyzoxy'.replace('xy','XY'))
abcXYzoXY
>>> print('abcxyzoxy'.replace('xy','XY',1))
abcXYzoxy
>>> print('abcxyzoxy'.replace('mn','XY',1))
abcxyzoxy

5.2 expandtabs

S.expandtabs(N)

该方法将字符串S中的\t替换为一定数量的空格。默认N=8。

注意，expandtabs(8)并非简单地将\t替换为8个空格。例如，'xyz\tab'.expandtabs()会将\t替换为5个空格，因为'xyz'占用了3个字符位。

此外，该方法不会替换换行符（\n或\r）。

例如：


>>> '01\t012\t0123\t01234'.expandtabs(4)
'01 012 0123 01234'

>>> '01\t012\t0123\t01234'.expandtabs(8)
'01  012  0123 01234'

>>> '01\t012\t0123\t01234'.expandtabs(7)
'01  012 0123 01234'

>>> print('012\t0123\n01234'.expandtabs(7))
012 0123
01234

5.3 translate和maketrans

S.translate(table) static str.maketrans(x[, y[, z]])

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

如果你熟悉Linux，应该知道tr命令，translate()实现的功能与tr类似。

例如，现在想要对'I love fairy'进行简单加密，将部分字符替换为数字，使他人无法直接解读转换后的内容。


>>> in_str='abcxyz'
>>> out_str='123456'

# maketrans()生成映射表
>>> map_table=str.maketrans(in_str,out_str)

# 使用translate()进行映射
>>> my_love='I love fairy'
>>> result=my_love.translate(map_table)
>>> print(result)
I love f1ir5

注意，maketrans(x[, y[, z]])中的x和y必须是字符串，且长度必须相等。

如果maketrans(x[, y[, z]])提供了第三个参数z，则z字符串中的每个字符都会被映射为None（即被删除）。

例如，不替换'o'和'y'。


>>> in_str='abcxyz'
>>> out_str='123456'
>>> map_table=str.maketrans(in_str,out_str,'ay')
>>> my_love='I love fairy'
>>> result=my_love.translate(map_table)
>>> print(result)
I love fir

字符串分割技巧

6. 分割

6.1 partition和rpartition

S.partition(sep) S.rpartition(sep)

该方法搜索字符串S中的子串sep，并从sep处对S进行分割，最后返回一个包含3个元素的元组：sep左边的部分是元组的第一个元素，sep自身是第二个元素，sep右边是第三个元素。

partition(sep)从左边第一个sep进行分割，rpartition(sep)从右边第一个sep进行分割。

如果未搜索到sep，返回的3元素元组中会有两个元素为空。partition()返回后两个元素为空，rpartition()返回前两个元素为空。

例如：


# 只搜索到一个sep时，两者结果相同
>>> print('abcxyzopq'.partition('xy'))
('abc', 'xy', 'zopq')
>>> print('abcxyzopq'.rpartition('xy'))
('abc', 'xy', 'zopq')

# 搜索到多个sep时，分别从左第一个、右第一个sep分割
>>> print('abcxyzxyopq'.partition('xy'))
('abc', 'xy', 'zxyopq')
>>> print('abcxyzxyopq'.rpartition('xy'))
('abcxyz', 'xy', 'opq')

# 搜索不到sep
>>> print('abcxyzxyopq'.partition('xyc'))
('abcxyzxyopq', '', '')
>>> print('abcxyzxyopq'.rpartition('xyc'))
('', '', 'abcxyzxyopq')

6.2 split、rsplit和splitlines

S.split(sep=None, maxsplit=-1) S.rsplit(sep=None, maxsplit=-1) S.splitlines([keepends=True])

这些方法均用于分割字符串，并生成一个列表。

split()根据sep对S进行分割，maxsplit用于指定分割次数。如果不指定maxsplit或给定值为-1，则会从左向右搜索，每遇到一次sep就分割一次，直到字符串末尾。如果不指定sep或指定为None，则改变分割算法：以空格为分隔符，并将连续的空白字符压缩为一个空格。

rsplit()与split()功能相同，只是从右边向左边搜索。

splitlines()专门用于分割换行符。虽然它看起来像split('\n')或split('\r\n')，但两者存在区别，详见下文解释。

首先是split()的示例分析（rsplit()示例略）。


# sep为单个字符时
>>> '1,2,3'.split(',')
['1', '2', '3']

>>> '1,2,3'.split(',',1)
['1', '2,3']  # 只分割了一次

>>> '1,2,,3'.split(',')
['1', '2', '', '3'] # 不会压缩连续的分隔符

>>> '<hello><><world>'.split('<')
['', 'hello>', '>', 'world>']

# sep为多个字符时
>>> '<hello><><world>'.split('<>')
['<hello>', '<world>']

# 不指定sep时
>>> '1 2 3'.split()
['1', '2', '3']

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

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

>>> '  1  2  3 \n'.split()
['1', '2', '3']

# 显式指定sep为空格、制表符、换行符时
>>> ' 1 2 3 \n'.split(' ')
['', '1', '', '2', '', '3', '', '\n']

>>> ' 1 2 3 \n'.split('\t')
[' 1 2 3 \n']

>>> ' 1 2\n3 \n'.split('\n')
[' 1 2', '3 ', ''] # 注意列表的最后一项''

>>> ''.split('\n')
['']

再是splitlines()的示例分析。

splitlines()中可以指定各种换行符，常见的是\n、\r、\r\n。如果指定keepends为True，则保留所有的换行符。


>>> 'ab c\n\nde fg\rkl\r\n'.splitlines()
['ab c', '', 'de fg', 'kl']

>>> 'ab c\n\nde fg\rkl\r\n'.splitlines(keepends=True)
['ab c\n', '\n', 'de fg\r', 'kl\r\n']

将split()和splitlines()进行比较：


#### split()
>>> ''.split('\n')
['']      # 因为没换行符可分割

>>> 'One line\n'.split('\n')
['One line', '']

#### splitlines()
>>> "".splitlines()
[]       # 因为没有换行符可分割

>>> 'Two lines\n'.splitlines()
['Two lines']

字符串连接操作

7. join

S.join(iterable)

该方法将可迭代对象（iterable）中的字符串使用S连接起来。注意，iterable中的所有元素必须是字符串类型，否则报错。

如果你是Python初学者，尚不清楚iterable是什么，但想了解join的具体语法，可以暂时将其理解为：字符串string、列表list、元组tuple、字典dict、集合set。

例如：

字符串


>>> L='python'
>>> '_'.join(L)
'p_y_t_h_o_n'

元组


>>> L1=('1','2','3')
>>> '_'.join(L1)
'1_2_3'

集合。注意，集合是无序的。


>>> L2={'p','y','t','h','o','n'}
>>> '_'.join(L2)
'n_o_p_h_y_t'

列表


>>> L2=['py','th','o','n']
>>> '_'.join(L2)
'py_th_o_n'

字典


>>> L3={'name':"malongshuai",'gender':'male','from':'China','age':18}
>>> '_'.join(L3)
'name_gender_from_age'

iterable参与迭代的部分必须是字符串类型，不能包含数字或其他类型。


>>> L1=(1,2,3)
>>> '_'.join(L1)
Traceback (most recent call last):
 File "<stdin>", line 1, in <module>
TypeError: sequence item 0: expected str instance, int found

以下两种情况也不能使用join。


>>> L1=('ab',2)
>>> L2=('AB',{'a','cd'})

字符串修剪方法

8. 修剪：strip、lstrip和rstrip

S.strip([chars]) S.lstrip([chars]) S.rstrip([chars])

这些方法分别移除左右两边、左边、右边的字符char。如果不指定chars或指定为None，则默认移除空白字符（空格、制表符、换行符）。

唯一需要注意的是，chars可以是多个字符组成的序列。在移除时，只要字符属于这个序列中的任何一个，都会被移除。

例如：

移除单个字符或空白。


>>> '  spacious  '.lstrip()
'spacious  '
　
>>> '  spacious  '.rstrip()
'  spacious'
　
>>> 'spacious  '.lstrip('s')
'pacious  '
　
>>> 'spacious'.rstrip('s')
'spaciou'

移除字符序列中的字符。


>>> print('www.example.com'.lstrip('cmowz.'))
example.com
>>> print('wwwz.example.com'.lstrip('cmowz.'))
example.com
>>> print('wwaw.example.com'.lstrip('cmowz.'))
aw.example.com
>>> print('www.example.com'.strip('cmowz.'))
'example'

由于'www.example.com'的前4个字符都在字符序列'cmowz.'中，因此都被移除，而第5个字符'e'不在序列中，所以修剪到此结束。同理适用于'wwwz.example.com'。

'wwaw.example.com'中第3个字符'a'不在字符序列中，因此修剪到此结束。

总结

以上就是本文的全部内容，希望这些内容对大家的学习或工作具有一定的参考价值。如有疑问欢迎留言交流，感谢大家对本站的支持。