Ваше руководство по функции печати Python

Самый простой пример использования Pythonprint() требует всего нескольких нажатий клавиш:

>>>

Вы не передаете никаких аргументов, но вам все равно нужно поставить в конце пустые круглые скобки, которые сообщают Python на самом делеexecute the function, а не просто ссылаются на него по имени.

Это приведет к появлению невидимого символа новой строки, что, в свою очередь, приведет к появлению пустой строки на вашем экране. Вы можете вызыватьprint() несколько раз таким образом, чтобы добавить вертикальное пространство. Это как если бы вы нажимали[.kbd .key-enter]#Enter # на клавиатуре в текстовом редакторе.

Как вы только что видели, вызовprint() без аргументов приводит к появлениюblank line, которое представляет собой строку, состоящую исключительно из символа новой строки. Не путайте это сempty line, которое вообще не содержит никаких символов, даже символа новой строки!

Вы можете использовать литералы Pythonstring для визуализации этих двух:

Первый из них имеет длину одного символа, а второй не имеет содержимого.

Note: Чтобы удалить символ новой строки из строки в Python, используйте его метод.rstrip(), например:

>>>

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

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

Во-первых, вы можете передать строковый литерал непосредственно вprint():

>>>

Это распечатает сообщение дословно на экране.

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

>>>

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

>>>

На самом деле, существует множество способов форматировать сообщения в Python. Я настоятельно рекомендую вам взглянуть наf-strings, представленный в Python 3.6, потому что они предлагают самый лаконичный синтаксис из всех:

>>>

Кроме того, f-строки не позволят вам совершить типичную ошибку, которая забывает вводить конкатенированные операнды. Python является строго типизированным языком, что означает, что он не позволит вам сделать это:

>>>

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

>>>

Если вы сами неhandle such errors, интерпретатор Python сообщит вам о проблеме, показываяtraceback.

Note:str() - это глобальная встроенная функция, которая преобразует объект в его строковое представление.

Вы можете позвонить прямо на любой объект, например, на номер:

>>>

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

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

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

>>>

Однако обратите внимание на константуNone. Несмотря на то, что он используется для обозначения отсутствия значения, он будет отображаться как'None', а не как пустая строка:

>>>

Какprint() знает, как работать со всеми этими разными типами? Ну, короткий ответ, что это не так. Он неявно вызываетstr() за кулисами для преобразования любого объекта в строку. После этого он обрабатывает строки единообразно.

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

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

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

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

Давайте посмотрим на этот пример:

>>>

print() объединил все четыре переданных ему аргумента и вставил между ними один пробел, так что вы не получите сжатое сообщение вроде'My name isjdoeand I am42'.

Обратите внимание, что он также позаботился о правильном приведении типов, неявно вызываяstr() для каждого аргумента перед их объединением. Если вы помните из предыдущего подраздела, наивная конкатенация может легко привести к ошибке из-за несовместимых типов:

>>>

Помимо приема переменного числа позиционных аргументов,print() определяет четыре именованных илиkeyword arguments, которые являются необязательными, поскольку все они имеют значения по умолчанию. Вы можете просмотреть их краткую документацию, вызвавhelp(print) из интерактивного интерпретатора.

Давайте пока сосредоточимся наsep. Это означаетseparator и по умолчанию назначается один пробел (' '). Он определяет значение для объединения элементов.

Это должна быть либо строка, либоNone, но последнее имеет тот же эффект, что и пространство по умолчанию:

>>>

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

>>>

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

>>>

Более полезный пример параметраsep - это напечатать что-то вроде путей к файлам:

>>>

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

>>>

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

Note: Будьте осторожны при объединении элементов списка или кортежа.

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

>>>

Безопаснее просто распаковать последовательность с помощью оператора звезды (*) и позволитьprint() обрабатывать приведение типа:

>>>

Распаковка фактически аналогична вызовуprint() с отдельными элементами списка.

Еще одним интересным примером может быть экспорт данных в форматcomma-separated values (CSV):

>>>

