Lặp lại chuỗi đến độ dài nhất định

Một cách hiệu quả để lặp lại một chuỗi đến một độ dài nhất định là gì? Ví dụ:repeat('abc', 7) -> 'abcabca'

Đây là mã hiện tại của tôi:

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

Có cách nào tốt hơn (nhiều pythonic) để làm điều này không? Có thể sử dụng danh sách hiểu?

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

Đối với python3:

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

Câu trả lời của Jason Scheirer là đúng nhưng có thể sử dụng một số giải trình khác.

Trước hết, để lặp lại một chuỗi số nguyên số lần, bạn có thể sử dụng phép nhân quá tải:

>>> 'abc' * 7
'abcabcabcabcabcabcabc'

Vì vậy, để lặp lại một chuỗi cho đến khi nó dài ít nhất bằng độ dài bạn muốn, bạn tính toán số lần lặp lại thích hợp và đặt nó ở phía bên phải của toán tử nhân:

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

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

Sau đó, bạn có thể cắt nó theo độ dài chính xác mà bạn muốn với một lát mảng:

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

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

Ngoài ra, như được đề xuất trong câu trả lời của Pillmod mà có lẽ không ai cuộn xuống đủ xa để chú ý nữa, bạn có thể sử dụng divmodđể tính số lần lặp lại đầy đủ cần thiết và số lượng ký tự phụ, cùng một lúc:

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

Cái nào tốt hơn? Hãy để điểm chuẩn cho nó:

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

Vì vậy, phiên bản của Pillmod chậm hơn 40%, điều này quá tệ, vì cá nhân tôi nghĩ nó dễ đọc hơn nhiều. Có một số lý do có thể cho việc này, bắt đầu với việc biên dịch các hướng dẫn mã byte thêm khoảng 40%.

Lưu ý: những ví dụ này sử dụng //toán tử new-ish để cắt bớt số nguyên. Đây thường được gọi là tính năng Python 3, nhưng theo PEP 238 , nó đã được giới thiệu hoàn toàn trong Python 2.2. Bạn chỉ phải sử dụng nó trong Python 3 (hoặc trong các mô-đun có from __future__ import division) nhưng bạn có thể sử dụng nó bất kể.

Đây là pythonic khá:

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

Có lẽ không phải là giải pháp hiệu quả nhất, nhưng chắc chắn ngắn & đơn giản:

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

repstr("foobar", 14)

Cung cấp "foobarfoobarfo". Một điều về phiên bản này là nếu độ dài <len (chuỗi) thì chuỗi đầu ra sẽ bị cắt ngắn. Ví dụ:

repstr("foobar", 3)

Cho "foo".

Chỉnh sửa: thực sự làm tôi ngạc nhiên, điều này nhanh hơn giải pháp hiện được chấp nhận (chức năng 'repeat_to_length'), ít nhất là trên các chuỗi ngắn:

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

Có lẽ nếu chuỗi dài hoặc độ dài rất cao (nghĩa là nếu độ lãng phí của string * lengthphần cao) thì nó sẽ hoạt động kém. Và trên thực tế, chúng ta có thể sửa đổi những điều trên để xác minh điều này:

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

Làm thế nào về string * (length / len(string)) + string[0:(length % len(string))]

tôi sử dụng cái này

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

Không phải là không có đủ câu trả lời cho câu hỏi này, nhưng có một chức năng lặp lại; chỉ cần lập một danh sách và sau đó tham gia đầu ra:

from itertools import repeat

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

Yay đệ quy!

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

Sẽ không mở rộng mãi mãi, nhưng nó tốt cho các chuỗi nhỏ hơn. Và nó thật đẹp.

Tôi thừa nhận tôi vừa đọc Little Schemer và tôi thích đệ quy ngay bây giờ.

Đây là một cách để làm điều đó bằng cách hiểu danh sách, mặc dù nó ngày càng lãng phí khi độ dài của rptchuỗi tăng lên.

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

Một aproach FP khác:

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