Répétez la chaîne à une certaine longueur

Quel est un moyen efficace de répéter une chaîne à une certaine longueur? Par exemple:repeat('abc', 7) -> 'abcabca'

Voici mon code actuel:

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

Existe-t-il une meilleure façon (plus pythonique) de procéder? Peut-être en utilisant la compréhension de liste?

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

Pour python3:

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

La réponse de Jason Scheirer est correcte mais pourrait utiliser un peu plus d'exposé.

Tout d'abord, pour répéter une chaîne un nombre entier de fois, vous pouvez utiliser une multiplication surchargée:

>>> 'abc' * 7
'abcabcabcabcabcabcabc'

Donc, pour répéter une chaîne jusqu'à ce qu'elle soit au moins aussi longue que la longueur souhaitée, vous calculez le nombre approprié de répétitions et la placez sur le côté droit de cet opérateur de multiplication:

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

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

Ensuite, vous pouvez le couper à la longueur exacte que vous souhaitez avec une tranche de tableau:

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

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

Alternativement, comme suggéré dans la réponse de pillmod que personne ne fait probablement défiler suffisamment pour remarquer, vous pouvez utiliser divmodpour calculer le nombre de répétitions complètes nécessaires et le nombre de caractères supplémentaires, à la fois:

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

Ce qui est mieux? Essayons de le comparer:

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

Donc, la version de pillmod est quelque chose comme 40% plus lente, ce qui est dommage, car personnellement, je pense que c'est beaucoup plus lisible. Il y a plusieurs raisons possibles à cela, à commencer par sa compilation avec environ 40% d'instructions de bytecode supplémentaires.

Remarque: ces exemples utilisent l' //opérateur new-ish pour tronquer la division entière. Ceci est souvent appelé une fonctionnalité Python 3, mais selon PEP 238 , elle a été introduite tout au long de Python 2.2. Vous n'avez qu'à l'utiliser en Python 3 (ou dans les modules qui l'ont from __future__ import division) mais vous pouvez l' utiliser malgré tout.

C'est assez pythonique:

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

Peut-être pas la solution la plus efficace, mais certainement courte et simple:

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

repstr("foobar", 14)

Donne "foobarfoobarfo". Une chose à propos de cette version est que si la longueur <len (chaîne) alors la chaîne de sortie sera tronquée. Par exemple:

repstr("foobar", 3)

Donne "foo".

Edit: à ma grande surprise, c'est plus rapide que la solution actuellement acceptée (la fonction 'repeat_to_length'), du moins sur les chaînes courtes:

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

Vraisemblablement, si la chaîne était longue ou si la longueur était très élevée (c'est-à-dire si le gaspillage de la string * lengthpièce était élevé), elle fonctionnerait mal. Et en fait, nous pouvons modifier ce qui précède pour vérifier cela:

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

Que diriez-vous string * (length / len(string)) + string[0:(length % len(string))]

j'utilise ceci:

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

Non pas qu'il n'y ait pas eu assez de réponses à cette question, mais il y a une fonction de répétition; suffit de faire une liste puis de rejoindre la sortie:

from itertools import repeat

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

Ouais récursivité!

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

N'augmentera pas pour toujours, mais c'est bien pour les petites cordes. Et c'est joli.

J'avoue que je viens de lire le Little Schemer et j'aime la récursivité en ce moment.

C'est une façon de le faire en utilisant une compréhension de liste, bien que cela devienne de plus en plus inutile à mesure que la longueur de la rptchaîne augmente.

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

Une autre approche de la PF:

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