Это не будет правильно обрабатывать крайние случаи, такие как экранирование запятыми, но для простых случаев использования это должно сработать. Строка выше будет отображаться в окне вашего терминала. Чтобы сохранить его в файл, вам нужно перенаправить вывод. Позже в этом разделе вы увидите, как использоватьprint() для записи текста в файлы прямо из Python.

Наконец, параметрsep не ограничен только одним символом. Вы можете объединять элементы со строками любой длины:

>>>

В следующих подразделах вы изучите оставшиеся ключевые аргументы функцииprint().

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

Многие языки программирования предоставляют функции, подобныеprint(), через свои стандартные библиотеки, но они позволяют вам решить, добавлять ли новую строку или нет. Например, в Java и C # у вас есть две разные функции, в то время как другие языки требуют, чтобы вы явно добавляли в конец строкового литерала.

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

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

С точки зрения семантики параметрend почти идентичен параметруsep, который вы видели ранее:

Теперь вы понимаете, что происходит под капотом, когда вы вызываетеprint() без аргументов. Поскольку вы не предоставляете никакие позиционные аргументы для функции, присоединять нечего, и поэтому разделитель по умолчанию вообще не используется. Однако значение по умолчаниюend по-прежнему применяется, и отображается пустая строка.

Note: Вам может быть интересно, почему параметрend имеет фиксированное значение по умолчанию, а не то, что имеет смысл в вашей операционной системе.

Что ж, вам не нужно беспокоиться о представлении новой строки в разных операционных системах при печати, потому чтоprint() выполнит преобразование автоматически. Просто не забывайте всегда использовать escape-последовательность в строковых литералах.

В настоящее время это наиболее переносимый способ печати символа новой строки в Python:

>>>

Например, если бы вы попытались принудительно напечатать характерный для Windows символ новой строки на компьютере с Linux, вы бы получили неработающий вывод:

>>>

С другой стороны, когда вы открываете файл для чтения с помощьюopen(), вам также не нужно заботиться о представлении новой строки. Функция преобразует любые системные символы новой строки, с которыми она сталкивается, в универсальный' '. В то же время у вас есть контроль над тем, как переводить строки на ввод и вывод, если вам это действительно нужно.

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

Несмотря на то, что это два отдельных вызоваprint(), которые могут выполняться длительное время друг от друга, в конечном итоге вы увидите только одну строку. Во-первых, это будет выглядеть так:

Однако после второго вызоваprint() на экране появится такая же строка, как:

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

Эти три инструкции выведут одну строку текста:

Вы можете смешать два ключевых аргумента:

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

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

Было бы распечатать следующий фрагмент текста:

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

Note: Цикл по строкам в текстовом файле сохраняет их собственные символы новой строки, что в сочетании с поведением по умолчанию функцииprint() приведет к избыточному символу новой строки:

>>>

Есть две новые строки после каждой строки текста. Вы хотите удалить один из них, как показано ранее в этой статье, перед печатью строки:

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

>>>

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

Вы знакомитесь с печатью на Python, но впереди еще много полезной информации. В следующем подразделе вы узнаете, как перехватить и перенаправить вывод функцииprint().

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

print() - это абстракция над этими уровнями, предоставляющая удобный интерфейс, который просто делегирует фактическую печать потоку илиfile-like object. Потоком может быть любой файл на вашем диске, сетевой сокет или, возможно, буфер в памяти.

В дополнение к этому, есть три стандартных потока, предоставляемых операционной системой:

В Python вы можете получить доступ ко всем стандартным потокам через встроенный модульsys:

>>>

Как видите, эти предопределенные значения напоминают файловые объекты с атрибутамиmode иencoding, а также методы.read() и.write() среди многих других.

По умолчаниюprint() привязан кsys.stdout через свой аргументfile, но вы можете это изменить. Используйте этот аргумент ключевого слова, чтобы указать файл, который был открыт в режиме записи или добавления, чтобы сообщения направлялись прямо к нему:

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

Для получения дополнительной информации оworking with files in Python, вы можете проверитьReading and Writing Files in Python (Guide).

Note: Не пытайтесь использоватьprint() для записи двоичных данных, поскольку он подходит только для текста.

Просто вызовите.write() двоичного файла напрямую:

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

>>>

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

>>>

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

