Как отступить строчку в питоне

Подробно про отступы в Python

Отступы в Python используются для создания группы операторов. Многие популярные языки, такие как C и Java, используют фигурные скобки (<>) для определения блока кода, Python использует отступы.

Как работает отступ в Python?

При написании кода на Python мы должны определить группу операторов для функций и циклов. Это делается путем правильного отступа операторов для этого блока.

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

Обычно четыре пробела или один символ табуляции используются для создания или увеличения уровня отступа кода. Давайте посмотрим на пример, чтобы понять отступы кода и группировку операторов.

Правила отступов

Преимущества

Недостатки

Примеры IndentationError

Давайте посмотрим на несколько примеров ошибки IndentationError в коде Python.

У нас не может быть отступа в первой строке кода. Вот почему возникает ошибка IndentationError.

Строки кода внутри блока if имеют другой уровень отступа, отсюда и ошибка IndentationError.

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

Вывод

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

Источник

Отступы в Python — вариант решения

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

Казалось бы, в случае с Python такая операция не возможна.

По крайней мере, я нигде не смог найти, как моментально обнаружить случайно смещенные отступы в Python. Пришлось решить эту проблему самому.

Вступление

Уважаемый читатель!
Если для тебя близко утверждение:
1) Что программирование — это высокое искусство.
2) Что при программировании на каком-либо языке нужно по возможности максимально использовать всю мощь и разнообразие этого языка для минимализации исходного кода.
3) Что при программировании нужно показать в исходном тексте программы свой высокий уровень, чтобы про твою программу ни кто не мог сказать, что она «тупая».

Если хотя бы один(!) из вышеперечисленных моментов тебе близок, то пожалуйста, не читай эту статью! Не трать, пожалуйста, на нее свое время.
В ней пойдет речь об одном совершенно надуманном и абсурдном моменте программирования.

Уважаемый читатель!
Если для тебя уже близко утверждение:
1) Что программирование — это рутинная, довольно однообразная работа, похожая просто на рытье бесконечной извилистой канавы.
2) Что при программировании на каком-либо языке нужно использовать определенный минимально-оптимальный набор команд языка (возможно отбросив большую часть его команд), чтобы в твоей программе легко(!) разобрался даже программист-юниор.
3) Что при программировании твоя программа должна быть в определенной степени «тупой». Чтобы после того, как ты ее внедрил, ты мог заняться новым проектом и спокойно поставить программиста-юниора, участвовавшего в проекте, на ее сопровождение и доработку под регулярные небольшие новые требования заказчика.

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

Основные недостатки Python:

1) Python «не минимизирован» по использованию ресурсов и своих данных и, таким образом, не подходит для написания программ, требовательных к использованию ресурсов, таких как мобильные приложения, программы низкого уровня (драйвера, резидентные программы и т.п.) и т.д.

2) Python медленный и однопоточный ( GIL — Global Interpreter Lock ).

3) В Python программные блоки основаны ТОЛЬКО(!) на отступах. Из-за этого:

Второй недостаток Python решается тем, что у него прекрасная двусторонняя интероперабельность с C/C++.

Часто успешный проект развивается довольно стремительно. И сначала высоких требований к быстродействию нет, и в Python при необходимости используют крошечные вставки на С/С++.
Но по мере развития и расширения проекта, требования к быстродействию соответственно возрастают, и Python все чаще начинает выполнять функции вызываемого языка из С/С++. При этом, роль самого Python не уменьшается, т.к. при программировании участков, не требующих высокой скорости выполнения (а их обычно довольно много в крупных проектах), Python является более удобным инструментом, чем С/С++.

А для третьего недостатка Python я хотел бы предложить свой вариант решения.

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

Т.е. с какими бы отступами ни была написана программа на этом языке, при запуске автоформатирования все отступы будут приведены к стандартному виду. Для Python такое кажется невозможным.

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

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

