Строки (str): кавычки, конкатенация и экранирование

Мы уже работали с числами, но в реальных программах чаще приходится иметь дело с текстом. Имена пользователей, сообщения, адреса, описания товаров — всё это строки.

В этой статье мы разберём:

• Что такое строка в Python
• Одинарные и двойные кавычки
• Конкатенацию (склеивание строк)
• Экранирование специальных символов
• Основные методы работы со строками

Что нужно знать перед началом

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

• Установленный Python
• Базовое понимание переменных

Строки тесно связаны с переменными, так что если ты пропустил статью о переменных, лучше вернись.

Совет: Открывай VS Code и повторяй примеры. Строки лучше всего понимать на практике.

Основная часть

Что такое строка (str)

Строка — это последовательность символов. Это может быть одно слово, целое предложение или даже целая книга.

В Python строки создаются с помощью кавычек.

name = "Анна"
city = 'Москва'
empty = ""

Строка может быть пустой — это совершенно нормально.

Тип данных: Проверить тип можно функцией type()

text = "Привет"
print(type(text))  # <class 'str'>

Одинарные и двойные кавычки

В Python можно использовать и одинарные, и двойные кавычки. Разницы нет — выбирай то, что удобнее.

single_quotes = 'Привет, мир!'
double_quotes = "Привет, мир!"

Но есть один нюанс. Если внутри строки есть кавычка того же типа, её нужно экранировать.

# Так будет ошибка
# text = 'It's a book'

# А так правильно — экранируем внутреннюю кавычку
text = 'It\'s a book'

# Или просто используем другой тип кавычек
text = "It's a book"

Совет: Для английских строк с апострофами используй двойные кавычки, для русских с кавычками-ёлочками — одинарные. Или всегда используй двойные — так проще.

# Пример с русскими кавычками
quote = 'Он сказал: "Привет!"'   # Одинарные снаружи, двойные внутри

 Конкатенация (склеивание строк)

Конкатенация — это объединение двух или более строк в одну. В Python для этого используется оператор +.

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

Можно склеивать несколько строк подряд:

greeting = "Привет" + " " + "мир" + "!"
print(greeting)    # Привет мир!

Важно: Нельзя склеивать строку с числом напрямую.

age = 25
# print("Мне " + age + " лет")   # Ошибка!
print("Мне " + str(age) + " лет")  # Правильно

Совет: Для склеивания строк с числами лучше использовать f-строки (о них чуть позже). Это удобнее и читаемее.

Экранирование специальных символов

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

Примеры:

# Перевод строки
print("Первая строка\nВторая строка")
# Выведет:
# Первая строка
# Вторая строка

# Табуляция
print("Имя:\tАнна")
# Выведет: Имя:    Анна

# Обратный слеш
path = "C:\\Users\\Name\\Desktop"
print(path)   # C:\Users\Name\Desktop

Полезно: Экранирование нужно не только для кавычек. Например, пути в Windows содержат обратные слеши — их нужно дублировать или использовать сырые строки.

Сырые строки (raw-строки)

Если ты не хочешь, чтобы Python обрабатывал экранирование, используй сырые строки — добавь перед кавычками букву r.

# Обычная строка — \n обрабатывается
normal = "C:\\Users\\Name"
print(normal)   # C:\Users\Name

# Сырая строка — обратные слеши не экранируются
raw = r"C:\Users\Name"
print(raw)      # C:\Users\Name

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

Индексация строк

Строка — это последовательность символов. К каждому символу можно обратиться по его номеру (индексу).

Важно: Индексация начинается с 0!

text = "Python"
# Индексы: P-0, y-1, t-2, h-3, o-4, n-5

print(text[0])   # P
print(text[1])   # y
print(text[-1])  # n (отрицательные индексы — с конца)
print(text[-2])  # o

Внимание: Если выйти за границы строки, будет ошибка IndexError.

text = "Hi"
print(text[5])   # IndexError: string index out of range

Срезы строк (slicing)

Срезы позволяют получить часть строки. Синтаксис: [start:stop:step]

text = "Программирование"

print(text[0:5])     # Програ (с 0 по 4)
print(text[:5])      # Програ (то же самое, можно опустить 0)
print(text[5:])      # мммирование (с 5 до конца)
print(text[::2])     # Прммиоие (каждый второй символ)
print(text[::-1])    # еинаворимморгПр (строка задом наперёд)

Совет: Срезы — мощный инструмент. Запомни: начало включается, конец — нет. [0:5] даст символы с 0 по 4.

f-строки (форматирование)

Современный и удобный способ вставлять значения переменных в строки. Перед кавычками ставится буква f, а переменные пишутся внутри фигурных скобок {}.

name = "Анна"
age = 25
city = "Москва"

# Старый способ (конкатенация)
print("Меня зовут " + name + ", мне " + str(age) + " лет")

# f-строки (гораздо удобнее)
print(f"Меня зовут {name}, мне {age} лет, я живу в {city}")

Внутри фигурных скобок можно писать не только переменные, но и целые выражения:

x, y = 5, 10
print(f"Сумма {x} и {y} равна {x + y}")   # Сумма 5 и 10 равна 15

Совет: Используй f-строки везде, где можно. Это стандарт современного Python (начиная с версии 3.6).

Основные методы строк

У строк есть много полезных методов. Вот самые нужные:

Примеры:

text = "  Python программирование  "

print(text.strip())                 # "Python программирование"
print(text.upper())                 # "  PYTHON ПРОГРАММИРОВАНИЕ  "
print(text.lower())                 # "  python программирование  "

words = "один,два,три"
print(words.split(","))   # ['один', 'два', 'три']

items = ["яблоко", "банан", "вишня"]
print(", ".join(items))   # яблоко, банан, вишня

text = "Hello World"
print(text.replace("World", "Python"))   # Hello Python
print(text.find("World"))                 # 6
print(len(text))                          # 11

Совет: Методы строк не изменяют исходную строку (строки неизменяемы), а возвращают новую. Запомни это.

original = "Hello"
original.upper()
print(original)   # Hello (не изменилась!)

correct = original.upper()
print(correct)    # HELLO

Проверка содержимого строки

Python предоставляет несколько удобных методов для проверки содержимого строк:

Примеры:

text = "Python programming"

print("Python" in text)        # True
print("Java" in text)          # False
print(text.startswith("Py"))   # True
print(text.endswith("ing"))    # True

phone = "+7-123-456-78-90"
print(phone.isdigit())         # False (есть дефисы и плюс)

code = "12345"
print(code.isdigit())          # True

Совет: Методы isalpha(), isdigit(), isalnum() очень полезны для валидации пользовательского ввода.

Форматирование строк (старые способы)

Помимо f-строк, есть и другие способы форматирования. Они считаются устаревшими, но их полезно знать для чтения старого кода.

Способ 1: Через % (как в C)

name = "Анна"
age = 25
print("Меня зовут %s, мне %d лет" % (name, age))
# %s — строка, %d — целое число

Способ 2: Через format()

print("Меня зовут {}, мне {} лет".format(name, age))
print("Меня зовут {0}, мне {1} лет".format(name, age))
print("Меня зовут {n}, мне {a} лет".format(n=name, a=age))

Совет: Для нового кода используй f-строки. Это самый современный, читаемый и быстрый способ.

Экранирование (ещё примеры)

Некоторые символы нужно экранировать всегда. Вот полная таблица спецсимволов:

Интересный пример с \r (возврат каретки):

print("Hello", end="")
print("\rWorld")   # Перезапишет Hello поверх

Важно: В реальных программах \n и \t используются часто, \r — реже, остальные — в особых случаях.

Задачи для закрепления

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

Задача 1. Создай строку с твоим именем и фамилией. Выведи их через пробел, используя конкатенацию.

Задача 2. Пользователь вводит строку. Выведи её в верхнем регистре и в нижнем регистре.

Задача 3. Удали лишние пробелы из строки: " Привет, мир! ".

Задача 4. Разбей предложение на слова и выведи третье слово (по индексу 2).

Задача 5. Напиши программу, которая проверяет, содержит ли строка слово «Python» (без учёта регистра).

Ответы (не подглядывай)

Задача 1

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

Задача 2

text = input("Введите строку: ")
print(text.upper())
print(text.lower())

Задача 3

text = "   Привет, мир!   "
clean_text = text.strip()
print(clean_text)   # "Привет, мир!"

Задача 4

sentence = "Python это мощный язык программирования"
words = sentence.split()
if len(words) >= 3:
    print(words[2])   # "мощный"

Задача 5

text = "Я люблю python и программирование"
text_lower = text.lower()
if "python" in text_lower:
    print("Слово Python найдено!")
else:
    print("Слово Python не найдено")

Нюансы и подводные камни

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

Это важно запомнить. Строку нельзя изменить по индексу.

text = "Hello"
# text[0] = "h"   # Ошибка! TypeError

Если нужно изменить символ, создай новую строку:

text = "Hello"
new_text = "h" + text[1:]
print(new_text)   # "hello"

Конкатенация в цикле — плохая практика

Если склеиваешь много строк в цикле, это может быть очень медленно.

Плохо (медленно):

result = ""
for i in range(1000):
    result += str(i)   # Создаёт много промежуточных строк

Хорошо (быстро):

parts = []
for i in range(1000):
    parts.append(str(i))
result = "".join(parts)

Путаница с кавычками в JSON

Шпаргалка (быстрый справочник)

Заключение / Выводы

Сегодня мы узнали:

• Строки (str) — последовательности символов в кавычках
• Конкатенация — склеивание строк через +
• Экранирование — специальные символы: \n, \t, \\
• Индексация и срезы — доступ к отдельным символам
• Методы строк — upper(), lower(), strip(), split(), join(), replace()
• Форматирование — f-строки (современный способ)
• Важно — строки неизменяемы

КВИЗ

Что дальше?

• Следующая статья: «Логический тип (bool)» — про True и False

Строки — основа работы с текстом. Теперь ты можешь обрабатывать имена, сообщения, файлы и многое другое.