Обратите внимание, чтоprint() не контролируетcharacter encoding. Ответственность за правильное кодирование полученных строк Юникода в байты лежит на потоке. В большинстве случаев вы не будете устанавливать кодировку самостоятельно, потому что вы хотите использовать UTF-8 по умолчанию. Если вам действительно нужно, например, для устаревших систем, вы можете использовать аргументencoding дляopen():

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

>>>

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

В предыдущем подразделе вы узнали, чтоprint() делегирует печать файловому объекту, напримерsys.stdout. Однако некоторые потоки буферизуют определенные операции ввода-вывода для повышения производительности, что может помешать. Давайте посмотрим на пример.

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

Ваша первая попытка может выглядеть примерно так:

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

Неожиданно, вместо обратного отсчета каждую секунду, программа бездействует в течение трех секунд, а затем внезапно печатает всю строку сразу:

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

Unbuffered не требует пояснений, то есть буферизация не выполняется, и все записи имеют немедленный эффект. Потокline-buffered ожидает перед запуском любых вызовов ввода-вывода, пока где-то в буфере не появится разрыв строки, тогда как потокblock-buffered просто позволяет буферу заполниться до определенного размера независимо от его содержимого. Стандартный вывод - этоline-buffered иblock-buffered, в зависимости от того, какое событие наступит первым.

Буферизация помогает сократить количество дорогих вызовов ввода / вывода. Например, подумайте об отправке сообщений по сети с высокой задержкой. Когда вы подключаетесь к удаленному серверу для выполнения команд по протоколу SSH, каждое нажатие клавиши может фактически генерировать отдельный пакет данных, который на порядки больше его полезной нагрузки. Какие накладные расходы! Имеет смысл подождать, пока наберется хотя бы несколько символов, а затем отправить их вместе. Вот где начинается буферизация.

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

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

Поздравляем! На этом этапе вы видели примеры вызоваprint(), охватывающие все его параметры. Вы знаете их цель и когда их использовать. Однако понимание подписи - это только начало. В следующих разделах вы увидите, почему.

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

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

>>>

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

Если вы сейчас создадите экземпляр классаPerson и попытаетесь его распечатать, вы получите этот странный результат, который сильно отличается от эквивалентногоnamedtuple:

>>>

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

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

Note: В Python 3 операторpass можно заменить литераломellipsis (...) для обозначения заполнителя:

Это предотвращает повышение интерпретаторомIndentationError из-за отсутствия блока кода с отступом.

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

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

Note: Вслед за другими языками и фреймворками Python 3.7 представилdata classes, которые можно рассматривать как изменяемые кортежи. Таким образом, вы получаете лучшее из обоих миров:

>>>

Синтаксис дляvariable annotations, который требуется для указания полей класса с соответствующими типами, был определен в Python 3.6.

Из предыдущих подразделов вы уже знаете, чтоprint() неявно вызывает встроенную функциюstr() для преобразования своих позиционных аргументов в строки. Действительно, вызовstr() вручную для экземпляра обычного классаPerson дает тот же результат, что и его печать:

>>>

str(), в свою очередь, ищет один из двухmagic methods в теле класса, который вы обычно реализуете. Если он не находит, то возвращается к уродливому представлению по умолчанию. Эти магические методы в порядке поиска:

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

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

>>>

Обратите внимание на использование другой встроенной функции,repr(), которая всегда пытается вызвать.__repr__() в объекте, но возвращается к представлению по умолчанию, если не находит этот метод.

Note: Несмотря на то, чтоprint() сам используетstr() для приведения типов, некоторые составные типы данных делегируют этот вызовrepr() своим членам. Это случается со списками и кортежами, например.

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

Если вы напечатаете единственный объект классаUser, то вы не увидите пароль, потому чтоprint(user) вызоветstr(user), который в конечном итоге вызоветuser.__str__():

>>>

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

>>>

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

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

Вы видели, чтоprint() - это функция в Python 3. В частности, это встроенная функция, которая означает, что вам не нужно импортировать ее из любого места:

>>>

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

>>>

Таким образом, вы можете избежать конфликтов имен с помощью пользовательских функций. Допустим, вы хотелиredefineprint(), чтобы он не добавлял завершающую новую строку. В то же время вы хотели переименовать исходную функцию во что-то вродеprintln():

