Что такое плавающая точка в python

Числа, строки и другие типы данных в Python

Из этого руководства вы узнаете о базовых встроенных типах данных Python: числовых, строковых и логических (булевых).

Целые числа

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

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

Следующие строки могут быть добавлены к значению числа, чтобы обозначить основание отличное от 10:

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

Базовый тип целого числа в Python, вне зависимости от используемого основания, называется int :

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

Многие примеры будут использовать эту особенность интерпретатора.
Но это не работает с файлами скриптов. Значение в строке файла со скриптом не делает ничего само по себе.

Числа с плавающей точкой

Тип float в Python означает число с плавающей точкой. Значения float определяются с десятичной точкой. По желанию можно добавить символ e или E после целого числа, чтобы обозначить, что это экспоненциальная запись.

Подробнее: представление float

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

Почти все платформы представляют числа с плавающей точкой Python как 64-битные значения двойной точности в соответствии со стандартом IEEE 754. В таком случае максимальное значение числа с плавающей точкой — это приблизительно 1.8 х 10308. Числа больше Python будет помечать в виде строки inf :

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

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

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

Строки

Строковые литералы могут выделяться одинарными или двойными кавычками. Все символы между открывающей и закрывающей кавычкой являются частью строки:

Строка может включать сколько угодно символов. Единственное ограничение — ресурсы памяти устройства. Строка может быть и пустой.

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

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

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

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

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

Управляющие последовательности (исключенные последовательности)

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

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

Посмотрим, как это работает.

Подавление значения специальных символов

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

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

То же работает и со строками, определенными двойными кавычками:

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

Обычно символ новой строки ( newline ) заменяет enter. Поэтому он в середине строки заставит Python думать, что она неполная:

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

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

Добавление специального значения символам

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

В Python (и большинстве других распространенных языков) символ табуляции определяется управляющей последовательностью \t :

Она заставляет символ \t терять свое привычное значение и интерпретируется как символ табуляции.

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

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

«Сырые» строки

Строки в тройных кавычка

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

Таким же образом удобно создавать строки, разбитые на несколько строк кода:

Наконец, этот способ используется для создания комментариев кода Python.

Булев тип, Булев контекст и «истинность»

В Python 3 три типа Булевых данных. Объекты булевого типа принимают одно из двух значений, True или False :

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

«Истинность» объекта типа Boolean самоочевидна: объекты равные True являются истинными, а те, что равны False — ложными. Но не-Булевы объекты также могут быть оценены в Булевом контексте.

Источник

О точности float в Python

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

Здравый смысл подсказывает нам, что здесь что-то не так, должно же равняться! Новичков это вообще может вбить в ступор. Программисты поопытнее могут объяснить это ошибками округления float-чисел. Давайте же разберемся, что на самом деле там происходит.

Экспоненциальное представление чисел

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

Плавающая точка

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

Число = ±мантисса * основание экпонента

Меняя экспоненту можно двигать положение точки в любую сторону. Например, если основание было бы 10, то числа 1,2345678; 1 234 567,8; 0,000012345678; 12 345 678 000 000 000 отличались бы только экспонентой.

float в Python

float – встроенные тип в Python (CPython) и представляет собой число с плавающей точкой двойной точности, независимо от системы и версии.

float в Python – это double из C, C++, C# или Java и имеет 64 бита (8 байт) для хранения данных о числе.

Примечание: сторонними библиотеками можно получить и другие типы, а еще есть Decimal.

В эти 64 бита упакованы как 11 бит на экспоненту и 52 бита на мантиссу (+ 1 бит на знак, итого 53). Вот так:

Здесь про 0.6, но смысл тот же.

Источник ошибок

Откуда же берутся ошибки?

Дело в том, что числа 0.1 – нет! Действительно, нет способа представить это немудреное число в формате с плавающей точкой с основанием 2!

0.1 – это просто текст, для которого Python должен подобрать максимально близкое представление в памяти компьютера. Можно найти число поменьше или побольше, но точно 0.1 – не получится. Все дело в основании 2 – именно двойка фигурирует под степенью. Надо подобрать такие J и N, чтобы получить число максимально близкое к 0.1:

