Répéter la chaîne jusqu'à une certaine longueur

Question

Qu'est-ce qu'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 

Y at-il une meilleure façon (plus de pythonique) pour le faire? Peut-être en utilisant la compréhension de la liste?

Answer 1

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] 

Answer 2

Répétition d'une chaîne plusieurs fois fixe est une opération intégrée:

'abc' * 7 

Ainsi, calculer simplement le nombre de répétitions que vous devez atteindre la longueur que vous voulez, et mettez cela sur le RHS. Vous devrez ensuite le couper à la bonne longueur.

(Il semble que ce soit ce que l'autre réponse fait, mais un peu plus d'explications semblait utile.)

Answer 3

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

Answer 4

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

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

récursion Yay!

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

Est-ce pas pour toujours l'échelle, mais il est très bien pour les chaînes plus petites. Et c'est joli. J'avoue que je viens de lire le Petit Schemer et j'aime la récursivité en ce moment.

Answer 8

Peut-être pas la solution la plus efficace, mais certainement à court & 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: en fait à ma grande surprise, c'est plus rapide que la solution actuellement acceptée (la fonction « repeat_to_length »), au 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 

On peut supposer que si la chaîne était longue, ou la longueur était très élevé (c'est-à-dire, si le gaspillage de la partie string * length était élevé) alors il aurait de mauvaises performances.Et en fait, nous pouvons modifier ce qui précède pour vérifier:

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

Un autre aproche FP:

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

Answer 10

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

from itertools import repeat 

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

Answer 11

j'utilise ceci:

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

Answer 12

C'est assez pythonique:

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