Какие версии python являются несовместимыми по операциям ввода и вывода

Базовый ввод, вывод и форматирование строки в Python

Базовый ввод, вывод и форматирование строки в Python

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

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

В previous tutorial в этой вводной серии вы:

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

Узнали об итераторах и итераторах, двух концепциях, которые составляют основу определенной итерации в Python

Связали все вместе, чтобы узнать о циклах Python для for

Без лишних слов, давайте окунемся!

Чтение ввода с клавиатуры

Программы часто должны получать данные от пользователя, обычно путем ввода с клавиатуры. Самый простой способ сделать это в Python — с помощью + input () + .

+ Входной сигнал ([<запрос>]) +

_ Читает строку ввода с клавиатуры. _

+ input () + приостанавливает выполнение программы, чтобы позволить пользователю вводить строку ввода с клавиатуры. Когда пользователь нажимает клавишу [.keys] # Enter #, все набранные символы читаются и возвращаются в виде строки:

Обратите внимание, что новая строка, сгенерированная, когда пользователь нажимает клавишу [.keys] # Enter #, не включена в возвращаемую строку.

Если вы включите необязательный аргумент + <prompt> + , + input () + отобразит его как приглашение для пользователя, прежде чем приостановить чтение ввода:

+ input () + всегда возвращает строку. Если вам нужен числовой тип, вам нужно преобразовать строку в соответствующий тип с помощью встроенных функций + int () + , + float () + или + complex () + ):

В приведенном выше примере выражение + n + 100 + в строке 3 недопустимо, поскольку + n + является строкой, а + 100 + является целым числом. Строка 8 преобразует + n + в целое число, поэтому оператор + print () + в строке 10 завершается успешно.

+ raw_input () + в Python 2 считывает ввод с клавиатуры и возвращает его. + raw_input () + в Python 2 ведет себя так же, как + input () + в Python 3, как описано выше.

Но в Python 2 также есть функция с именем + input () + . В Python 2 + input () + читает ввод с клавиатуры, parses и оценивает его как выражение Python, а затем возвращает полученное значение.

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

См. Https://docs.python.org/3/library/functions.html#eval[Python документацию] для получения дополнительной информации о + eval () + и https://en.wikipedia.org/wiki./Eval [Wikipedia + eval + page] для обсуждения потенциальных угроз безопасности.

Запись вывода на консоль

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

Неформатированный консольный вывод

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

_ Отображает строковое представление каждого + <obj> + на консоли. _

По умолчанию + print () + отделяет каждый объект одним пробелом и добавляет новую строку в конец вывода:

Любой тип объекта может быть указан в качестве аргумента + print () + . Если объект не является строкой, то + print () + преобразует его в соответствующее строковое представление, отображающее его:

Как видите, даже сложные типы, такие как списки, словари и функции, могут отображаться на консоли с помощью + print () + .

Ключевое слово Аргументы в + print () +

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

А сейчас вот что вам нужно знать:

Аргументы ключевых слов имеют вид + <ключевое слово> = <значение> + . *Любые ключевые аргументы, передаваемые в + print () + , должны заканчиваться после списка отображаемых объектов.

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

+ Sep = + Аргумент ключевого слова

Добавление ключевого аргумента + sep = <str> + приводит к разделению объектов строкой + <str> + вместо единственного пробела по умолчанию:

Чтобы объединить объекты без пробелов между ними, укажите + sep = » + :

Вы можете указать любую произвольную строку в качестве разделителя с помощью ключевого слова + sep = + .

+ End = + Аргумент ключевого слова

Ключевое слово аргумент + end = <str> + заставляет вывод завершаться символом + <str> + вместо новой строки по умолчанию:

Например, если вы отображаете значения в цикле, вы можете использовать + end = + , чтобы значения отображались в одной строке, а не в отдельных строках:

Любая строка может быть указана как выходной терминатор с ключевым словом + end = + .

Аргументы ключевого слова выходного потока

+ print () + принимает два дополнительных ключевых аргумента, оба из которых влияют на обработку выходного потока:

Эти два ключевых аргумента представлены здесь для полноты картины. Возможно, вам не нужно слишком беспокоиться о выходных потоках на этом этапе. Они обсуждаются позже в этой серии в руководстве по File I/O.

Форматированный строковый вывод

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

Во многих случаях вам потребуется более точный контроль над отображением данных, предназначенных для отображения. Python предоставляет несколько способов форматирования выходных строковых данных. В этом разделе вы узнаете об одном из старых: оператор* string modulo *.

В последних версиях Python появились более новые способы форматирования строковых данных, которые, возможно, превосходят оператор строкового модуля: string + .format () + method и f-strings . Вы узнаете об этом в следующем уроке этой серии. Вы также можете проверить эти статьи:

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

С другой стороны, если вы не знакомы с + printf () + , не беспокойтесь! Следующее должно иметь смысл.

Строковый оператор по модулю

Оператор modulo ( +% + ) обычно используется с числами, и в этом случае он вычисляет остаток от деления:

Для строковых операндов оператор по модулю выполняет совершенно другую функцию: форматирование строки. (Эти две операции не очень похожи друг на друга. Они имеют одинаковое имя, потому что они представлены одним и тем же символом: +% + .)

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

В левой части оператора +% + , + <format_string> + — строка, содержащая один или несколько спецификаторов преобразования. + <Values> + справа вставляется в + <format_string> + вместо спецификаторов преобразования. Результирующая форматированная строка является значением выражения.

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

Помимо представления самой строковой операции по модулю, символ + ‘%’ + также обозначает спецификаторы преобразования в строке формата — в этом случае + ‘% d’ + , + ‘% s’ + и + ‘%. 2f’ + .

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

Первым элементом в кортеже является + 6 + , числовое значение, которое заменяет + ‘% d’ + в строке формата.

Следующим элементом является строковое значение + ‘bananas’ + , которое заменяет + ‘% s’ + .

Последний элемент — это значение с плавающей точкой + 1.74 + , которое заменяет + ‘%. 2f’ + .

В результате получается строка «+6 бананов стоимостью $ 1,74 +», как показано на следующей диаграмме:

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

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

(Опять же, если вы знакомы с функциями, связанными с + printf () + , то это напоминает + sprintf () + . Если нет, то не переживайте.)

Спецификаторы конверсии

Спецификаторы преобразования появляются в + <format_string> + и определяют, как значения форматируются, когда они вставляются.

Спецификатор преобразования начинается с символа +% + и состоит из следующих компонентов:

+% + и + <тип> + обязательны. Остальные компоненты, показанные в квадратных скобках, не являются обязательными.

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

Introduces the conversion specifier

Indicates one or more flags that exert finer control over formatting

Specifies the minimum width of the formatted result

Determines the length and precision of floating point or string output

Indicates the type of conversion to be performed

Читайте дальше, чтобы узнать, как это работает.

Тип конверсии

Тип преобразования + <тип> + является последним компонентом спецификатора преобразования:

Числа в Python

Когда мы хотим представить информацию о количестве деревьев в саду, остатке на банковской карте или же провести какие-либо математические расчеты, мы используем числа. В Python числа представлены сразу несколькими родственными категориями типов. Сюда относятся целые ( int ), вещественные ( float ) и комплексные ( complex ) числа. Если возможностей базовых типов не хватает, всегда можно воспользоваться числовыми расширениями в виде модулей decimal или fractions. Все перечисленные числовые типы довольно легко преобразуются между собой, а математические операции с ними интуитивно понятны и производятся по общепринятым правилам математики.

Целые числа

По умолчанию для записи литералов целых чисел в Python используется десятичная система счисления, однако разрешается записывать их в двоичной, восьмеричной и шестнадца­теричной системах счисления. При этом следует помнить, что вне зависимости от использу­емого формата представления, результат все равно будет отображаться в десятич­ном виде (см. пример №1 ).

Пример №1. Литералы целых чисел в Python.

