将字符串重复到一定长度

Question

将字符串重复到一定长度的有效方法是什么？例如：repeat('abc', 7) -> 'abcabca'

这是我当前的代码：

def repeat(string, length):
    cur, old = 1, string
    while len(string) < length:
        string += old[cur-1]
        cur = (cur+1)%len(old)
    return string

是否有更好（更Pythonic）的方法来做到这一点？也许使用列表理解？

Answer 1

Jason Scheirer 的答案是正确的，但可以进行更多说明。

首先，要重复一个字符串整数次，您可以使用重载乘法：

>>> 'abc' * 7
'abcabcabcabcabcabcabc'

因此，要重复一个字符串，直到它至少与您想要的长度一样长，您可以计算适当的次数重复并将其放在乘法运算符的右侧：

def repeat_to_at_least_length(s, wanted):
    return s * (wanted//len(s) + 1)

>>> repeat_to_at_least_length('abc', 7)
'abcabcabc'

然后，您可以使用数组切片将其修剪为所需的精确长度：

def repeat_to_length(s, wanted):
    return (s * (wanted//len(s) + 1))[:wanted]

>>> repeat_to_length('abc', 7)
'abcabca'

或者，如 pillmod 的答案 可能没有人向下滚动足够远来注意到了，你可以使用 divmod 一次性计算所需的完整重复次数和额外字符数：

def pillmod_repeat_to_length(s, wanted):
    a, b = divmod(wanted, len(s))
    return s * a + s[:b]

哪个更好？让我们对其进行基准测试：

>>> import timeit
>>> timeit.repeat('scheirer_repeat_to_length("abcdefg", 129)', globals=globals())
[0.3964178159367293, 0.32557755894958973, 0.32851039397064596]
>>> timeit.repeat('pillmod_repeat_to_length("abcdefg", 129)', globals=globals())
[0.5276265419088304, 0.46511475392617285, 0.46291469305288047]

所以，pillmod 的版本大约慢了 40%，这太糟糕了，因为我个人认为它更具可读性。造成这种情况的可能原因有几个，首先是它编译的字节码指令增加了大约 40%。

注意：这些示例使用新的 // 运算符来截断整数除法。这通常被称为 Python 3 功能，但根据 PEP 238，它早在 Python 2.2 中就被引入了。您只需在 Python 3 中（或在具有 from __future__ import division 的模块中）使用它，但无论如何您都可以使用它。

Answer 2

def repeat_to_length(string_to_expand, length):
   return (string_to_expand * ((length/len(string_to_expand))+1))[:length]

对于Python3：

def repeat_to_length(string_to_expand, length):
    return (string_to_expand * (int(length/len(string_to_expand))+1))[:length]

Answer 3

这是相当Pythonic的：

newstring = 'abc'*5
print newstring[0:6]

Answer 4

def rep(s, m):
    a, b = divmod(m, len(s))
    return s * a + s[:b]

Answer 5

from itertools import cycle, islice
def srepeat(string, n):
   return ''.join(islice(cycle(string), n))

Answer 6

也许不是最有效的解决方案，但肯定是简短且有效的解决方案。简单：

def repstr(string, length):
    return (string * length)[0:length]

repstr("foobar", 14)

给出“foobarfoobarfo”。这个版本的一件事是，如果 length < len(string) 那么输出字符串将被截断。例如：

repstr("foobar", 3)

给出“foo”。

编辑：实际上令我惊讶的是，这比当前接受的解决方案（“repeat_to_length”函数）更快，至少在短字符串上：

from timeit import Timer
t1 = Timer("repstr('foofoo', 30)", 'from __main__ import repstr')
t2 = Timer("repeat_to_length('foofoo', 30)", 'from __main__ import repeat_to_length')
t1.timeit()  # gives ~0.35 secs
t2.timeit()  # gives ~0.43 secs

大概如果字符串很长，或者长度非常高（也就是说，如果string * length 部分很高），那么它的性能就会很差。事实上我们可以修改上面的内容来验证这一点：

from timeit import Timer
t1 = Timer("repstr('foofoo' * 10, 3000)", 'from __main__ import repstr')
t2 = Timer("repeat_to_length('foofoo' * 10, 3000)", 'from __main__ import repeat_to_length')
t1.timeit()  # gives ~18.85 secs
t2.timeit()  # gives ~1.13 secs

Answer 7

我用这个：

def extend_string(s, l):
    return (s*l)[:l]

Answer 8

怎么样：

string * (length / len(string)) + string[0:(length % len(string))]

Answer 9

并不是说这个问题没有足够的答案，而是有一个重复功能；只需要列出一个列表，然后加入输出：

from itertools import repeat

def rep(s,n):
  ''.join(list(repeat(s,n))

Answer 10

耶递归！

def trunc(s,l):
    if l > 0:
        return s[:l] + trunc(s, l - len(s))
    return ''

不会永远扩展，但对于较小的字符串来说它很好。而且很漂亮。

我承认我刚刚读了《小阴谋家》，我现在喜欢递归。

Answer 11

这是使用列表理解来实现此目的的一种方法，尽管随着 rpt 字符串长度的增加，这种方法越来越浪费。

def repeat(rpt, length):
    return ''.join([rpt for x in range(0, (len(rpt) % length))])[:length]

Answer 12

另一种 FP 方法：

def repeat_string(string_to_repeat, repetitions):
    return ''.join([ string_to_repeat for n in range(repetitions)])

Answer 13

目前 print(f"{'abc'*7}") 生成：

abcabcabcabcabcabcabc

Answer 14

def extended_string (word, length) :

    extra_long_word = word * (length//len(word) + 1)
    required_string = extra_long_word[:length]
    return required_string

print(extended_string("abc", 7))

Answer 15

c = s.count('a')    
div=n//len(s)    
if n%len(s)==0:
    c= c*div
else:
    m = n%len(s)
    c = c*div+s[:m].count('a')
print(c)