>>>

Теперь у вас есть две отдельные функции печати, как в языке программирования Java. Вы также определите пользовательские функцииprint() вmocking section позже. Также обратите внимание, что вы не смогли бы перезаписатьprint(), если бы это не была функция.

С другой стороны,print() не является функцией в математическом смысле, потому что она не возвращает никакого значимого значения, кроме неявногоNone:

>>>

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

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

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

Еще одно преимущество функцииprint() - этоcomposability. Функции в Python называютсяfirst-class objects илиfirst-class citizens, что является причудливым способом обозначить, что они являются значениями, такими же, как строки или числа. Таким образом, вы можете назначить функцию переменной, передать ее другой функции или даже вернуть одну из другой. print() в этом отношении не отличается. Например, вы можете воспользоваться этим для внедрения зависимости:

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

Note: Adependency - это любой фрагмент кода, требуемый другим битом кода.

Dependency injection - это метод, используемый в разработке кода, чтобы сделать его более тестируемым, многоразовым и открытым для расширения. Вы можете достичь этого, косвенно ссылаясь на зависимости через абстрактные интерфейсы и предоставляя их в видеpush, а неpull.

Есть забавное объяснение инъекций зависимости, циркулирующих в Интернете:

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

>>>

Эта пользовательская функция используетpartial functions для достижения желаемого эффекта. Это продвинутая концепция, заимствованная из парадигмыfunctional programming, поэтому вам не нужно сейчас слишком углубляться в эту тему. Однако, если вам интересна эта тема, я рекомендую взглянуть на модульfunctools.

В отличие от утверждений, функции являются значениями. Это означает, что вы можете смешивать их сexpressions, в частности, сlambda expressions. Вместо определения полномасштабной функции для заменыprint(), вы можете создать анонимное лямбда-выражение, которое ее вызывает:

>>>

Однако, поскольку лямбда-выражение определено на месте, нет ссылки на него в другом месте кода.

Note:. В Python нельзя помещать такие операторы, как присваивания, условные операторы, циклы и т. д., вanonymous lambda function. Это должно быть одно выражение!

Другим видом выражения является троичное условное выражение:

>>>

В Python есть какconditional statements, так иconditional expressions. Последнее оценивается как одно значение, которое может быть присвоено переменной или передано функции. В приведенном выше примере вас интересует побочный эффект, а не значение, которое оценивается какNone, поэтому вы просто игнорируете его.

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

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

Это синтаксическая ошибка в Python 2.

Вот еще несколько примеров утверждений в Python:

Note: Python 3.8 приносит спорнуюwalrus operator (:=), которая являетсяassignment expression. С его помощью вы можете вычислить выражение и назначить результат переменной одновременно, даже внутри другого выражения!

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

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

Спор за этот новый синтаксис вызвал много споров. Обилие негативных комментариев и жарких споров в конечном итоге привело к тому, что Гвидо ван Россум ушел с должностиBenevolent Dictator For Life или BDFL.

Утверждения обычно состоят из зарезервированных ключевых слов, таких какif,for илиprint, которые имеют фиксированное значение в языке. Вы не можете использовать их для именования ваших переменных или других символов. Вот почему переопределение или имитация оператораprint в Python 2 невозможны. Вы застряли с тем, что вы получаете.

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

>>>

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

>>>

В другое время они меняют способ печати сообщения:

>>>

Конкатенация строк может привести к увеличениюTypeError из-за несовместимых типов, с которыми вам придется работать вручную, например:

>>>

Сравните это с аналогичным кодом в Python 3, который использует распаковку последовательности:

>>>

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

>>>

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

Список проблем можно продолжать и продолжать. Если вам интересно, вы можете вернуться кprevious section и поискать более подробные объяснения синтаксиса в Python 2.

Однако вы можете смягчить некоторые из этих проблем с помощью гораздо более простого подхода. Оказывается, функцияprint() была перенесена, чтобы упростить переход на Python 3. Вы можете импортировать его из специального модуля__future__, который предоставляет набор языковых функций, выпущенных в более поздних версиях Python.

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

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

>>>

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

