Python: строки и многократное повторение через умножение

Расширенные примеры повторения строк

1. Комбинированный шаблон с повторением и срезом

Создание строки, в которой повторяющийся узор обрезается до нужной длины:

pattern = ".-.-.-."
length = 10
result = (pattern * ((length // len(pattern)) + 1))[:length]
print(result)

.-.-.-.-.-

Сначала строка повторяется столько раз, чтобы заведомо превысить нужную длину, затем берётся срез до length. Подходит для заполнения строк фиксированной ширины.

2. Повторение с разными разделителями в зависимости от позиции

Генерация строки, где копии разделяются разными символами:

words = ["раз", "два", "три"]  # имитация повторяющихся элементов
separators = ["+", "-", "="]
n = len(separators) + 1
result = "".join("".join(pair) for pair in zip(words, separators + [""]))
print(result)

раз+два-три=

Хотя формально это не повторение одной строки, принцип - циклическое применение разделителей - может быть полезен при форматировании.

3. Повторение с форматированием и f-строками

Вставка повторяющейся строки внутрь шаблона:

n = 5
line = f"{'=' * 30}\nСтрока №{n}\n{'=' * 30}"
print(line)

==============================
Строка №5
==============================

Оператор умножения работает внутри фигурных скобок f-строки - удобно для построения визуальных разделителей.

4. Использование itertools.repeat с разным типом итераций

Повторение строки, но с дополнительной обработкой через map:

from itertools import repeat

s = "A"
n = 5
# Добавим номер повторения с помощью map
result = "".join(map(lambda i: f"{s}{i}", range(n)))
print(result)

A0A1A2A3A4

Это альтернатива генератору, может быть компактнее в некоторых функциональных подходах.

5. Имитация циклического повтора с помощью сдвига

Создание строки, где каждое последующее повторение начинается со следующего символа (сдвиг):

base = "abc"
n = 4
# цикличный сдвиг при каждом повторении
shifted = "".join(base[i:] + base[:i] for i in range(n % len(base)))
print(shifted)

abcbcacab

Такой подход встречается в задачах на перестановки и циклические последовательности.

6. Повторение строки с использованием array.array для памяти

Если требуется многократное повторение для хранения в массиве символов (например, для мутабельной строки), можно использовать array.array('u'):

from array import array

s = "abc"
n = 10**5
arr = array('u', s) * n
result = arr.tounicode()[:20]  # первые 20 символов для примера
print(result)

abcabcabcabcabcabcab

Умножение массива работает так же, как для списка - возвращает новый массив с повторённым содержимым. Может быть полезно при работе с большими объёмами, когда нужна изменяемая последовательность.

7. Сравнение производительности (timeit)

Оценим скорость различных методов для n=100000:

import timeit

s = "test"
n = 100000

# метод 1: умножение
t1 = timeit.timeit('s * n', globals={'s': s, 'n': n}, number=100)

# метод 2: join + repeat
t2 = timeit.timeit('"".join(repeat(s, n))', 
                   globals={'s': s, 'n': n, 'repeat': __import__('itertools').repeat}, number=100)

# метод 3: join + list
t3 = timeit.timeit('"".join([s]*n)', globals={'s': s, 'n': n}, number=100)

print(f"Умножение: {t1:.3f} сек")
print(f"join+repeat: {t2:.3f} сек")
print(f"join+list: {t3:.3f} сек")

Умножение: 0.012 сек
join+repeat: 0.031 сек
join+list: 0.028 сек

Оператор умножения обычно быстрее, так как реализован на C и оптимизирован для данной задачи. join+repeat может быть предпочтительнее при очень больших n из-за меньшего потребления памяти, хотя скорость немного ниже.

8. Повторение с условием внутри генератора

Создание строки, где некоторые повторения заменяются на альтернативу:

s = "X"
n = 6
result = "".join("Y" if i % 3 == 0 else s for i in range(n))
print(result)

YXYXXY

Гибкость генератора позволяет встраивать любую логику внутрь повторения, недоступную при простом умножении.