Zeichenfolge auf bestimmte Länge wiederholen

Question

Wie kann eine Zeichenfolge auf eine bestimmte Länge effizient wiederholt werden? ZB: repeat('abc', 7) -> 'abcabca'

Hier ist mein aktueller Code:

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

Gibt es einen besseren (pythonic) Weg, dies zu tun? Vielleicht mit Listenverständnis?

Answer 1

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

Für python3:

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

Answer 2

eine Zeichenfolge eine feste Anzahl von Malen ist eine integrierte Bedienung:

'abc' * 7 

So berechnen nur die Anzahl der Wiederholungen Sie müssen erreiche die gewünschte Länge und lege das auf die RHS. Sie müssen es dann auf die richtige Länge trimmen. obwohl

(Es scheint, dass das ist, was die andere Antwort tut, aber ein bisschen mehr Erklärung schien nützlich.)

Answer 3

Wie wäre es string * (length/len(string)) + string[0:(length % len(string))]

Answer 4

Dies ist eine Möglichkeit, es mit einer Liste Verständnis zu tun, es wird zunehmend verschwenderisch, wenn die Länge der rpt Zeichenfolge zunimmt.

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

Answer 5

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

Answer 6

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

Answer 7

Yay Rekursion!

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

Wird nicht immer maßstäblich, aber es ist für kleinere Strings in Ordnung. Und es ist hübsch.

Ich gebe zu, ich habe gerade den Little Schemer gelesen und ich mag Rekursion jetzt.

Answer 8

Vielleicht nicht die effizienteste Lösung, aber sicherlich kurze & einfach:

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

repstr("foobar", 14) 

Gibt "foobarfoobarfo". Eine Sache über diese Version ist, dass bei Länge < len (string) dann die Ausgabezeichenfolge abgeschnitten wird. Zum Beispiel:

repstr("foobar", 3) 

Gibt "foo".

Edit: tatsächlich zu meiner Überraschung, das ist schneller als die derzeit akzeptierte Lösung (die ‚repeat_to_length‘ -Funktion), zumindest auf kurze 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 

Vermutlich, wenn die Zeichenfolge war lang, oder die Länge war sehr hoch (das heißt, wenn die Verschwendung des string * length Teils hoch war), dann würde es schlecht funktionieren.Und in der Tat können wir die oben ändern, dies zu überprüfen:

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 9

Ein weiterer FP aproach:

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

Answer 10

Nicht, dass es nicht genug gewesen, um Antworten auf diese Frage, aber es gibt eine Repeat-Funktion; müssen nur eine Liste und dann den Ausgang anschließen machen:

from itertools import repeat 

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

Answer 11

i verwenden:

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

Answer 12

Das ist ziemlich pythonic:

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