# Repeat string to certain length

### Question

What is an efficient way to repeat a string to a certain length? Eg: `repeat('abc', 7) -> 'abcabca'`

Here is my current code:

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

Is there a better (more pythonic) way to do this? Maybe using list comprehension?

1
177
8/2/2010 7:35:35 PM

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

For python3:

``````def repeat_to_length(string_to_expand, length):
return (string_to_expand * (int(length/len(string_to_expand))+1))[:length]
``````
62
11/23/2017 10:56:06 PM

Jason Scheirer's answer is correct but could use some more exposition.

First off, to repeat a string an integer number of times, you can use overloaded multiplication:

``````>>> 'abc' * 7
'abcabcabcabcabcabcabc'
``````

So, to repeat a string until it's at least as long as the length you want, you calculate the appropriate number of repeats and put it on the right-hand side of that multiplication operator:

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

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

Then, you can trim it to the exact length you want with an array slice:

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

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

Alternatively, as suggested in pillmod's answer that probably nobody scrolls down far enough to notice anymore, you can use `divmod` to compute the number of full repetitions needed, and the number of extra characters, all at once:

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

Which is better? Let's benchmark it:

``````>>> 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]
``````

So, pillmod's version is something like 40% slower, which is too bad, since personally I think it's much more readable. There are several possible reasons for this, starting with its compiling to about 40% more bytecode instructions.

Note: these examples use the new-ish `//` operator for truncating integer division. This is often called a Python 3 feature, but according to PEP 238, it was introduced all the way back in Python 2.2. You only have to use it in Python 3 (or in modules that have `from __future__ import division`) but you can use it regardless.