Как видно из примера №1 , синтаксис записи целых чисел в разрешенных системах счисления должен иметь следующий вид.

• В десятичной системе счисления целые числа записываются в виде привычной нам последовательности цифр от нуля до десяти, например, 0 , -33 , +127 .
• В двоичной системе счисления запись целого числа должна начинаться с нуля и латинской буквы B в верхнем или нижнем регистре (т.е. 0b или 0B ), после чего должна идти последовательность нулей и единиц. Например, 0b01101 , 0B1011 , -0b1001 . Если будут использованы другие цифры, интерпретатор сгенерирует сообщение об ошибке.
• В восьмеричной системе счисления целое число должно начинаться с нуля и латинской буквы O в верхнем или нижнем регистре (т.е. 0o или 0O ), после чего должна идти последовательность цифр от нуля до семи ( 01234567 ). Например, 0o77 , 0O35 , -0O174 . Если будут использованы цифры не входящие в данный диапазон, интерпретатор сгенерирует сообщение об ошибке.
• В шестнадцатеричной системе счисления запись целого числа должна начинаться с нуля и латинской буквы X в верхнем или нижнем регистре (т.е. 0x или 0X ), после чего должны идти символы последовательности 0123456789ABCDEF , представляющих данную систему счисления. При этом буквы также разрешается использовать в любом регистре. Например, 0x7F , 0XDD5A , -0xfF9 . Если будут использованы символы не входящие в данный диапазон, интерпретатор сгенерирует сообщение об ошибке.

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

• bin(int_num) – преобразует целое число в двоичную систему счисления, возвращая строку с представлением литерала числа в этой системе.
• oct(int_num) – преобразует целое число в восьмеричную систему счисления, возвращая строку с представлением литерала числа в этой системе.
• hex(int_num) – преобразует целое число в шестнадцатеричную систему счисления, возвращая строку с представлением литерала числа в этой системе.
• int(obj) – конструктор типа int может использоваться как с одним, так и с двумя аргументами. Когда указан только один аргумент, функция пытается преобразовать объект в целое число в десятичной системе счисления, а в случае невозможности такого преобразования возбуждает соответствующее исключение. При этом, если объект obj является вещественным числом, оно преобразуется в целое путем усечения дробной части, например, int(21.302) вернет 21 .
• int(num_str, base=10) – если указано два аргумента, то первый аргумент должен быть строковым представлением целого числа в системе счисления с указанным основанием base . Разрешается использовать системы счисления с основаниями от 2 до 36 . При этом префикс 0b , 0o или 0x у строкового представления числа можно опускать. Если же точно известно, что в строковом представлении числа присутствует соответствующий префикс, второму аргументу разрешается передавать ноль, т.к. интерпретатор сможет определить систему счисления переводимого числа по указанному префиксу. В случае невозможности преобразования строки в целое число функция возбуждает соответствующее исключение (см. пример №2 ).

Пример №2. Перевод целых чисел между СС.

Итак, функции bin(int_num) , oct(int_num) и hex(int_num) принимают целые числа и возвращают строковые представления этих чисел в соответствующих системах счисления. Если же требуется обратное преобразование в десятичную систему, то следует передавать числа функции int(num_str, base=10) , предварительно приведя число к строке ( num_str = str(num) ) и указав основание системы счисления переводимого числа.

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

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

Пример №3. Пример очень большого целого числа.

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

Таблица №4. Список битовых операций, применимых к целым числам.

Также у типа int имеется несколько дополнительных методов:

• int.bit_length() – метод возвращает количество бит, которое необходимо для представления числа в памяти в двоичном виде, без учета знака и незначащих (лидирующих) нулей;
• int.to_bytes(length, byteorder, *, signed=False) – метод возвращает массив байтов, который соответствует данному числу;
• int.from_bytes(bytes, byteorder, *, signed=False) – метод класса, который возвращает целое число, соответствующее указанному массиву байтов.

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

Вещественные числа

Что касается записи литералов вещественных чисел (по-другому чисел с плавающей точкой), то в Python для них используется привычный нам математический синтаксис: сперва записывается знак числа (плюс можно не указывать), затем последовательность цифр целой части, разделительная точка и последовательность цифр дробной части. Например, 0.33 , .33 , 0.0 , .0 , -123.45 , -.123 . Также допустима запись вещественных чисел в экспоненциальной форме. При этом для представления степени 10 n используется латинская буква E в верхнем или нижнем регистре (т.е. e или E ), следующий за ней необязательный знак плюс или обязательный знак минус, а также сам показатель степени в виде положительного целого числа или нуля (см. пример №5 ).

Пример №5. Литералы вещественных чисел в Python.

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

Пример №6. Точность представления вещественных чисел в Python.

Неточное представление вещественных чисел в Python , впрочем как и в других языках программирования, может иногда приводить к неожиданным результатам (см. пример №7 ). Это связано с тем, что мы в основном привыкли вести расчеты в десятичной системе счисления, а компьютер перед вычислениями преобразует все числа в двоичную систему. Но не все вещественные числа могут быть точно преобразованы из десятичной системы счисления в двоичную, что и приводит к некоторой потере точности при хранении десятичных чисел в памяти компьютера.

Пример №7. Побочные эффекты сложения вещественных чисел в Python.

Как видим, на первый взгляд результат действительно получился неожиданным (не забываем про кнопку «Результат» ). Однако все верно. Ведь в данном случае при переводе десятичных чисел в двоичную систему компьютер не смог перевести их точно, округлив результат так, чтобы получившееся двоичное число поместилось в пределах выделяемого для хранения вещественного числа объема памяти. В результате у нас получилось число несколько меньшее, чем 0.8 . Но, повторимся, это не проблема Python , это проблема математики и невозможности во всех случаях осуществить точный перевод чисел из одной системы счисления в другую.

Не стоит сравнивать вещественные числа, доверяя их точности до последнего знака.

В заключение данного пункта перечислим дополнительные методы типа float .

• float.as_integer_ratio() – метод возвращает кортеж из пары целых чисел, которые представляют собой числитель и знаменатель наименьшей дроби, равной данному вещественному числу. Если вещественное число отрицательное, то первое число в возвращаемом кортеже будет со знаком минус. При этом второе число всегда положительное (см. пример №8 ).
• float.is_integer() – метод возвращает True , если дробная часть вещественного числа равна нулю.
• float.hex() – метод возвращает строковое представление числа с плавающей точкой в шестнадцатеричной системе счисления. При этом следует иметь в виду, что экспонента в таком представлении обозначается буквой p , т.к. буква e представляет собой допустимый символ в 16 -ной системе счисления.
• float.fromhex(float_num_str) – этот метод класса осуществляет преобразование строкового представления вещественного числа float_num_str в шестнадца­теричной системе счисления обратно в вещественное число в десятичной системе счисления.

Пример №8. Дополнительные методы типа float.

Комплексные числа

Комплексные числа в Python представлены типом complex , который хранит два вещественных числа: первое представляет собой действительную часть комплексного числа, а второе – мнимую. Как и принято в математике, действительная и мнимая части литерала комплексного числа объединяются знаком плюс или минус (см. пример №9 ). Однако за мнимой частью в Python следует символ j , как это принято в инженерии (в математике мнимая единица обозначается через i ).

Пример №9. Литералы комплексных чисел в Python.

Как видно из примера, если действительная часть комплексного числа равна 0 , ее можно опустить. Кроме того, отдельные части комплексного числа доступны в виде атрибутов real и imag , а получить сопряженное данному комплексное число можно изменив знак мнимой части при помощи метода complex.conjugate() .

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

Математические операции в Python

Все известные нам со школы математические операции полностью поддерживаются в Python . Перечислим их и рассмотрим примеры.

