在字符串Python中的a:之前，如何获取所有内容

我正在寻找一种方法，在a:之前把所有字母都放在一个字符串中，但我不知道从哪里开始。我会用正则表达式吗？如果是，怎么做

string = "Username: How are you today?"

---

有人能给我举一个我能做什么的例子吗？

只需使用

split

功能。它返回一个列表，因此您可以保留第一个元素：

>>> s1.split(':')
['Username', ' How are you today?']
>>> s1.split(':')[0]
'Username'

---

对此，您不需要

regex

>>> s = "Username: How are you today?"

您可以使用

split

方法拆分

'：'

字符上的字符串

>>> s.split(':')
['Username', ' How are you today?']

并切掉元素

[0]

，以获取字符串的第一部分

>>> s.split(':')[0]
'Username'

---

使用

索引

：

>>> string = "Username: How are you today?"
>>> string[:string.index(":")]
'Username'

索引将给出

：

在字符串中的位置，然后您可以对其进行切片

如果要使用正则表达式：

>>> import re
>>> re.match("(.*?):",string).group()
'Username'                       

match

从字符串开始匹配

您还可以使用

itertools.takewhile

>>> import itertools
>>> "".join(itertools.takewhile(lambda x: x!=":", string))
'Username'

---

我已经在Python3.7.0（IPython）下对这些不同的技术进行了基准测试

太长，读不下去了

• 最快（当分裂符号

  c

  已知时）：预编译正则表达式
• 最快（否则）：

  s.partition（c）[0]

• 安全（即当

  c

  可能不在

  s

  中时）：分区、拆分
• 不安全：索引，正则表达式

代码 结果

---

可能比split（）更好，因为它在没有分隔符或分隔符更多的情况下具有更好的可预测结果。

可以限制分割，或者在这种情况下-使用

s1.partition（“：”）[0]

谢谢这非常有用且信息丰富。另外，这是一个很大的帮助，谢谢！不要使用split，因为它会处理所有的“：”并创建一个完整的数组，不适合较长的字符串。请参阅@Hackaholic使用索引的方法。只是其中一个还推荐了一个显然没有那么有效的正则表达式。还必须有一个python选项来执行基于索引的.substringBefore（）的标准操作。还有一些变体，如.substringBeforeLast（）等，为了方便起见，应该放在那里（代码不应该重复）。注意到关于分区的一点-是的，在“：”之后的处理更少，但仍然返回：（“1”，““：”，“2:3”）而不是“1”。此方法（string[：string.index（“：”）可能比splitFor speed更干净。不要使用正则表达式-使用这里提到的第一个索引选项。Regex显然没有那么有效。还必须有一个python选项来执行基于索引的.substringBefore（）的标准操作。还有一些变体，如.substringBeforeLast（）等，为了方便起见，应该放在那里（代码不应该重复）。建议更新此答案，以解释为什么索引工作得更好，以及为什么它应该用于其他方法，包括fredtantini的回答中现在投票较高的方法。如果它不存在，索引将失败。在正则表达式中：re.match（（*）：，string）。group（）为什么我们需要一个“？”这个不应该用于re.match（（*），string）。group（）它不应该是

re.match（（*）：，string）.group（1）

（如果没有冒号，可能需要一些检查）<代码> > .Read（“（.*）：”，字符串）。GROUP（）/代码>似乎仍然包含Calm。为什么您认为索引不安全？<代码> Sindex（C）< /C> >当代码> C < /> >不在<代码> S/<代码>时，引发了一个ValueError错误。所以，当我确信要被分割的字符串包含分隔符时，它是安全的，否则，对于索引，C是在S中，所以它不是不安全的并且仍然是最快的。值得注意的是，

word[：word.index（'：'）]

在这两种情况下都会弹出。

import string, random, re

SYMBOLS = string.ascii_uppercase + string.digits
SIZE = 100

def create_test_set(string_length):
    for _ in range(SIZE):
        random_string = ''.join(random.choices(SYMBOLS, k=string_length))
        yield (random.choice(random_string), random_string)

for string_length in (2**4, 2**8, 2**16, 2**32):
    print("\nString length:", string_length)
    print("  regex (compiled):", end=" ")
    test_set_for_regex = ((re.compile("(.*?)" + c).match, s) for (c, s) in test_set)
    %timeit [re_match(s).group() for (re_match, s) in test_set_for_regex]
    test_set = list(create_test_set(16))
    print("  partition:       ", end=" ")
    %timeit [s.partition(c)[0] for (c, s) in test_set]
    print("  index:           ", end=" ")
    %timeit [s[:s.index(c)] for (c, s) in test_set]
    print("  split (limited): ", end=" ")
    %timeit [s.split(c, 1)[0] for (c, s) in test_set]
    print("  split:           ", end=" ")
    %timeit [s.split(c)[0] for (c, s) in test_set]
    print("  regex:           ", end=" ")
    %timeit [re.match("(.*?)" + c, s).group() for (c, s) in test_set]

String length: 16
  regex (compiled): 156 ns ± 4.41 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each)
  partition:        19.3 µs ± 430 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)
  index:            26.1 µs ± 341 ns per loop (mean ± std. dev. of 7 runs, 10000 loops each)
  split (limited):  26.8 µs ± 1.26 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)
  split:            26.3 µs ± 835 ns per loop (mean ± std. dev. of 7 runs, 10000 loops each)
  regex:            128 µs ± 4.02 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)

String length: 256
  regex (compiled): 167 ns ± 2.7 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each)
  partition:        20.9 µs ± 694 ns per loop (mean ± std. dev. of 7 runs, 10000 loops each)
  index:            28.6 µs ± 2.73 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)
  split (limited):  27.4 µs ± 979 ns per loop (mean ± std. dev. of 7 runs, 10000 loops each)
  split:            31.5 µs ± 4.86 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)
  regex:            148 µs ± 7.05 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)

String length: 65536
  regex (compiled): 173 ns ± 3.95 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each)
  partition:        20.9 µs ± 613 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)
  index:            27.7 µs ± 515 ns per loop (mean ± std. dev. of 7 runs, 10000 loops each)
  split (limited):  27.2 µs ± 796 ns per loop (mean ± std. dev. of 7 runs, 10000 loops each)
  split:            26.5 µs ± 377 ns per loop (mean ± std. dev. of 7 runs, 10000 loops each)
  regex:            128 µs ± 1.5 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)

String length: 4294967296
  regex (compiled): 165 ns ± 1.2 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each)
  partition:        19.9 µs ± 144 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)
  index:            27.7 µs ± 571 ns per loop (mean ± std. dev. of 7 runs, 10000 loops each)
  split (limited):  26.1 µs ± 472 ns per loop (mean ± std. dev. of 7 runs, 10000 loops each)
  split:            28.1 µs ± 1.69 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)
  regex:            137 µs ± 6.53 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)