И тогда в Python, в случае значительного изменения десятков кусков чужой(!) программы (или же своей, но которую уже совершенно не помнишь), стоит при переносе блока случайно зацепить лишний участок кода, принадлежащего другому блоку, то программа может остаться полностью работоспособной, но алгоритм ее работы поменяется (читай «программа начнет работать неправильно»), и найти место такой ошибки в чужой программе и потом правильно восстановить отступы иногда бывает очень непросто!

В этом случае можно, конечно, посмотреть исходный текст (до изменений), но если уже внес в этом месте много корректировок, то придется «отматывать» всю эту цепочку исправлений.

Решение проблемы отступов в Python

Отступы в Python формируются следующими командами:

И для удаления зависимости от отступов, для каждой из этих команд я решил взять за правило использовать «завершающую» команду, которая однозначно будет закрывать блок команд (отступов).

Команды «class» и «def»

Для команд class/def обычно нет проблемы с завершением блока отступов, т.к. блок закрывается новой командой class/def.

Единственный случай — это наличие одной или нескольких подпрограмм, объявленных внутри другой подпрограммы/метода.

Тогда, если случайно сместить блок команд последней внутренней подпрограммы, то он сольётся с командами подпрограммы/метода, в которой объявлена эта внутренняя подпрограмма.

В этом случае в конце этой внутренней подпрограммы/метода нужно просто поставить «return», что и будет четко обозначать окончание блока её команд.

Команды «for» и «while»

В конце оператора «for» и «while» нужно ставить «continue».

Т.е. команда будут выглядеть так:

Случайное удаление отступа в последних командах блока «for» не приводит к ошибке выполнения программы, но приводит к ошибочным результатам! И очень не просто найти такой сбой, если точно не знаешь алгоритм программы (например, если это программа уволившегося коллеги)!

А в нижеуказанном примере случайное удаление отступа сразу выдаст ошибку:

Команда «if»

В конце оператора «if» нужно ставить команду «elif 0: pass», а вместо «else» использовать команду «elif 1:».

Т.е. для «if» будет законченный блок команд:

Если оформить так, как показано выше, то в блоке команд «if… elif 0: pass» удаление отступа сформирует ошибку запуска.

Без «elif 0: pass», если потом случайно удалятся отступы в последних строках блока «if», то сначала будешь искать место, из-за которого программа неожиданно стала неправильно работать, а потом думать: какие отступы должны быть в блоке, а какие — нет.

Почему еще, на мой взгляд, желательно закрывать блоки команд, созданные операторами «for»,
«while», «if» и т.д…

Потому что, когда смотришь на участок кода, где присутствует большая разница в уровне
отступов между непосредственно концом текущего блока и началом следующего, то часто уже не можешь понять, какой отступ чему принадлежит.

Тогда конструкции с «continue» и «elif 0: pass», помимо защиты от случайного удаления, позволят также указать какой блок чем начат и написать комментарий к нему.

Например, видишь конец большого блока:

И сложно вспомнить, что значит каждый уровень отступов.

Но уже гораздо проще, когда это выглядит вот так:

Команда «try»

Тут полная аналогия с «if».

Единственная проблема — команда «finally:». После нее больше нельзя поставить ни одну из команд текущего try-блока.

Поэтому если есть необходимость в ее использовании, то для сохранения возможности автоформата и защиты от случайного удаления отступов нужно убрать весь блок команд после «finally:» в локальную подпрограмму (т.е. объявить её как подпрограмму внутри текущей подпрограммы).

Т.е. текст с «finally:» будет таким:

В этом случае тоже можно спокойно применить автоформатирование и не бояться
случайного удаления отступов.

Команда «with»

Для «with» в Python нет никаких дополнительных команд, которые могли бы послужить концом блока. Поэтому ситуация с «with» аналогична ситуации с «finally».
Т.е. либо мы все команды, выполняющиеся в блоке оператора «with», выносим в локальную подпрограмму, либо… А вот дальше я скажу жутко кощунственную вещь: «… либо просто не нужно его никогда использовать.»

