Работа с числами – обязательная составляющая программирования. И хотя роль математики в обучении этой специальности во многом преувеличена, в любом случае необходимо уметь взаимодействовать с числами, понимать, какие они бывают и как гибко управлять ими.
В целом, в Python есть три основных типа чисел – целочисленные, с плавающей точкой и комплексные. В то время, как первые два типа мозг воспринимает органично, в большинстве языков программирования предусмотрены отдельные типы данных для целочисленных значений и чисел с плавающей точкой. Сегодня подробно рассмотрим то, как осуществляется объявление переменной того или иного типа, а также то, какие операции еще могут использоваться с числами.
Типы чисел в Python
Итак, каждый тип чисел в Python кодируется отдельным словом. За целочисленный формат отвечает int(), за числа с плавающей точкой (десятичные дроби, то есть) – float. Отдельно от них стоят комплексные числа, понять которые довольно непросто.
Но начнем с самого простого – с целочисленных значений. Это тип Integer, который в большом количестве языков программирования так и записывается. В Python указывается сокращенное название – int, но принципиальных отличий от других в этом вопросе нет.
Переменная целочисленного типа объявляется таким же образом, как и любая другая. Необходимо написать ее название, а потом с помощью оператора присваивания дать ей значение.
x = 1 # int
Числа с плавающей точкой – это привычные нам десятичные дроби. Они получили такое название, потому что точка (или запятая) может стоять в любом месте. Перед ней может быть 10 чисел, а после нее – 20. Или же перед точкой может быть всего одно число, а вот после нее ряд стремится к бесконечности.
В языке Python разделение типов осуществляется настолько жестко, что иногда появляется необходимость конвертировать тип с плавающей точкой в стандартный целочисленный. Но об этом дальше.
Самый тяжелый для понимания тип – это комплексные числа. Тяжело разобраться в их особенностях потому, что они не являются понятными. Нельзя их аналогов найти в реальном мире. По крайней мере, в осязаемой его части. Тем не менее, они активно используются в целом спектре областей человеческой деятельности.
Запись комплексных чисел осуществляется с использованием буквы j. Как в этом примере.
z = 1j # complex
Int
В качестве переменной этого типа могут использоваться не только натуральные числа, но и отрицательные значения. Длина числа может быть любой. Главное требование – отсутствие десятичных знаков.
x = 1 y = 35656222554887711 z = -3255522 print(type(x)) print(type(y)) print(type(z))
Обратите внимание! Мы использовали функцию type() в качестве аргумента функции print(). С ее помощью мы можем узнать тип переменной для того, чтобы использовать это в условных операторах или для отладки приложения. Здесь мы используем эту функцию для демонстрации того, какой будет вывод.
Собственно, вывод интерпретатора здесь будет следующим.
<class 'int'> <class 'int'> <class 'int'>
Float
Этот тип данных являет собой число с плавающей точкой. Приведем несколько примеров с выводом консоли интерпретатора.
x = 1.10 y = 1.0 z = -35.59 print(type(x)) print(type(y)) print(type(z))
Этот фрагмент кода объявляет три переменные, присваивает им значения чисел с плавающей точкой (включая отрицательные и аналоги целым числам типа 1.0), а потом определяет тип данных этих переменных и выводит в консоль.
Собственно, вывод будет следующим.
<class 'float'> <class 'float'> <class 'float'>
Число экспоненциального формата (то бишь, с e) также относится к этому типу, если в нем указывается степень десятичности.
Комплексные числа
Если говорить просто, то это двухмерные числа. Хотя среднестатистическому начинающему разработчику Python от этого более понятно не становится. Если говорить более понятно, то для обычного числа можно нарисовать прямую, и есть закономерность – справа находятся большие значения. А вот комплексные числа уже требуют плоскости и новых определений того, что является большим или меньшим.
Если выражать в формуле, то комплексное число являет собой такое, которое представлено в виде a + bi, где в качестве i выступает мнимая единица (ее квадрат равен -1).
Работа с комплексными числами в Python осуществляется с использованием буквы j. Приведем пример кода, в котором это реализовано на практике.
x = 3+5j y = 5j z = -5j print(type(x)) print(type(y)) print(type(z))
Если запустить эту программу, то интерпретатор выведет следующие строки.
<class 'complex'> <class 'complex'> <class 'complex'>
Присвоение типа переменной
Работа с числами в Python должна осуществляться исключительно с переменными, которые являются числовыми. То есть, если в переменных строчного типа будет число, то ее нельзя добавить к числу, чтобы получить сумму. Для этого необходимо предварительно перевести такую строку в числовой формат.
Это делается с помощью двух функций. Также мы рассмотрим третью функцию, которая выполняет обратную операцию – переводит число в строку. Это также связано с нашей темой, поскольку это действие, которое мы осуществляем с числами.
Для преобразования одного типа переменных в другой используются специализированные переменные, которые называются конструкторами.
Первая переменная – это int(). Она используется для того, чтобы превратить строку или число с плавающей точкой в целочисленную переменную. Это делается путем непосредственного преобразования для строки или с помощью отсекания дробной части у числа с плавающей точкой.
Приведем пример использования функции int() для разных задач.
x = int(1) # x станет 1
y = int(2.8) # y станет 2
z = int("3") # z станет 3
В первом случае используется обычное целочисленное значение в качестве аргумента. В этом случае функция вернет это же самое целочисленное значение. Такой подход используется для того, чтобы указать конкретный тип переменной и предотвратить ошибочное его присвоение. На практике же, необходимость в этом бывает довольно редко.
Во втором случае мы присвоили функции int() значение 2.8. Видим, что само это число имеет в дробной части цифру 8, которая должна была бы округляться таким образом, чтобы в целочисленной части стало 3. Но на практике мы видим, что станет 2 в этом случае. То есть, округление происходит не по правилам.
И, наконец, в этом примере мы использовали строку ‘3’ для того, чтобы переменная z стала целочисленной.
Важное уточнение: число с плавающей точкой округляется при этом в меньшую сторону. То есть, остается исключительно целое число. Законы округления игнорируются. Результирующее значение всегда будет меньшим, чем изначальное.
Что касается строк, то необходимо соблюдать требование: значение строки должно состоять исключительно из цифр.
Для преобразования строки или целочисленного значения в число с плавающей точкой используется функция float(). Она создает число с плавающей точкой из целочисленного значения типа 34.0. Если строка состоит исключительно из числа с плавающей точкой, эта функция может его конвертировать в соответствующий тип данных.
Приведем пример кода, демонстрирующего разные особенности использования этой функции.
x = float(1) # x станет 1.0
y = float(2.8) # y станет 2.8
z = float("3") # z станет 3.0
w = float("4.2") # w станет 4.2
Видим, что в первой строке число, передаваемое в качестве аргумента функции float(), целочисленное. В этом случае оно превращается в число с плавающей точкой, где в дробной части написан ноль. То есть, 1.0.
С дробными частями и со строками все понятно. Только обратите внимание, что можно использовать как строки с целочисленными значениями в качестве аргументов. В этом случае логика такая же самая. Фактически строка конвертируется в целочисленное значение, а потом конвертируется в дробное.
Отдельно поговорим о функции str(). Хотя она не имеет непосредственного отношения к нашей теме, ее приходится часто использовать для чисел. Например, для создания строки, включающей число, которое получилось в результате вычислений. И хотя в большинстве случаев Python все делает самостоятельно и правильно, иногда приходится вручную задавать тип данных.
Приведем три примера, как разные типы данных конвертируются в строки. Обратите внимание, что функции str() можно также передавать строчные данные.
x = str("s1") # x станет 's1'
y = str(2) # y станет '2'
z = str(3.0) # z станет '3.0'
Операции с числами в Python
Как правило, для работы с числами в Python используются арифметические операторы, которые очень напоминают привычные нам математические знаки.
С числами можно совершать такие действия.
Сложение. Делается так же, как и в математике, без каких-либо особенностей.
>>> 3+2 5
Также можно складывать непосредственно целочисленные переменные.
>>> a = 3 >>> b = 2 >>> a + b 5
Вычитание. Здесь также нет отличий от математики.
>>> 4-2 2 >>> a = 5 >>> b = 7 >>> a - b -2
Умножение. В качестве знака умножения здесь используется звездочка.
>>> 5 * 8 40 >>> a = 4 >>> a *= 10 >>> print(a) 40
Деление. Для совершения этой операции используется слэш.
>>> 9 / 3 3.0 >>> a = 7 >>> b = 4 >>> a / b 1.75
Получение целочисленного значения от деления.
>>> 9 // 3 3 >>> a = 7 >>> b = 4 >>> a // b 1
Получение остатка от деления.
>>> 9 % 5 4 >>> a = 7 >>> b = 4 >>> a % b 3
Возведение в степень. Для этого используется два знака умножения.
>>> 5 ** 4 625 >>> a = 4 >>> b = 3 >>> a ** b 64
Выводы
Мы разобрались, как работать с числами в Python. Оказывается, нет в этом ничего сложного. Надо просто понять, что есть три числовых типа данных: целые числа, числа с плавающей точкой и комплексные числа. Каждый из них имеет свои особенности, которые мы рассмотрели выше.
