第一次出现时分割

Question

在第一次出现分隔符时分割字符串的最佳方法是什么？

例如：

"123mango abcd mango kiwi peach"

拆分第一个

mango

得到：

" abcd mango kiwi peach"

---

_{要在 last 出现处进行拆分，请参阅 Python 中的分区字符串并获取冒号后最后一段的值。}

Answer 1

来自文档：

str.split([sep[, maxsplit]])

返回字符串中的单词列表，使用 sep 作为分隔符字符串。如果给出 maxsplit，则最多完成 maxsplit 分割（因此，列表最多有

maxsplit+1

个元素）。

s.split('mango', 1)[1]

Answer 2

>>> s = "123mango abcd mango kiwi peach"
>>> s.split("mango", 1)
['123', ' abcd mango kiwi peach']
>>> s.split("mango", 1)[1]
' abcd mango kiwi peach'

Answer 3

对我来说更好的方法是：

s.split('mango', 1)[-1]

...因为如果发生的情况不在字符串中，您将得到“

IndexError: list index out of range"

。

因此

-1

不会受到任何伤害，因为发生次数已经设置为1。

Answer 4

您还可以使用

str.partition

:

>>> text = "123mango abcd mango kiwi peach"

>>> text.partition("mango")
('123', 'mango', ' abcd mango kiwi peach')

>>> text.partition("mango")[-1]
' abcd mango kiwi peach'

>>> text.partition("mango")[-1].lstrip()  # if whitespace strip-ing is needed
'abcd mango kiwi peach'

使用

str.partition

的优点是它总是会返回以下形式的元组：

(<pre>, <separator>, <post>)

因此这使得解压输出变得非常灵活，因为结果元组中总是将有 3 个元素。

Answer 5

总结

最简单且性能最佳的方法是使用字符串的

.partition

方法。

通常，人们可能想要获取找到的定界符之前或之后的部分，并且可能想要查找字符串中出现的定界符的第一个或最后一个。对于大多数技术来说，所有这些可能性都大致一样简单，并且从一种技术转换为另一种技术也很简单。

对于以下示例，我们将假设：

>>> import re
>>> s = '123mango abcd mango kiwi peach'

使用

.split

>>> s.split('mango', 1)
['123', ' abcd mango kiwi peach']

.split

的第二个参数限制字符串被分割的次数。这给出了分隔符之前和之后的部分；然后我们就可以选择我们想要的了。

如果分隔符没有出现，则不进行分割：

>>> s.split('grape', 1)
['123mango abcd mango kiwi peach']
Thus, to check whether the delimiter was present, check the length of the result before working with it.

使用

.partition

>>> s.partition('mango')
('123', 'mango', ' abcd mango kiwi peach')

结果是一个元组，并且分隔符本身在找到时被保留。

当没有找到分隔符时，结果将是一个相同长度的元组，结果中有两个空字符串：

>>> s.partition('grape')
('123mango abcd mango kiwi peach', '', '')

因此，要检查分隔符是否存在，请检查第二个元素的值。

使用正则表达式

>>> # Using the top-level module functionality
>>> re.split(re.escape('mango'), s, 1)
['123', ' abcd mango kiwi peach']
>>> # Using an explicitly compiled pattern
>>> mango = re.compile(re.escape('mango'))
>>> mango.split(s, 1)
['123', ' abcd mango kiwi peach']

正则表达式的

.split

方法与内置字符串

.split

方法具有相同的参数，用于限制拆分次数。同样，当分隔符不出现时，不会进行分割：

>>> grape = re.compile(re.escape('grape'))
>>> grape.split(s, 1)
['123mango abcd mango kiwi peach']

在这些示例中，

re.escape

没有任何作用，但在一般情况下，为了将分隔符指定为文字文本，有必要使用它。另一方面，使用

re

模块可以发挥正则表达式的全部威力：

>>> vowels = re.compile('[aeiou]')
>>> # Split on any vowel, without a limit on the number of splits:
>>> vowels.split(s)
['123m', 'ng', ' ', 'bcd m', 'ng', ' k', 'w', ' p', '', 'ch']

（注意空字符串：在

e

和

a

的

peach

之间找到。）

使用索引和切片

使用字符串的

.index

方法找出分隔符在哪里，然后用它进行切片：

>>> s[:s.index('mango')] # for everything before the delimiter
'123'
>>> s[s.index('mango')+len('mango'):] # for everything after the delimiter
' abcd mango kiwi peach'

这直接给出了前缀。但是，如果未找到分隔符，则会引发异常：

>>> s[:s.index('grape')]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: substring not found

最后一次出现之后的所有内容

虽然没有人问，但我在这里提供了相关技术以供参考。

.split

和

.partition

技术有直接的对应物，用于获取字符串的最后部分（即，last出现的分隔符之后的所有内容）。供参考：

>>> '123mango abcd mango kiwi peach'.rsplit('mango', 1)
['123mango abcd ', ' kiwi peach']
>>> '123mango abcd mango kiwi peach'.rpartition('mango')
('123mango abcd ', 'mango', ' kiwi peach')

类似地，有一个 

.rindex

来匹配

.index

，但它仍然会给出分区最后一个匹配的

beginning of

的索引。因此：

>>> s[:s.rindex('mango')] # everything before the last match
'123mango abcd '
>>> s[s.rindex('mango')+len('mango'):] # everything after the last match
' kiwi peach'

对于正则表达式方法，我们可以依靠反转输入的技术，查找反转分隔符的第一次出现，反转各个结果，以及反转结果列表：

>>> ognam = re.compile(re.escape('mango'[::-1]))
>>> [x[::-1] for x in ognam.split('123mango abcd mango kiwi peach'[::-1], 1)][::-1]
['123mango abcd ', ' kiwi peach']

当然，这几乎肯定是付出的努力超过了其价值。

另一种方法是从分隔符到字符串末尾使用负向前查找：

>>> literal_mango = re.escape('mango')
>>> last_mango = re.compile(f'{literal_mango}(?!.*{literal_mango})')
>>> last_mango.split('123mango abcd mango kiwi peach', 1)
['123mango abcd ', ' kiwi peach']

由于前瞻，这是最坏情况的 O(n^2) 算法。

性能测试

$ python -m timeit --setup="s='123mango abcd mango kiwi peach'" "s.partition('mango')[-1]"
2000000 loops, best of 5: 128 nsec per loop
$ python -m timeit --setup="s='123mango abcd mango kiwi peach'" "s.split('mango', 1)[-1]"
2000000 loops, best of 5: 157 nsec per loop
$ python -m timeit --setup="s='123mango abcd mango kiwi peach'" "s[s.index('mango')+len('mango'):]"
1000000 loops, best of 5: 250 nsec per loop
$ python -m timeit --setup="s='123mango abcd mango kiwi peach'; import re; mango=re.compile(re.escape('mango'))" "mango.split(s, 1)[-1]"
1000000 loops, best of 5: 258 nsec per loop

虽然更灵活，但正则表达式方法肯定更慢。限制分割数量可以提高字符串方法和正则表达式的性能（没有限制的时间不会显示，因为它们速度较慢并且会给出不同的结果），但

.partition仍然是明显的赢家。

对于此测试数据，

.index

方法速度较慢，尽管它只需创建一个子字符串，并且不必迭代匹配范围之外的文本（为了创建其他子字符串）。预先计算分隔符的长度会有所帮助，但这仍然比

.split

和

.partition

方法慢。