Повторете низа до определена дължина

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

За python3:

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

Отговорът на Джейсън Шайрър е правилен, но би могъл да използва още малко изложение.

Първо, за да повторите низ цял брой пъти, можете да използвате претоварено умножение:

>>> 'abc' * 7
'abcabcabcabcabcabcabc'

И така, за да повторите низ, докато стане поне толкова дълъг, колкото дължината, която желаете, изчислявате подходящия брой повторения и го поставяте от дясната страна на този оператор за умножение:

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

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

След това можете да го отрежете до точната дължина, която искате, с резен от масив:

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

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

Като алтернатива, както се предлага в отговора на pillmod, че вероятно вече никой не превърта достатъчно надолу, за да забележи, можете да използвате divmod за изчисляване на необходимия брой пълни повторения и броя на допълнителните знаци, всички наведнъж :

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

Кое е по добре? Нека го сравним:

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

И така, версията на pillmod е около 40% по-бавна, което е много лошо, тъй като лично аз смятам, че е много по-четлива. Има няколко възможни причини за това, като се започне с компилирането му до около 40% повече инструкции за байт код.

Забележка: тези примери използват оператора new-ish // за съкращаване на целочислено деление. Това често се нарича функция на Python 3, но според PEP 238, беше въведен още в Python 2.2. Вие трябва да го използвате само в Python 3 (или в модули, които имат from __future__ import division), но можете да го използвате независимо от това.

Това е доста питонично:

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

Може би не най-ефективното решение, но със сигурност кратко и просто:

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

repstr("foobar", 14)

Дава "foobarfoobarfo". Едно нещо за тази версия е, че ако дължина ‹ len(string), тогава изходният низ ще бъде съкратен. Например:

repstr("foobar", 3)

Дава "foo".

Редактиране: всъщност за моя изненада, това е по-бързо от текущо приетото решение (функцията 'repeat_to_length'), поне на къси низове:

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

Предполага се, че ако низът е дълъг или дължината е много голяма (т.е. ако разточителството на частта string * length е високо), тогава той ще се представи зле. И всъщност можем да променим горното, за да проверим това:

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

Какво ще кажете за string * (length / len(string)) + string[0:(length % len(string))]

използвам това:

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

Не че няма достатъчно отговори на този въпрос, но има функция за повторение; просто трябва да направите списък и след това да се присъедините към изхода:

from itertools import repeat

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

Ура рекурсия!

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

Няма да се мащабира вечно, но е добре за по-малки низове. И е хубава.

Признавам, че току-що прочетох Little Schemer и харесвам рекурсията в момента.

Това е един от начините да го направите с помощта на разбиране на списък, въпреки че е все по-разточителен, тъй като дължината на низа rpt се увеличава.

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

Друг FP подход:

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