Python как сделать отступ строки в консоли

Обновлено: 01.07.2024

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

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

Правильно:

Не правильно:

Правило 4 пробелов не является обязательным для строк продолжения.

По желанию:

Когда условная часть if достаточно длинная (более 79 символов) и мы должны записать ее в несколько строк, стоит отметить, что сочетание двухсимвольного ключевого слова (например, if ), одного пробела и открывающей скобки, при переносе, создает естественный отступ в 4 символа для последующих строк. Это может привести к визуальному конфликту с дальнейшим набором кода, вложенным в конструкцию if, которое также будет иметь отступ в 4 пробела. Этот PEP не занимает явной позиции о том, как следует дополнительно визуально отличать такие строки от вложенного кода внутри конструкции if . Приемлемые варианты в этой ситуации можно посмотреть в примерах ниже, но не ограничиваться этим:

Закрывающая скобка в многострочных конструкциях может располагаться либо под первым символом последней строки списка:

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

TAB или пробелы?

Пробелы являются предпочтительным методом отступа.

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

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

При вызове интерпретатора командной строки Python 2 с параметром -t выдает предупреждения о коде, который смешивает табуляции и пробелы. При использовании -tt эти предупреждения становятся ошибками. Эти варианты настоятельно рекомендуются!

Максимальная длина строки с кодом:

Ограничьте все строки максимум 79 символами.

Для строк документации или комментариев длина строки должна быть ограничена 72 символами.

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

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

Некоторые команды разработчиков предпочитают более длинные строки при написании кода. Исключительно для поддержания такого кода внутри команды, разрешается увеличить ограничение длины строки до 99 символов, при условии, что комментарии и документация должна быть ограничена 72 символами

Стандартная библиотека Python консервативна и требует ограничения строки до 79 символов (и строки документации/комментариев до 72).

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

Если такое не возможно, например, длинные строковые параметры в аргументах функций, то допустимо использование обратного слеша \ .

Еще один такой случай возможен с assert утверждениями.

Удостоверьтесь, что сделали отступ в 4 пробела для продолжения строки кода.

Перенос строки до или после двоичного оператора?

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

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

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

Пустые строки:

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

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

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

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

Python принимает символ перевода формы control-L (т.е. ^ L ) в качестве пробела. Многие инструменты обрабатывают эти символы как разделители страниц, поэтому, вы можете использовать их для разделения страниц связанных разделов вашего файла. Обратите внимание, что некоторые редакторы и IDE могут не распознавать control-L .

Кодировка файла с кодом:

Код в основном дистрибутиве Python всегда должен использовать UTF-8 (или ASCII в Python 2).

Файлы, использующие ASCII (в Python 2) или UTF-8 (в Python 3), не должны иметь декларации кодировки.

В стандартной библиотеке, кодировки, отличные от заданных по умолчанию, следует использовать только для целей тестирования или в тех случаях, когда в комментариях или строке документации необходимо упомянуть имя автора, содержащее символы, отличные от ASCII. В противном случае использование \x , \u , \U или \N escape-файлов является предпочтительным способом включения данных не-ASCII в строковые литералы.

Для Python 3.0 и выше, для стандартной библиотеки предписана следующая политика. Все идентификаторы в стандартной библиотеке Python ДОЛЖНЫ использовать идентификаторы только ASCII и ДОЛЖНЫ использовать английские слова везде, где это возможно (сокращения и технические термины, которые не являются английскими). Кроме того, все строковые литералы и комментарии также должны быть в ASCII.

Единственными исключениями являются:

Контрольные примеры, тестирующие функции, отличные от ASCII,
Имена авторов. Авторы, чьи имена не основаны на латинском алфавите, ДОЛЖНЫ обеспечить транслитерацию своих имен.

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

Импорт:

Импорт обычно должен быть в отдельных строках:

Это нормально, хотя:

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

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

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

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

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

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

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

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

Если это написание вызывает локальные конфликты имен, то запишите импорт через точку:

и используйте myclass.MyClass и foo.bar.yourclass.YourClass .

Следует избегать импорта подстановочных знаков ( from <module> import * ), так как из-за этого неясно, какие имена присутствуют в пространстве имен, запутывает как читателей, так и многие автоматизированные инструменты. Существует один оправданный вариант использования для импорта с использованием подстановочного знака, который заключается в повторной публикации внутреннего интерфейса как части общедоступного API.

При повторной публикации имен, все же применяются приведенные ниже рекомендации, касающиеся открытых и внутренних интерфейсов.

Расположение имен "dunders" в коде:

Имена "dunders" (имена с двумя начальными и двумя замыкающими подчеркиваниями), такие как __all__ , __author__ , __version__ и т. ., Должны быть помещены после строки документации модуля, но перед любыми операторами импорта, кроме __future__ . Python предписывает, что в __future__ импорт должен стоять перед любым другим кодом, кроме строк документации:

Кавычки в строках:

В Python одинарные и двойные кавычки функционально одинаковы. PEP не дает рекомендации какие из них предпочтительнее. Выберите правило и придерживайтесь его. Если, например, строка содержит одинарные кавычки, чтобы избежать обратной косой черты в строке, используйте дополнительно двойные кавычки. Это улучшает читаемость.

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

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