При этом в J должно быть ровно 53 бита. Наиболее подходящие N для такого случая равняется 56.

Оно чуть больше, чем реальное 0.1. Если бы мы не прибавили единицу, то получилось бы число чуть меньшее, чем 0.1, но никакое сочетание J и N не даст нам ровно 0.1 ни в едином случае!

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

Теперь понятно, что 0.1 и 0.3 аппроксимируются к каким-то ближайшим представлениям в экспоненциальной форме в памяти компьютера. Поэтому и возникает эта разница:

Она мала, но она есть! Именно поэтому никогда не советуют точно сравнивать числа типа float, даже если для вас они равны, их представления могут отличаться, если числа получены разным путем. Могут отличаться, а могут и совпадать! Так что это может сыграть злую шутку.

Там есть функция, которая делает более аккуратное сложение IEEE-754 чисел, но она тоже работает не идеально. На примере из документации – отлично и проваливается на нашем пресловутом триплете из 0.1:

Поверьте, это не единственная особенность такого представления чисел. Я обязательно расскажу больше. Будьте на связи!

Специально для канала @pyway. Подписывайтесь на мой канал в Телеграм @pyway 👈

Источник

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

Другой отличительной чертой является необязательное наличие символа » e » – экспоненты:

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

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

Арифметические операции

Целые числа поддерживают следующие математические операции, которые отсортированы по убыванию приоритета:

Важно: приоритет математических операций выше побитовых логических операций и операций сравнения.

I. возведение \(0\) в степень \(0\) возвращает \(1\):

Извлечение корней четной степени из отрицательных чисел не вызывает ошибки, а возвращает комплексное число:

Использование в выражении x ** y слишком больших значений x и y типа float может привести к ошибке OverflowError.

IV. встроенная функция int() отбрасывает дробную часть вещественных чисел:

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

Операции сравнения

Для сравнения чисел, доступно \(8\) операций сравнения, причем все они имеют одинаковый приоритет:

Важно: приоритет операций сравнения ниже математических и побитовых операций.

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

В Python сравнение x > y and y > z является эквивалентным x > y > z т.е. сравнения связаные оператором and в произвольные цепочки могут быть записаны в более компактной форме. Выполнение таких выражений начинается слева направо и останавливается как только будет получено первое значение False. Это означает, что если в выражении x > y > z сравнение x > y вернет False то сравнение y > z выполняться не будет.

Методы вещественных чисел

Вещественные числа – это объекты, которые обладают следующими методами:

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

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

Показатель степени ‘p’ exponent является степенью двойки, например, перевод числа ‘0x2.f1ap+3’ из шестнадцатеричной системы счисления в десятичную будет выглядеть следующим образом:

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

Источник

Работа с числами в Python

В этом материале рассмотрим работу с числами в Python. Установите последнюю версию этого языка программирования и используйте IDE для работы с кодом, например, Visual Studio Code.

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

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

Целые и числа с плавающей точкой в Python

Создание int и float чисел

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

Здесь также не стоит использовать кавычки.

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

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

Значение выведем с помощью функции print :

Арифметические операции над целыми и числами с плавающей точкой

Сложение

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

Теперь запустим такой код.

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

Вычитание

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

Умножение

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

Деление

Деление без остатка

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

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

Остаток от деления

На этих примерах видно, как это работает.

Возведение в степень

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

Комплексные числа — это числа, которые включают мнимую часть. Python поддерживает их «из коробки». Их можно запросто создавать и использовать. Пример:

Источник

Числа в Python

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

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

В этом руководстве вы научитесь:

Целые числа и числа с плавающей запятой

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

Целые числа

Вы можете создать целое число, набрав желаемое число. Например, следующее присваивает переменной num целое число 25:

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

int(«25») не является целочисленным литералом, потому что целое значение создается из строки.

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

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

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

Числа с плавающей запятой

Как и целые числа, числа с плавающей запятой можно создавать из литералов с плавающей запятой(floating-point literals) или путем преобразования строки в число с плавающей запятой с помощью функции float() :

Есть три способа представить литерал с плавающей запятой. Каждое из следующих действий создает литерал с плавающей запятой со значением один миллион:

Первые два способа аналогичны двум методам создания целочисленных литералов. Третий подход использует нотацию E для создания литерала с плавающей запятой.

Чтобы написать литерал с плавающей запятой в нотации E, введите число, за которым следует буква e, а затем другое число. Python берет число слева от e и умножает его на 10, возведенное в степень числа после e. Итак, 1e6 эквивалентно 1 × 10⁶.

Python также использует нотацию E для отображения больших чисел с плавающей запятой:

В отличие от целых чисел, числа с плавающей запятой имеют максимальный размер. Максимальное число с плавающей запятой зависит от вашей системы, но что-то вроде 2e400 должно выходить за рамки возможностей большинства машин. 2e400 составляет 2 × 10⁴⁰⁰, что намного больше, чем общее количество атомов во Вселенной!

Когда вы достигнете максимального числа с плавающей запятой, Python вернет специальное значение с плавающей запятой, inf :

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

Проверьте свое понимание

Два способа записать целые числа

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

Способ решения

Сначала присвойте num1 значение 25000000 без подчеркивания:

Затем в новой строке присвойте значение 25_000_000 переменной num2 :

Выведите обе переменные в отдельные строки, передав каждую переменную в отдельные вызовы print() :

На выходе вы можете видеть, что оба числа одинаковы:

Хотя обеим переменным присвоено значение 25000000, запись значения с использованием подчеркивания для группировки цифр значительно упрощает человеку быстрое определение числа. Больше не надо щуриться в экран и считать нули!

Когда вы будете готовы, можете переходить к следующему разделу.

Арифметические операторы и выражения

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

Сложение

Сложение выполняется с помощью оператора +:

Два числа по обе стороны от оператора + называются операндами. В приведенном выше примере оба операнда являются целыми числами, но не обязательно, чтобы операнды были одного типа.

Вы можете без проблем добавить int к float :

Вычитание

Оператор – также используется для обозначения отрицательных чисел:

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

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

Умножение

Чтобы умножить два числа, используйте оператор *:

Деление

Оператор / используется для деления двух чисел:

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

Имейте в виду, что int() отбрасывает любую дробную часть числа:

Целочисленное деление

