Строковые данные в Python

Python предоставляет тип str для работы с текстом: от приветствий пользователю до парсинга файлов. В этой статье разберём, как создавать строки, какие операции и методы у них есть, и как удобно подставлять значения переменных в текст.

Что такое строки в Python?

Строки (тип str) — это последовательности символов, которые помогают хранить и обрабатывать текстовую информацию.

Как создавать строки в Python

Python предлагает несколько способов создания строк. Можно использовать одинарные, двойные или тройные кавычки:

Python 3.13
# Строки в одинарных кавычках
>>> single_quotes = 'Привет, мир!'
>>> print(single_quotes)
Привет, мир!

# Строки в двойных кавычках
>>> double_quotes = "Hello, world"
>>> print(double_quotes)
Hello, world

# Многострочные строки в тройных кавычках
>>> multi_line = """Рецепт кофе:
>>> 1. Вскипятить воду
>>> 2. Залить молотый кофе
>>> 3. Подождать 4 минуты"""
>>> print(multi_line)
Рецепт кофе:
1. Вскипятить воду
2. Залить молотый кофе
3. Подождать 4 минуты

Выбор типа кавычек зависит от ситуации:

• Одинарные (') и двойные (") кавычки работают одинаково
• Если в строке уже есть одинарные кавычки, удобнее обернуть её в двойные, и наоборот
• Тройные кавычки (""" или ''') подходят для многострочного текста

Экранирование символов

Иногда нам нужно включить в строку особые символы, например, кавычки или перенос строки. Для этого используются последовательности с обратной косой чертой (\):

Python 3.13
# Использование кавычек внутри строк с экранированием
>>> quote_inside = "Он сказал: \"Привет!\""
>>> print(quote_inside)
Он сказал: "Привет!"

>>> path = "C:\\Program Files\\Python"
>>> print(path)
C:\Program Files\Python

# Часто используемые последовательности экранирования
>>> newline = "Первая строка.\nВторая строка."  # \n - перенос строки
>>> print(newline)
Первая строка.
Вторая строка.

>>> tab = "Имя:\tИван"  # \t - табуляция
>>> print(tab)
Имя:	Иван

Полезные последовательности экранирования:

• \n для переноса строки
• \t для табуляции
• \\ для обратной косой черты
• \' для одинарной кавычки
• \" для двойной кавычки

Raw-строки для путей и регулярных выражений

Если вы работаете с путями к файлам или регулярными выражениями, постоянное экранирование обратных косых черт может быть утомительным. Python предлагает «сырые» (raw) строки с префиксом r:

Python 3.13
# Обычная строка требует двойного обратного слеша
>>> normal_path = "C:\\Users\\Username\\Documents"
>>> print(normal_path)
C:\Users\Username\Documents

# Raw-строка понимает обратные слеши буквально
>>> raw_path = r"C:\Users\Username\Documents"
>>> print(raw_path)
C:\Users\Username\Documents

Raw-строки упрощают работу с путями в Windows и с регулярными выражениями.

Неизменяемость строк

Строки в Python являются неизменяемыми (immutable). Это значит, что после создания строки её нельзя поменять «на месте»: любая операция, которая выглядит как изменение, на самом деле создаёт новую строку.

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

Python 3.13
>>> language = "Python"

>>> try:
...     language[0] = "J"
... except TypeError as e:
...     print(f"Ошибка: {e}")
Ошибка: 'str' object does not support item assignment

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

Python 3.13
>>> language = "Python"
>>> language = "J" + "ython"
>>> print(language)
Jython

Это правило касается всех операций над строками: +, .upper(), .replace() и другие возвращают новую строку, а не меняют исходную.

Основные операции со строками

Сложение строк (конкатенация)

Строки можно складывать с помощью оператора +, чтобы создавать новые строки:

Python 3.13
>>> first_name = "Иван"
>>> last_name = "Петров"
>>> full_name = first_name + " " + last_name
>>> print(full_name)
Иван Петров

>>> greeting = "Привет, " + full_name + "!"
>>> print(greeting)
Привет, Иван Петров!

Повторение строк

С помощью оператора * можно повторить строку несколько раз:

Python 3.13
>>> border = "=" * 20
>>> print(border)
====================

Длина строки

Количество символов в строке узнаём через встроенную функцию len():

Python 3.13
>>> word = "Python"
>>> print(len(word))
6

>>> empty = ""
>>> print(len(empty))
0

Доступ к отдельным символам

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

Python 3.13
>>> word = "Python"
>>> first_letter = word[0]
>>> second_letter = word[1]
>>> last_letter = word[5]

>>> print(f"Первая буква: {first_letter}")
>>> print(f"Вторая буква: {second_letter}")
>>> print(f"Последняя буква: {last_letter}")
Первая буква: P
Вторая буква: y
Последняя буква: n

# Можно также использовать отрицательные индексы для отсчета с конца
>>> last_letter = word[-1]
>>> second_last_letter = word[-2]
>>> print(f"Последняя буква (с конца): {last_letter}")
>>> print(f"Предпоследняя буква: {second_last_letter}")
Последняя буква (с конца): n
Предпоследняя буква: o

Получение части строки (срезы)

В Python есть мощный приём для работы со строками: срезы (slices). Они позволяют извлекать подстроки, указывая начальный и конечный индексы:

Python 3.13
>>> message = "Python Programming"

# Синтаксис среза: строка[начало:конец:шаг]
# начало включается, конец исключается

>>> first_word = message[0:6]     # первые 6 символов
>>> print(f"Первое слово: {first_word}")
Первое слово: Python

>>> second_word = message[7:]      # от 7-го до конца
>>> print(f"Второе слово: {second_word}")
Второе слово: Programming

>>> prefix = message[:6]           # от начала до 6-го (не включая 6-й)
>>> print(f"Префикс: {prefix}")
Префикс: Python

>>> every_second = message[::2]    # каждый второй символ
>>> print(f"Каждая вторая буква: {every_second}")
Каждая вторая буква: Pto rgamn

>>> reversed_string = message[::-1]  # строка задом наперед
>>> print(f"В обратном порядке: {reversed_string}")
В обратном порядке: gnimmargorP nohtyP

Срезы гибкие:

• Если не указать начальный индекс, срез начнется с начала строки
• Если не указать конечный индекс, срез продолжится до конца строки
• Отрицательный шаг позволяет обходить строку в обратном порядке

Полезные методы для работы со строками

Python предоставляет множество встроенных методов для работы со строками. Рассмотрим самые полезные.

Изменение регистра текста

Python 3.13
>>> text = "Hello PYTHON world"

>>> upper_case = text.upper()
>>> print(f"Верхний регистр: {upper_case}")
Верхний регистр: HELLO PYTHON WORLD

>>> lower_case = text.lower()
>>> print(f"Нижний регистр: {lower_case}")
Нижний регистр: hello python world

>>> title_case = text.title()
>>> print(f"Каждое слово с заглавной: {title_case}")
Каждое слово с заглавной: Hello Python World

>>> capitalized = text.capitalize()
>>> print(f"Только первая буква заглавная: {capitalized}")
Только первая буква заглавная: Hello python world

Поиск и замена в строках

Python 3.13
>>> text = "Python это отличный язык программирования"

# Поиск подстроки
>>> position = text.find("отличный")
>>> print(f"Слово 'отличный' начинается с позиции: {position}")
Слово 'отличный' начинается с позиции: 12

>>> count = text.count("о")
>>> print(f"Буква 'о' встречается {count} раза")
Буква 'о' встречается 4 раза

# Проверка начала и конца строки
>>> starts_with = text.startswith("Python")
>>> print(f"Строка начинается с 'Python': {starts_with}")
Строка начинается с 'Python': True

>>> ends_with = text.endswith("!")
>>> print(f"Строка заканчивается на '!': {ends_with}")
Строка заканчивается на '!': False

# Проверка наличия подстроки
>>> contains = "отличный" in text
>>> print(f"Строка содержит слово 'отличный': {contains}")
Строка содержит слово 'отличный': True

# Замена подстрок
>>> new_text = text.replace("отличный", "прекрасный")
>>> print(f"Текст после замены: {new_text}")
Текст после замены: Python это прекрасный язык программирования

Разделение и объединение строк

Python 3.13
# Разделение строки на список слов
>>> sentence = "Python это отличный язык программирования"
>>> words = sentence.split()
>>> print(f"Список слов: {words}")
Список слов: ['Python', 'это', 'отличный', 'язык', 'программирования']

# Разделение по конкретному разделителю
>>> csv_data = "яблоко,банан,вишня"
>>> fruits = csv_data.split(",")
>>> print(f"Список фруктов: {fruits}")
Список фруктов: ['яблоко', 'банан', 'вишня']

# Объединение списка в строку
>>> words_to_join = ["Python", "это", "здорово"]
>>> joined_sentence = " ".join(words_to_join)
>>> print(f"Объединенное предложение: {joined_sentence}")
Объединенное предложение: Python это здорово

# Объединение с другим разделителем
>>> path_parts = ["C:", "Users", "Username", "Documents"]
>>> path = "\\".join(path_parts)
>>> print(f"Путь к файлу: {path}")
Путь к файлу: C:\Users\Username\Documents

Удаление лишних символов

Для очистки текста от лишних пробелов или других символов:

Python 3.13
>>> text_with_spaces = "   Python   "

# Удаление пробелов с обоих концов
>>> cleaned = text_with_spaces.strip()
>>> print(f"Без пробелов: '{cleaned}'")
Без пробелов: 'Python'

>>> left_cleaned = text_with_spaces.lstrip()
>>> print(f"Без пробелов слева: '{left_cleaned}'")
Без пробелов слева: 'Python   '

>>> right_cleaned = text_with_spaces.rstrip()
>>> print(f"Без пробелов справа: '{right_cleaned}'")
Без пробелов справа: '   Python'

# Удаление конкретных символов
>>> text_with_dots = "...Python..."
>>> without_dots = text_with_dots.strip('.')
>>> print(f"Без точек: '{without_dots}'")
Без точек: 'Python'

Цепочки методов

Каждый строковый метод возвращает новую строку (помним про неизменяемость). А значит, их можно вызывать подряд через точку — результат одного сразу передаётся следующему. Это называется цепочкой методов.

Например, нужно нормализовать пользовательский ввод: убрать лишние пробелы по краям и привести к нижнему регистру.

В три шага через временные переменные:

Python 3.13
raw_input = "  Hello  "
without_spaces = raw_input.strip()
normalized = without_spaces.lower()

Цепочкой в одну строку:

Python 3.13
>>> raw_input = "  Hello  "
>>> normalized = raw_input.strip().lower()
>>> print(f"'{normalized}'")
'hello'

Цепочки работают, потому что после strip() мы получаем новую строку, у которой тут же вызывается lower(). Это типичный паттерн Python-кода: вместо ведра промежуточных переменных — одна выразительная цепочка.

Форматирование строк

Часто нужно вставлять значения переменных в текст. В современном Python для этого используют f-строки:

Python 3.13
>>> name = "Анна"
>>> age = 25

# Просто добавьте 'f' перед строкой и вставляйте переменные в {}
>>> greeting = f"Привет, меня зовут {name} и мне {age} лет."
>>> print(greeting)
Привет, меня зовут Анна и мне 25 лет.

# Внутри {} можно вставлять любые выражения
>>> price = 19.99
>>> quantity = 3
>>> total = f"Итого: {price * quantity:.2f} руб."
>>> print(total)
Итого: 59.97 руб.

Помимо f-строк существуют ещё два способа форматирования, которые встречаются в старом коде: метод "...".format(...) и оператор "..." % (...). В новом коде их обычно не используют: f-строки проще и быстрее.

Проверка понимания

Давайте проверим, насколько хорошо вы поняли работу со строками:

Что будет результатом выполнения следующего кода?

Python 3.13
text = "Python"
result = text[1:4]