Казалось бы, в случае с 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 — для оформления блоков кода вместо привычных фигурных скобок, как в C, C ++, Java или операторных скобок begin … end как в Pascal, используются отступы (или табуляция).

Подробнее о том, какие есть правила расстановки отступов — рассмотрим далее.

Почему табуляция в Питоне так важна?

Что такое отступ? Говоря простыми словами, это просто добавление пробела перед определенным оператором.

Отступы — важная концепция языка Питон, так как без правильного их оформления в итоге программист получит ошибку типа IndentationError , код при этом не будет скомпилирован.

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

Не нужно проверять, не потерялась ли лишняя скобка;
Читать такой код удобнее (по " Философии Python " — читаемость имеет значение);
Легче работать со сторонними библиотеками;
Код вашего коллеги будет максимально похож на ваш код.

💁‍♂️ Чтобы понять, насколько это важно, можно представить ситуацию, когда в книге удалить все номера страниц, в результате чего нельзя будет понять, где продолжать чтение. Без использования indent-отступа интерпретатор Python не сможет определить, какой оператор необходимо выполнять следующим, что относится к разным блокам кода. В результате и возникает исключение типа IndentationError .

Отступы в языке Python — это способ указать интерпретатору, что оператор (или целая их группа) — это определенный block-комбинация команд для выполнения задачи.

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

💡 По умолчанию в Python используется 4 пробела в качестве отступа

Однако программист может использовать и другое их количество, но не менее одного.

Что нам говорит PEP8?

Для каждого уровня отступов необходимо использовать по 4 пробела.

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

Примеры кода

👍 Правильное оформление

Расположение закрывающих скобок в конструкциях с многими строками под началом первой строки:

👎 Ошибочное оформление

😐 Выборочное оформление

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

Табуляция или пробелы — что использовать? 🤷‍♂️

Согласно официальной документации, самым предпочтительным способом оформления отступов является использование пробелов, обычно 4

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

В Python 3 версии запрещено оформлять отступы с использованием табуляции и пробелов, только какой-то один способ. Во второй версии интерпретатор пытается преобразовывать табуляцию в пробелы. Так, при вызове интерпретатора в командной строке с использованием параметра -t появляется предупреждение о наличии смешанного стиля оформления отступов. Если же запуск выполнен с параметром -tt, в этих местах кода будут ошибки. Так что рекомендуется использовать вызова интерпретатора именно с этими параметрами.

Настройка IDE для работы с отступами

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

Рассмотрим, как можно настроить или изменить такие параметры в самых популярных IDE, когда возникает такая необходимость.

PyCharm

В случае использования интегрированной среды разработки PyCharm для настройки оформления отступов необходимо последовательно перейти по таким пунктам меню:

File → Settings → Editor → Code style → Python

Для настроек параметров есть 3 поля:

Tab size — количество пробелов при нажатии клавиши Tab;
Indent — количество пробелов для одного отступа;
Continuation indent — количество пробелов для отступа, когда следующая строка продолжает предыдущую.

💭 Еще одна полезная опция — отображение точек вместо каждого пробела, что особо удобно при поддержке чужого кода. В PyCharm для активации этой функции следует перейти File → Settings → Editor → General → Appearance → Show whitespaces , установив галочку напротив соответствующего пункта.

VSCode

Для настройки аналогичных функций в VSCode нужно нажать комбинацию клавиш ctrl + , или перейти по пунктам меню

File → Preferences → Settings

Далее для ускорения в строке поиска ввести tab и установить нужные значения для таких опций:

editor: insert spaces — использовать ли пробелы вместо табуляции;
editor: tab size — желаемое количество пробелов для одного отступа.

Ошибки при работе с отступами

При неправильном оформлении отступов интерпретатор Python будет сообщать об ошибках. Таких ошибок может быть несколько, рассмотрим основные.

expected an indented block

Данная ошибка может возникать в случае, когда после оглашения начала блока кода — def, if, while и некоторых других на следующей строке отсутствует отступ. Для ее исправления после начала блока должна быть хотя бы одна вложенная строка с отступом.

Возникает ошибка в том случае, когда перед началом строки есть отступ, но на предыдущей отсутствует оглашение начала блока кода, то есть, нет def, if, elif, else, for или while. Обычно такая ситуация возникает случайно, когда программист ставит слишком много пробелов в начале строки.

Indentationerror: expected an indented block

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

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

Основы

Одним из самых распространённых типов данных является строковый. Вопреки расхожему мнению, программист чаще сталкивается не с числами, а с текстом. В Python, как известно, всё является объектами. Не исключение и строки – это объекты, состоящие из набора символов. Естественно, в языке существует широкий набор инструментов для работы с этим типом данных.

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

Операторы «+» и «*» в Питоне применимы не только к числам, но и к строкам.

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

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

Оператор «*» дублирует строку указанное количество раз.