Если написание int(5.0 / 2) кажется вам немного утомительным, Python предоставляет второй оператор деления, называемый оператором целочисленного деления (//), также известный как оператор деления операндов:

Оператор // сначала делит число слева на число справа, а затем округляет до целого числа. Это может не дать ожидаемого значения, если одно из чисел отрицательное.

Давайте посмотрим, что произойдет, когда вы попытаетесь разделить число на 0:

Степень

Вы можете возвести число в степень с помощью оператора **:

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

Вы также можете возвести числа в отрицательную степень:

Оператор модуля

Оператор % или модуль возвращает остаток от деления левого операнда на правый операнд:

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

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

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

Арифметические выражения

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

Вот несколько примеров арифметических выражений:

Правила вычисления выражений такие же, как и в повседневной арифметике. В школе вы, вероятно, выучили эти правила под названием «порядок операций».

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

Если используются операторы с разными приоритетами, рассмотрите возможность добавления пробелов вокруг операторов с самым низким приоритетом(-ами). Используйте свое собственное суждение; однако никогда не используйте более одного пробела и всегда используйте одинаковое количество пробелов с обеих сторон бинарного оператора.

Заставьте Python лгать вам

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

Число 0,1 можно представить как дробь 1/10. И число 0,1, и его дробная часть 1/10 являются десятичными представлениями или представлениями base-10. Однако компьютеры хранят числа с плавающей запятой в представлении base-2, которое чаще называется двоичным представлением.

При представлении в двоичном формате с десятичным числом 0,1 происходит что-то знакомое, но, возможно, неожиданное. Дробь 1/3 не имеет конечного десятичного представления. То есть 1/3 = 0,3333 … с бесконечным числом 3 после десятичной точки. То же самое происходит с дробью 1/10 в двоичной системе.

Двоичное представление 1/10 – это следующая бесконечно повторяющаяся дробь:

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

Однако вы могли заметить, что, когда хотите вывести 0,1, Python печатает 0,1, а не приблизительное значение, указанное выше:

Python не просто обрезает цифры в двоичном представлении 0,1. То, что происходит на самом деле, немного более тонкое.

Поскольку приближение 0,1 в двоичном формате – это всего лишь приблизительно, вполне возможно, что более одного десятичного числа имеют одинаковое двоичное приближенное значение.

Например, и 0,1, и 0,10000000000000001 имеют одинаковое двоичное приближенное значение. Python выводит самое короткое десятичное число, которое разделяет приближенное значение.

Это объясняет, почему в первом примере этого раздела 0,1 + 0,2 не равно 0,3. Python складывает двоичные приближенные значения для 0,1 и 0,2, что дает число, которое не является двоичным приближенным значением для 0,3.

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

Математические функции и числовые методы

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

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

Круглые числа с round()

Вы можете использовать round() для округления числа до ближайшего целого:

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

Число 3,14159 округляется до трех десятичных знаков, чтобы получить 3,142, а число 2,71828 округляется до двух десятичных знаков, чтобы получить 2,72.

Второй аргумент round() должен быть целым числом. Если это не так, Python вызывает TypeError :

Иногда round() не дает правильного ответа:

Работа с числами с плавающей запятой может вызывать разочарование, но это разочарование не характерно для Python. Все языки, реализующие стандарт IEEE с плавающей запятой, имеют одинаковые проблемы, включая C / C ++, Java и JavaScript.

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

Найдите абсолютное значение с помощью abs()

Чтобы получить абсолютное значение числа в Python, вы используйте abs() :

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

Возвести в степень с помощью pow()

pow() принимает два аргумента. Первый аргумент – это основание или число, которое нужно возвести в степень, а второй аргумент – это показатель степени или степень, до которой число должно быть возведено в степень.

Например, в следующем примере функция pow() возводит 2 в степень 3:

Вот пример, в котором x = 2, y = 3 и z = 2:

Сначала 2 возводится в степень 3, чтобы получить 8. Затем вычисляется 8 % 2, что равно 0, потому что 2 делит 8 без остатка.

Проверка, является ли float целым числом

Проверьте свое понимание

Округлите числа до двух цифр

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

Решение

Чтобы получить ввод от пользователя, вызовите input() :

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

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

Теперь вы можете использовать round() для округления значения до двух десятичных знаков:

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

Наконец, вы можете распечатать вывод, вставив rounded_num в f-строку:

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

Когда будете готовы, можете переходить к следующему разделу

Печать чисел в Style

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

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

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

Мини-язык форматирования является мощным и обширным. Вы видели здесь только основы. Для получения дополнительной информации ознакомьтесь с официальной документацией.

Проверьте свое понимание

Отобразите валюту

Выведите число 150000 в виде валюты с тысячами, сгруппированными через запятую. Валюта должна отображаться с двумя десятичными знаками и начинаться с символа доллара США.

Решение

Давайте постепенно наращивать нашу f-строку.

Во-первых, f-строка, которая отображает значение 150000 без какого-либо форматирования, выглядит так:

Это может показаться странным, но заставляет вас добавить спецификаторы форматирования.

Чтобы значение отображалось как число с плавающей запятой, поставьте двоеточие ( : ) после числа 150000, а затем букву f :

По умолчанию Python отображает число с точностью до шести десятичных знаков. Валюта должна иметь только два десятичных знака точности, поэтому вы можете добавить 0,2 между : и f :

F-строки – это всего лишь один из способов форматирования чисел для отображения.

Когда будете готовы, можете переходить к следующему разделу.

Сложные числа

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

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

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

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

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

Различие между методами и свойствами – важный аспект объектно-ориентированного программирования.

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

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

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

Заключение: числа в Python

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

В этом уроке вы узнали:

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

Источник