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

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

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

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

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

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

Python 3.13
123
# Строки в одинарных кавычках
single_quotes = 'Привет, мир!'
print(single_quotes)
Привет, мир!
456
# Строки в двойных кавычках
double_quotes = "Hello, world"
print(double_quotes)
Hello, world
789101112
# Многострочные строки в тройных кавычках
multi_line = """Рецепт кофе:
1. Вскипятить воду
2. Залить молотый кофе
3. Подождать 4 минуты"""
print(multi_line)
Рецепт кофе:
1. Вскипятить воду
2. Залить молотый кофе
3. Подождать 4 минуты

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

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

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

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

Python 3.13
123
# Использование кавычек внутри строк с экранированием
quote_inside = "Он сказал: \"Привет!\""
print(quote_inside)
Он сказал: "Привет!"
45
path = "C:\\Program Files\\Python"
print(path)
C:\Program Files\Python
678
# Часто используемые последовательности экранирования
newline = "Первая строка.\nВторая строка."  # \n - перенос строки
print(newline)
Первая строка.
Вторая строка.
910
tab = "Имя:\tИван"  # \t - табуляция
print(tab)
Имя:	Иван

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

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

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

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

Python 3.13
123
# Обычная строка требует двойного обратного слеша
normal_path = "C:\\Users\\Username\\Documents"
print(normal_path)
C:\Users\Username\Documents
456
# Raw-строка понимает обратные слеши буквально
raw_path = r"C:\Users\Username\Documents"
print(raw_path)
C:\Users\Username\Documents

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

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

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

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

Python 3.13
123456
language = "Python"

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

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

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

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

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

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

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

Python 3.13
1234
first_name = "Иван"
last_name = "Петров"
full_name = first_name + " " + last_name
print(full_name)
Иван Петров
56
greeting = "Привет, " + full_name + "!"
print(greeting)
Привет, Иван Петров!

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

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

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

Длина строки

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

Python 3.13
12
word = "Python"
print(len(word))
6
34
empty = ""
print(len(empty))
0

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

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

Индексы строки Python: положительные 0–5 над буквами, отрицательные -6…-1 под ними. Срез word[1:4] выделяет y, t, h

Python 3.13
12345678
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
910111213
# Можно также использовать отрицательные индексы для отсчета с конца
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
1234567
message = "Python Programming"

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

first_word = message[0:6]     # первые 6 символов
print(f"Первое слово: {first_word}")
Первое слово: Python
89
second_word = message[7:]      # от 7-го до конца
print(f"Второе слово: {second_word}")
Второе слово: Programming
1011
prefix = message[:6]           # от начала до 6-го (не включая 6-й)
print(f"Префикс: {prefix}")
Префикс: Python
1213
every_second = message[::2]    # каждый второй символ
print(f"Каждая вторая буква: {every_second}")
Каждая вторая буква: Pto rgamn
1415
reversed_string = message[::-1]  # строка задом наперед
print(f"В обратном порядке: {reversed_string}")
В обратном порядке: gnimmargorP nohtyP

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

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

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

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

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

Python 3.13
1234
text = "Hello PYTHON world"

upper_case = text.upper()
print(f"Верхний регистр: {upper_case}")
Верхний регистр: HELLO PYTHON WORLD
56
lower_case = text.lower()
print(f"Нижний регистр: {lower_case}")
Нижний регистр: hello python world
78
title_case = text.title()
print(f"Каждое слово с заглавной: {title_case}")
Каждое слово с заглавной: Hello Python World
910
capitalized = text.capitalize()
print(f"Только первая буква заглавная: {capitalized}")
Только первая буква заглавная: Hello python world

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

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

# Поиск подстроки
position = text.find("отличный")
print(f"Слово 'отличный' начинается с позиции: {position}")
Слово 'отличный' начинается с позиции: 12
67
count = text.count("о")
print(f"Буква 'о' встречается {count} раза")
Буква 'о' встречается 4 раза
8910
# Проверка начала и конца строки
starts_with = text.startswith("Python")
print(f"Строка начинается с 'Python': {starts_with}")
Строка начинается с 'Python': True
1112
ends_with = text.endswith("!")
print(f"Строка заканчивается на '!': {ends_with}")
Строка заканчивается на '!': False
131415
# Проверка наличия подстроки
contains = "отличный" in text
print(f"Строка содержит слово 'отличный': {contains}")
Строка содержит слово 'отличный': True
161718
# Замена подстрок
new_text = text.replace("отличный", "прекрасный")
print(f"Текст после замены: {new_text}")
Текст после замены: Python это прекрасный язык программирования

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

Python 3.13
1234
# Разделение строки на список слов
sentence = "Python это отличный язык программирования"
words = sentence.split()
print(f"Список слов: {words}")
Список слов: ['Python', 'это', 'отличный', 'язык', 'программирования']
5678
# Разделение по конкретному разделителю
csv_data = "яблоко,банан,вишня"
fruits = csv_data.split(",")
print(f"Список фруктов: {fruits}")
Список фруктов: ['яблоко', 'банан', 'вишня']
9101112
# Объединение списка в строку
words_to_join = ["Python", "это", "здорово"]
joined_sentence = " ".join(words_to_join)
print(f"Объединенное предложение: {joined_sentence}")
Объединенное предложение: Python это здорово
13141516
# Объединение с другим разделителем
path_parts = ["C:", "Users", "Username", "Documents"]
path = "\\".join(path_parts)
print(f"Путь к файлу: {path}")
Путь к файлу: C:\Users\Username\Documents

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

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

Python 3.13
12345
text_with_spaces = "   Python   "

# Удаление пробелов с обоих концов
cleaned = text_with_spaces.strip()
print(f"Без пробелов: '{cleaned}'")
Без пробелов: 'Python'
67
left_cleaned = text_with_spaces.lstrip()
print(f"Без пробелов слева: '{left_cleaned}'")
Без пробелов слева: 'Python   '
89
right_cleaned = text_with_spaces.rstrip()
print(f"Без пробелов справа: '{right_cleaned}'")
Без пробелов справа: '   Python'
10111213
# Удаление конкретных символов
text_with_dots = "...Python..."
without_dots = text_with_dots.strip('.')
print(f"Без точек: '{without_dots}'")
Без точек: 'Python'

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

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

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

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

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

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

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

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

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

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

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

# Просто добавьте 'f' перед строкой и вставляйте переменные в {}
greeting = f"Привет, меня зовут {name} и мне {age} лет."
print(greeting)
Привет, меня зовут Анна и мне 25 лет.
7891011
# Внутри {} можно вставлять любые выражения
price = 19.99
quantity = 3
total = f"Итого: {price * quantity:.2f} руб."
print(total)
Итого: 59.97 руб.

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

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

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

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

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

Telegram