Чтобы включить функциюprint() в Python 2, вам необходимо добавить этот оператор импорта в начало исходного кода:

С этого момента операторprint больше не доступен, но в вашем распоряжении есть функцияprint(). Обратите внимание, что это не та же функция, что и в Python 3, потому что в ней отсутствует аргумент ключевого словаflush, но остальные аргументы такие же.

Кроме того, он не избавляет вас от правильного управления кодировкой символов.

Вот пример вызова функцииprint() в Python 2:

>>>

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

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

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

Python поставляется с модулемpprint в своей стандартной библиотеке, который поможет вам красиво печатать большие структуры данных, которые не помещаются в одну строку. Поскольку он печатает более удобным для человека способом, многие популярные инструментыREPL, включаяJupyterLab and IPython, используют его по умолчанию вместо обычной функцииprint().

Note: Чтобы переключить красивую печать в IPython, введите следующую команду:

>>>

Это примерMagic в IPython. Существует множество встроенных команд, которые начинаются со знака процента (%), но вы можете найти больше оPyPI или даже создать свои собственные.

Если вас не волнует, что у вас нет доступа к исходной функцииprint(), вы можете заменить ее наpprint() в своем коде, используя переименование импорта:

>>>

Лично мне нравится иметь обе функции под рукой, поэтому я предпочитаю использовать что-то вродеpp в качестве короткого псевдонима:

На первый взгляд, между этими двумя функциями почти нет различий, а в некоторых случаях их практически нет:

>>>

Это потому, чтоpprint() вызываетrepr() вместо обычногоstr() для приведения типов, так что вы можете оценить его вывод как код Python, если хотите. Различия становятся очевидными, когда вы начинаете кормить его более сложными структурами данных:

>>>

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

>>>

Обычныйprint() также использует эллипсы, но для отображения рекурсивных структур данных, которые образуют цикл, чтобы избежать ошибки переполнения стека:

>>>

Однакоpprint() более четко описывает это, включая уникальную идентификацию объекта, ссылающегося на себя:

>>>

Последний элемент в списке - это тот же объект, что и весь список.

Note: Рекурсивные или очень большие наборы данных можно также обрабатывать с помощью модуляreprlib:

>>>

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

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

Словари часто представляютJSON data, что широко используется в Интернете. Чтобы правильно преобразовать словарь в допустимую строку в формате JSON, вы можете воспользоваться модулемjson. У этого также есть симпатичные возможности печати:

>>>

Заметьте, однако, что вам нужно справиться с печатью самостоятельно, потому что это не то, что вы обычно хотите делать. Точно так же в модулеpprint есть дополнительная функцияpformat(), которая возвращает строку на случай, если вам нужно было сделать что-то, кроме ее печати.

Удивительно, но сигнатураpprint() не похожа на сигнатуру функцииprint(). Вы даже не можете передать более одного позиционного аргумента, который показывает, насколько он фокусируется на печати структур данных.

По мере того как персональные компьютеры становились все более изощренными, они имели улучшенную графику и могли отображать больше цветов. Однако у разных поставщиков было свое представление о разработке API для управления им. Ситуация изменилась несколько десятилетий назад, когда люди из Американского национального института стандартов решили унифицировать это, определивANSI escape codes.

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

Чтобы проверить, понимает ли ваш терминал подмножество escape-последовательностей ANSI, например, связанных с цветами, вы можете попробовать использовать следующую команду:

Мой терминал по умолчанию в Linux говорит, что он может отображать 256 разных цветов, в то время как xterm дает мне только 8. Команда выдаст отрицательное число, если цвета не поддерживаются.

Экранирующие последовательности ANSI подобны языку разметки для терминала. В HTML вы работаете с тегами, такими как<b> или<i>, чтобы изменить внешний вид элементов в документе. Эти теги смешиваются с вашим контентом, но сами по себе они не видны. Точно так же коды выхода не будут отображаться в терминале, пока он их распознает. В противном случае они будут отображаться в буквальном виде, как если бы вы просматривали источник веб-сайта.

