Методы строк в Python: upper, lower, find, replace — полный гайд

Однажды я парсил лог-файл почтового сервера и не мог понять, почему программа не находит строки с "From". Оказалось, часть строк начиналась с "from" в нижнем регистре. Одна строка line.lower() перед сравнением решила проблему. Методы строк в Python это встроенные функции, которые вызываются через точку после строковой переменной и возвращают новую строку, не изменяя оригинал.

В этой статье разбираю методы изменения регистра, поиска, замены, очистки и разбиения строк. Каждый метод показан на практических примерах с пояснением параметров.

Как вызываются методы строк

Строка в Python это объект типа str. У него есть встроенные методы, которые вызываются через точечную нотацию: переменная.метод(аргументы). Этот вызов называется invocation.

word = 'banana'
new_word = word.upper()
print(new_word)  # BANANA
print(word)  # banana (оригинал не изменился)

Строки неизменяемы (immutable), поэтому каждый метод возвращает новую строку. Оригинал остаётся прежним.

Список всех методов

Python предоставляет более 40 строковых методов. Полный список можно посмотреть через функцию dir():

stuff = 'Hello world'
print(dir(stuff))
# [..., 'capitalize', 'casefold', 'center', 'count', 'encode',
# 'endswith', 'find', 'format', 'index', 'isalpha', 'isdigit',
# 'join', 'lower', 'lstrip', 'replace', 'rfind', 'rstrip',
# 'split', 'startswith', 'strip', 'swapcase', 'title', 'upper', ...]

Документация по каждому методу доступна через help(str.метод).

Методы изменения регистра

upper()

Возвращает копию строки, в которой все буквы преобразованы в верхний регистр. Символы, не являющиеся буквами, остаются без изменений.

text = 'Hello, World! 123'
print(text.upper())  # HELLO, WORLD! 123

Типичное применение: приведение данных к единому формату для сравнения или вывода.

user_input = input('Согласны? (да/нет): ')
if user_input.upper() == 'ДА':
    print('Принято')

lower()

Возвращает копию строки с буквами в нижнем регистре.

text = 'Hello, World!'
print(text.lower())  # hello, world!

Метод lower() незаменим при регистронезависимом сравнении. Без него строки "Have" и "have" считаются разными.

line = 'Have a nice day'
print(line.startswith('h'))  # False
print(line.lower().startswith('h'))  # True

Цепочка вызовов line.lower().startswith("h") сначала приводит строку к нижнему регистру, потом проверяет начало.

casefold()

Агрессивная версия lower(), предназначенная для регистронезависимого сравнения в многоязычных текстах. Разница проявляется на специальных символах Unicode.

german = 'Straße'
print(german.lower())  # straße
print(german.casefold())  # strasse

Немецкая буква ß при lower() остаётся ß, а при casefold() превращается в ss.

capitalize() и title()

text = 'hello world'
print(text.capitalize())  # Hello world
print(text.title())  # Hello World

capitalize() делает заглавной только первую букву строки, остальные приводит к нижнему регистру. title() делает заглавной первую букву каждого слова.

Подводный камень title():

print('it\'s a test'.title())  # It'S A Test

Апостроф считается границей слова, и буква после него становится заглавной.

swapcase()

Меняет регистр каждой буквы на противоположный.

text = 'Hello World'
print(text.swapcase())  # hELLO wORLD

Методы поиска

find()

Ищет подстроку и возвращает индекс первого вхождения. Если подстрока не найдена, возвращает -1.

word = 'banana'
print(word.find('a'))  # 1 (первое вхождение 'a')
print(word.find('na'))  # 2
print(word.find('z'))  # -1 (не найдено)

find() принимает необязательные аргументы start и end, ограничивающие область поиска:

word = 'banana'
print(word.find('na', 3))  # 4 (ищем начиная с индекса 3)
print(word.find('a', 2, 4))  # 3 (ищем в диапазоне [2, 4))

Практический пример: извлечение хоста из email

data = 'From stephen.marquard@uct.ac.za Sat Jan 5 09:14:16 2008'
at_pos = data.find('@')
sp_pos = data.find(' ', at_pos)
host = data[at_pos + 1 : sp_pos]
print(host)  # uct.ac.za

Первый find() находит позицию @, второй ищет пробел после неё. Срез извлекает подстроку между ними.

rfind()

Аналог find(), но ищет последнее вхождение подстроки (справа налево).

path = '/home/user/documents/report.txt'
print(path.rfind('/'))  # 20
print(path.find('/'))  # 0

index()

Работает как find(), но при отсутствии подстроки выбрасывает ValueError вместо возврата -1.

word = 'banana'
print(word.index('a'))  # 1

try:
    print(word.index('z'))
except ValueError as e:
    print(e)  # substring not found

Используйте find() когда отсутствие подстроки допустимо, и index() когда отсутствие это ошибка, которую нужно поймать.

count()

Считает количество неперекрывающихся вхождений подстроки.

word = 'banana'
print(word.count('a'))  # 3
print(word.count('na'))  # 2
print(word.count('ana'))  # 1 (неперекрывающийся подсчёт)

Методы проверки содержимого

startswith() и endswith()

line = 'From stephen.marquard@uct.ac.za'
print(line.startswith('From'))  # True
print(line.startswith('from'))  # False (регистрозависимо)
print(line.endswith('.za'))  # True

startswith() принимает кортеж для проверки нескольких вариантов:

filename = 'photo.jpg'
print(filename.endswith(('.jpg', '.png', '.gif')))  # True

