Python 字符串分割方法汇总：split、rsplit、splitlines 与 re.split 用法详解

在 Python 里，字符串分割是非常高频的基础操作。最常见的是 split()，但如果场景稍微复杂一点，比如要从右往左分割、按行拆分、保留分隔符，或者直接按正则规则拆分，就不能只靠一个方法了。

这篇文章把 Python 里最常见的 6 种字符串分割方法放在一起做一个实用总结：

slpit
rsplit
splitlines
partition
rpartition
re.split

下面各部分是各方法的详细介绍

开始前先记住一个选择思路

如果你只是想先有一个整体判断，可以直接按这个顺序选：

普通按固定分隔符拆分，优先用 split
想限制次数并且从右边开始拆，用 rsplit
专门处理多种换行符，用 splitlines
只想拆成“前半段 + 分隔符 + 后半段”，用 partition 或 rpartition
分隔规则比较复杂，需要正则表达式时，再用 re.split

split(sep=None, maxsplit=-1)

最常见的方法。它会根据 sep 指定的分隔符拆分字符串，并返回一个 list。同时也可以通过 maxsplit 控制最多拆分多少次。

需要注意两点：

默认情况下，第一个参数是分隔符 sep，第二个参数是最大拆分次数 maxsplit
如果 sep 保持默认值，但你想只设置 maxsplit，就需要写成 split(maxsplit=2) 这种形式

split 例子1

不指定分割符时，Python 会把连续空白字符当成分隔条件，包括空格和换行。

## 平常的空格分割
normal = "this is a string"
normal.split()
#Out[1]: ['this', 'is', 'a', 'string']

## 多个空格，自动合并处理
twospace = "string  two  space one" 
twospace.split()
#Out[2]: ['string', 'two', 'space', 'one']
## 换行符分割
line = "aother\nstring"
line.split()
#Out[5]: ['aother', 'string']

## widnwos下的换行符
wline = "windows\r\nstring"
wline.split()

#Out[7]: ['windows', 'string']

split 例子2

自定义分割字符串。


## 用一般逗号句号等
normal = "this,is,a,string"
normal.split(",")
# Out[1]: ['this', 'is', 'a', 'string']
##也可以使用单词等字符串
words = u"我是春江暮客博客博主"
words.split(u"博客")
#Out[1]: ['我是春江暮客', '博主']

split 例子3

指定拆分次数，参数为 maxsplit。


## 只需要分成三部分,注意此处份数从0开始计算
spe_len = "this,is,a,string"
spe_len.split(",",2)
#['this', 'is', 'a,string']

##第一个参数默认，第二个参数自定则需要指定参数名，此处为maxsplit
spe_len = "this is a string"
spe_len.split(maxsplit=2)
#['this', 'is', 'a string']

rsplit(sep=None, maxsplit=-1)

这个函数和 split 基本一样，区别在于 r 代表 right。也就是说，当你限制拆分次数时，它会优先从右边开始拆。

## 平常的空格分割,与split一模一样
normal = "this is a string"
normal.rsplit()
#Out[1]: ['windows', 'string']

## 指定分割符，与split一模一样

normal = "this,is,a,string" 
normal.rsplit(",")                                                                                                                                   
#Out[2]: ['this', 'is', 'a', 'string']

## 指定分割长度，与split不一样

### split
spe_len = "this is a string"
spe_len.split(maxsplit=2)
#['this', 'is', 'a string']

### rsplit
spe_len = "this is a string"
spe_len.rsplit(maxsplit=2)
Out[2]: ['this is', 'a', 'string']

可以看到在 rsplit 里，多余的内容会留在左侧；而 split 在相同条件下，多余内容会留在右侧。

splitlines(keepends=False)

这个方法专门用于按“行”分割字符串。和普通 split() 不同的是，它能识别多种换行符，并且可以通过 keepends 控制是否保留换行符本身。

它可以识别的换行符包括：

["\n","\r","\r\n","\v","\x0b","\f","\x0c","\x1c","\x1d","\x1e","\x85","\u2028","\u2029"]

下面看两个典型例子：

# 行分割
s = "我是\n春江暮客\r博客\r\n博主"
s.splitlines()
#Out[1]: ['我是', '春江暮客', '博客', '博主']

#指定保留分割符号，此时分割符号会紧跟前面的字符串