Как следует из названия, последовательность должна начинаться с непечатаемого символа[.kbd .key-escape]#Esc #, значение ASCII которого равно 27, иногда обозначается как0x1b в шестнадцатеричном виде или033 в восьмеричном. Вы можете использовать числовые литералы Python, чтобы быстро убедиться, что это действительно одно и то же число:

>>>

Кроме того, вы можете получить его с помощью escape-последовательности\e в оболочке:

Наиболее распространенные escape-последовательности ANSI имеют следующую форму:

numeric code может быть одним или несколькими числами, разделенными точкой с запятой, аcharacter code - всего одной буквой. Их конкретное значение определяется стандартом ANSI. Например, чтобы сбросить все форматирование, вы должны ввести одну из следующих команд, в которых используется нулевой код и букваm:

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

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

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

>>>

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

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

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

Note: Чтобы использовать библиотекуcurses в Windows, вам необходимо установить сторонний пакет:

Это потому, чтоcurses недоступен в стандартной библиотеке дистрибутива Python для Windows.

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

Как насчет создания ретро игры змеи? Давайте создадим симулятор Python Snake:

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

Обратите внимание: функция должна принимать ссылку на объект экрана, также известный какstdscr, который вы будете использовать позже для дополнительной настройки.

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

На этот раз экран на секунду стал совершенно пустым, но курсор все еще мигал. Чтобы скрыть это, просто вызовите одну из функций конфигурации, определенных в модуле:

Давайте определим змею как список точек в координатах экрана:

Голова змеи всегда является первым элементом в списке, а хвост - последним. Начальная форма змеи - горизонтальная, начиная с верхнего левого угла экрана и направляясь вправо. В то время как его координата y остается в нуле, его координата x уменьшается от головы до хвоста.

Чтобы нарисовать змею, вы начнете с головы, а затем продолжите с остальными сегментами. Каждый сегмент содержит координаты(y, x), поэтому вы можете их распаковать:

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

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

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

Чтобы получить новые координаты головы, вам нужно добавить к ней вектор направления. Однако добавление кортежей в Python приводит к большему кортежу вместо алгебраической суммы соответствующих компонент вектора. Один из способов исправить это - использовать встроенные функцииzip(),sum() иmap().

Направление будет изменяться при нажатии клавиши, поэтому вам нужно вызвать.getch(), чтобы получить код нажатой клавиши. Однако, если нажатая клавиша не соответствует клавишам со стрелками, определенным ранее как клавиши словаря, направление не изменится:

Однако по умолчанию.getch() - это блокирующий вызов, который не позволяет змее двигаться, если не было нажатия клавиши. Следовательно, вам нужно сделать вызов неблокирующим, добавив еще одну конфигурацию:

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

Наконец, это все, что вам нужно для игры в змею в Python:

Это просто царапина на поверхности возможностей, которые открывает модульcurses. Вы можете использовать его для разработки игр, таких как это или более бизнес-ориентированные приложения.

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

Чтобы оживить текст в терминале, вы должны иметь возможность свободно перемещать курсор. Вы можете сделать это с помощью одного из инструментов, упомянутых ранее, то есть управляющих кодов ANSI или библиотекиcurses. Тем не менее, я хотел бы показать вам еще более простой способ.

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

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

Давайте посмотрим на несколько примеров.

Вы часто хотите отображать какие-тоspinning wheel, чтобы указать на незавершенную работу, не зная точно, сколько времени осталось до завершения:

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

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

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

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

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

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

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

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

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

Обычно это печатает текст, но флаг-e позволяет интерпретировать экранирование обратной косой черты. Как видите, есть специальная escape-последовательность, что означает «предупреждение», которая выводит специальныйbell character. Некоторые терминалы издают звук всякий раз, когда видят его.

Точно так же вы можете напечатать этот символ в Python. Возможно, в цикле, чтобы сформировать какую-то мелодию. Хотя это только одна нота, вы все равно можете варьировать продолжительность пауз между последовательными экземплярами. Это похоже на идеальную игрушку для воспроизведения азбуки Морзе!

Правила следующие:

Согласно этим правилам, вы можете «печатать» сигнал SOS бесконечно следующим образом:

В Python вы можете реализовать его всего за десять строк кода:

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

