Python: проверка, является ли переменная числом
В этой статье мы рассмотрим несколько примеров того, как проверить, является ли переменная числом в Python.
Python имеет динамическую типизацию. Нет необходимости объявлять тип переменной во время ее создания — интерпретатор определяет тип во время выполнения:
Кроме того, переменную можно переназначить новому типу в любой момент:
Этот подход, имея преимущества, также знакомит нас с несколькими проблемами. А именно, когда мы получаем переменную, мы обычно не знаем, какого она типа. Если мы ожидаем число, но получаем неопределенный variable , мы захотим проверить, является ли он числом, прежде чем выполнять какие-то действия.
Использование функции type()
В Python функция type() возвращает тип аргумента:
Таким образом, способ проверки типа:
Здесь мы проверяем, является ли тип переменной, введенной пользователем, int или float , продолжая выполнение программы, если это так. В противном случае мы уведомляем пользователя, что он ввел переменную, отличную от Number. Помните, что если вы сравниваете несколько типов, например int или float , вам придется использовать эту type() функцию оба раза.
Если бы мы просто сказали if type(var) == int or float , что вроде бы нормально, возникла бы проблема:
Это, независимо от ввода, возвращает:
Это потому, что Python проверяет значения истинности утверждений. Переменные в Python могут быть оценены как True за исключением False , None , 0 и пустых [] , <> , set() , () , » или «» .
Следовательно, когда мы пишем or float в нашем условии, это эквивалентно записи or True , которая всегда будет возвращать True .
numbers.Number
Хороший способ проверить, является ли переменная числом — это модуль numbers . Вы можете проверить, является ли переменная экземпляром класса Number , с помощью функции isinstance() :
Примечание. Этот подход может неожиданно работать с числовыми типами вне ядра Python. Некоторые фреймворки могут иметь нечисловую реализацию Number , и в этом случае этот подход вернет ложный результат False .
Использование блока try-except
Другой способ проверить, является ли переменная числом — использовать блок try-except. В блоке try мы преобразуем данную переменную в int или float . Успешное выполнение блока try означает, что переменная является числом, то есть либо int , либо float :
Это работает как для int, так и для float, потому что вы можете привести int к float и float к int.
Если вы специально хотите только проверить, является ли переменная одной из них, вам следует использовать функцию type() .
String.isnumeric()
В Python isnumeric() — это встроенный метод, используемый для обработки строк. Методы issnumeric() возвращают «True», если все символы в строке являются числовыми символами. В противном случае он возвращает «False».
Эта функция используется для проверки, содержит ли аргумент все числовые символы, такие как: целые числа, дроби, нижний индекс, верхний индекс, римские цифры и т.д. (Все написано в юникоде)
String.isdigit()
Метод isdigit() возвращает истину, если все символы являются цифрами, в противном случае значение False.
Числа: целые, вещественные, комплексные
Числа в Python 3: целые, вещественные, комплексные. Работа с числами и операции над ними.
Целые числа (int)
Числа в Python 3 ничем не отличаются от обычных чисел. Они поддерживают набор самых обычных математических операций:
| x + y | Сложение |
| x — y | Вычитание |
| x * y | Умножение |
| x / y | Деление |
| x // y | Получение целой части от деления |
| x % y | Остаток от деления |
| -x | Смена знака числа |
| abs(x) | Модуль числа |
| divmod(x, y) | Пара (x // y, x % y) |
| x ** y | Возведение в степень |
| pow(x, y[, z]) | x y по модулю (если модуль задан) |
Также нужно отметить, что целые числа в python 3, в отличие от многих других языков, поддерживают длинную арифметику (однако, это требует больше памяти).
Битовые операции
Над целыми числами также можно производить битовые операции
Дополнительные методы
int.bit_length() — количество бит, необходимых для представления числа в двоичном виде, без учёта знака и лидирующих нулей.
int.to_bytes(length, byteorder, *, signed=False) — возвращает строку байтов, представляющих это число.
classmethod int.from_bytes(bytes, byteorder, *, signed=False) — возвращает число из данной строки байтов.
Системы счисления
Те, у кого в школе была информатика, знают, что числа могут быть представлены не только в десятичной системе счисления. К примеру, в компьютере используется двоичный код, и, к примеру, число 19 в двоичной системе счисления будет выглядеть как 10011. Также иногда нужно переводить числа из одной системы счисления в другую. Python для этого предоставляет несколько функций:
- int([object], [основание системы счисления]) — преобразование к целому числу в десятичной системе счисления. По умолчанию система счисления десятичная, но можно задать любое основание от 2 до 36 включительно.
- bin(x) — преобразование целого числа в двоичную строку.
- hex(х) — преобразование целого числа в шестнадцатеричную строку.
- oct(х) — преобразование целого числа в восьмеричную строку.
Вещественные числа (float)
Вещественные числа поддерживают те же операции, что и целые. Однако (из-за представления чисел в компьютере) вещественные числа неточны, и это может привести к ошибкам:
Для высокой точности используют другие объекты (например Decimal и Fraction)).
Также вещественные числа не поддерживают длинную арифметику:
Простенькие примеры работы с числами:
Дополнительные методы
float.as_integer_ratio() — пара целых чисел, чьё отношение равно этому числу.
float.is_integer() — является ли значение целым числом.
float.hex() — переводит float в hex (шестнадцатеричную систему счисления).
classmethod float.fromhex(s) — float из шестнадцатеричной строки.
Помимо стандартных выражений для работы с числами (а в Python их не так уж и много), в составе Python есть несколько полезных модулей.
Модуль math предоставляет более сложные математические функции.
Модуль random реализует генератор случайных чисел и функции случайного выбора.
Целые числа — int
Python поддерживает десятичные, двоичные, восьмеричные и шестнадцатеричные целые числа, причем не накладывается никаких ограничений на величину (длину) числа, лишь бы хватило памяти для его хранения.
Десятичные целые числа создаются, как обычно, с помощью десятичных цифр:
причем, в десятичной системе счисления ни одно число, кроме нуля не может начинаться с цифры \(0\), что в общем-то и ежу понятно, но это значит что отбрасывания незначащих нулей не происходит, а их наличие приводит к ошибке:
Двоичные числа состоят из префикса 0b (или 0B ) и двоичных цифр: \(0\) и \(1\):
Восьмеричные числа начинаются с префикса 0o ( 0O ) и могут содержать только восьмиричные цифры: \(0\), \(1\), \(2\), \(3\), \(4\), \(5\), \(6\) и \(7\):
Шестнадцатеричные числа начинаются с префикса 0x ( 0X ) и могут содержать как все десятичные цифры, так и символы латинского алфавита: a, b, c, d, e, f (или A, B, C, D, E, F ), которые в данном случае выступают в роли цифр:
В языках со строгой типизацией необходимо указывать как тип числа, так и то, что создаваемый объект сам является числом. Но в Python такой необходимости нет, интерпретатор сам, на основе анализа литералов целых чисел, способен понять что перед ним: число или нет, целое или вещественное, восьмеричное или двоичное.
Кстати, благодаря встроенной функции int() мы можем перевести в десятичную систему счисления, любое число представленное в другой системе счисления с основанием меньшим \(37\). Интересующее число указывается в виде строки в первом аргументе, а система счисления в котором оно представлено в виде целого числа во втором аргументе:
Арифметические операции
Целые числа поддерживают следующие математические операции, которые отсортированы по убыванию приоритета:
| № | Операция | Результат | Замечание |
|---|---|---|---|
| 1 | x ** y | возводит x в степень y | (I) |
| 2 | pow(x, y[, z]) | возводит x в степень y по модулю z, где z – необязательный аргумент | (I) |
| 3 | divmod(x, y) | возвращает кортеж с парой чисел (x // y, x % y) | (II) |
| 4 | x.conjugate() | возвращает \(\bar |
|
| 5 | complex(re, im) | преобразует re в комплексное число (по умолчанию im = 0 ) | (VI) |
| 6 | float(x) | преобразует x в вещественное число (число с плавающей точкой) | (VI) |
| 7 | int(x) | переобразует x в целое число, представленное в десятичной системе счисления | (V)(VI) |
| 8 | abs(x) | абсолютное значение (модуль) числа x | |
| 9 | +x | делает число x положительным | |
| 10 | -x | делает число x отрицательным | |
| 11 | x % y | остаток от деления x на y | (II) |
| 12 | x // y | результат целочисленного деления x на y | (III) (II) |
| 13 | x / y | результат «истинного» деления x на y | (IV) |
| 14 | x * y | произведение x и y | |
| 15 | x — y | разность x и y | |
| 16 | x + y | сумма x и y |
Важно: приоритет математических операций выше побитовых логических операций и операций сравнения.
I. возведение \(0\) в степень \(0\) возвращает \(1\):
Извлечение корней четной степени из отрицательных чисел не вызывает ошибки, а возвращает комплексное число:
II. функция divmod() и операция % , // не работают для комплексных чисел. Для вас это может быть и очевидно, но не пользователя для которого вы пишите программу.
III. если оба числа типа int то и результат будет типа int. Данная операция всегда возвращает целое число, т.е. если число x можно представить в виде d*y + r , то x//y = d (r – остаток от деления). Так же следует иметь ввиду, что результат данной операции всегда округляется в сторону минус бесконечности:
Это немного сбивает с толку, но проверив результат по формуле x = d*y + r , вы убедитесь что все верно.
IV. даже если оба числа типа int, то результат все равно будет преобразован к типу float.
V. встроенная функция int() пропускает числа (объекты) типа int «как есть», не выполняя над ними, абсолютно никаких действий.
VI. строго говоря эти функции не являются математическими, но они могут учавствовать в математических выражениях Python и поэтому должны обладать приоритетом.
Логические побитовые операции
Фактически, если число можно перевести в двоичную систему счисления, значит его можно рассматривать как двоичные данные. Учитывая, что такие данные состоят из нулей и единиц, которые интерпретируются как логические значения True и False, мы можем выполнять над ними логические операции. Логические операции выполняются по отдельным битам соответствующих разрядов. Если в операции учавствуют числа с разным количеством разрядов, то недостающие разряды дополняются нулями слева.
Данные операции могут быть выполнены, только над целыми числами. Если в выражении или в результате операции имеются отрицательные числа, то они представляются в виде дополнительного кода. Например, мы знаем, что результатом логического оператора
(побитовое НЕ) примененного, скажем, к числу 0b111 должно быть число 0b000 , но вместо этого мы видим число дополнительный код которого соответствует данной операции:
В таблице перечислены все побитовые операции в порядке убывания их приоритета:
Важно: приоритет побитовых операций ниже математически, но выше операций сравнения.
I. унарные операции
, + и — имеют одинаковый приоритет.
II. отрицательное значение в выражеиях x << n и x >> n приведет к ошибке и вызовет исключение ValueError.
III. операция x << n эквивалентна команде x*pow(2, n) , но проверка переполнения в этой команде не выполняется:
IV. операция x >> n эквивалентна команде x // pow(2, n) , но проверка переполнения в этой команде не выполняется:
Операции сравнения
Для сравнения чисел, доступно \(8\) операций сравнения, причем все они имеют одинаковый приоритет:
| № | Операция | Результат | Замечание |
|---|---|---|---|
| 1 | x < y | True если x меньше y, иначе False | |
| 2 | x <= y | True если x меньше или равно y, иначе False | |
| 3 | x > n | True если x больше y, иначе False | |
| 4 | x >= n | True если x больше или равно y, иначе False | |
| 5 | x == y | True если x равно y, иначе False | |
| 6 | x != y | True если x не равно y, иначе False | |
| 7 | x is y | True если x и y это один и тот же объект, иначе False | |
| 8 | x is not y | True если x и y это не один и тот же объект, иначе False |
Важно: приоритет операций сравнения ниже математических и побитовых операций.
Наряду с оператором сравнения значений чисел == и != , в Python имеются операторы is и is not , которые позволяют выяснить, являются сравниваемые значения одним и тем же объектом или нет. Например:
Не смотря на то, что значения a и b равны, в памяти компьютера они хранятся как разные объекты:
Однако, придумать для данного оператора сколь-нибудь полезное практическое применение, относительно математических операций я не могу.
В Python сравнение x > y and y > z является эквивалентным x > y > z т.е. сравнения связаные оператором and в произвольные цепочки могут быть записаны в более компактной форме. Выполнение таких выражений начинается слева направо и останавливается как только будет получено первое значение False. Это означает, что если в выражении x > y > z сравнение x > y вернет False то сравнение y > z выполняться не будет.
Методы целых чисел
Целые числа – это объекты, которые обладают следующими методами:
Параметр length задает необходимое количество байтов, а byteorder определяет в каком порядке возвращать байты: значение ‘big’ – от старшего к младшему, ‘little’ – от младшего к старшему. Оба параметра являются обязательными:
Если указанных байтов недостаточно для представления числа, то будет вызвано исключение OverflowError. А что бы узнать и (или) использовать порядок байтов который использует машина, выполняющая код используйте sys.byteorder .
Параметр signed позволяет установить использование дополнительного кода для отрицательных целых чисел:
Если signed = False , а число является отрицательным, то будет вызвано исключение OverflowError.