Типы данных языка Python
Данные в языке Python делятся на две группы: простые (обозначают единственное значение) и составные (хранят в себе несколько значений). Рассмотрим основные типы данных языка Python.
- Простые типы данных:
- int — целое число.
- float — вещественное (дробное, действительное) число.
- str — строка.
- bool — булевский (логический) тип.
- list — список, изменяемый набор значений, пронумерованных целыми числами, начиная с 0 .
- tuple — кортеж, неизменяемый набор значений, пронумерованных целыми числами, начиная с 0 .
- dict — словарь (ассоциативный массив) — изменяемый набор значений, индексируемый неизменяемыми типами данных (числа, строки, кортежи).
- set — множество — неупорядоченный набор значений без повторений.
Целые числа ( int )
Целые числа могут быть записаны в разных системах счисления. В десятичной форме они записываются как последовательности десятичных цифр. В шестнадцатеричной форме — как последовательности шестнадцатеричных цифр ( 0 … 9 , A … F ), предварённых знаком 0x . Восьмеричные числа — последовательности восьмеричных цифр, начинаются на 0t . Двоичные — начинаются 0b .
Если у операций + , — , * , // , % оба операнда целые, то результат будет целым. Если хотя бы один из операндов вещественный — результат вещественный. Результат операции / всегда вещественный.
Размер целых чисел неограничен. Длина целого числа ограничивается лишь доступной памятью компьютера.
Тип целых чисел в Python называется int . Одновременно, int можно как встроенную функцию, преобразующую свой аргумент в целое число:
Вещественные числа
Вещественные числа в Python моделируют действительные числа в математике. В отличие от целых чисел, вещественные числа имеют ограниченный диапазон и ограниченную точность.
Диапазон от 10 −323 до 10 +308 . Если при расчётах получится меньшее число, то оно представляется как ноль, если большее — произойдёт ошибка переполнения. Точность ограничена ≈15 десятичными знаками после запятой.
Вещественные числа, в отличие от целых, всегда содержат или знак разделителя целой и дробной части (точку, . ), или показатель степени ( e ). Разделителем целой и дробной части является точка, т.к. запятая используется для разделения параметров функции и при построении составных типов данных (массивы, кортежи и т.д.)
Вещественное число может быть записано в показательной форме в виде
которое означает ‹мантисса› ×10 ‹степень› . Примеры:
Класс вещественных чисел в Python называется float , он же — встроенная функция-конструктор, преобразующая свой аргумент к вещественному числу:
Математическая библиотека ( math )
В Python есть библиотека, содержащая основные математические функции, работающие с вещественными числами: тригонометрия, логарифмы и т.д. Называется она math , подключается к программе как
В форме №1 в программе становятся доступными все константы и функции, определённые в библиотеке.
В форме №2 — те, что явно перечислены после ключевого слова import .
В форме №3 — в программе доступен объект math , функции библиотеки доступны как поля и методы этого объекта.
Функции библиотеки можно посмотреть во встроенной документации:
Преобразование между целыми и вещественными числами
Для преобразования, во-первых, можно использовать конструкторы float и int . В библиотеке math есть функции floor , ceil и round . Разобраться с ними самостоятельно.
Функция abs(x)
Функция abs(x) возвращает абсолютное значение числа:
Строки
Строка (класс str ) представляет последовательность печатных знаков. Знаки, которые представляют строки в Python 3, являются символами Юникода, т.е. включают в себя буквы разных алфавитов, цифры, знаки препинания, иероглифы, пиктограммы, математические знаки и эмодзи. В противоположность, в Python 2.7 строки состояли из однобайтовых символов конкретной кодировки (например, кодировки Windows-1251 на Windows в русскоязычной локализации).
Строки занимают промежуточное положение между простыми и составными типами данных. С одной стороны, они хранят несколько значений. А с другой стороны, у этих значений нет собственного типа — операция индексации s[i] возвращает не печатный символ, а строку из одного знака.
Строки — неизменяемый тип данных.
Конструктор строки — функция str , которая для аргумента любого типа построит строку. Если ей передать строку — то вернётся точная копия строки.
Запись строк в программе
Строки записываются в одинарных ‘. ‘ или двойных «. » кавычках. В каких кавычках записывать — это дело принятого стиля программирования. Чаще пишутся одинарные кавычки.
Если строка записана в одинарных кавычках, то внутри можно использовать двойные:
Если в двойных — внутри можно использовать одинарные (апострофы):
Помимо обычных, печатных символов, существуют особые управляющие символы, например, символ перевода строки. Для записи подобных символов используются так называемые escape-последовательности — последовательности знаков, начинающися со знака \ . (Клавиша «\» рядом с Backspace или «Ъ» на клавиатуре, не путать с «/», расположенной между «Ю» и Shift!)
Escape-последовательность значение \\ Собственно, знак \ \n Перевод строки \r Возврат каретки (возврат к началу строчки) \t Знак табуляции (клавиша Tab) \xNN Символ с шестнадцатиричным кодом NN \uNNNN Символ с шестнадцатиричным кодом NNNN \UNNNNNNNN Символ с шестнадцатиричным кодом NNNNNNNN \b Возврат на символ назад при печати \a При печати выдаёт звуковой сигнал \» Двойная кавычка \’ Одинарная кавычка (апостроф) Примеры на \r и \b (нужно запускать в окне консоли, в IDLE не работает):
Другие примеры (работают в IDLE):
Из всех escape-последовательностей чаще всего мы будем пользоваться переводом строки ( \n ), чуть реже табуляцией ( \t ), представлением самого знака \ ( \\ ) и кавычками, чтобы их записывать внутри строк ( \’ , \» ).
Символ перевода строки \n при печати выполняет переход на новую строку.
Одна escape-последовательность представляет 1 символ строки. Например, строка \n\n\n состоит из трёх символов — трёх переводов строки.
Операции, применимые к строке
К строкам применима операция + , выполняющая конкатенацию (склеивание) строк:
Для целых чисел из курса 1 класс известно, что 3×5 = 3+3+3+3+3 (5 раз). В Python это же применимо и к строкам:
Можно использовать сокращённые операторы присваивания:
Строки можно сравнивать при помощи операций отношения, сравнение осуществляется в алфавитном порядке (точнее, по номерам символов в таблице Юникода):
Если одна строка является префиксом другой, то более короткая строка считается меньше.
Для строк есть ещё одна операция отношения — in , проверяет вхождение подстроки
Операция not in противоположна операции in .
К строкам применима встроенная функция len(•) , возвращающая длину строки:
Можно обращаться символу в строке по номеру, используя операцию индексации s[i] , где s — строка, i — индекс или номер символа. Индекс может быть положительным от 0 до len(s)-1 , где len(s) — длина строки (символы строки нумеруются с нуля).
Либо отрицательным от -len(s) до -1 , в этом случае имеется ввиду номер от конца строки. Если индекс отрицательный, например s[-x] , то подразумевается индекс s[len(s)-x] . Т.е. чтобы из отрицательного индекса получить настоящий, нужно его прибавить к длине строки.
Полезные методы строк
Строки, как и другие типы данных Python, являются объектами, и у них есть свои методы. Все методы строк можно получить во встроенной справке:
Некоторые полезные методы:
- s.split() — разбивает строку по пробельным символам,
- s.split(sep) — разбивает строку по указанному разделителю,
- s.join(xs) — объединяет элементы последовательности xs с разделителем s , xs — должна быть последовательностью строк,
- s.startswith(t) , s.endswith(t) — True , если строка s начинается или заканчивается на t ,
- s.find(t) — ищет индекс, начиная с которого подстрока t входит в строку s , -1 , если не найдено.
- s.trim() — удаляет из строки начальные и конечные пробельные символы (пробелы, табуляции, \n , \r ),
- семейство методов, проверяющих содержание — True , когда строка непустая и все символы заданного типа:
- s.isdigit() — все цифры,
- s.isalpha() — все буквы,
- s.isalnum() — все либо буквы, либо цифры,
- s.isspace() — все пробельные символы (пробел, \t , \n , \r ),
- s.ispunct() — все знаки пунктуации и т.д.
Функции chr(n) и ord(n)
Юникод — международный стандарт на кодирование символов. В таблицу Юникода входят символы различных алфавитов, знаки пунктуации, математические символы, управляющие символы ( \n , \t , \r , \b …), смайлики (эмодзи) и так далее.
В таблице Юникода каждому символу сопоставляется его номер, т.н. кодовая точка. Всего в Юникоде возможно 1 114 112 ( 2**20 + 2**16 ), многие из кодовых точек до сих пор не распределены.
Функция chr(n) возвращает символ с кодовой точкой n :
Функция ord(c) возвращает кодовую точку символа c :
UTF-8 — один из способов кодирования символов Юникода в виде последовательности байтов. При данном способе кодирования различным символам Юникода назначаются последовательности длиной от 1 до 4 байтов. Символы, входящие в таблицу ASCII (латинские буквы, десятичные цифры, основные знаки пуктуации) кодируются 1 байтом, греческие и кириллические буквы — двумя, иероглифы и смайлики — 3–4 байтами в зависимости от кода.
Булевский тип ( bool )
Мы о нём уже говорили, когда обсуждали логические выражения, условный оператор и цикл с предусловием ( while ). Конструктор булевского типа — функция bool , принимает любое значение и трактует его как истину или ложь.
Операции с логическим типом and , or , not мы подробно рассматривали ранее.
Функция abs(x) , которая возвращает абсолютное значение числа, как ни странно, применима и для логических значений. Возвращает 1 для истины, 0 для лжи:
Литералы типа bool : True и False .
Списки ( list )
Список — изменяемый контейнер значений, индексируемый целыми числами в диапазоне от 0 до некоторой величины — длины списка.
Литерал списка — элементы списка, перечисленные через запятую в квадратных скобках
Пример:
Это список из 7 значений, которые являются первыми 7 простыми числами.
Конструктор списка — функция list , которая принимает любую итерируемую последовательность и формирует список с этими элементами:
Длину списка можно узнать при помощи встроенной функции len(xs) :
Операции, применимые к списку
Операция индексирования. К элементам списка можно обращаться по номеру, используя квадратные скобки. Нумерация может быть как положительной — от 0 до len(‹список›)−1 , так и отрицательной — от −1 до −len(‹список›) . Положительный индекс позволяет обратиться к элементу, начиная с начала, отрицательный — начиная с конца ( xs[-1] — последний элемент, xs[-len(xs)] — первый элемент). Т.е. тут аналогично со строками:
Но, в отличие от строк, список является изменяемой структурой данных. Обращение к элементу списка может располагаться слева в операторе присваивания:
«Сложение и умножение». Тут тоже похоже на строки: операция + позволяет склеивать два списка:
Операция * , применённая к списку и целому числу, конкатенирует (склеивает) список с собой указанное количество раз:
В примере с ys мы создали список из нулей длины 10. Вообще, это распространённый приём. Если в задаче требуется иметь список чисел заданной длины, заполненный изначально нулями, то просто умножаем список из одного нуля [0] на заданную длину: [0] * n .
К спискам применимы и сокращённые операторы присваивания:
Операция in позволяет узнать, есть ли в списке данное значение:
Полезные методы списков
Самый распространённый метод — xs.append(x) — добавляет элемент в конец списка.
Метод xs.sort() сортирует список на месте. Список можно отсортировать, если к его элементам применимы отношения > , < , >= и т.д., в противном случае получим ошибку.
Список сортируется на месте, т.е. его содержимое изменяется.
Метод xs.count(x) возвращает количество элементов с заданным значением:
Полезные функции, работающие со списками
На самом деле, многие из рассмотренных функций могут работать не только со списками, но и с любыми другими итерируемыми последовательностями, но об этом поговорим позже.
Функция max(xs) возвращает наибольшее значение в списке. Список должен быть не пустым. min(xs) — соответственно, наименьшее значение.
Функция sorted(xs) возвращает новый список со значениями, отсортированными по возрастанию. Исходный список не меняется.
Функция reversed(xs) строит итерируемую последовательность элементов списка в обратном порядке. Чтобы её сделать списком, её нужно передать конструктору list :
Кортежи ( tuple )
Кортеж — неизменяемый контейнер с элементами, нумеруемыми последовательными целыми числами. Используется для группировки нескольких значений в одно.
Конструктор типа — функция tuple , работает аналогично функции list .
Запись кортежей — перечисление элементов через запятую в круглых скобках, иногда снаружи круглые скобки можно опустить:
Чтобы создать кортеж из одного элемента, нужно после него добавить запятую:
Запятая после 1 означает, что это кортеж, а не просто число.
Кортеж можно считать аналогом списка, содержимое которого запрещено изменять:
В программе, как правило, списки используют для представления набора однородных данных (список чисел, список строк, список каких-то объектов) неизвестной длины (длина определяется входными данными), который можно менять. Кортежи используются для представления разнородных данных, они небольшого размера и длина известна программисту на момент написания программы.
Упаковка и распаковка списков и кортежей
Если длина списка или кортежа известна, то его содержимое можно распаковать оператором присваивания. Для этого слева нужно перечислить через запятую столько переменных, сколько элементов в самом контейнере:
Такой приём удобен, если список или кортеж небольшой. Если контейнер справа в операторе присваивания большой, то при помощи распаковки можно выделить несколько значений в начале, в конце, а всё, что между ними — поместить в новый список. Перед переменной, куда будет помещён список, нужно поставить звёздочку:
Переменная со звёздочкой может быть только одна, в эту переменную всегда попадает список, даже если справа находится не список:
Распаковка контейнеров позволяет элегантно обменивать значения двух переменных:
Справа в операторе присваивания строится кортеж (b, a) (скобки тут опущены), который тут же распаковывается.
Возврат нескольких значений из функции
В Python, в отличие от языков типа C++ или Pascal, нет параметров-ссылок, т.е. нет возможности из функции изменить значение переменной, которая передана как параметр:
После вызова other_function переменные a и b будут иметь те же значения, что и до вызова — в a будет лежать число 100 , в b — ссылка на тот же список (хотя содержимое списка может измениться). В Python нет возможности изменить значения переменных из вызванной функции.
Поэтому поступить как в Паскале или C++ — передать параметр по ссылке и изменить его внутри функции, мы не можем.
Единственный способ передать из вызова функции наружу — вернуть значение при помощи return .
Если мы хотим передать из функции несколько значений — нам нужно упаковать их в какой-нибудь контейнер и вернуть контейнер. В качестве такого контейнера чаще всего используют кортеж.
Если в операторе return перечислить через запятую несколько значений, функция вернёт кортеж из этих значений:
Для анализа этих значений можно использовать распаковку
Функция divmod(a, b) выполняет деление с остатком: возвращает частное и остаток.
Срезы строк, списков и кортежей
Ранее мы говорили, что операция индексирования xs[i] позволяет обратиться к одному элементу строки, списка или кортежа. В случае списков, операция индексирования может располагаться в левой части оператора присваивания:
поскольку список является изменяемым типом данных.
Однако, при помощи операции индексирования можно обращаться и целым участкам последовательностей, т.е. списков, строк или кортежей. Это так называемый синтаксис срезов:
- ‹start› — индекс первого элемента среза,
- ‹limit› — индекс граничного элемента среза, т.е. участок от ‹start› до ‹limit› включает в себя ‹start› и не включает в себя ‹limit› . Пользуясь математическими обозначениями, границы можно записать как полуоткрытый интервал [‹start›, ‹limit›) .
- ‹step› — шаг, с которым выбираются элементы.
Каждый из этих компонентов может отсутствовать, в этом случае подразумевается:
- отсутствует ‹start› — подразумевается от начала последовательности,
- отсутствует ‹limit› — до конца последовательности, т.е. до len(xs) ,
- отсутствует ‹step› — шаг равен 1, т.е. элементы перечисляются без пропусков.
Шаг может быть отрицательным — в этом случае элементы перечисляются в обратном порядке. В этом случае ‹start› должен быть больше, чем ‹limit› :
На практике чаще всего используют отрицательный шаг -1 для того, чтобы перевернуть список, кортеж или строку:
Списки являются изменяемой структурой данных, с ними можно использовать присваивания срезам:
А что означает срез xs[:] ? Очевидно, это всё содержимое списка от начала и до конца. Зачем оно нужно? На практике такой срез используется, чтобы получить копию списка.
Дело в том, что список — ссылочный тип данных. Когда мы присваиваем список другой переменной, то у нас копируется только ссылка — обе переменные ссылаются на один и тот же список. Можно сказать, что у одного списка получаются два равноправных псевдонима.
И если теперь поменять значение списка через одну переменную, мы это же изменение увидим через другую:
Переменные xs и ys в примере — два псевдонима для одного объека списка. В этом примере в памяти компьютера находится один список, на который ссылаются переменные xs и ys , можем видеть и менять его содержимое через любую из них.
Во втором примере мы при помощи среза xs[:] создали новый список с тем же содержимым. Т.е. в памяти компьютера образовалось два равных списка, на один ссылается переменная xs , на другой — zs . Через переменную xs мы можем видеть и менять содержимое первого списка, через zs — второго. Изменения обоих списков независимы.
Срез xs[:] может использоваться для изменения содержимого всего списка.
Когда мы присвоили переменной ys новый список, мы просто в неё положили ссылку на новый список. Содержимое списка xs мы не меняли.
Тут мы поменяли содержимое списка, на который ссылаются две переменные xs и ys через переменную ys . Соответственно, т.к. эти переменные — псевдонимы, через xs видно изменение.
Ещё про ссылочные типы данных
В Python все данные — ссылочные. Но для неизменяемых типов ( int , float , str , tuple ) это не важно, т.к. для них копирование ссылки эквивалентно копированию значения.
Для изменяемых типов данных ( list , dict , set ) о том, что данные ссылочные, помнить нужно. Присваивание переменной не создаёт новый список (или словарь, или множество), а просто копирует ссылку на объект, создаёт псевдоним. Изменения, сделанные через один псевдоним, будут видны и через другой. Чтобы создать новый объект и менять его независимо, нужно его явно скопировать. Например, для списка при помощи среза xs[:] .
Частный случай присваивания — присваивания параметрам при вызове функции:
При вызове этой функции содержимое списка будет меняться:
При вызове функции параметру xs была присвоена ссылка на тот же список, что и в переменной ys — а значит, функция изменила чужой список.
Тут мы хитрые, передали в функцию копию списка, функция поменяла содержимое копии, исходный список остался неприкосновенным.
Словари ( dict )
Ранее мы рассматривали последовательности — контейнеры, элементы в которых сопоставлялись последовательным целым числам: от 0 до N−1 или (если ссылаться справа налево) от −1 до −N. К элементам последовательности мы обращаемся по номеру.
Словарь ( dict ) — контейнер, к элементам которого можно обращаться по ключам, например, строкам. Словарь хранит внутри себя пары значений в произвольном порядке. Первый элемент каждой пары называется ключом, второй — значением. Каждому ключу сопоставляется ровно одно значение — ключи повторяться не могут. А значения повторяться могут.
Словарь позволяет находить или изменять значение (второй компонент пары), зная её ключ. Синтаксис тот же, что и при индексации массива:
Т.е. в словаре exam_scores (экзаменационные оценки) с ключом ‘Вася’ мы связали значение 5 , ранее с другим ключом ‘Маша’ было связано значение 4 .
Можно сказать, что ключ — это «имя» для некоторого значения.
Конструктор словаря — функция dict() . Без параметров создаёт пустой словарь, её параметром может быть список пар.
Создать словарь можно, перечислив его содержимое в фигурных скобках. Содержимое записывается как пары ‹ключ› : ‹значение› , перечисленные через запятую. В каждой паре ключ и значения разделяются двоеточием:
Ключами словаря могут служить только неизменяемые значения:
- числа: int , float ,
- строки str ,
- кортежи ( tuple ) из других неизменяемых значений.
Операции со словарями
Обращаться к элементам словаря можно при помощи операции индексации, примеры на которую мы рассмотрели выше:
Объединять значения двух словарей можно при помощи операции | : d1 | d2 , при этом значения из d2 имеют приорирет, т.е. если в обоих словарях есть одинаковые ключи, то значения для них берутся из второго словаря:
Операция del позволяет удалить значение из словаря:
Полезные методы словарей
Метод dict.get() извлекает значение из словаря:
Операция индексации при обращении к несуществующему ключу приводит к ошибке (как и при выходе за границы списка).
Метод get к ошибке не приводит. Если ключа не существует, то возвращается значение по умолчанию default , если default не указан, то подразумевается None :
При помощи метода get можно представлять себе словарь как бесконечный, при этом всем реально не существующим ключам get сопоставляет значение по умолчанию.
Например, если мы посчитываем какие-то значения (например, слова), то можем считать, что для несуществующих слов их количество равно нулю, вызывая words.get(word, 0) .
Пример. Напишем функцию dict_get , имитирующую поведение метода get :
В словаре d_ext заведомо будет нужный ключ, т.к. он получен объединением словаря
с исходным. При этом в операции объединения | исходный словарь указан справа, поэтому если в нём есть искомое значение, то оно перекроет значение default из словаря слева. Если нет, в d_ext останется default для ключа key . Метод items возвращает список (на самом деле, итератор, но о них позже) с парами (‹ключ›, ‹значение›) .
Метод items удобно использовать в цикле for (об этом на следующей лекции).
Метод copy создаёт копию словаря (похож на срез xs[:] для списков).
Множество ( set )
Тип данных «множество» ( set ) хранит неупорядоченный набор значений без повторений. Элементами множества могут быть только неизменяемые типы данных (как и ключи в словаре): числа, строки, кортежи из чисел и строк.
В отличие от списка, данные во множестве неупорядочены — при переборе его содержимого элементы будут просматриваться в произвольном порядке. Т.е. как множество захочет расположить внутри себя элементы, так и расположит, мы на это повлиять никак не можем.
Элементы во множестве не повторяются — если мы попробуем добавить ко множеству элемент, который там присутствует, то множество просто не изменится.
Контструктор и литералы
Конструктор множества — set , может быть вызван без параметров, тогда будет создано пустое множество, может получать на входе некоторый другой контейнер (например, список или строку) — будет построено множество из элементов этого контейнера.
Можно создать множество путём перечисления элементов в фигурных скобках:
В Python фигурные скобки используются в двух ролях: для создания словарей и создания множеств. Разница между ними в том, что при создании словарей указываются ключи:
В переменной xs будет находиться словарь, в переменной ys будет находиться множество. Поскольку мы отличаем создание словаря от создания множества по содержимому фигурных скобок, то пустые фигурные скобки <> могут трактоваться неоднозначно: и как пустой словарь, и как пустое множество.
Поскольку на практике словари используются чаще множеств, разработчики Python решили, что пустые фигурные скобки <> будут представлять пустой словарь. А для создания пустого множества нужно вызывать конструктор set() без параметров.
Основные операции над множествами
Операция in ( not in ) проверяет входит ли (не входит ли) элемент во множество:
Операция | , как и для словарей, строит объединение множеств:
Операция & строит пересечение множеств:
Операция — вычисляет разность множеств:
Для этих операций есть соответствующие сокращёные записи оператора присваивания: |= , &= , -= .
Некоторые методы множеств
Самый основной метод — метод .add(x) , добавляющий элемент во множество:
Метод .remove(x) удаляет элемент из множества. Если его вызвать к отсутствующему элементу, получим ошибку. Для того, чтобы удалить элемент, но при этом не получить ошибку, если он отсутствовал, нужно просто вычесть множество из одного элемента:
Пример применения множеств
Дан список элементов. Составить новый список, в котором отстутсвуют дубликаты, причём порядок не важен. Для этого мы из списка делаем множество, а из него — снова список:
Дан список элементов. Проверить — есть ли в нём дубликаты?
Почему работает эта функция? Потому что если в списке будут дубликаты, то множество, построенное из него, будет содержать меньше элементов, чем в исходном списке.
All about Python Integers(int)
In Python programming language, everything is an object. Even literals are also an object. If everything is an object, then definitely every object will have their own set of methods. Depending upon the type of literals, each literals have their own set of methods. In this short article, we are focusing only on integer object.
Let’s first have look at different operations we can perform on interger:
Methods:
- divmod() :
Returns tuple, where first element is result of division of given two integer and second element is mod of integers.
2. int(): Converts float value and numeric string to integer.
3. float(): Converts given integer value to float.
4. pow(): Returns the value of x to the power of y.
5. round(): Returns round off value of given float.
6. str(): Converts given integer to string.
7. bin(): Returns binary value of given integer.
8. bit_length(): Returns the number of bits required to represent in binary.
9. int.to_bytes(): Converts the integer into given length of bytes
Syntax:
(int_value).to_bytes(length, byteorder, *, signed=False)
where,
int_value: Integer value to be converted into bytes
length : The integer is represented using length bytes. An OverflowError is
raised if the integer is not representable with the given value of length arguement.byteorder: The byteorder argument determines the byte order used to represent the integer. If byteorder is ‘big’, the most significant byte is at the beginning of the byte array. If byteorder is ‘little’, the most significant byte is at the end of the byte array. To request the native byte order of the host system, use ‘sys.byteorder’ as the byte order val
signed: This argument determines whether two’s complement is used to represent the integer. If signed is False and a negative integer is given, an OverflowError is raised.
Examples:
10. int.from_bytes(): Return the integer represented by the given array of bytes.
Syntax:
int.from_bytes(bytes, byteorder, *, signed=False)
where,
bytes: This argument must be a bytes-like object (e.g. bytes or bytearray).
byteorder: The byteorder argument determines the byte order used to represent theinteger. If byteorder is ‘big’, the most significant byte is at the beginning of the byte array. If byteorder is ‘little’, the most significant byte is at the end of the byte array. To request the native byte order of the host system, use `sys.byteorder’ as the byte order value.
signed: This argument indicates whether two’s complement is used to represent the integer.Example:
Here, you must be thinking , we are calling this function using integer object which we need as output. from_bytes() function is a method of integer object, so we can call it using integer object only. You can call function using any integer object like below:
But, it may be bit confusing, following is the best approach of calling this function:
So far, we have seen the different operations we can perform on integer object and total ten methods of integer object. If you want to learn more about python integer type ‘help(int)’ in interpreter.
Числа в 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 int()
The int() method returns an integer object from any number or string.
The syntax of int() method is:
int() Parameters
int() method takes two arguments:
- x — Number or string to be converted to integer object.
The default argument is zero . - base — Base of the number in x.
Can be 0 (code literal) or 2-36.
Return value from int()
int() method returns:
- an integer object from the given number or string treats default base as 10
- (No parameters) returns 0
- (If base given) treats the string in the given base (0, 2, 8, 10, 16)
Example 1: How int() works in Python?
Output
Example 2: How int() works for decimal, octal and hexadecimal?
Output
Example 3: int() for custom objects
Internally, int() method calls an object’s __int__() method.
So, even if an object isn’t a number, you can convert the object into an integer object.
You can do this by overriding __index__() and __int__() methods of the class to return a number.
These two methods should return the same value as older versions of Python uses __int__() , while newer uses __index__() method.