isdigit(), isalpha(), isalnum()

print('12345'.isdigit())  # True
print('12.5'.isdigit())  # False (точка не цифра)
print('hello'.isalpha())  # True
print('hello1'.isalnum())  # True (буквы + цифры)

Методы замены и очистки

replace()

Заменяет все вхождения одной подстроки на другую. Возвращает новую строку.

text = 'Hello World'
print(text.replace('World', 'Python'))  # Hello Python
print(text.replace('l', 'L'))  # HeLLo WorLd

Третий аргумент ограничивает количество замен:

text = 'aaa bbb aaa bbb aaa'
print(text.replace('aaa', 'xxx', 2))  # xxx bbb xxx bbb aaa

strip(), lstrip(), rstrip()

Удаляют пробельные символы (пробелы, табуляции, переносы строк) с краёв строки.

line = ' Here we go \n'
print(line.strip())  # 'Here we go'
print(line.lstrip())  # 'Here we go \n'
print(line.rstrip())  # ' Here we go'

Методы принимают аргумент с символами для удаления:

text = '###Hello###'
print(text.strip('#'))  # Hello
print(text.lstrip('#'))  # Hello###

Практический пример: очистка строк файла

При чтении файла каждая строка заканчивается символом \n. Метод rstrip() убирает его:

fhand = open('mbox-short.txt')
for line in fhand:
    line = line.rstrip()
    if line.startswith('From:'):
        print(line)

Методы разбиения и соединения

split()

Разбивает строку на список подстрок по разделителю. Без аргумента разделяет по пробельным символам.

text = 'Python is great'
print(text.split())  # ['Python', 'is', 'great']
print(text.split('i'))  # ['Python ', 's great']

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

Второй аргумент maxsplit ограничивает количество разбиений:

text = 'one:two:three:four'
print(text.split(':', 2))  # ['one', 'two', 'three:four']

join()

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

words = ['Python', 'is', 'great']
print(' '.join(words))  # Python is great
print('-'.join(words))  # Python-is-great
print(''.join(words))  # Pythonisgreat

join() это обратная операция к split().

partition()

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

email = 'user@example.com'
name, sep, domain = email.partition('@')
print(name)  # user
print(domain)  # example.com

Методы форматирования и выравнивания

center(), ljust(), rjust()

title = 'Python'
print(title.center(20, '='))  # =======Python=======
print(title.ljust(20, '.'))  # Python..............
print(title.rjust(20, '.'))  # ..............Python

zfill()

Дополняет строку нулями слева до заданной ширины. Учитывает знак числа.

print('42'.zfill(5))  # 00042
print('-42'.zfill(5))  # -0042

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

Каждый метод возвращает строку, поэтому к результату можно сразу применить следующий метод.

raw = ' Hello, WORLD! \n'
clean = raw.strip().lower().replace(',', '').replace('!', '')
print(clean)  # hello world

Порядок вызовов: strip() убирает пробелы и \n, lower() приводит к нижнему регистру, два replace() удаляют знаки пунктуации.

Пример: нормализация email

email = ' User@Example.COM '
normalized = email.strip().lower()
print(normalized)  # user@example.com

Пример: проверка расширения файла

filename = ' Report.PDF '
if filename.strip().lower().endswith(('.pdf', '.doc', '.txt')):
    print('Документ')
# Документ

Неочевидные детали

Первый факт: split() без аргументов и split(" ") дают разный результат. Без аргументов метод разделяет по любым пробельным символам и игнорирует пустые элементы. С аргументом " " каждый пробел создаёт разделение.

text = ' a b c '
print(text.split())  # ['a', 'b', 'c']
print(text.split(' '))  # ['', '', 'a', '', 'b', '', 'c', '', '']

Второй факт: replace() с пустой строкой как первым аргументом вставляет символ между каждым символом:

print('abc'.replace('', '-'))  # -a-b-c-

Третий факт: методы проверки (isdigit, isalpha) для пустой строки возвращают False.

Четвёртый факт: casefold() может вернуть строку длиннее исходной (как "ß" → "ss").

Пятый факт: startswith() и endswith() принимают кортеж, но не список. Передача списка вызовет TypeError.

FAQ

Чем find() отличается от index()?‍

find() возвращает -1 при отсутствии подстроки, index() выбрасывает ValueError. Используйте find() для проверки наличия, index() когда отсутствие подстроки это ошибка.

Можно ли вызвать метод от строкового литерала?‍

Да. Литерал это тоже объект str: "hello".upper() вернёт "HELLO", " ".join(["a", "b"]) вернёт "a b".

Как заменить только первое вхождение?‍

Передайте третий аргумент count=1 в replace(): "aaa".replace("a", "b", 1) вернёт "baa".

Почему strip() не удаляет символы из середины строки?‍

strip() работает только с краями строки. Для удаления символов из середины используйте replace() или регулярные выражения.

Как разбить строку на строки?‍

Метод splitlines() разбивает текст по символам переноса строки:

text = 'строка 1\nстрока 2\r\nстрока 3'
print(text.splitlines())  # ['строка 1', 'строка 2', 'строка 3']

splitlines() корректно обрабатывает и \n (Unix), и \r\n (Windows), и \r (старый Mac).

‍

Мой совет: выучите шесть методов и закроете 90% задач со строками: lower() для нормализации регистра, strip() для очистки, find() для поиска, replace() для замены, split() для разбиения и join() для склейки. Остальные 40 методов подтянутся по мере необходимости.