Также известная какprint debugging илиcaveman debugging, это самая простая форма отладки. Хотя он немного старомодный, он все же мощный и имеет свое применение.

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

Посмотрите на этот пример, который проявляет ошибку округления:

>>>

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

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

С другой стороны, как только вы овладеете более продвинутыми техниками, вам будет сложно вернуться назад, потому что они позволяют вам находить ошибки гораздо быстрее. Отслеживание - это трудоемкий ручной процесс, который может допустить еще больше ошибок. Цикл сборки и развертывания занимает время. После этого вам нужно не забыть тщательно удалить все сделанные вами вызовыprint(), не касаясь случайно подлинных.

Кроме того, он требует от вас внесения изменений в код, что не всегда возможно. Возможно, вы отлаживаете приложение, работающее на удаленном веб-сервере, или хотите диагностировать проблему методомpost-mortem. Иногда у вас просто нет доступа к стандартному выводу.

Именно здесь сияетlogging.

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

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

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

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

Вот разбивка типичной записи журнала:

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

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

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

Как правило, неправильно настроенное ведение журнала может привести к нехватке места на диске сервера. Чтобы предотвратить это, вы можете настроитьlog rotation, который будет хранить файлы журнала в течение определенного периода времени, например, одной недели или после того, как они достигнут определенного размера. Тем не менее, всегда полезно архивировать старые журналы. Некоторые нормативные акты предписывают хранить данные клиентов в течение пяти лет!

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

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

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

Note: В Python есть несколько связанный модульwarnings, который также может записывать сообщения в стандартный поток ошибок. Однако у него более узкий спектр приложений, в основном это библиотечный код, тогда как клиентские приложения должны использовать модульlogging.

Тем не менее, вы можете заставить их работать вместе, вызвавlogging.captureWarnings(True).

Последняя причина переключиться с функцииprint() на ведение журнала - безопасность потоков. В следующем разделе вы увидите, что первый не очень хорошо работает с несколькими потоками исполнения.

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

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

Однако у него нет графического интерфейса, поэтомуusing pdb может быть немного сложным. Если вы не можете редактировать код, вы должны запустить его как модуль и передать местоположение вашего скрипта:

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

>>>

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

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

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

Начиная с Python 3.7, вы также можете вызвать встроенную функциюbreakpoint(), которая делает то же самое, но более компактным способом и с некоторыми дополнительнымиbells and whistles:

Вы, вероятно, по большей части будете использовать визуальный отладчик, интегрированный с редактором кода. PyCharm имеет отличный отладчик, который может похвастаться высокой производительностью, но вы найдетеplenty of alternative IDEs с отладчиками, как платными, так и бесплатными.

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

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

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

>>>

Функция всегда возвращает строку, поэтому вам, возможно, потребуется проанализировать ее соответствующим образом:

Параметр prompt не является обязательным, поэтому вы ничего не увидите, если пропустить его, но функция все равно будет работать:

>>>

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

Note: Для чтения из стандартного ввода в Python 2 вы должны вместо этого вызватьraw_input(), который является еще одной встроенной функцией. К сожалению, существует функцияinput() с ошибочным названием, которая делает несколько иное.

Фактически, он также принимает входные данные из стандартного потока, но затем пытается оценить его, как если бы это был код Python. Поскольку это потенциальныйsecurity vulnerability, эта функция была полностью удалена из Python 3, аraw_input() был переименован вinput().

Вот быстрое сравнение доступных функций и того, что они делают:

Как вы можете сказать, все еще возможно моделировать старое поведение в Python 3.

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

>>>

В модулеgetpass есть еще одна функция для получения имени пользователя из переменной окружения:

>>>

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

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

Демонстрация таких инструментов выходит за рамки этой статьи, но вы можете попробовать их. Я лично узнал о некоторых из них черезPython Bytes Podcast. Вот они:

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

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

На первый взгляд, когда вы запускаете его, это выглядит как типичное приглашение:

Но как только вы совершите ошибку и захотите ее исправить, вы увидите, что ни одна из функциональных клавиш не работает должным образом. Например, нажатие стрелки[.kbd .key-arrow-left]#Left # приводит к следующему результату вместо перемещения курсора назад:

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

Разве это не здорово?