strip: обрезаем пробелы и мусор

Реальные данные грязные: пользователь ставит пробел в конце имени, ячейка CSV тащит лишний пробел перед числом, выгрузка из старой системы добавляет запятые по краям. Метод strip — инструмент чистки краёв строки. Он соседствует с методами регистра из урока 5: их часто ставят в одну цепочку очистки.

Сценарий: выгрузка, где всё в пробелах

Выгрузка из старой учётной системы приходит одной строкой: значения по краям обёрнуты пробелами, между ними стоит табуляция, в конце — перевод строки. Считать такие значения напрямую нельзя: « 1250 » и «1250» для Python разные строки, и итог в отчёте не сойдётся. Чистка краёв — первый шаг обработки любой выгрузки, и именно этим занимается strip.

raw = ' \tпривет  '
print(len(raw))
print(len(raw.strip()))
print(repr(raw.strip()))

10
6
'привет'

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

Какие символы считаются пробельными

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

text = '\r\nОтчёт\r\n'
print(len(text))
print(len(text.strip()))

9
5

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

strip: пробелы по обоим краям

raw = '   аня  '
print(len(raw))
print(raw.strip())
print(len(raw.strip()))

8
аня
3

strip снимает с обоих концов строки все пробелы подряд — и начальные, и конечные. Важно, что внутри строки пробелы не трогаются: чистятся только края. Без аргумента strip снимает пробелы, а также переводы строк и табуляции — всё, на чём обычно «пачкаются» тексты из файлов.

lstrip и rstrip: одна сторона

s = '  коткод  '
print('[' + s.lstrip() + ']')
print('[' + s.rstrip() + ']')

[коткод  ]
[  коткод]

lstrip чистит только левый край, rstrip — только правый. Квадратные скобки в выводе — приём для отладки: видно, где строка начинается и заканчивается. Односторонние версии нужны, когда пробел с одной стороны значим: например, отступ в начале строки кода трогать нельзя, а хвостовой перевод строки — пора снять:

word = 'кот...'
print(word.rstrip('.'))
print('...' + word.rstrip('.'))

кот
...кот

Аргумент: набор символов

Без аргумента strip работает с пробельными символами. Аргумент расширяет арсенал: в кавычках перечисляются символы, которые разрешено снять с краёв:

entry = ',,кот,код,,'
print(entry.strip(','))

word = 'кот...'
print(word.rstrip('.'))

кот,код
кот

print('коткод'.strip('код'))

т

Чистка ввода и CSV-полей

Типовой конвейер очистки данных: срезать пробелы, привести регистр — и значение готово к хранению и сравнению. А для полей CSV strip ставят на каждую ячейку, разобранную split'ом:

row = ' яблоко , банан '
for cell in row.split(','):
    print(cell.strip())

user_input = '  АНЯ '
name = user_input.strip().lower()
print(name)

яблоко
банан
аня

Методы строк можно ставить цепочкой: user_input.strip().lower() сработал слева направо — сначала края, потом регистр. Получилась одна строка кода вместо двух. Дальше по курсу: replace вычищает мусор не только с краёв, но и из середины строки, а split подробно разберёт разбор строк на части.

Внутренние пробелы: strip не поможет

Strip чистит края и не трогает середину — и это правильное поведение, потому что пробелы внутри текста обычно несут смысл. Но если из строки «Масло подсолнечное» нужно убрать лишние пробелы внутри, помогает связка ' '.join(s.split()): split разбивает текст по пробельным сериям, а join склеивает части одним пробелом.

s = '  Масло   подсолнечное  '
print('[' + s.strip() + ']')
print('[' + ' '.join(s.split()) + ']')

[Масло   подсолнечное]
[Масло подсолнечное]

t = '\u200bкот\u200b'
print(repr(t.strip()))
print(repr(t.strip('\u200b')))

'\u200bкот\u200b'
'кот'

Где strip нужен каждый день

• Чтение файлов: readline() оставляет перевод строки на конце — rstrip() его убирает.
• Ввод пользователя: input() не добавляет переноса, но человек может набрать пробелы по краям.
• Поля CSV: у каждой ячейки почти всегда есть пробелы по краям — их чистят перед разбором.
• Сравнение строк: перед == полезно привести обе стороны к одному виду.
• Ключи и идентификаторы: « 1234 » и «1234» должны быть одним ключом, а не двумя.

strip и числа: чистим перед преобразованием

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

print(float(' 1250.50 '))
try:
    print(float('1 250.50'))
except ValueError as e:
    print('Ошибка:', e)

1250.5
Ошибка: could not convert string to float: '1 250.50'

Первая строка прошла: float сам игнорирует пробелы по краям. Вторая упала — и это правильное поведение: молча выкинуть пробел из «1 250.50» значит превратить чужую опечатку в другое число. Чистить надо края, а середину — проверять.

Цепочка очистки: порядок решает

Методы строк можно вызывать цепочкой, и порядок в ней влияет на результат. Общее правило: сначала края, потом всё остальное. Если сначала привести к нижнему регистру, а потом чистить края, результат не изменится — strip не смотрит на регистр. А вот replace смотрит, и там порядок уже может на счёт.