Это работает только с целочисленными множителями. Если умножить на ноль или отрицательное число, результатом будет пустая строка. Но лучше так не делать.

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

Если надо проверить, содержится ли подстрока в строке, удобно пользоваться оператором “in”

Так же можно использовать этот оператор с «not» для инвертирования результата.

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

Пайтон содержит ряд удобных встроенных функций для работы со строками.

Функция ord() возвращает числовое значение символа, при чём, как для кодировки ASCII, так и для UNICODE.

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

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

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

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

Строка является упорядоченной последовательностью символов. Другими словами, она состоит из символов, стоящих в определённом порядке. Благодаря этому, к символу можно обратиться по его порядковому номеру. Для этого надо указать номер символа в квадратных скобках. Нумерация начинается с нуля (0 – это первый символ).

Попытка обращения по индексу большему чем длина строки вызовет исключение IndexError:

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

Срезы строк

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

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

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

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

Чтобы это сделать с помощью f-строки необходимо:

Указать f или F перед кавычками строки (что сообщит интерпретатору, что это f-строка).
В любом месте внутри строки вставить имя переменной в фигурных скобках (< >).

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

Тип данных строка в Python относится к неизменяемым (immutable), но это почти не влияет на удобство их использования, ведь можно создать изменённую копию. Для этого есть два возможных пути:

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

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

Поскольку строка в Пайтон – это объект, у него есть свои методы. Методы – это те же самые функции, просто они «закреплены» за объектами определённого класса.

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

Если Вам надо изменить регистр строки, удобно использовать один из следующих методов

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

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

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

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

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

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

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

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

Каждый метод в этой группе поддерживает необязательные аргументы start и end. Они задают диапазон поиска: действие метода ограничено частью целевой строки, начинающейся в позиции символа start и продолжающейся вплоть до позиции символа end, но не включая его. Если start указано, а end нет, метод применяется к части строки от start до конца.

count() подсчитывает количество точных вхождений подстроки в строку.

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

find() ищет в строке заданную подстроку. Возвращает первый индекс который соответствует началу подстроки. Если указанная подстрока не найдена, возвращает -1.

index() ищет в строке заданную подстроку.

Этот метод идентичен find(), за исключением того, что он вызывает исключение ValueError, если подстрока не найдена.

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

Возвращает индекс последнего вхождения подстроки, который соответствует её началу.

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

Этот метод идентичен rfind(), за исключением того, что он вызывает исключение ValueError, если подстрока не найдена.

startswith() определяет, начинается ли строка с заданной подстроки.

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

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

isalnum() возвращает True, если строка не пустая, а все ее символы буквенно-цифровые (либо буква, либо цифра).

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

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

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

isidentifier() вернет True для строки, которая соответствует зарезервированному ключевому слову Пайтон, даже если его нельзя использовать.

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

Если вы действительно хотите убедиться, что строку можно использовать как идентификатор Питон, вы должны проверить, что isidentifier() = True и iskeyword() = False.

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

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

Это единственный метод данной группы, который возвращает True, если строка не содержит символов. Все остальные возвращаются False.

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

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

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

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

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

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

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

Если указан необязательный аргумент fill, он используется как символ заполнения:

Если строка больше или равна указанной ширине, строка возвращается без изменений:

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

ljust() выравнивание по левому краю.

lstrip() удаляет переданные в качестве аргумента символы слева. По умолчанию это пробелы.

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

Необязательный аргумент count, указывает количество замен, которое нужно осуществить:

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

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

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

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

zfill() возвращает копию строки дополненную нулями слева для достижения длины строки указанной в параметре width:

Если строка короче или равна параметру width, строка возвращается без изменений:

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

Методы в данной группе превращают строку в другой тип данных и наоборот. Эти методы возвращают или принимают коллекции (чаще всего это список).

join() возвращает строку, которая является результатом конкатенации элементов коллекции и разделителя.

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

Сложнее ситуация, когда нужны пары ключ-значение. Здесь придётся сперва распаковать кортежи.

partition() делит строку на основе разделителя (действие, обратное join). Возвращаемое значение представляет собой кортеж из трех частей:

Часть строки до разделителя
Разделитель
Часть строки после разделителя

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

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

rsplit() делит строку на список из подстрок. По умолчанию разделителем является пробел.

split() делит строку на список из подстрок.

Ведет себя как rsplit(), за исключением того, что при указании maxsplit – максимального количества разбиений, деление начинается с левого края строки:

Если параметр maxsplit не указан, между rsplit() и split() разницы нет.

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

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

Заключение

В этом уроке мы рассмотрели основные инструменты для работы со строками в Python. Как видите, они удобны и гибки. Есть встроенные функции и методы объекта «строка», строковые литералы. Ещё больше возможностей даёт нерассмотренный в этом уроке метод format и модуль re. Так же отдельного разговора заслуживает работа с кодировками. Следует отметить для тех, кто уже знаком с другими языками программирования: в отличие от некоторых из них, один символ в Пайтоне тоже является строкой. И изюминка напоследок. Поскольку в Питоне всё является объектом, у каждой строки тоже есть атрибуты.

Читайте также: