Repite cadena a cierta longitud

Question

¿Cuál es una forma eficiente de repetir una cadena a una determinada longitud? Por ejemplo: repeat('abc', 7) -> 'abcabca'

Aquí está mi código actual:

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

¿Existe una (más Pythonic) forma mejor de hacer esto? Tal vez usando la lista de comprensión?

Answer 1

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

Para python3:

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

Answer 2

Repetición de una cadena de un número fijo de veces que es una operación integrada:

'abc' * 7 

lo tanto, sólo calcular el número de repeticiones que usted necesita alcance la longitud que desee, y ponga eso en el RHS. Luego deberá recortarla a la longitud correcta.

(Parece ser que esto es lo que hace la otra respuesta, pero un poco más de explicación pareció útil.)

Answer 3

¿Qué tal string * (length/len(string)) + string[0:(length % len(string))]

Answer 4

Ésta es una manera de hacerlo usando una lista por comprensión, aunque es cada vez más derrochador a medida que aumenta la longitud de la cadena rpt.

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 recursividad!

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

no se escala para siempre, pero está bien para las cadenas más pequeñas. Y es lindo

Admito que acabo de leer el Pequeño Schemer y me gusta la recursión en este momento.

Answer 8

Tal vez no sea la solución más eficiente, pero ciertamente corta & simple:

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

repstr("foobar", 14) 

Da "foobarfoobarfo". Una cosa sobre esta versión es que si la longitud es < len (cadena), la cadena de salida se truncará. Por ejemplo:

repstr("foobar", 3) 

Da "foo".

Editar: en realidad, para mi sorpresa, esto es más rápido que la solución actualmente aceptado (la función 'repeat_to_length'), al menos en cadenas cortas:

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 

Es de suponer que si la cadena era larga, o la longitud era muy alto (es decir, si el desperdicio de la pieza string * length fuera alto), no funcionaría bien.Y, de hecho, podemos modificar el anterior para comprobar esto:

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

Otro aproach FP:

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

Answer 10

No es que no han sido suficientes respuestas a esta pregunta, pero no es una función de repetición; sólo tiene que hacer una lista de y luego unirse a la salida:

from itertools import repeat 

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

Answer 11

yo uso esto:

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

Answer 12

Esto es bastante Pythonic:

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