values = ['  АННА ', 'анна  ', ' Анна']
cleaned = []
for v in values:
    cleaned.append(v.strip().lower())
print(len(cleaned), len(set(cleaned)))

3 1

Три записи на входе, три одинаковые строки на выходе — множество из них содержит один элемент. Именно так и проверяют, что в данных нет дублей: привели к общему виду и посчитали. Если бы порядок операций был другим, скажем, сначала lower, потом strip, результат получился бы тем же — но в цепочке с replace пришлось бы думать.

Мини-практика: три строки из списка

Список строк, в котором у каждой свой мусор по краям. Почистите их и выведите в квадратных скобках — так видно, что именно осталось после чистки.

lines = ['  чай  ', 'кофе ', '  молоко']
for line in lines:
    print('[' + line.strip() + ']')

[чай]
[кофе]
[молоко]

Тот же приём в реальной выгрузке занимает одну строку на ячейку. Дальше по курсу: replace вычищает мусор из середины строки, а урок 13 разберёт, как вообще записывать переводы строк и кавычки внутри строк.

Как убрать пробелы в Python: strip, lstrip, rstrip

Три метода отвечают на три разных вопроса, и путаница между ними стоит часа работы в первый месяц. strip() срезает с обоих краёв, lstrip() — только слева, rstrip() — только справа. Разница видна не на словах, а на данных: имя файла с пробелом в конце пути, поле CSV, где разделитель схлопнулся с последним значением.

s = '  коткод  '
print('[' + s.lstrip() + ']')
print('[' + s.rstrip() + ']')
print('[' + s.strip() + ']')

[коткод  ]
[  коткод]
[коткод]

Обратите внимание на rstrip(): он срезает и пробелы справа, и хвостовой перевод строки. Именно поэтому readline() из файла почти всегда требует rstrip() — метод вернёт строку вместе с \n, и любое сравнение с ожидаемым значением развалится. Классика: if line == 'quit': не срабатывает, потому что в line сидит невидимый перевод строки. Правильный вариант — if line.strip() == 'quit':.

strip с аргументом: набор символов, а не подстрока

Аргумент strip — не префикс и не суффикс, а набор символов, которые разрешено снимать с краёв. Символы идут в любом порядке и могут повторяться. Это отличает strip от removesuffix, который убирает ровно конкретное окончание.

entry = ',,кот,код,,'
print(repr(entry.strip(',')))
print(repr(entry.strip(', ')))

'кот,код'
'кот,код'

В первом случае с краёв сняты только запятые, во втором — запятые и пробелы, поэтому результат совпал. А вот обратная ситуация ломается мгновенно: strip('.') не уберёт точку из середины и не разберётся с многоточием.

raw = '2026-03-14T10:30:00Z'
print(raw.strip('Z'))
print(raw.strip('0123456789'))

2026-03-14T10:30:00
-03-14T10:30:00Z

Вторая строка — наглядная ловушка: с краёв срезаны все цифры подряд, и от даты остался обрывок -03-14T10:30:00Z. Так выглядит метод, применённый не к тому набору символов. Вывод: аргумент strip подходит для фиксированного списка вроде ', ' или '\r\n', и не подходит для «убрать всё, что похоже на цифру».

text = '  две   внутренних  пробела  '
print(repr(text))
print(repr(text.strip()))
print(len(text.strip()))

'  две   внутренних  пробела  '
'две   внутренних  пробела'
25

Чистка CSV-строки: strip в цикле

Типичная задача — разобрать строку CSV, где поля разделены запятыми и вокруг значений остались пробелы. Дальше либо strip на каждом поле, либо один split с последующей чисткой. Разница в том, что вы будете делать с пустыми полями.

row = '  хлеб , 45 , 89  '
cells = [cell.strip() for cell in row.split(',')]
print(cells)
print([len(c) for c in cells])

['хлеб', '45', '89']
[4, 2, 2]

Второй вывод полезнее первого: он показывает, что после чистки все поля имеют ожидаемую длину. Если бы strip не применили, длины были бы 6, 4 и 4 — и код, который режет строку по фиксированной ширине, сломался бы на данных, выгруженных другим инструментом. Тонкость: strip не спасает от пустых полей. Строка 'a,,b' даст три части, и средняя останется пустой — её надо отфильтровать осознанно, а не «на всякий случай убрать», потому что пустое поле и поле из одного пробела — разные вещи в логике импорта.

Отдельно про strip и невидимые символы. strip() без аргументов снимает всё, у чего str.isspace() возвращает True: обычный пробел, табуляцию, перевод строки, а также неразрывный пробел U+00A0 и узкий неразрывный U+202F — те Python тоже считает пробельными, и split() по ним режет не хуже. А вот zero-width space (U+200B) и BOM (U+FEFF) в этот список не входят: у них isspace() равно False, поэтому strip() их не тронет, а repr() честно покажет ​. Если данные пришли из файла с BOM или из веба без нормализации — сравнение молча развалится. Лечится это явно: s.replace('​', '').replace('', ''), и делать это лучше один раз при чтении данных, а не в каждом месте сравнения.

Аргумент strip — это не префикс и не суффикс, а набор символов, которые разрешено снять с краёв.