Операции со строками: конкатенация, повторение, срезы

Строки в Python — это не просто текст. Это последовательности символов, к которым применимы мощные операции: склеивание, повторение, извлечение отдельных символов и подстрок. В этом уроке освоим базовые операции со строками. Глубже — методы .split(), .join(), .replace() и другие — разберём в модуле 7, когда наберём достаточно контекста.

Конкатенация: оператор +

Оператор + склеивает строки в одну. Операнды должны быть строками — смешивать с числами нельзя:

first = "Hello"
last = "World"
full = first + ", " + last + "!"
print(full)   # Hello, World!

Конкатенация создаёт новую строку; исходные при этом не изменяются.

Для накопления строки удобен +=:

result = ""
result += "Python"
result += " is"
result += " great"
print(result)   # Python is great

Повторение: оператор *

Оператор * повторяет строку заданное количество раз:

print("=" * 40)     # ========================================
print("Ha" * 3)     # HaHaHa
print("-+-" * 10)   # -+--+--+--+--+--+--+--+--+--+-

Количество повторений должно быть целым числом (int). Результат — пустая строка, если n <= 0:

print("abc" * 0)   # '' — пустая строка
print("abc" * -1)  # '' — тоже пустая

Индексация: обращение по позиции

Строка — это последовательность символов, и к каждому можно обратиться по индексу (номеру позиции). Индексы начинаются с 0:

word = "Python"
#       P y t h o n
#       0 1 2 3 4 5

print(word[0])   # P — первый символ
print(word[1])   # y
print(word[5])   # n — последний (6-й по счёту, индекс 5)

Python также поддерживает отрицательные индексы — они считают с конца строки:

#       P  y  t  h  o  n
#      -6 -5 -4 -3 -2 -1

print(word[-1])   # n — последний символ
print(word[-2])   # o — предпоследний
print(word[-6])   # P — первый (то же, что word[0])

Попытка обратиться по индексу за пределами строки вызовет IndexError:

# word[10]   # IndexError: string index out of range

Срезы: извлечение подстрок

Срез (slice) позволяет получить подстроку по диапазону индексов. Синтаксис: s[start:stop], где stop — не включается:

word = "Python"
print(word[0:3])   # Pyt — символы 0, 1, 2 (без 3)
print(word[2:5])   # tho — символы 2, 3, 4
print(word[1:4])   # yth

Если пропустить start — берёт с начала; если пропустить stop — берёт до конца:

print(word[:3])    # Pyt — от начала до индекса 3 (не включая)
print(word[3:])    # hon — от индекса 3 до конца
print(word[:])     # Python — полная копия строки

С отрицательными индексами:

print(word[-3:])   # hon — последние 3 символа
print(word[:-2])   # Pyth — всё, кроме последних 2

Срезы с шагом

Срез поддерживает третий параметр — шаг: s[start:stop:step]. По умолчанию шаг равен 1:

s = "abcdefgh"
print(s[::2])     # aceg — каждый второй символ
print(s[1::2])    # bdfh — начиная с 1, каждый второй
print(s[::-1])    # hgfedcba — строка задом наперёд

Шаг -1 — это классический способ перевернуть строку. Удобно и часто используется.

Строки неизменяемы

Важное свойство строк в Python: они неизменяемы (immutable). Нельзя изменить отдельный символ через индекс:

word = "Python"
# word[0] = "J"   # TypeError: 'str' object does not support item assignment

Чтобы «изменить» строку, нужно создать новую:

word = "Python"
new_word = "J" + word[1:]   # "J" + "ython"
print(new_word)   # Jython

Это следствие неизменяемости. Операции +, [:], срезы — всегда создают новую строку.

Оператор in для проверки вхождения

Оператор in проверяет, входит ли одна строка в другую как подстрока:

text = "Hello, World!"

print("Hello" in text)   # True
print("world" in text)   # False (регистр важен)
print("World" in text)   # True
print("xyz" in text)     # False

# not in — обратная проверка
print("xyz" not in text) # True

in возвращает bool и часто используется в условиях: «если ключевое слово есть в строке — сделать что-то».

Функции len, min, max со строками

len(s) — длина строки (количество символов).
min(s) — символ с наименьшим кодом Unicode.
max(s) — символ с наибольшим кодом Unicode.

s = "Python"
print(len(s))   # 6
print(min(s))   # P (заглавная, меньший код в ASCII)
print(max(s))   # y (строчная, больший код)

Проверь себя

Что выведет следующий код?

s = "abcdef"
print(s[1:4])
print(s[-2:])
print(s[::-1])

s[1:4] → "bcd" (индексы 1, 2, 3)
s[-2:] → "ef" (последние 2 символа)
s[::-1] → "fedcba" (строка задом наперёд)

Итог

+ конкатенирует строки; * повторяет строку n раз.
s[i] — символ по индексу (начиная с 0); отрицательные индексы считают с конца.
s[start:stop] — срез от start включительно до stop не включительно.
s[::step] — срез с шагом; s[::-1] — строка наоборот.
Строки неизменяемы: нельзя изменить символ по индексу; нужно создавать новую строку.
in / not in проверяют вхождение подстроки; возвращают bool.

Поздравляем — модуль 2 пройден! Вы освоили все ключевые операторы Python. В модуле 3 применим сравнения и логику на практике: научимся управлять потоком выполнения программы с помощью условных операторов if, elif, else.

Операции со строками: конкатенация, повторение, срезы