• x + y – сложение двух чисел.
• x — y – вычитание двух чисел.
• x * y – умножение двух чисел.
• x / y – деление двух чисел. При делении вещественных и целых чисел (даже без остатка) результат всегда является вещественным числом. Если же в делении присутствуют комплексные числа, интерпретатор возвращает комплексный результат (см. пример №10 ).
• x // y – деление с округлением вниз. Например, 1//2 = 0 , -1//2 = -1 , 1//-2 = -1 , -1//-2 = 0 .
• x % y – операция возвращает остаток от деления целых и вещественных чисел. Если оба числа целые, то возвращается целочисленный остаток (тип int ). Например, 5%3 = 2 , -5%3 = 1 (т.к. -5 = 3*(-2) + 1 ), 6%3 = 0 . Если хотя бы одно число вещественное, остаток от деления также возвращается в вещественном виде (тип float ), при чем из-за неточности представления вещественных чисел результат может оказаться неточным. Например, 5.2%3 = 2.2 (все в порядке), -5.2%3 = 0.7999999999999998 (получили неточный результат, хотя ожидали 0.8 , т.к. -5.2 = 3*(-2) + 0.8 ). Что касается комплексных чисел, то для них операция неприменима.
• +x – операция используется в основном для повышения удобочитаемости кода, т.к. по факту она ничего не делает.
• -x – инверсия знака числа отличного от нуля, т.е. изменение плюса на минус или наоборот. Для нуля ничего не происходит.
• x ** y – возведение в степень. Отметим, что 0**0 = 1 .

Пример №10. Базовые математические операции в Python.

