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

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情况。

下面是一个简洁的解决方案，它避免了正则表达式和缓慢的python循环:

def principal_period(s):
    i = (s+s).find(s, 1, -1)
    return None if i == -1 else s[:i]

请参阅由@davidism开始的社区Wiki回答以获得基准测试结果。总之,

David Zhang的解决方案显然是赢家，在大型示例集中，它的表现至少比其他所有解决方案好5倍。

(这是我的原话，不是我的。)

这是基于这样的观察:当且仅当字符串等于自身的非平凡旋转时，它是周期性的。感谢@AleksiTorhamo实现了从(s+s)[1:-1]中第一次出现的s的索引中恢复主周期，并通知我Python的string.find的可选开始和结束参数。

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

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

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

这是一个直接的解决方案，没有正则表达式。

对于从第0个索引开始，长度为1到len(s)的s子字符串，检查substr是否是重复模式。这个检查可以通过将substr与它自身的ratio乘以连接来执行，这样形成的字符串长度等于s的长度。因此ratio=len(s)/len(substr)。

当找到第一个这样的子字符串时返回。这将提供尽可能小的子字符串(如果存在的话)。

def check_repeat(s):
    for i in range(1, len(s)):
        substr = s[:i]
        ratio = len(s)/len(substr)
        if substr * ratio == s:
            print 'Repeating on "%s"' % substr
            return
    print 'Non repeating'

>>> check_repeat('254725472547')
Repeating on "2547"
>>> check_repeat('abcdeabcdeabcdeabcde')
Repeating on "abcde"

这个函数运行得非常快(经过测试，在超过100k字符的字符串上，它比这里最快的解决方案快3倍以上，并且重复模式的时间越长，差异就越大)。它试图最小化得到答案所需的比较次数:

def repeats(string):
    n = len(string)
    tried = set([])
    best = None
    nums = [i for i in  xrange(2, int(n**0.5) + 1) if n % i == 0]
    nums = [n/i for i in nums if n/i!=i] + list(reversed(nums)) + [1]
    for s in nums:
        if all(t%s for t in tried):
            print 'Trying repeating string of length:', s
            if string[:s]*(n/s)==string:
                best = s
            else:
                tried.add(s)
    if best:
        return string[:best]

注意，例如对于长度为8的字符串，它只检查大小为4的片段，不需要进一步测试，因为长度为1或2的模式将导致长度为4的重复模式:

>>> repeats('12345678')
Trying repeating string of length: 4
None

# for this one we need only 2 checks 
>>> repeats('1234567812345678')
Trying repeating string of length: 8
Trying repeating string of length: 4
'12345678'

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

一些函数被修改以适应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

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