s = "我是\n春江暮客\r博客\r\n博主" 
s.splitlines(True)                                                                                                                                   
#Out[2]: ['我是\n', '春江暮客\r', '博客\r\n', '博主']

partition(sep)

partition 会在分隔符第一次出现的位置把字符串拆成三段，并返回一个长度固定为 3 的元组：

分隔符前面的内容
分隔符本身
分隔符后面的内容

由于 sep 没有默认值，所以不传会直接报错。如果分隔符没有出现，则结果会是“原字符串 + 两个空字符串”。

例子：


# 空格分割
s = "我是 春江暮客 博客博主"
s.partition(" ")
# Out[3]: ('我是', ' ', '春江暮客 博客博主')


# 回车分割
s2 = "我是\n春江暮客\r博客\r\n博主"
s2.partition("\r")

# Out[2]: ('我是\n春江暮客', '\r', '博客\r\n博主')

# 不指定分割报错
s3 = "我是\n春江暮客\r博客\r\n博主"  
s3.partition()
#TypeError: partition() takes exactly one argument (0 given)


# 没有出现的分割符
s4 = "我是\n春江暮客\r博客\r\n博主"  
s4.partition(",")  
#Out[2]: ('我是\n春江暮客\r博客\r\n博主', '', '')

rpartition(sep)

和 partition 类似，只不过它是从右边开始找第一个匹配的分隔符。

## 这是partition
s3 = "我是\n春江暮客\r博客\r\n博主"   
s3.partition("\r")  
#Out[2]: ('我是\n春江暮客', '\r', '博客\r\n博主')

## 这是rpartition
s3 = "我是\n春江暮客\r博客\r\n博主"
s3.rpartition("\r")
#Out[3]: ('我是\n春江暮客\r博客', '\r', '\n博主')

re.split(pattern, string, maxsplit=0, flags=0)

最后一个是 re 模块提供的 split。它的优势是可以直接使用正则表达式，不需要像前面几个方法那样只能处理固定分隔符，但代价是性能和理解成本都会更高一点。

参数含义如下：

pattern：正则表达式
string：待拆分的字符串
maxsplit：最大拆分次数，默认 0 表示不限制
flags：正则标志，例如 re.IGNORECASE

例子：

#导入re模块
import re
#直接使用空格分割
s = "我是 春江暮客 博客 博主"
re.split(' ',s)
#Out[1]: ['我是', '春江暮客', '博客', '博主']

# 使用正则表达式的\s，代表任意的空白字符
s = "我是 春江暮客 博客 博主"
re.split('\s',s)
#Out[2]: ['我是', '春江暮客', '博客', '博主']


s = "我是 春江暮客\n 博客 博主" 
re.split('\s',s)                                                                                                                                     
#Out[3]: ['我是', '春江暮客', '', '博客', '博主']

#指定分割数
s = "我是 春江暮客 博客 博主"
re.split('\s',s,2)
#Out[2]: ['我是', '春江暮客', '博客 博主']

# 忽略大小写
## 一般小写匹配
s =  "hello World pythOn" 
re.split('o',s,2)                                                                                                                                    
#Out[6]: ['hell', ' W', 'rld pythOn']
## 忽略大小写匹配
s =  "hello World pythOn" 
re.split('o',s,2,re.IGNORECASE)                                                                                                                      
#Out[7]: ['hell', ' W', 'rld pythOn']

这 6 个方法应该怎么选

如果把这几个方法放在一起看，它们最核心的区别其实是“分隔规则有多复杂”和“返回结果是不是固定结构”。

方法	典型场景	返回值
`split`	最普通的按固定分隔符拆分	`list`
`rsplit`	想从右边开始限制拆分次数	`list`
`splitlines`	处理多种换行符文本	`list`
`partition`	只切第一次出现的位置	`tuple`
`rpartition`	只切最后一次出现的位置	`tuple`
`re.split`	需要正则规则拆分	`list`

如果你的目标只是解析一个简单字符串，优先用内置字符串方法；只有在分隔条件明显复杂时，再考虑 re.split。

总结

本文系统整理了 Python 中最常用的 6 种字符串分割方式，以及它们之间的差异和适用场景。

实际使用时，优先记住这条经验就够了：普通拆分先用 split，按行处理用 splitlines，只切第一次或最后一次出现的位置用 partition / rpartition，只有规则复杂时再上 re.split。这样在日常开发里基本就够用了。