Что касается математических выражений, в которых используются сразу несколько операций, то для их группировки предназначены круглые скобки (см. пример №11 ). При этом внутри скобок приоритет отдается сперва возведению в степень ( x**y ), затем равносильно умножению ( x*y ), делению ( x/y ), делению с округлением вниз ( x//y ) и получению остатка от деления ( x%y ); в конце равнозначно выполняются сложение ( x + y ) и вычитание ( x — y ). Более подробно о приоритете операторов в Python (и не только математических) мы поговорим позже.

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

Пример №11. Математические выражения в Python.

Обратите внимание, что при наличии в одном выражении целых и вещественных чисел, интерпретатор при необходимости осуществляет приведение целых чисел к типу float , т.е. к более объемлющему типу (в математике целые числа являются подмножеством вещест­вен­ных, а те в свою очередь принадлежат множеству комплексных чисел).

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

• divmod(x, y) – возвращает кортеж (x//y, x%y) . При этом для комплексных чисел она не предназначена.
• pow(x, y) – возвращает x в степени y (аналог x ** y ).
• abs(x) – возвращает абсолютное значение (модуль) числа x .
• round(x, n) – округляет число до n -го разряда после запятой. Если аргумент n не указан, то число округляется до ближайшего целого.
• max(num_1, num_2, . num_n) – возвращает максимальное из двух и более чисел.
• min(num_1, num_2, . num_n) – возвращает минимальное из двух и более чисел.
• sum(num_1, num_2, . num_n) – возвращает сумму двух и более чисел.
• int(x) – приведение числа к типу int .
• float(x) – приведение числа к типу float .
• complex(re, im=0) – приведение к типу complex . Аргумент im (мнимая часть будущего комплексного числа) можно не передавать, тогда он по умолчанию будет равен нулю.

Пример №12. Встроенные математические функции в Python.

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

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

• x < y – выражение вернет True , если x строго меньше y .
• x > y – выражение вернет True , если x строго больше y .
• x <= y – выражение вернет True , если x меньше или равно y .
• x >= y – выражение вернет True , если x больше или равно y .
• x == y – выражение вернет True , если x равно y (в программировании один знак равно означает присвоить , поэтому для обозначения равенства используются два знака равно).
• x != y – выражение вернет True , если x не равно y .

Использование операторов сравнения показано в примере №13 .

Пример №13. Операторы сравнения чисел в Python.

В дополнение к базовому оператору присваивания = в Python применяется целый ряд комбинированных операторов присваивания, которые объединяют операцию присваивания с другой операцией. В общем случае выражение присваивания с комбини­рованным оператором x op= y можно считать сокращенной записью выражения x = x op y , где вместо op следует подставлять один из арифметических операторов. Например, x += y является сокращенной записью выражения x = x + y , в котором к значению переменной x прибавляется значение переменной y , после чего результат присваивается переменной x . Использование некоторых комбинированных операторов присваивания показано в примере №14 .

Пример №14. Комбинированные операторы присваивания в Python.

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

Модуль math

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

Для начала давайте рассмотрим представленные в модуле math математические константы и функции проверки чисел на принадлежность к ним.

• math.pi – представляет значение числа π с точностью, которая зависит от конкретной платформы. Мы его помним, как число 3.14 .
• math.tau ( чит. тау) – представляет удвоенное значение числа π с точностью, которая зависит от конкретной платформы. Т. о. τ – это отношение радиуса окружности к ее длине. Прибли­зительно оно равно 6.28 .
• math.e – представляет значение числа e с точностью, которая зависит от конкретной платформы. Мы его помним, как число 2.72 .
• math.inf (от англ. infinity) – представляет положительную бесконечность. Отметим, что значение является типом float и может быть получено вызовом конструктора float(‘inf’) . Для получения отрицательной бесконечности следует использовать унарный оператор — (см. пример №15 ). К значению inf в математике приводит, например, операция деления на 0 .
• math.nan (от англ. not a number) – представляет значение не число , которое также является типом float и может быть получено вызовом конструктора float(‘nan’) . К значению nan приводят недопустимые математические операции (например, извлечение корня четной степени из отрицательного числа на множестве вещественных чисел) или выход за допустимый диапазон значений для данной математической функции.
• math.isinf(x) – возвращает True , если x является отрицательной или положительной бесконечностью, или False в противном случае.
• math.isnan(x) – возвращает True , если x является значением nan , или False в противном случае.
• math.isfinite(x) – возвращает False , только если x является nan , inf или -inf . Во всех остальных случаях функция возвращает True .

Пример №15. Математические константы модуля math.

Что касается конкретно функций модуля math , то в нем представлены различные функции теории чисел, степенные, логарифмические, тригонометрические, гиперболические и ряд других функций. Все мы их здесь рассматривать не будем, однако краткое описание некоторых из них приведем в списке ниже. Остальные в случае необходимости всегда можно с легкостью найти в разделе «Numeric and Mathematical Modules» справочника стандартной библиотеки в описании модуля math (или cmath для комплексных чисел). Итак.

• math.ceil(x) – возвращает x , округленное вверх до ближайшего целого (см. пример №16 ).
• math.floor(x) – возвращает x , округленное вниз до ближайшего целого.
• math.trunc(x) – возвращает целую часть x , полностью отсекая дробную.

Пример №16. Функции модуля math (часть 1).

• math.factorial(x) – возвращает факториал неотрицательного целого числа x . Отметим, что факториалы чисел 0 и 1 принимаются равными 1 .
• math.sqrt(x) – возвращает квадратный корень из неотрицательного числа x (см. пример №17 ).
• math.log(x[, base]) – возвращает логарифм числа x по основанию base . Аргумент base можно опустить, тогда функция вернет натуральный логарифм числа x .

Пример №17. Функции модуля math (часть 2).

• math.sin(x) – возвращает синус угла x , значение которого задано в радианах. Отметим, что для косинуса угла функция имеет вид math.cos(x) (см. пример №18 ).
• math.tan(x) – возвращает тангенс угла x , значение которого задано в радианах.
• math.asin(x) – возвращает арксинус числа x . Для аркосинуса нужно использовать функцию math.acos(x) , а для арктангенса – math.atan(x) .
• math.degrees(x) – преобразует угол x из радиан в градусы.
• math.radians(x) – преобразует угол x из градусов в радианы.

Пример №18. Функции модуля math (часть 3).

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

Модуль decimal

Как мы уже знаем, числа типа float имеют весьма ограниченную точность. И хотя во многих случаях это не существенно, бывают ситуации, когда требуется повышенная точность вычислений, пусть даже и в ущерб производительности. В таких случаях нам на помощь приходит модуль decimal , который реализует неизменяемый числовой тип Decimal , представляющий числа с фиксированной точностью (см. пример №19 ).

Пример №19. Создание чисел фиксированной точности.

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

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

Числа типа Decimal обычно используются в определенном контексте, который подразумевает использование установленной точности представления, методики округления (вверх, вниз и т.д.) и некоторых других настроек (см. пример №20 ).

Пример №20. Изменение точности представления чисел Decimal.

Все настройки среды для арифметических операций получаемые при помощи метода decimal.getcontext() доступны для изменения. Кроме того, для установки нового контекста можно использовать метод decimal.setcontext() . С этим и некоторыми другими методами для работы с контекстами вы можете ознакомиться в модуле decimal стандартной библиотеки (см. раздел «Numeric and Mathematical Modules» ).

Отметим, что все арифметические операции, включая комбинированные, применимы и к числам Decimal . Однако модуль math для них неприменим. В тоже время некоторые функции, присутствующие в модуле math , реализованы как методы типа Decimal (см. пример №21 ).

Пример №21. Операции с числами Decimal.

Модуль fractions

Еще одним числовым типом в Python является тип Fraction . Он реализует объекты рациональных чисел, которые явным образом хранят числитель и знаменатель рациональной дроби (см. пример №22 ), что опять же при необходимости помогает избежать недостатков вещественных чисел.

Пример №22. Создание рациональных чисел.

В примере мы создали объекты рациональных чисел, указав в конструкторе Fraction в первом выражении числитель и знаменатель, а во втором передав ему вещественное число и строковое представление вещественного числа. Кроме того, рациональную дробь можно создать и конвертацией типа Decimal . В любом случае после создания объекты рациональных чисел могут участвовать в арифметических операциях, как обычные числа (см. пример №23 ).

Пример №23. Операции с рациональными числами.

Познакомиться с рациональными числами и их методами более подробно вы можете в модуле fractions стандартной библиотеки Python (см. раздел «Numeric and Mathematical Modules» ).

Краткие итоги параграфа

• Числа в Python представлены тремя базовыми типами: целые числа int , числа с плавающей точкой float и комплексные числа complex . Также посредством стандартной библиотеки доступны два расширения в виде чисел с фиксированной точностью Decimal и рациональных чисел Fraction .
• Для записи литералов целых чисел используется десятичная система счисления, однако разрешается записывать их в двоичной (например, 0b101 ), восьмеричной (например, -0o175 ) и шестнадцатеричной (например, 0xF5A ) системах счисления. Для перевода целых чисел из одной системы счисления в другую предназначены встроенные функции bin(int_num) , oct(int_num) , hex(int_num) , int(num_str, base=10) .
• Целые числа поддерживают длинную арифметику и могут быть сколь угодно большими. При этом следует помнить, что при обработке очень больших чисел приходится жертвовать скоростью их обработки.
• Для записи литералов вещественных чисел используется привычный нам математический синтаксис, например, -2.57 , 0.0 , .28 (ноль перед точкой можно опускать). Также допустима запись вещественных чисел в экспоненциальной форме, например, 1.2345e2 (т.е. 1.2345*10 2 ) или -1.2345E-3 (т.е. -1.2345*10 -3 ).
• В обычных условиях точность вещественных чисел ограничивается максимум 17 значащими цифрами. Поэтому не стоит сравнивать их, доверяя точности до последнего знака.
• Комплексные числа в Python хранят два вещественных числа: первое представляет собой действительную часть комплексного числа, а второе – мнимую. Например, -0.4+7j , 2-1.45j или 3.1j (нулевую действительную часть можно опускать).
• В Python поддерживаются все известные нам со школы математические операции: сложение x + y , вычитание x — y , умножение x*y , деление x/y , деление с округлением вниз x//y , получение остатка от деления x%y , возведение в степень x**y . Стоит помнить, что некоторые операции не применимы к комплексным числам.
• В дополнение к базовому оператору присваивания = в Python применяется целый ряд комбинированных операторов присваивания, которые объединяют операцию присваивания с другой операцией. Например, += , -= , *= , /= , //= , %= , **= . Как видим, в общем случае выражение присваивания с комбини­рованным оператором x op= y можно считать сокращенной записью выражения x = x op y , где вместо op следует подставлять один из арифметических операторов.
• Для сравнения чисел используются операторы < , > , <= , >= , == (равно), != (не равно).
• Помимо стандартных арифметических операций имеется и ряд полезных встроенных функций для работы с числами: divmod(x, y) – возвращает кортеж (x//y, x%y) , pow(x, y) – возвращает x в степени y , abs(x) – возвращает модуль числа x , round(x, n) – округляет число до n -го разряда после запятой, max(num_1, num_2, . num_n) , min(num_1, num_2, . num_n) и sum(num_1, num_2, . num_n) – соответственно возвращают максимальное, минимальное и сумму из двух и более чисел.
• Если встроенных функций недостаточно, можно воспользоваться расширением math стандартной библиотеки, которое обеспечивает доступ к широкому кругу математических функций и констант, которые определены стандартом языка C . Для комплексных чисел следует использовать модуль cmath .
• Для случаев, когда требуется повышенная точность вычислений, в Python предусмотрены дополнительные типы числовых объектов: числа с фиксированной точностью Decimal , которые позволяют устанавливать требуемую точность вычислений, способ округления и некоторые другие параметры, а также рациональные числа Fraction , которые явным образом хранят числитель и знаменатель рациональной дроби. Оба модуля доступны в стандартной библиотеке Python в разделе «Numeric and Mathematical Modules» .

Вопросы и задания для самоконтроля

1. Какие из представленых литералов чисел относятся к типу int , а какие к типу float : 3.4 , 0 , 5.0 , 0.0 , 123+4.1j , 795 ? Проверьте типы программно. Показать решение.

Ответ. Тип int : 0 и 795 . Тип float : 3.4 , 5.0 , 0.0 .

2. Определите системы счисления целых чисел 0x1101 , 0b1101 , 0o755 , 0X755 и 755 , записанные в исходном коде программы. Показать решение.

Ответ. Двоичная СС: 0b1101 ; восьмеричная СС: 0o755 ; десятичная СС: 755 , шестнадцатеричная СС: 0x1101 и 0X755 .

3. Какая операция над целыми числами никогда не дает в результате целое число? Показать решение.

Ответ. Результат деления целых чисел всегда имеет тип float , даже при делении без остатка. Например, 15/5 вернет 3.0 , а не 3 .

4. Как можно получить действительную и мнимую части комплексного числа? А как получить число, сопряженное к данному комплексному числу? Показать решение.

Ответ. Отдельные части комплексного числа доступны в виде атрибутов real и imag , а получить сопряженное данному комплексное число можно изменив знак мнимой части при помощи метода complex.conjugate() .

5. Вычислите устно и программно значения выражений 2*(3 + 4) и 2*3 + 4 . Объясните результаты. Показать решение.

Ответ. В Python как и в математике первыми выполняются действия в скобках, поэтому 2*(3 + 4) = 14 . Если скобки отсутствуют, то первыми выполняются операции с более высоким приоритетом. А так как приоритет умножения выше приоритета сложения, то 2*3 + 4 = 10 .

6. Каким будет тип результата вычисления выражения 7 — 3 + 2.0 и почему? Проверьте свой ответ программно. Показать решение.

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

7. Каким будет остаток от деления числа 63 на число 5 ? Проверьте свой ответ программно. Показать решение.

8. Как получить доступ к функциям модуля math ? Показать решение.

Ответ. Нужно импортировать его при помощи инструкции import math .

9. Исправьте в коде пять ошибок (по одной в каждом блоке). Показать решение.

10. Дополнительные упражнения и задачи по теме расположены в разделе «Числа и математические выражения» нашего сборника задач и упражнений по языку программирования Python .

Python Language
Несовместимость, перемещающаяся с Python 2 на Python 3

В отличие от большинства языков, Python поддерживает две основные версии. С 2008 года, когда был выпущен Python 3, многие сделали переход, в то время как многие из них этого не сделали. Чтобы понять оба варианта, в этом разделе рассматриваются важные различия между Python 2 и Python 3.

замечания

В настоящее время существуют две поддерживаемые версии Python: 2.7 (Python 2) и 3.6 (Python 3). Кроме того, версии 3.3 и 3.4 получают обновления безопасности в исходном формате.

Python 2.7 совместим с предыдущими версиями Python и может запускать код Python из версий 1.x и 2.x Python без изменений. Он широко доступен с обширной коллекцией пакетов. Он также считается устаревшим разработчиком CPython и получает только защиту и исправление ошибок. Разработчики CPython намерены отказаться от этой версии языка в 2020 году .

Согласно Python Enhancement Proposal 373 , запланированные будущие выпуски Python 2 после 25 июня 2016 года не будут исправлены, но исправления ошибок и обновления безопасности будут поддерживаться до 2020 года. (В нем не указано, какой точной датой в 2020 году станет дата заката Python 2.)

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

За время между первоначальным выпуском Python 3.0 и текущей версией некоторые функции Python 3 были перенесены в Python 2.6, а другие части Python 3 были расширены, чтобы иметь синтаксис, совместимый с Python 2. Поэтому можно писать Python, который будет работать как на Python 2, так и на Python 3, используя будущие импорты и специальные модули (например, шесть ).

Будущий импорт должен быть в начале вашего модуля:

Для получения дополнительной информации о модуле __future__ см. Соответствующую страницу в документации Python .

Инструмент 2to3 — это программа Python, которая преобразует код Python 2.x в код Python 3.x, см. Также документацию Python .

В пакете 6 предусмотрены утилиты для совместимости с Python 2/3:

• унифицированный доступ к переименованным библиотекам
• переменные для типов string / unicode
• функции для метода, который был удален или был переименован

Ссылка на различия между Python 2 и Python 3 приведена здесь .

Операция печати и функции печати

В Python 2 print — это утверждение:

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

Функция печати имеет следующие параметры:

sep — это то, что отделяет объекты, которые вы передаете, для печати. Например:

end — это то, что следует за завершением инструкции print. Например:

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

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

Эта функция имеет тот же формат, что и Python 3, за исключением того, что ему не хватает параметра flush .

См. PEP 3105 для обоснования.

Строки: байты против Unicode

В Python 2 есть два варианта строки: те из байтов с типом ( str ) и те, что сделаны из текста с типом ( unicode ).

В Python 2 объект типа str всегда является байтовой последовательностью, но обычно используется как для текстовых, так и для двоичных данных.

Строковый литерал интерпретируется как байтовая строка.

Есть два исключения: вы можете явно определить литерал Unicode (text) , префиксного литерала с помощью u :

Кроме того, вы можете указать, что строковые литералы всего модуля должны создавать литералы Unicode (text):

Чтобы проверить, является ли ваша переменная строкой (либо Unicode, либо байтовая строка), вы можете использовать:

В Python 3 тип str — это текстовый тип Unicode.

Кроме того, Python 3 добавил объект bytes , подходящий для двоичных «blobs» или записи в независимые от кодирования файлы. Чтобы создать объект байтов, вы можете префикс b в строковый литерал или вызвать метод encode строки:

Чтобы проверить, является ли значение строкой, используйте:

Также возможно префикс строковых литералов с префиксом u чтобы упростить совместимость между базами данных Python 2 и Python 3. Поскольку в Python 3 все строки по умолчанию Unicode, добавление строкового литерала с u имеет никакого эффекта:

Python 2 в сырце Unicode строки префикс ur не поддерживаются, однако:

Обратите внимание, что вы должны encode объект Python 3 text ( str ), чтобы преобразовать его в представление bytes этого текста. Кодировка по умолчанию этого метода — UTF-8 .

Вы можете использовать decode чтобы задать объект bytes для текста Unicode, который он представляет:

Хотя тип bytes существует как в Python 2, так и в 3, тип unicode существует только в Python 2. Чтобы использовать неявные строки Unicode Python 3 в Python 2, добавьте следующее в начало файла кода:

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

В то время как разрезание в размере одного результата приводит к объекту длиной 1 байт:

Кроме того, Python 3 исправляет некоторые необычные действия с помощью unicode, т. Е. Обратные байтовые строки в Python 2. Например, разрешена следующая проблема :

Целостный отдел

Стандартный символ разделения ( / ) работает по-разному в Python 3 и Python 2 при применении к целым числам.

При делении целого на другое целое число в Python 3 операция деления x / y представляет собой истинное деление (использует метод __truediv__ ) и производит результат с плавающей запятой. Между тем, та же операция в Python 2 представляет собой классическое разделение, которое округляет результат до отрицательной бесконечности (также известный как слово ).

Код	Выход Python 2	Выход Python 3
3 / 2	1	1,5
2 / 3	0	0,6666666666666666
-3 / 2	-2	-1,5

Поведение округления к нулю было устарело в Python 2.2 , но осталось в Python 2.7 для обратной совместимости и было удалено в Python 3.

Примечание. Чтобы получить результат с плавающей точкой в Python 2 (без округления по полу), мы можем указать один из операндов с десятичной точкой. Вышеприведенный пример 2/3 который дает 0 в Python 2, должен использоваться как 2 / 3.0 или 2.0 / 3 или 2.0/3.0 для получения 0.6666666666666666

Код	Выход Python 2	Выход Python 3
3.0 / 2.0	1,5	1,5
2 / 3.0	0,6666666666666666	0,6666666666666666
-3.0 / 2	-1,5	-1,5

Существует также оператор деления пола ( // ), который работает одинаково в обеих версиях: он округляется до ближайшего целого. (хотя float возвращается при использовании с float). В обеих версиях оператор // сопоставляется с __floordiv__ .

Код	Выход Python 2	Выход Python 3
3 // 2	1	1
2 // 3	0	0
-3 // 2	-2	-2
3.0 // 2.0	1,0	1,0
2.0 // 3	0.0	0.0
-3 // 2.0	-2,0	-2,0

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

Хотя ясное и ясное, использование операторских функций для каждого деления может быть утомительным. Частое изменение поведения оператора / часто бывает предпочтительным. Общей практикой является устранение типичного поведения деления путем добавления from __future__ import division в качестве первого оператора в каждом модуле:

Код	Выход Python 2	Выход Python 3
3 / 2	1,5	1,5
2 / 3	0,6666666666666666	0,6666666666666666
-3 / 2	-1,5	-1,5

from __future__ import division гарантирует, что оператор / представляет истинное деление и только внутри модулей, которые содержат импорт __future__ , поэтому нет никаких веских причин не включать его во все новые модули.

Примечание . Некоторые другие языки программирования используют округление до нуля (усечение), а не округление до отрицательной бесконечности, как это делает Python (т.е. на этих языках -3 / 2 == -1 ). Такое поведение может вызвать путаницу при переносе или сравнении кода.

Примечание по операндам float . В качестве альтернативы from __future__ import division можно использовать обычный символ разделения / и гарантировать, что хотя бы один из операндов является float: 3 / 2.0 == 1.5 . Однако это можно считать плохой практикой. Слишком просто написать average = sum(items) / len(items) и забыть использовать один из аргументов для float. Более того, такие случаи могут часто уклоняться от уведомления во время тестирования, например, если вы тестируете массив, содержащий float s, но получаете массив int s в процессе производства. Кроме того, если тот же код используется в Python 3, программы, ожидающие, что 3/2 3 / 2 == 1 будет True, будут работать неправильно.

См. PEP 238 для более подробного обоснования того, почему оператор разделения был изменен в Python 3 и почему следует избегать разделения в старом стиле.

См. Раздел « Простая математика» для получения дополнительной информации о разделении.

Сокращение больше не является встроенным

В Python 2 reduce доступно либо как встроенная функция, либо из пакета functools (начиная с версии 2.6), тогда как в Python 3 reduce доступно только из functools . Однако синтаксис reduce как в Python2, так и в Python3 одинаковый и reduce(function_to_reduce, list_to_reduce) .

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

В Python 2.x это просто:

В Python 3.x пример становится немного сложнее:

Мы также можем использовать from functools import reduce чтобы избежать reduce вызова с помощью имени пространства имен.

Различия между диапазонами и функциями xrange

В Python 2 функция range возвращает список, тогда как xrange создает специальный объект xrange , который является неизменной последовательностью, которая, в отличие от других встроенных типов последовательностей, не поддерживает срез и не имеет ни методов index ни count :

В Python 3 xrange был расширен до последовательности range , что теперь создает объект range . Нет типа xrange :

Кроме того, поскольку Python 3.2, range также поддерживает нарезку, index и count :

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

Поскольку последнее поведение обычно желательно, первое было удалено в Python 3. Если вы все еще хотите иметь список в Python 3, вы можете просто использовать конструктор list() для объекта range :

Совместимость

Чтобы поддерживать совместимость между версиями Python 2.x и Python 3.x, вы можете использовать builtins модуль из future внешнего пакета для достижения как совместимости с переходом, так и обратной совместимости :

range в future библиотеке поддерживает нарезку, index и count во всех версиях Python, как и встроенный метод на Python 3.2+.

Распаковка итераций

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

Примечание . При использовании синтаксиса *variable variable всегда будет списком, даже если исходный тип не был списком. Он может содержать ноль или более элементов в зависимости от количества элементов в исходном списке.

Аналогично, распаковка str :

Пример распаковки date ; _ Используется в этом примере в качестве переменной (холостой мы заинтересованы только в year стоимости):

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

До сих пор мы обсуждали распаковку в заданиях. * и ** были расширены в Python 3.5 . Теперь в одном выражении можно иметь несколько операций распаковки:

Также можно распаковать итерируемый аргумент функции:

Распаковка словаря использует две соседние звезды ** ( PEP 448 ):

Это позволяет как переопределять старые значения, так и объединять словари.

Python 3 удаляет распаковку в функции. Следовательно, в Python 3 не работает следующее

См. PEP 3113 для подробного обоснования.

Поднятие и обработка исключений

Это синтаксис Python 2, обратите внимание на запятые , на raise и except строк:

В Python 3, , синтаксис отбрасывается и заменяется скобкой и в as ключевого слова:

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

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

Исключение, возникающее в инструкции except имеет тип DatabaseError , но исходное исключение помечено как атрибут __cause__ этого исключения. Когда отображается трассировка, исходное исключение также будет отображаться в traceback:

Если вы выбрали except блок без явной цепочки:

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

Чтобы «забыть» ранее заброшенное исключение, используйте raise from None

Теперь трассировка будет просто

Или, чтобы сделать его совместимым с Python 2 и 3, вы можете использовать шесть пакетов следующим образом:

.next () для итераторов, переименованных

В Python 2 итератор может быть пройден с помощью метода, называемого next на самом итераторе:

В Python 3 метод .next был переименован в .__next__ , признав свою «магическую» роль, поэтому вызов .next повысит AttributeError . Правильный способ доступа к этой функциональности как в Python 2, так и в Python 3 — это вызов next функции с итератором в качестве аргумента.

Этот код переносится в разных версиях от версии 2.6 до последних версий.

Сравнение различных типов

Можно сравнить объекты разных типов. Результаты являются произвольными, но непротиворечивыми. Они упорядочены так, что None меньше, чем что-либо еще, числовые типы меньше, чем нечисловые типы, а все остальное упорядочено лексикографически по типу. Таким образом, int меньше, чем str а tuple больше, чем list :

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

Исключение возникает при сравнении разных (нечисловых) типов:

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

Использование str в качестве key функции временно преобразует каждый элемент в строку только для целей сравнения. Затем он видит строковое представление, начиная с [ , ' , < или 0-9 и он может сортировать эти (и все следующие символы).

Вход пользователя

В Python 2 пользовательский ввод принимается с использованием функции raw_input ,

В то время как в Python 3 пользовательский ввод принимается с использованием функции input .

В Python 2 input функция принимает вход и интерпретирует его. Хотя это может быть полезно, оно имеет несколько соображений безопасности и было удалено в Python 3. Для доступа к той же функциональности можно использовать eval(input()) .

Чтобы сохранить сценарий переносимым по двум версиям, вы можете поместить код ниже в верхней части своего сценария Python:

Изменения в словаре

В Python 3 многие из методов словаря отличаются поведением от Python 2, и многие также были удалены: has_key , iter* и view* исчезли. Вместо d.has_key(key) , который давно устарел, теперь нужно использовать key in d .

В Python 2 словарные keys методов, values и items возвращают списки. В Python 3 вместо этого они возвращают объекты вида ; объекты представления не являются итераторами, и они отличаются от них двумя способами, а именно:

• они имеют размер (на них можно использовать функцию len )
• они могут повторяться много раз

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

Python 2.7 поддерживает эти методы с Python 3; они доступны как viewkeys , viewvalues и viewitems . Чтобы преобразовать код Python 2 в код Python 3, соответствующие формы:

• d.keys() , d.values() и d.items() Python 2 должны быть изменены в list(d.keys()) , list(d.values()) и list(d.items())
• d.iterkeys() , d.itervalues() и d.iteritems() должны быть изменены на iter(d.keys()) или даже лучше, iter(d) ; iter(d.values()) и iter(d.items()) соответственно
• и, наконец, методы Python 2.7 вызовы d.viewkeys() , d.viewvalues() и d.viewitems() могут быть заменены на d.keys() , d.values() и d.items() .

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

Код выглядит так, как если бы он работал аналогично в Python 3, но там метод keys возвращает объект вида, а не список, и если словарь изменяет размер при повторении, код Python 3 будет сбой с RuntimeError: dictionary changed size during iteration . Разумеется, решение должно правильно записываться for key in list(d) .

Аналогично, объекты просмотра ведут себя иначе, чем итераторы: нельзя использовать next() для них, и нельзя возобновить итерацию; он вместо этого перезапустится; если код Python 2 передает возвращаемое значение d.iterkeys() , d.itervalues() или d.iteritems() в метод, который ожидает итератор вместо итерабельного , то это должно быть iter(d) , iter(d.values()) или iter(d.items()) в Python 3.

Оператор exec является функцией в Python 3

В Python 2 exec — это оператор со специальным синтаксисом: exec code [in globals[, locals]]. В Python 3 exec теперь есть функция: exec(code, [, globals[, locals]]) , а синтаксис Python 2 поднимет SyntaxError .

Поскольку print была изменена из оператора в функцию, был __future__ импорт __future__ . Тем не менее, нет from __future__ import exec_function , поскольку он не нужен: оператор exec в Python 2 также может использоваться с синтаксисом, который выглядит точно так же, как вызов функции exec в Python 3. Таким образом, вы можете изменить утверждения

и последние формы гарантированно работают одинаково как в Python 2, так и в Python 3.

Ошибка функции hasattr в Python 2

В Python 2, когда свойство hasattr ошибку, hasattr игнорирует это свойство, возвращая False .

Эта ошибка исправлена ​​в Python3. Поэтому, если вы используете Python 2, используйте

или вместо этого использовать getattr

Переименованные модули

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

Старое название	Новое имя
_winreg	WinREG
ConfigParser	ConfigParser
copy_reg	copyreg
Очередь	очередь
SocketServer	SocketServer
_markupbase	markupbase
магнезии	reprlib
test.test_support	test.support
Tkinter	Tkinter
tkFileDialog	tkinter.filedialog
urllib / urllib2	urllib, urllib.parse, urllib.error, urllib.response, urllib.request, urllib.robotparser

Некоторые модули даже были преобразованы из файлов в библиотеки. Возьмите tkinter и urllib сверху в качестве примера.

Совместимость

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

Октальные константы

В Python 2 восьмой литерал можно определить как

Чтобы обеспечить кросс-совместимость, используйте

Все классы являются «классами нового стиля» в Python 3.

В Python 3.x все классы являются классами нового стиля ; при определении нового класса python неявно делает его наследуемым от object . Таким образом, указание object в определении class является полностью необязательным:

Оба этих класса теперь содержат object в своем mro (порядок разрешения метода):

В классах Python 2.x по умолчанию используются классы старого стиля; они не неявно наследуют от object . Это заставляет семантику классов различаться в зависимости от того, если мы явно добавляем object в качестве базового class :

В этом случае, если мы попытаемся напечатать __mro__ of Y , __mro__ аналогичный вывод, как в случае с Python 3.x :

Это происходит потому, что мы явно наследовали Y от объекта при его определении: class Y(object): pass . Для класса X который не наследуется от объекта, атрибут __mro__ не существует, попытка доступа к нему приводит к __mro__ AttributeError .

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

В качестве альтернативы, если переменная __metaclass__ задана для type в глобальной области видимости, все последующие классы в данном модуле являются неявно новыми, не требуя явно наследовать от object :

Удаленные операторы <> и «, синонимичные с! = И repr ()

В Python 2 <> является синонимом для != ; Аналогично, `foo` является синонимом для repr(foo) .

кодирование / декодирование в hex больше недоступно

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

Обратите внимание, что codecs.encode возвращает объект bytes . Чтобы получить объект str просто decode в ASCII:

Функция cmp удалена в Python 3

В Python 3 была удалена встроенная функция cmp вместе со специальным методом __cmp__ .

Функция cmp() следует рассматривать как ушедшую, а специальный метод __cmp__() больше не поддерживается. Используйте __lt__() для сортировки __eq__() с __hash__() и другими богатыми сравнениями по мере необходимости. (Если вам действительно нужна функция cmp() , вы можете использовать выражение (a > b) — (a < b) как эквивалент для cmp(a, b) .)

Более того, все встроенные функции, которые принимают параметр cmp теперь принимают только параметр ключевого key слова.

В functools модуле есть также полезная функция cmp_to_key(func) , которая позволяет конвертировать из cmp функции -style к key -style функции:

Преобразуйте функцию сравнения старого стиля в ключевую функцию. Используется с инструментами, которые принимают ключевые функции (такие как sorted() , min() , max() , heapq.nlargest() , heapq.nsmallest() , itertools.groupby() ). Эта функция в основном используется в качестве инструмента перехода для программ, преобразованных из Python 2, которые поддерживают использование функций сравнения.

Исключенные переменные в понимании списка

Как видно из примера, в Python 2 значение x просочилось: оно замаскировало hello world! и распечатал U , так как это было последним значением x когда цикл закончился.

Тем не менее, в Python 3 x печатает первоначально определенный hello world! , так как локальная переменная из понимания списка не маскирует переменные из окружающей области.

Кроме того, ни одно из выражений генератора (доступно в Python начиная с версии 2.5), а также словарные или установочные представления (которые были переданы Python 2.7 из Python 3) в Python 2.

Обратите внимание, что в обоих Python 2 и Python 3 переменные будут просачиваться в окружающую область при использовании цикла for:

карта()

map() является встроенным, который полезен для применения функции к элементам итерации. В Python 2 map возвращает список. В Python 3 map возвращает объект карты , который является генератором.

В Python 2 вы можете передать None чтобы служить функцией идентификации. Это больше не работает в Python 3.

Более того, при передаче более одного итерабельного аргумента в Python 2, накладки map короче итераций с None (аналогично itertools.izip_longest ). В Python 3 итерация останавливается после кратчайшего повторения.

Примечание . Вместо map рассмотрите использование списков, совместимых с Python 2/3. Замена map(str, [1, 2, 3, 4, 5]) :

filter (), map () и zip () возвращают итераторы вместо последовательностей

В filter Python 2, встроенные функции map и zip возвращают последовательность. map и zip всегда возвращают список, а с filter тип возврата зависит от типа заданного параметра:

В Python 3 filter , map и zip обратный итератор вместо:

Поскольку Python 2 itertools.izip эквивалентен Python 3, zip izip был удален на Python 3.

Абсолютный / относительный импорт

В Python 3 PEP 404 изменяет способ работы импорта с Python 2. Имплицитный относительный импорт больше не разрешен в пакетах и from . import * импорт разрешен только в модульном уровне кода.

Чтобы достичь поведения Python 3 в Python 2:

• функция абсолютного импорта может быть включена с from __future__ import absolute_import
• явный относительный импорт поощряется вместо имплицитного относительного импорта

Для пояснения в Python 2 модуль может импортировать содержимое другого модуля, расположенного в том же каталоге, что и ниже:

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

Точка . позволяет явное объявление местоположения модуля в дереве каталогов.

Подробнее о относительном импорте

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

circle.py , square.py и triangle.py все import util.py в качестве модуля. Как они будут ссылаться на модуль на одном уровне?

. используется для относительного импорта на уровне одного уровня.

Теперь рассмотрим альтернативный макет модуля shapes :

Теперь, как эти 3 класса ссылаются на util.py?

The .. используется для относительного импорта родительского уровня. Добавить еще . s с количеством уровней между родительским и дочерним.

Файловый ввод-вывод

file больше не является встроенным именем в 3.x ( open still works).

Внутренние данные ввода-вывода файлов были перенесены в стандартный библиотечный модуль io , который также является новым домом для StringIO :

Режим файла (text vs binary) теперь определяет тип данных, полученных при чтении файла (и типа, необходимого для записи):

Кодировка для текстовых файлов по умолчанию соответствует тому, что возвращается locale.getpreferredencoding(False) . Чтобы явно указать кодировку, используйте параметр ключевого слова для encoding :

Функция round () для циклического размыкания и возврата

раунд ()

В Python 2, используя round() для числа, равного близкому к двум целым числам, вернется один из самых удаленных от 0. Например:

Однако в Python 3 round() вернет четное целое число (например , округление банкиров ). Например:

Функция round () следует стратегии от половины до четного округления , которая будет округлять половинные числа до ближайшего четного целого числа (например, round(2.5) теперь возвращает 2, а не 3.0).

Согласно ссылке в Википедии , это также известно как беспристрастное округление , округленное округление , округление статистики , голландское округление , гауссово округление или нечетное округление .

Половина и округление — это часть стандарта IEEE 754, а также режим округления по умолчанию в Microsoft .NET.

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

круглый () тип возврата

Функция round() возвращает тип float в Python 2.7

Начиная с Python 3.0, если второй аргумент (число цифр) опущен, он возвращает int .

Верно, ложно и нет

В Python 2, True , False и None есть встроенные константы. Это означает, что можно переназначить их.

Вы не можете сделать это с помощью None с Python 2.4.

В Python 3, True , False и None теперь используются ключевые слова.

Возвращаемое значение при записи в файл-объект

В Python 2 запись непосредственно в дескриптор файла возвращает None :

В Python 3 запись в дескриптор возвращает количество символов, записанных при записи текста, и количество байтов, записанных при написании байтов:

long vs. int

В Python 2 любое целое число, большее, чем C ssize_t , будет преобразовано в long тип данных, обозначенный суффиксом L в литерале. Например, в 32-битной сборке Python:

Однако в Python 3 был удален long тип данных; независимо от того, насколько велика целое число, это будет int .

Класс Boolean Value

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

Ответы на КР по ИКТ. Python 7 и 5 Pyhton 7 и 1

Единственный в мире Музей Смайликов

Самая яркая достопримечательность Крыма
Скачать 44.97 Kb.

Правильный ответ выделен желтым
НЕДЕЛЯ 1
ОПРОС №1.1
Какие версии Python являются несовместимыми по операциям ввода и вывода?

1. Python 2.7 и 3.5
2. Pyhton 2.7и2.1
3. Python 2.6и3.5
4. Python 3.3и3.5

Объяснение правильного ответа. Версии 2х и 3х являются несовместимыми по операторам ввода и вывода в связи с более корректной объектной моделью в 3х

Какими из приведенных ниже способов возможен запуск команд Python?

1. С помощью командной строки
2. С помощью интерактивного графического интерфейсаGUI
3. С помощью интерактивной командной строки

Объяснение правильного ответа. Даже теряюсь

Какие из выражений не являются частью Дзена Pyhon?

1. Явное лучше, чем неявное.
2. Простое лучше, чем сложное.
3. Сложное лучше, чем запутанное.
4. Читаемость не имеет значение.

Объяснение правильного ответа.См перевод importthis

ОПРОС №1.2
Каким образом можно получить 3 степень числа 5

1. 5.pow(3)
2. pow(5,3)
3. pow(3,5)
4. 5**3
5. 3**5
6. 5*5*5

Объяснение правильного ответа.Математические операции Python

Как можно получить остаток от деления 5 на 3?

1. 5//3
2. 5%3
3. 5/3
4. divmod(5,3)
5. 5.divmod(3)

Объяснение правильного ответа.Математические операции Python

Какая из операций не работает в Python

1. a++
2. ++a
3. a+=a
4. a**=a
5. a—

Объяснение правильного ответа.Инкремент и декремент в Pythonотсутствует

Что из приведенного не является логическим выражением:

1. a is b
2. a in b
3. a&&b
4. a==b
5. a>b

Объяснение правильного ответа. && отсутствует в Python, is — оператор тождественности, in – оператор членства.

ОПРОС №1.3
a=’i love python’получить первых 4 символа с помощью срезов

1. a[:4]
2. a[0:4]
3. a[1:4]
4. a[1:5]
5. a[:5]
6. a[0:4:1]

Объяснение правильного ответа. Нумерация в срезах начинается с 0

1. ‘%.4s’%a
2. ‘%4.s’%a
3. ‘%4.r’%a
4. ‘%4s’%a
5. ‘%4r’%a
6. ‘%4f’%a

Объяснение правильного ответа. Форматный ввод и вывод

a=’i love python’ получить первых 4 символа с помощью метода format

1. ‘<:.4>‘.format(a)
2. ‘<:.5>‘.format(a)
3. ‘<:4.>‘.format(a)
4. ‘<:.6>‘.format(a)
5. ‘<:1.4>‘.format(a)
6. ‘<:0.4>‘.format(a)

Объяснение правильного ответа. Форматный ввод и вывод

a=’i love python’ заменить на hate, используя срезы

1. a[1:3]+’hate’+a[6:-1]
2. a[0:2]+’hate’+a[6:]
3. a[0:2]+’hate’+a[6::1]
4. a[1:3]+’hate’+a[6:-1:-1]
5. a[1:4]+’hate’+a[6:-1:1]

Объяснение правильного ответа. Использование срезов

a=’i love python’ заменить на hate, используя методов строк

1. a.replace(‘love’,’hate’)
2. a.lstrip(‘love’,’hate’)
3. a.find(‘love’,’hate’)
4. a.count(‘love’,’hate’)
5. a.replace(‘hate’,’love’)

Создайте кортеж a из одного элемента 5

1. a=(5,)
2. a=(5)
3. a=tuple(5)
4. a=tuple(5,)
5. a=5

Объяснение правильного ответа. Создание и преобразование в кортеж

1. a[::-1]
2. a[0:-1:-1]
3. a[-1:0:-1]
4. a[::1]
5. a[-1:0:]

Объяснение правильного ответа. Срезы

Создайте списка из одного элемента 5

1. a=[5]
2. a=list(5)
3. a=list(int(5))
4. a=[5,]
5. a=list(int(‘5’))

Объяснение правильного ответа. int(5) не перечисляемый тип данных и для одного значения не пройдет, а вот a=list((5,)) будетработать

Дан список от 0 до 10, вывести в обратном порядке

1. a[::-1]
2. a[0:-1:-1]
3. a[-1:0:-1]
4. a[::1]
5. a[-1:0:]

Объяснение правильного ответа. Срезы

Для добавления элемента 4 в конец списка a=[1,2,3] можно использовать:

1. a.append(4)
2. a.extend([4])
3. a+=[4]
4. a.extend(4)
5. a.insert(4,4)

Объяснение правильного ответа. Методы списков

Для удаления элемента 4 в списке a=[1,2,3,4] можно использовать:

1. a.remove(4)
2. a.pop()
3. a.pop(3)
4. del a[3]
5. a.pop(4)

Объяснение правильного ответа. Методы списков

Для генерациисписка от 0 до 5элементов можно использовать:

1. a=list(range(6))
2. a=list(range(5))
3. a=range(5)
4. del a[3]
5. a.pop(5)

Объяснение правильного ответа. Методы списков и создание диапазона range

Создайте словарь a из одного элемента 5 с ключом ‘a’

1. a=<'a':5>
2. a=<5:'a'>
3. a=dict([(‘a’,5)])
4. a=dict([‘a’,5])
5. a=dict([‘a’,’5’])

Объяснение правильного ответа. Словарь можно сформировать или явным образом- описав словарь или использовать список кортежей.

Получите кортеж вида ([‘a’], [5]) из ключа значения словаря a=

1. list(a.keys()),list(a.values())
2. tuple(a.keys()),tuple(a.values())
3. a.keys(),a.values()
4. list(a.values()),list(a.keys())
5. tuple(a.values()),tuple(a.keys())

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

Добавьте в словарь a= <‘a’:5>значение

1. a+=<'b':6>
2. a.append(‘b’,6)
3. a.update(<'b':6>)
4. a.update(‘b’,6)
5. a.append(<'b'>,6)

Объяснение правильного ответа. Добавление элементов в словарь идет при помощи update.

Из словаря a= <‘a’:5,‘b’:6>удалите ‘b’:6

1. del a[‘b’]
2. a.pop(‘b’)
3. a.popitem()
4. a.clear()
5. a.popitem(‘b’)

Объяснение правильного ответа. Удаляет popпо ключу, popitemудаляет произвольное значение.

Для определения группы операторов в Pythonиспользуют:

1. 4 пробела
2. 5 пробелов
3. произвольное количество пробелов
4. табуляцию
5. фигурные скобки

Объяснение правильного ответа. традицией является 4 пробела, но и Pythonчувствителен к каждому пробелу.

if предполагает всегда многострочную запись

1. да
2. нет

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

for предполагает всегда многострочную запись

1. да
2. нет

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

Запись вида a=[i for i in range(11)] дает аналогичный результат с:

1. a=list(range(11))
2. a=tuple(range(11))
3. a=[1 for i in range(11)]
4. правильного ответа нет
5. a=[0,1,2,3,4,5,6,7,8,9,10]

Объяснение правильного ответа. Самый простор генератор массивов делается через range.

Получите массив из трех чисел делящихся без остатка на 3:

1. a=[i for i in range(11) if i%3==0]
2. a=[i for i in range(11) if i//3==0]
3. a=[i for i in range(11) if i/3==0]
4. a=[i for i in range(11) if i%3=0]
5. a=[i for i in range(11) if i//3=0]

Объяснение правильного ответа. Самый простор генератор массивов делается через range.

Получите словарь из из ключа в виде строки и целого значения от 1 до 10:

1. a=
2. a=
3. a=
4. a=
5. a=

Объяснение правильного ответа. Самый простор генератор словарей делается через range.

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

1. for key,val in a.items():print(key,val)
2. for key,val in a.items():print(key,a[key])
3. for key in a.keys():print(key,a[key])
4. for key,val in a.vals():print(key,a[key])
5. for key,val in a.keys():print(key,val)

Объяснение правильного ответа. items дает пару ключ, значение; keys – ключи, vals — значения