这个函数运行得非常快(经过测试，在超过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'

首先，将字符串减半，只要它是“2部分”副本。如果重复次数为偶数，这将减少搜索空间。然后，向前查找最小的重复字符串，检查将整个字符串拆分为越来越大的子字符串是否只得到空值。只有长度不超过// 2的子字符串需要测试，因为超过这个长度的任何子字符串都没有重复。

def shortest_repeat(orig_value):
    if not orig_value:
        return None

    value = orig_value

    while True:
        len_half = len(value) // 2
        first_half = value[:len_half]

        if first_half != value[len_half:]:
            break

        value = first_half

    len_value = len(value)
    split = value.split

    for i in (i for i in range(1, len_value // 2) if len_value % i == 0):
        if not any(split(value[:i])):
            return value[:i]

    return value if value != orig_value else None

这将返回最短的匹配，如果没有匹配则返回None。

下面是一个简洁的解决方案，它避免了正则表达式和缓慢的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的可选开始和结束参数。

这个函数运行得非常快(经过测试，在超过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'

在有前缀函数的最坏情况下，问题也可以在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

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

对于从第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"