Ripeti la stringa per una certa lunghezza

Qual è un modo efficace per ripetere una stringa per una certa lunghezza? Per esempio:repeat('abc', 7) -> 'abcabca'

Ecco il mio codice attuale:

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

C'è un modo migliore (più pitonico) per farlo? Forse usando la comprensione della lista?

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

Per python3:

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

La risposta di Jason Scheirer è corretta ma potrebbe usare qualche altra esposizione.

Prima di tutto, per ripetere una stringa un numero intero di volte, è possibile utilizzare la moltiplicazione sovraccarica:

>>> 'abc' * 7
'abcabcabcabcabcabcabc'

Quindi, per ripetere una stringa fino a quando è lunga almeno quanto la lunghezza desiderata, calcoli il numero appropriato di ripetizioni e lo metti sul lato destro dell'operatore di moltiplicazione:

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

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

Quindi, puoi tagliarlo alla lunghezza esatta desiderata con una porzione di matrice:

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

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

In alternativa, come suggerito nella risposta di pillmod che probabilmente nessuno scorre più in basso abbastanza da notare più, puoi usare divmodper calcolare il numero di ripetizioni complete necessarie e il numero di caratteri extra, tutto in una volta:

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

Che è migliore? Facciamo un benchmark:

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

Quindi, la versione di pillmod è qualcosa di più lento del 40%, il che è un peccato, dal momento che personalmente penso che sia molto più leggibile. Ci sono diverse possibili ragioni per questo, a partire dalla sua compilazione per circa il 40% in più di istruzioni bytecode.

Nota: questi esempi utilizzano l' //operatore new-ish per troncare la divisione di numeri interi. Questa è spesso chiamata funzionalità Python 3, ma secondo PEP 238 , è stata introdotta in Python 2.2. È solo necessario per utilizzarlo in Python 3 (o in moduli che hanno from __future__ import division), ma si può utilizzare a prescindere.

Questo è piuttosto pitonico:

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

Forse non è la soluzione più efficiente, ma sicuramente breve e semplice:

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

repstr("foobar", 14)

Fornisce "foobarfoobarfo". Una cosa di questa versione è che se la lunghezza <len (stringa) allora la stringa di output verrà troncata. Per esempio:

repstr("foobar", 3)

Dà "pippo".

Modifica: in realtà con mia sorpresa, questo è più veloce della soluzione attualmente accettata (la funzione 'repeat_to_length'), almeno su stringhe brevi:

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

Presumibilmente se la stringa fosse lunga o la lunghezza fosse molto alta (ovvero, se lo spreco della string * lengthparte fosse alto), avrebbe prestazioni scarse. E infatti possiamo modificare quanto sopra per verificarlo:

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

Che ne dite di string * (length / len(string)) + string[0:(length % len(string))]

io uso questo:

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

Non che non ci siano state abbastanza risposte a questa domanda, ma c'è una funzione di ripetizione; ho solo bisogno di fare un elenco e quindi unire l'output:

from itertools import repeat

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

Yay ricorsione!

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

Non si ridimensionerà per sempre, ma va bene per stringhe più piccole. Ed è carino.

Ammetto di aver appena letto il piccolo Schemer e mi piace la ricorsione in questo momento.

Questo è un modo per farlo usando una comprensione dell'elenco, sebbene sia sempre più dispendioso all'aumentare della lunghezza della rptstringa.

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

Un altro approccio FP:

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

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