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?
def repeat_to_length(string_to_expand, length): return (string_to_expand * ((length/len(string_to_expand))+1))[:length]
Repeating a string a fixed number of times is a built-in operation:
'abc' * 7
So, just calculate the number of repeats you need to reach the length you want, and put that on the RHS. You’ll then need to trim it to the right length.
(It appears that this is what the other answer does, but a little bit more explanation seemed useful.)
This is pretty pythonic:
newstring = 'abc'*5 print newstring[0:6]
def rep(s, m): a, b = divmod(m, len(s)) return s * a + s[:b]
from itertools import cycle, islice def srepeat(string, n): return ''.join(islice(cycle(string), n))
i use this:
def extend_string(s, l): return (s*l)[:l]
string * (length / len(string)) + string[0:(length % len(string))]
Not that there haven’t been enough answers to this question, but there is a repeat function; just need to make a list of and then join the output:
from itertools import repeat def rep(s,n): ''.join(list(repeat(s,n))
def trunc(s,l): if l > 0: return s[:l] + trunc(s, l - len(s)) return ''
Won’t scale forever, but it’s fine for smaller strings. And it’s pretty.
I admit I just read the Little Schemer and I like recursion right now.
Perhaps not the most efficient solution, but certainly short & simple:
def repstr(string, length): return (string * length)[0:length] repstr("foobar", 14)
Gives “foobarfoobarfo”. One thing about this version is that if length < len(string) then the output string will be truncated. For example:
Edit: actually to my surprise, this is faster than the currently accepted solution (the ‘repeat_to_length’ function), at least on short strings:
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
Presumably if the string was long, or length was very high (that is, if the wastefulness of the
string * length part was high) then it would perform poorly. And in fact we can modify the above to verify this:
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
This is one way to do it using a list comprehension, though it’s increasingly wasteful as the length of the
rpt string increases.
def repeat(rpt, length): return ''.join([rpt for x in range(0, (len(rpt) % length))])[:length]
Another FP aproach:
def repeat_string(string_to_repeat, repetitions): return ''.join([ string_to_repeat for n in range(repetitions)])