Дело в том, что «with», с одной стороны, всего лишь «обертка» для существующих команд Python (т.е. ее всегда можно заменить аналогичным набором команд), с другой стороны, практика показала, что для программистов-юниоров этот контекстный менеджер трудноват для полноценного освоения. И поэтому, если хочешь, чтобы после тебя внедренный проект спокойно сопровождал программист-юниор, то не нужно в проекте использовать команды, затрудняющие его работу.

Заключение

Я думаю вы уже поняли, что если на Python написать программу с применением ВЕЗДЕ(!) вышеуказанных приемов оформления блоков отступов, то достаточно легко написать ПОЛНОЦЕННОЕ АВТОФОРМАТИРОВАНИЕ такой программы даже при «перекосе» или полном удалении отступов в ней, т.к. для всех блоков команд есть начало и конец блока, не зависящие от отступов.

А теперь с улыбкой поставим вопрос так: «Какие недостатки есть у Python, если правильно оформлять блоки отступов, при необходимости взаимодействовать с С/С++ и не применять Python в мобильных и ресурсокритичных приложениях?».

Ответ: «Только несущественные недостатки. Т.е. по большому счету — нет.»

И при такой постановке вопроса нам останется только наслаждаться основными достоинствами Python.

Источник

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

Дата: 20.03.2019 Категория: Python Комментарии: 0

В этой статье вы узнаете почему отступы в Python это очень важно и как писать лучший код используя комментарии.

Отступы в Python

Большинство языков программирования, таких как C, C++, Java, используют фигурные скобки <> для определения блока кода. В отличии от них, Python использует отступы.

Блок кода (тело функции, цикл и т.д.) начинается с отступа и заканчивается первой строкой где этот отступ отсутствует. Количество отступов зависит от вас, но оно должно быть одинаковым на протяжении всего блока.

В Python, как правило, используются четыре пробела для выделения блока кода. Давайте рассмотрим на примере:

Применение отступов в Python делает код аккуратным и чистым. В результате, программы проще читать и поддерживать.

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

можно написать следующим образом:

Это не вызовет ошибок однако это является плохой практикой потому что снижает читабельность вашего кода.

Современные IDE и редакторы кода для Python автоматически расставляют отступы, соответственно вам не придется думать о них во время программирования. Выбрать подходящую вам IDE или редактор кода можно ознакомившись со статьей «Лучшие бесплатные IDE и редакторы кода для Python».

Комментарии в Python

Комментарии очень важны при написании программы. Они описывают, что происходит внутри программы, так что человеку, смотрящему на исходный код, не составит труда понять его. Даже не смотря на то что сам по себе код написанный на Python довольно хорошо читается, вы можете забыть ключевые детали программы, которую вы написали пол года назад. Поэтому уделять время объяснению деталей реализации в форме комментариев является хорошей практикой. Даже если ваш код кажется вам довольно простым, наличие комментариев никогда не повредит, а вот их отсутствие вполне может заставить вас потратить на разбор кода больше времени чем вам хотелось бы.

