Repetir cadena a cierta longitud

La respuesta de Jason Scheirer es correcta, pero podría necesitar más exposición.

En primer lugar, para repetir una cadena un número entero de veces, puede usar la multiplicación sobrecargada:

>>> 'abc' * 7
'abcabcabcabcabcabcabc'

Entonces, para repetir una cadena hasta que sea al menos tan larga como la longitud que desee, calcule el número apropiado de repeticiones y colóquela en el lado derecho de ese operador de multiplicación:

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

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

Luego, puede recortarlo a la longitud exacta que desee con una matriz slice:

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

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

Alternativamente, como se sugiere en la respuesta de pillmod que probablemente nadie se desplaza lo suficientemente lejos como para darse cuenta, puede usar divmod para calcular el número de repeticiones completas necesarias, y el número de caracteres adicionales, todo a la vez:

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

¿cuál es mejor? Vamos a compararlo:

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

Entonces, la versión de pillmod es algo así como un 40% más lenta, lo cual es una lástima, ya que personalmente creo que es mucho más legible. Hay varios posibles razones para esto, comenzando con su compilación a aproximadamente un 40% más de instrucciones de código de bytes.

Nota: estos ejemplos usan el operador new-ish // para truncar la división entera. A menudo se llamauna característica de Python 3, pero de acuerdo con PEP 238, se introdujo en Python 2.2. Solo tiene para usarlo en Python 3 (o en módulos que tienen from __future__ import division) pero puede usarlo independientemente.

Esto es bastante pitónico:

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

Yo uso esto:

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

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

Quizás no sea la solución más eficiente, pero ciertamente corta y simple:

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

repstr("foobar", 14)

Da "foobarfoobarfo". Una cosa acerca de esta versión es que si length

repstr("foobar", 3)

Da "foo".

Editar: en realidad para mi sorpresa, esto es más rápido que la solución actualmente aceptada (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

Presumiblemente si la cadena era larga, o la longitud era muy alto (es decir, si el desperdicio de la parte string * length era alto), entonces funcionaría mal. Y de hecho podemos modificar lo anterior para verificar 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

No es que no haya habido suficientes respuestas a esta pregunta, pero hay una función de repetición; solo hay que hacer una lista de y luego unir la salida:

from itertools import repeat

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

¡Yay recursión!

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

No escalará para siempre, pero está bien para cuerdas más pequeñas. Y es bonito.

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

Esta es una forma de hacerlo usando una comprensión de lista, aunque es cada vez más derrochadora 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]

Otro enfoque de FP:

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