String 重复字符串到一定长度

什么是将字符串重复到一定长度的有效方法？例如：

重复（'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

def repeat（字符串，长度）：
cur，old=1，字符串
而len（string）<长度：
字符串+=旧的[cur-1]
cur=（cur+1）%len（旧）
返回字符串

有没有更好（更像蟒蛇）的方法？也许使用列表理解

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]

---

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'

或者，正如中所建议的，可能没有人向下滚动到足够远而注意到，您可以使用计算所需的完整重复次数和额外字符数，所有这些都是一次性的：

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%左右

---

注意：这些示例使用新的ish

/

运算符截断整数除法。这通常被称为Python3特性，但根据，它是在Python2.2中引入的。你只需要在Python3中使用它（或者在具有来自未来导入部门的

的模块中使用它），但是你可以使用它。
关于
string*（length/len（string））+string[0:（length%len（string））]
这是使用列表理解的一种方法，尽管随着
rpt
字符串长度的增加，它越来越浪费

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

耶，递归

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

不会永远缩放，但对于较小的字符串也可以。而且很漂亮

我承认我刚刚读过《小阴谋家》，现在我喜欢递归。
也许不是最有效的解决方案，但肯定是简短的：

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

repstr("foobar", 14)

给出“foobarfoobarfo”。这个版本的一个特点是，如果length
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

另一个FP方案：

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

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

from itertools import repeat

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

我用这个：

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

这是一个很好的python：

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

length/len（string）
需要是括号中的包装器，您缺少最后一个
]
。在我看来，这是迄今为止最可读/最直观的。我认为在Python3中需要使用
/
进行整数除法。拼接中的
0
是可选的。（当然，冒号是必需的。）看起来这是在利用整数除法。在Python3中，这不需要是
/
？或者删除
+1
并使用对天花板函数的显式调用就足够了。另外，请注意：生成的字符串在等分时实际上有一个额外的重复；多余的部分被接头切断。一开始这让我很困惑。
int（）
在这里做同样的事情，但是是的，
/
可能在显微镜下更快，因为它在一个命令而不是两个命令中进行分割和地板操作。
0:7
如果您想要像OP这样的7个字符，您可以根据输入和输出长度在两个版本之间添加一个开关，以实现最大优化。@Mad物理学家认为，在两个版本之间切换可能会增加大约同样多的开销，正如Jason Scheirer答案中的划分所花费的成本。不，OP希望结果长度为7（不是3的倍数）。我有点矛盾，因为这不是OP的正确答案，但对我和489个其他人来说是正确答案…@MattFletcher，你刚刚把我推到了底线之外“我应该重写它，作为对“我将重写它…”的公认答案的解释。”；-）Pillmod/Pillmuncher的代码更漂亮，但不幸的是比Scheirer的代码慢，因为添加到已经很长的字符串是一项昂贵的操作（Python运行时必须将字符串复制到新的内存位置），而截断临时字符串的速度很快。此外，在Python中分配变量（并保留其存储）的速度相当慢。这就是我在只需要迭代字符串时使用的方法（那时不需要连接）。让python库来完成这项工作。这并不能回答问题。这个函数将字符串重复X次，直到X长度才会重复。例如，
“abc”，4
将期望
“abca”
。这将创建
abcabc
def extend_string(s, l):
    return (s*l)[:l]

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

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))

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)