如果你只想知道一个字符串是否在另一个字符串中重复，那么这是最好的(在我看来)和最短的代码片段:

def rep(repeat,fullstring):
    return len(fullstring.split(repeat)) > 2

#rep('test', 'test -others-') - no
#rep('hello', 'hello world') - yes

下面是这个问题的不同答案的一些基准。有一些令人惊讶的结果，包括完全不同的性能取决于测试的字符串。

一些函数被修改以适应Python 3(主要是用//替换/以确保整数除法)。如果你看到错误，想要添加你的函数，或者想要添加另一个测试字符串，在Python聊天室ping @ZeroPiraeus。

总之:对于OP在这里(通过这条评论)提供的大量示例数据，最佳和最差的解决方案之间大约有50倍的差异。David Zhang的解决方案显然是赢家，在大型示例集中，它的性能比其他所有解决方案高出约5倍。

在非常大的“不匹配”情况下，有两个答案非常慢。否则，根据测试的不同，这些功能似乎是相同的或明显的赢家。

以下是结果，包括使用matplotlib和seaborn绘制的图，以显示不同的分布:

语料库1(提供的示例-小集)

mean performance:
 0.0003  david_zhang
 0.0009  zero
 0.0013  antti
 0.0013  tigerhawk_2
 0.0015  carpetpython
 0.0029  tigerhawk_1
 0.0031  davidism
 0.0035  saksham
 0.0046  shashank
 0.0052  riad
 0.0056  piotr

median performance:
 0.0003  david_zhang
 0.0008  zero
 0.0013  antti
 0.0013  tigerhawk_2
 0.0014  carpetpython
 0.0027  tigerhawk_1
 0.0031  davidism
 0.0038  saksham
 0.0044  shashank
 0.0054  riad
 0.0058  piotr

语料库2(提供的示例-大集)

mean performance:
 0.0006  david_zhang
 0.0036  tigerhawk_2
 0.0036  antti
 0.0037  zero
 0.0039  carpetpython
 0.0052  shashank
 0.0056  piotr
 0.0066  davidism
 0.0120  tigerhawk_1
 0.0177  riad
 0.0283  saksham

median performance:
 0.0004  david_zhang
 0.0018  zero
 0.0022  tigerhawk_2
 0.0022  antti
 0.0024  carpetpython
 0.0043  davidism
 0.0049  shashank
 0.0055  piotr
 0.0061  tigerhawk_1
 0.0077  riad
 0.0109  saksham

语料库3(边缘情况)

mean performance:
 0.0123  shashank
 0.0375  david_zhang
 0.0376  piotr
 0.0394  carpetpython
 0.0479  antti
 0.0488  tigerhawk_2
 0.2269  tigerhawk_1
 0.2336  davidism
 0.7239  saksham
 3.6265  zero
 6.0111  riad

median performance:
 0.0107  tigerhawk_2
 0.0108  antti
 0.0109  carpetpython
 0.0135  david_zhang
 0.0137  tigerhawk_1
 0.0150  shashank
 0.0229  saksham
 0.0255  piotr
 0.0721  davidism
 0.1080  zero
 1.8539  riad

测试和原始结果可以在这里找到。

这个版本只尝试那些候选序列长度，是字符串长度的因素;并使用*操作符从候选序列构建一个完整的字符串:

def get_shortest_repeat(string):
    length = len(string)
    for i in range(1, length // 2 + 1):
        if length % i:  # skip non-factors early
            continue

        candidate = string[:i]
        if string == candidate * (length // i):
            return candidate

    return None

感谢TigerhawkT3注意到长度// 2没有+ 1将无法匹配abab情况。

如果你只想知道一个字符串是否在另一个字符串中重复，那么这是最好的(在我看来)和最短的代码片段:

def rep(repeat,fullstring):
    return len(fullstring.split(repeat)) > 2

#rep('test', 'test -others-') - no
#rep('hello', 'hello world') - yes

我从这个问题的八个以上的解决方案开始。一些基于正则表达式(match, findall, split)，一些基于字符串切片和测试，还有一些基于字符串方法(find, count, split)。每种方法在代码清晰、代码大小、速度和内存消耗方面都有好处。当我注意到执行速度同样重要时，我打算在这里发布我的答案，所以我做了更多的测试和改进，以达到以下结果:

def repeating(s):
    size = len(s)
    incr = size % 2 + 1
    for n in xrange(1, size//2+1, incr):
        if size % n == 0:
            if s[:n] * (size//n) == s:
                return s[:n]

这个答案似乎与这里的其他一些答案相似，但它有一些其他人没有使用的速度优化:

Xrange在这个应用程序中稍微快一点， 如果输入字符串是奇数长度，不要检查任何偶数长度的子字符串， 通过直接使用s[:n]，我们可以避免在每个循环中创建一个变量。

我很想看看这在普通硬件的标准测试中表现如何。我相信在大多数测试中，它会远远低于David Zhang的优秀算法，但在其他方面应该相当快。

我发现这个问题非常违反直觉。我认为快速的解决方案是缓慢的。看起来很慢的解决方案其实很快!Python使用乘法操作符创建字符串和字符串比较似乎得到了高度优化。

在有前缀函数的最坏情况下，问题也可以在O(n)中解决。

注意，在一般情况下，它可能会慢一些(UPD:并且要慢得多)，比其他依赖于n的除数的解决方案，但通常发现失败更快，我认为他们的坏情况之一将是aaa....Aab，其中n - 1 = 2 * 3 * 5 * 7…*p_n - 1a

首先你需要计算前缀函数

def prefix_function(s):
    n = len(s)
    pi = [0] * n
    for i in xrange(1, n):
        j = pi[i - 1]
        while(j > 0 and s[i] != s[j]):
            j = pi[j - 1]
        if (s[i] == s[j]):
            j += 1
        pi[i] = j;
    return pi

那么要么没有答案，要么最短周期是

k = len(s) - prefix_function(s[-1])

你只需要检查k != n和n % k == 0(如果k != n和n % k == 0，那么答案是s[:k]，否则没有答案

你可以在这里检查证明(俄语，但在线翻译可能会做的伎俩)

def riad(s):
    n = len(s)
    pi = [0] * n
    for i in xrange(1, n):
        j = pi[i - 1]
        while(j > 0 and s[i] != s[j]):
            j = pi[j - 1]
        if (s[i] == s[j]):
            j += 1
        pi[i] = j;
    k = n - pi[-1]
    return s[:k] if (n != k and n % k == 0) else None