В Python используется символ хэш (решетка, #) для обозначения начала строки комментария.

Интерпретатор Python игнорирует содержимое строки комментария.

Многострочные комментарии

Тройные кавычки часто используются как многострочный комментарий. Если они не являются строками документации, они не генерируют никакого дополнительного кода.

Docstring в Python

Это строка, которая вставляется как первая строка в определении модуля, функции, класса или метода. В нем вы должны написать, что функция/класс делает.

Строка документации доступна нам как атрибут __doc__ функции:

Источник

Строки в python 3: методы, функции, форматирование

В уроке по присвоению типа переменной в Python вы могли узнать, как определять строки: объекты, состоящие из последовательности символьных данных. Обработка строк неотъемлемая частью программирования на python. Крайне редко приложение, не использует строковые типы данных.

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

Ниже рассмотрим операторы, методы и функции, доступные для работы с текстом.

Строковые операторы

Оператор сложения строк +

+ — оператор конкатенации строк. Он возвращает строку, состоящую из других строк, как показано здесь:

Оператор умножения строк *

* — оператор создает несколько копий строки. Если s это строка, а n целое число, любое из следующих выражений возвращает строку, состоящую из n объединенных копий s :

Вот примеры умножения строк:

Значение множителя n должно быть целым положительным числом. Оно может быть нулем или отрицательным, но этом случае результатом будет пустая строка:

Оператор принадлежности подстроки in

Встроенные функции строк в python

Python предоставляет множество функций, которые встроены в интерпретатор. Вот несколько, которые работают со строками:

Более подробно о них ниже.

Функция ord(c) возвращает числовое значение для заданного символа.

На базовом уровне компьютеры хранят всю информацию в виде цифр. Для представления символьных данных используется схема перевода, которая содержит каждый символ с его репрезентативным номером.

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

Unicode — это современный стандарт, который пытается предоставить числовой код для всех возможных символов, на всех возможных языках, на каждой возможной платформе. Python 3 поддерживает Unicode, в том числе позволяет использовать символы Unicode в строках.

Функция ord() также возвращает числовые значения для символов Юникода:

Функция chr(n) возвращает символьное значение для данного целого числа.

chr() также обрабатывает символы Юникода:

Функция len(s) возвращает длину строки.

len(s) возвращает количество символов в строке s :

Функция str(obj) возвращает строковое представление объекта.

Практически любой объект в Python может быть представлен как строка. str(obj) возвращает строковое представление объекта obj :

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

Часто в языках программирования, отдельные элементы в упорядоченном наборе данных могут быть доступны с помощью числового индекса или ключа. Этот процесс называется индексация.

Например, схематическое представление индексов строки ‘foobar’ выглядит следующим образом:

Отдельные символы доступны по индексу следующим образом:

Вот несколько примеров отрицательного индексирования:

Срезы строк

Если пропустить первый индекс, срез начинается с начала строки. Таким образом, s[:m] = s[0:m] :

Для любой строки s и любого целого n числа ( 0 ≤ n ≤ len(s) ), s[:n] + s[n:] будет s :

Пропуск обоих индексов возвращает исходную строку. Это не копия, это ссылка на исходную строку:

Если первый индекс в срезе больше или равен второму индексу, Python возвращает пустую строку. Это еще один не очевидный способ сгенерировать пустую строку, если вы его искали:

Отрицательные индексы можно использовать и со срезами. Вот пример кода Python:

Шаг для среза строки

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

Иллюстративный код показан здесь:

Как и в случае с простым срезом, первый и второй индексы могут быть пропущены:

Вы также можете указать отрицательное значение шага, в этом случае Python идет с конца строки. Начальный/первый индекс должен быть больше конечного/второго индекса:

В приведенном выше примере, 5:0:-2 означает «начать с последнего символа и делать два шага назад, но не включая первый символ.”

Когда вы идете назад, если первый и второй индексы пропущены, значения по умолчанию применяются так: первый индекс — конец строки, а второй индекс — начало. Вот пример:

Это общая парадигма для разворота (reverse) строки:

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

В Python версии 3.6 был представлен новый способ форматирования строк. Эта функция официально названа литералом отформатированной строки, но обычно упоминается как f-string.

Возможности форматирования строк огромны и не будут подробно описана здесь.
Одной простой особенностью f-строк, которые вы можете начать использовать сразу, является интерполяция переменной. Вы можете указать имя переменной непосредственно в f-строковом литерале ( f’string’ ), и python заменит имя соответствующим значением.

Но это громоздко. Чтобы выполнить то же самое с помощью f-строки:

Код с использованием f-string, приведенный ниже выглядит намного чище:

Любой из трех типов кавычек в python можно использовать для f-строки:

Изменение строк

Строки — один из типов данных, которые Python считает неизменяемыми, что означает невозможность их изменять. Как вы ниже увидите, python дает возможность изменять (заменять и перезаписывать) строки.

Такой синтаксис приведет к ошибке TypeError :

На самом деле нет особой необходимости изменять строки. Обычно вы можете легко сгенерировать копию исходной строки с необходимыми изменениями. Есть минимум 2 способа сделать это в python. Вот первый:

Есть встроенный метод string.replace(x, y) :

Читайте дальше о встроенных методах строк!

Встроенные методы строк в python

В руководстве по типам переменных в python вы узнали, что Python — это объектно-ориентированный язык. Каждый элемент данных в программе python является объектом.

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

Методы похожи на функции. Метод — специализированный тип вызываемой процедуры, тесно связанный с объектом. Как и функция, метод вызывается для выполнения отдельной задачи, но он вызывается только вместе с определенным объектом и знает о нем во время выполнения.

Синтаксис для вызова метода объекта выглядит следующим образом:

Вы узнаете намного больше об определении и вызове методов позже в статьях про объектно-ориентированное программирование. Сейчас цель усвоить часто используемые встроенные методы, которые есть в python для работы со строками.

В приведенных методах аргументы, указанные в квадратных скобках ( [] ), являются необязательными.

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

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

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

s.capitalize() возвращает копию s с первым символом, преобразованным в верхний регистр, и остальными символами, преобразованными в нижний регистр:

Не алфавитные символы не изменяются:

string.lower() преобразует все буквенные символы в строчные.

s.lower() возвращает копию s со всеми буквенными символами, преобразованными в нижний регистр:

string.swapcase() меняет регистр буквенных символов на противоположный.

s.swapcase() возвращает копию s с заглавными буквенными символами, преобразованными в строчные и наоборот:

string.title() преобразует первые буквы всех слов в заглавные

s.title() возвращает копию, s в которой первая буква каждого слова преобразуется в верхний регистр, а остальные буквы — в нижний регистр:

Этот метод использует довольно простой алгоритм. Он не пытается различить важные и неважные слова и не обрабатывает апострофы, имена или аббревиатуры:

string.upper() преобразует все буквенные символы в заглавные.

s.upper() возвращает копию s со всеми буквенными символами в верхнем регистре:

Найти и заменить подстроку в строке

Эти методы предоставляют различные способы поиска в целевой строке указанной подстроки.

string.count(_{[, [, ]])} подсчитывает количество вхождений подстроки в строку.

s.count(_{) возвращает количество точных вхождений подстроки в s :}

Количество вхождений изменится, если указать и :

string.endswith( [, [, ]]) определяет, заканчивается ли строка заданной подстрокой.

s.endswith( ) возвращает, True если s заканчивается указанным и False если нет:

string.find(_{[, [, ]])} ищет в строке заданную подстроку.

s.find(_{) возвращает первый индекс в s который соответствует началу строки :}

string.index(_{[, [, ]])} ищет в строке заданную подстроку.

string.rfind(_{[, [, ]])} ищет в строке заданную подстроку, начиная с конца.

string.rindex(_{[, [, ]])} ищет в строке заданную подстроку, начиная с конца.

Классификация строк

Методы в этой группе классифицируют строку на основе символов, которые она содержит.

string.isalnum() определяет, состоит ли строка из букв и цифр.

string.isalpha() определяет, состоит ли строка только из букв.

string.isdigit() определяет, состоит ли строка из цифр (проверка на число).

s.digit() возвращает True когда строка s не пустая и все ее символы являются цифрами, а в False если нет:

string.isidentifier() определяет, является ли строка допустимым идентификатором Python.

string.islower() определяет, являются ли буквенные символы строки строчными.

string.isprintable() определяет, состоит ли строка только из печатаемых символов.

s.isprintable() возвращает, True если строка s пустая или все буквенные символы которые она содержит можно вывести на экран. Возвращает, False если s содержит хотя бы один специальный символ. Не алфавитные символы игнорируются:

string.isspace() определяет, состоит ли строка только из пробельных символов.

Тем не менее есть несколько символов ASCII, которые считаются пробелами. И если учитывать символы Юникода, их еще больше:

‘\f’ и ‘\r’ являются escape-последовательностями для символов ASCII; ‘\u2005’ это escape-последовательность для Unicode.

string.istitle() определяет, начинаются ли слова строки с заглавной буквы.

string.isupper() определяет, являются ли буквенные символы строки заглавными.

Выравнивание строк, отступы

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

string.center( [, ]) выравнивает строку по центру.

string.expandtabs(tabsize=8) заменяет табуляции на пробелы

s.expandtabs() заменяет каждый символ табуляции ( ‘\t’ ) пробелами. По умолчанию табуляция заменяются на 8 пробелов:

tabsize необязательный параметр, задающий количество пробелов:

string.ljust( [, ]) выравнивание по левому краю строки в поле.

string.lstrip([ ]) обрезает пробельные символы слева

s.lstrip() возвращает копию s в которой все пробельные символы с левого края удалены:

string.replace(

, [, ]) заменяет вхождения подстроки в строке.

s.replace(

, ) возвращает копию s где все вхождения подстроки
, заменены на :

string.rjust( [, ]) выравнивание по правому краю строки в поле.

string.rstrip([ ]) обрезает пробельные символы справа

s.rstrip() возвращает копию s без пробельных символов, удаленных с правого края:

string.strip([ ]) удаляет символы с левого и правого края строки.

Важно: Когда возвращаемое значение метода является другой строкой, как это часто бывает, методы можно вызывать последовательно:

string.zfill( ) дополняет строку нулями слева.

s.zfill( ) возвращает копию s дополненную ‘0’ слева для достижения длины строки указанной в :

Если s содержит знак перед цифрами, он остается слева строки:

.zfill() наиболее полезен для строковых представлений чисел, но python с удовольствием заполнит строку нулями, даже если в ней нет чисел:

Методы преобразование строки в список

Методы в этой группе преобразовывают строку в другой тип данных и наоборот. Эти методы возвращают или принимают итерируемые объекты — термин Python для последовательного набора объектов.

Многие из этих методов возвращают либо список, либо кортеж. Это два похожих типа данных, которые являются прототипами примеров итераций в python. Список заключен в квадратные скобки ( [] ), а кортеж заключен в простые ( () ).

Теперь давайте посмотрим на последнюю группу строковых методов.

string.join( ) объединяет список в строку.

В результате получается одна строка, состоящая из списка объектов, разделенных запятыми.

В следующем примере указывается как одно строковое значение. Когда строковое значение используется в качестве итерируемого, оно интерпретируется как список отдельных символов строки:

Это можно исправить так:

string.partition( ) делит строку на основе разделителя.

s.rpartition( ) делит строку на основе разделителя, начиная с конца.

string.rsplit(sep=None, maxsplit=-1) делит строку на список из подстрок.

Без аргументов s.rsplit() делит s на подстроки, разделенные любой последовательностью пробелов, и возвращает список:

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

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

string.split(sep=None, maxsplit=-1) делит строку на список из подстрок.

string.splitlines([ ]) делит текст на список строк.

s.splitlines() делит s на строки и возвращает их в списке. Любой из следующих символов или последовательностей символов считается границей строки:

Разделитель	Значение
\n	Новая строка
\r	Возврат каретки
\r\n	Возврат каретки + перевод строки
\v или же \x0b	Таблицы строк
\f или же \x0c	Подача формы
\x1c	Разделитель файлов
\x1d	Разделитель групп
\x1e	Разделитель записей
\x85	Следующая строка
\u2028	Новая строка (Unicode)
\u2029	Новый абзац (Unicode)

Вот пример использования нескольких различных разделителей строк:

Если в строке присутствуют последовательные символы границы строки, они появятся в списке результатов, как пустые строки:

Заключение

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

Python есть другие встроенные типы данных. В этих урока вы изучите два наиболее часто используемых:

Источник