Методы строк для обработки текста

Со строками в Python вы уже работали: писали литералы, конкатенировали, получали ввод через input(). Сейчас переходим к следующему уровню — методам строки. Это встроенные функции, которые позволяют не просто хранить текст, а активно его обрабатывать.

Что такое метод строки и подстрока

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

text = 'hello'
result = text.upper()
print(result)  # HELLO
print(text)    # hello — исходная строка не изменилась

Здесь важно зафиксировать одно ключевое свойство строк в Python: они неизменяемы. Метод не трогает исходную строку — он возвращает новую. Если результат не сохранить, он просто исчезнет.

Это самая распространённая ошибка новичков:

name = '  Анна  '
name.strip()       # результат вычислен, но никуда не записан
print(name)        # '  Анна  ' — пробелы никуда не делись

Правильно — сохранить результат обратно в переменную:

name = '  Анна  '
name = name.strip()
print(name)  # 'Анна'

Теперь о подстроке. Подстрока — это любой непрерывный фрагмент строки. Например, 'py' является подстрокой 'python', а 'ton' — тоже.

Проверить, входит ли одна строка в другую, можно оператором in:

print('py' in 'python')   # True
print('java' in 'python') # False
print('on' in 'python')   # True

Оператор in возвращает булево значение и работает со строками так же, как с другими коллекциями — чисто и лаконично. Его удобно использовать в условиях:

query = 'ошибка'
message = 'произошла ошибка в строке 42'

if query in message:
    print('Найдено!')

Таким образом, базовая модель для работы со строками выглядит так: строка — объект, методы вызываются через точку, возвращают новое значение, результат обязательно нужно сохранять. В следующих секциях разберём конкретные методы — начнём с очистки пробелов и приведения регистра.

Методы очистки и изменения регистра: strip(), lower(), upper()

Самая частая ситуация при работе с пользовательским вводом — строка приходит с лишними пробелами по краям или в непредсказуемом регистре. Для этого у строк есть три метода.

strip(), lstrip(), rstrip()

strip() обрезает пробелы и символы переноса строки с обоих концов строки. Если нужно убрать только с одной стороны, есть lstrip() (левый край) и rstrip() (правый):

raw = '   Москва   '
print(raw.strip())   # 'Москва'
print(raw.lstrip())  # 'Москва   '
print(raw.rstrip())  # '   Москва'

Чаще всего нужен именно strip() — когда не знаешь, с какой стороны пришли лишние символы.

Можно передать в strip() аргумент — строку с символами, которые нужно обрезать:

path = '###раздел###'
print(path.strip('#'))  # 'раздел'

Но для работы с вводом пользователя такая форма нужна редко; без аргумента — стандартный случай.

lower() и upper()

lower() переводит все буквы строки в нижний регистр, upper() — в верхний:

city = 'САНКТ-ПЕТЕРБУРГ'
print(city.lower())  # 'санкт-петербург'

abbr = 'python'
print(abbr.upper())  # 'PYTHON'

Практическая ценность lower() — регистронезависимое сравнение. Пользователь может написать «Да», «ДА», «да» или «дА», и все четыре варианта должны обрабатываться одинаково:

answer = input('Продолжить? ').strip().lower()

if answer == 'да':
    print('Продолжаем')
else:
    print('Останавливаемся')

Здесь strip() и lower() вызываются подряд — это называется цепочкой методов. Каждый метод применяется к результату предыдущего. Такой стиль читается естественно: сначала убрали пробелы, потом привели к нижнему регистру.

upper() реже используется для сравнения, но пригождается для форматирования вывода — например, когда нужно показать заголовок или аббревиатуру.

Оба метода работают корректно с кириллицей — Python обрабатывает Unicode, так что 'Привет'.lower() даст 'привет' без каких-либо дополнительных настроек.

Самостоятельная практика. Примените strip и lower самостоятельно: напишите функцию, которая распознаёт команду выхода с лишними пробелами и разным регистром. Написать функцию и проверить решение. Другие упражнения на строки, условия и функции доступны в бесплатном курсе Python; после регистрации дальнейший прогресс сохраняется. Продолжить обучение Python бесплатно.

Замена, разбивка и сборка строк: replace(), split(), join()

Предыдущие методы работали с краями строки и регистром. Теперь разберём инструменты, которые меняют саму структуру строки: заменяют фрагменты, режут на части и собирают обратно.

replace(): замена подстрок

replace(old, new) находит все вхождения подстроки old и заменяет их на new:

phrase = 'кот и кот'
result = phrase.replace('кот', 'пёс')
print(result)   # 'пёс и пёс'
print(phrase)   # 'кот и кот' — исходная строка не изменилась

По умолчанию заменяются все вхождения. Если нужно ограничить число замен, передаётся третий аргумент:

text = 'а-а-а-а'
print(text.replace('а', 'б', 2))  # 'б-б-а-а' — заменены только первые два

Чаще всего третий аргумент не нужен, но полезно знать о его существовании.

split(): строка → список

split(sep) разбивает строку по разделителю и возвращает список подстрок:

csv_line = 'Иван,25,Москва'
parts = csv_line.split(',')
print(parts)   # ['Иван', '25', 'Москва']

Если не передавать разделитель, split() разрезает по любым пробельным символам и при этом автоматически отбрасывает лишние пробелы:

sentence = '  раз   два    три  '
words = sentence.split()
print(words)   # ['раз', 'два', 'три']

Это удобно при обработке ввода: пользователь может наставить двойные пробелы, а split() без аргумента всё равно вернёт чистый список слов.

join(): список → строка

join() делает обратное: берёт список строк и собирает их в одну, вставляя разделитель между элементами. Синтаксис немного непривычный — разделитель стоит перед точкой:

words = ['яблоко', 'груша', 'слива']
result = ', '.join(words)
print(result)   # 'яблоко, груша, слива'

Разделителем может быть что угодно — пробел, дефис, пустая строка:

print(' '.join(['раз', 'два', 'три']))   # 'раз два три'
print('-'.join(['раз', 'два', 'три']))   # 'раз-два-три'
print(''.join(['р', 'а', 'з']))          # 'раз'

split и join как пара обратных операций

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

original = 'раз два три'
words = original.split()          # ['раз', 'два', 'три']
result = '-'.join(words)          # 'раз-два-три'
print(result)

В одну строку:

result = '-'.join('раз два три'.split())
print(result)   # 'раз-два-три'

Паттерн split → обработка → join встречается повсеместно: разбить CSV-строку, отфильтровать или трансформировать части, собрать обратно.

Ловушка: join() не принимает не-строковые элементы

Если в списке оказался хотя бы один элемент не типа str, join() выбросит TypeError:

numbers = [1, 2, 3]
print(', '.join(numbers))   # TypeError: sequence item 0: expected str instance, int found

Решение — привести каждый элемент к строке перед join(). Удобнее всего через генераторное выражение:

numbers = [1, 2, 3]
print(', '.join(str(n) for n in numbers))   # '1, 2, 3'

Или через map():

print(', '.join(map(str, numbers)))   # '1, 2, 3'

Оба варианта работают — выбирайте тот, который читается проще в конкретном контексте.

Функция нормализации пользовательского ввода

Теперь соберём всё изученное в одну функцию. Задача простая: пользователь вводит что-то через input(), а программа должна работать с этим стабильно — вне зависимости от того, написал ли он «Да», « ДА » или «да ».

Функция normalize() принимает сырую строку и последовательно применяет методы:

def normalize(text):
    text = text.strip()        # убираем пробелы по краям
    text = text.lower()        # приводим к нижнему регистру
    text = text.replace('ё', 'е')  # унифицируем символы, если нужно
    return text

Каждый шаг решает свою конкретную проблему. strip() убирает то, что пользователь случайно добавил нажатием пробела. lower() снимает вопрос о регистре. replace() здесь показан на примере классической русскоязычной проблемы: буква «ё» и «е» — разные символы, и без замены сравнение 'ёж' == 'еж' вернёт False.

Использовать функцию так:

raw = input('Введите город: ')
city = normalize(raw)

if city == 'москва':
    print('Столица!')
elif city == 'санкт-петербург':
    print('Северная столица!')
else:
    print(f'Город: {city}')

Без normalize() пришлось бы в каждом условии проверять все возможные варианты написания. С функцией — один вызов, и строка готова к сравнению.

Цепочку методов можно записать компактнее — через chaining:

def normalize(text):
    return text.strip().lower().replace('ё', 'е')

Эта запись делает то же самое: strip() возвращает новую строку, на ней сразу вызывается lower(), на её результате — replace(). Итог — одна строка кода вместо трёх. Оба варианта правильны; чем больше шагов, тем читабельнее пошаговая запись.

Функцию можно расширять под конкретную задачу. Например, если нужно ещё и убрать лишние внутренние пробелы:

def normalize(text):
    text = text.strip()
    text = text.lower()
    text = ' '.join(text.split())  # схлопываем множественные пробелы
    return text

print(normalize('  Санкт -  Петербург  '))  # 'санкт - петербург'

Здесь split() без аргумента разбивает строку по любым пробелам и выбрасывает пустые фрагменты, а ' '.join(...) собирает слова обратно через одиночный пробел. Паттерн ' '.join(text.split()) — стандартный способ нормализовать внутренние пробелы в строке.

Главная идея функции нормализации: вместо того чтобы разбрасывать strip() и lower() по всему коду, один раз описываешь правила очистки в одном месте и вызываешь normalize() там, где приходит внешний ввод.