第一次出现时分裂

Question

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

例如：

"123mango abcd mango kiwi peach"

在第一个 mango 上进行拆分以获得：

" abcd mango kiwi peach"

---

_{要在最后出现处进行拆分，请参阅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：列表索引超出范围”。

因此 -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方法。

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

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

>>> 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 技术有直接的对应项，用于获取字符串的最后一部分（即，最后之后的所有内容） 分隔符的出现）。供参考：

>>> '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，但它仍然会给出最后一个匹配的开头的索引分区的。因此：

>>> 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 方法慢。