Как задать float python

Преобразует число/строку с записью числа в вещественное число

Если аргумент является строкой, то запись должна содержать десятичное число и может иметь предшествующий знак и начальные(конечные) пробелы. Предшествующий знак может быть ‘+’ или ‘-‘ , знак ‘+’ не имеет никакого влияния на результат. Аргумент может также быть строкой, представляющей NaN (не число), или положительной или отрицательной бесконечностью. Точнее, входные данные должны соответствовать общепринятой грамматике после удаления начальных и конечных пробельных символов

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

Дополнительно смотрите материал по теме «Проблемы точности типа float в Python».

Примеры преобразований числа или строки в число с плавающей запятой.

str_to_float = ' -3.500 ' x = float(str_to_float) print(x) # Вывод -3.5 x = float(10) print(x) # Вывод 10.0 

• ОБЗОРНАЯ СТРАНИЦА РАЗДЕЛА
• Функция abs(), абсолютное значение числа
• Функция all(), все элементы True
• Функция any(), хотя бы один элемент True
• Функция ascii(), преобразует строку в ASCII
• Функция bin(), число в двоичную строку
• Класс bool(), логическое значение объекта
• Функция breakpoint(), отладчик кода
• Класс bytearray(), преобразует в массив байтов
• Класс bytes(), преобразует в строку байтов
• Функция callable(), проверяет можно ли вызвать объект
• Функция chr(), число в символ Юникода
• Класс classmethod, делает функцию методом класса
• Функция compile() компилирует блок кода Python
• Класс complex(), преобразует в комплексное число
• Функция delattr(), удаляет атрибут объекта
• Класс dict() создает словарь
• Функция dir(), все атрибуты объекта
• Функция divmod(), делит числа с остатком
• Функция enumerate(), счетчик элементов последовательности
• Функция eval(), выполняет строку-выражение с кодом
• Функция exec(), выполняет блок кода
• Функция filter(), фильтрует список по условию
• Класс float(), преобразует в вещественное число
• Функция format(), форматирует значение переменной
• Класс frozenset(), преобразует в неизменяемое множество
• Функция getattr(), значение атрибута по имени
• Функция globals(), переменные глобальной области
• Функция hasattr(), наличие атрибута объекта
• Функция hash(), хэш-значение объекта
• Функция help(), справка по любому объекту
• Функция hex(), число в шестнадцатеричную строку
• Функция id(), идентификатор объекта
• Функция input(), ввод данных с клавиатуры
• Класс int(), преобразует в тип int
• Функция isinstance(), принадлежность экземпляра к классу
• Функция issubclass(), проверяет наследование класса
• Функция iter(), создает итератор
• Функция len(), количество элементов объекта
• Класс list(), преобразовывает в список
• Функция locals(), переменные локальной области
• Функция map(), обработка последовательности без цикла
• Функция max(), максимальное значение элемента
• Класс memoryview(), ссылка на буфер обмена
• Функция min(), минимальное значение элемента
• Функция next(), следующий элемент итератора
• Класс object(), возвращает безликий объект
• Функция oct(), число в восьмеричную строку
• Функция open(), открывает файл на чтение/запись
• Функция ord(), число символа Unicode
• Функция pow(), возводит число в степень
• Функция print(), печатает объект
• Класс property(), метод класса как свойство
• Класс range(), генерирует арифметические последовательности
• Функция repr(), описание объекта
• Функция reversed(), разворачивает последовательность
• Функция round(), округляет число
• Класс set(), создает или преобразовывает в множество
• Функция setattr(), создает атрибут объекта
• Класс slice(), шаблон среза
• Функция sorted(), выполняет сортировку
• Декоратор staticmethod(), метод класса в статический метод
• Класс str(), преобразует объект в строку
• Функция sum(), сумма последовательности
• Функция super(), доступ к унаследованным методам
• Класс tuple(), создает или преобразует в кортеж
• Класс type(), возвращает тип объекта
• Функция vars(), словарь переменных объекта
• Функция zip(), объединить элементы в список кортежей
• Функция __import__(), находит и импортирует модуль
• Функция aiter(), создает асинхронный итератор
• Функция anext(), следующий элемент асинхронного итератора

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

Десятичные дроби в Python хранятся в формате с плавающей точкой и представлены типом float . Они могут быть записаны несколькими способами:

>>> 1. 1.0 >>> .1 0.1 >>> 4.2 4.2 >>> 4.2e3 # то же, что и 4.2 * 10 ** 3 == 4.2 * 1000 4200.0 >>> 4.2e-3 # то же, что и 4.2 * 10 ** (-3) == 4.2 * 0.001 0.0042 

Конструкция float(x) принимает строку или целое число и возвращает число с плавающей точкой, т.е. объект типа float . Примеры:

>>> float("1.2") 1.2 >>> float(42) 42.0 >>> float("42e3") 42000.0 

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

pi = 3.1415 print(pi) print(f"pi = pi>") 

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

pi = 3.1415 print(f"pi = pi:.3f>") print(f"pi = pi:.4f>") 

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

>>> int(42.9) 42 

Для решения вычислительных задач может быть полезен модуль math из стандартной библиотеки языка Python. Для его использования нужно написать строку import math . Для решения задач нам понадобятся число \(\pi\) и функция извлечения квадратного корня. Примеры их использования:

import math print(f"pi = math.pi>") r = math.sqrt(4) print(f"square root of 4 = r>") 

Задачи¶

1. Дан диаметр окружности \(d\) . Найти ее длину по формуле \(length = \pi \cdot d\) .
2. Дано значение температуры \(t\_f\) в градусах Фаренгейта. Определить значение этой же температуры в градусах Цельсия. Температура по Цельсию \(t\_c\) и температура по Фаренгейту \(t\_f\) связаны следующим соотношением:

\[t\_c = (t\_f — 32) \cdot \frac<5>\]
\[ \begin\beginc = \sqrt\\p = a + b + c\end\end \]

© Copyright Revision d00c0df4 .

Built with Sphinx using a theme provided by Read the Docs.
Read the Docs v: latest

Versions latest Downloads html On Read the Docs Project Home Builds Free document hosting provided by Read the Docs.

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

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

Кто-то, вероятно, слышал о проблеме 0.1 + 0.1 + 0.1 == 0.3 . Вкратце, вбейте в интерпретаторе Python:

>>> 0.1 + 0.1 + 0.1 == 0.3 False

Здравый смысл подсказывает нам, что здесь что-то не так, должно же равняться! Новичков это вообще может вбить в ступор. Программисты поопытнее могут объяснить это ошибками округления 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). Вот так:

Думаете, любое реальное число можно представить, используя эти 64 бита? Конечно, нет. Простая комбинаторика скажет, что у нас может быть не более 2 64 разных чисел (64 позиции по 2 варианта), а на деле их и того меньше. Диапазон чисел, представимых таким форматом составляет: ±1.7*10 -308 до 1.7*10 +308 . То есть от очень малых по модулю чисел, до очень больших. Допустимые числа на числовой прямой распределены неравномерно: гуще в районе нуля и реже в районе огромных чисел.

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

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

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

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

0.1 = 1 / 10 ≈ J / (2**N) или J ≈ 2**N / 10

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

>>> 2**52 >> divmod(2**56, 10) (7205759403792793, 6)

Остаток от деления – 6 чуть больше половины делителя (10), поэтому наилучшее приближение будет, если мы округлим частное вверх, то есть добавим к 7205759403792793 + 1 = 7205759403792794 . Таким образом, это будет ближайшее к 0.1 число, возможное в представлении float. Доказательство проверкой:

>>> 7205759403792794 / 2 ** 56 == 0.1 True

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

>>> format(7205759403792793 / 2 ** 56, '.56f') '0.09999999999999999167332731531132594682276248931884765625' >>> format(7205759403792794 / 2 ** 56, '.56f') '0.10000000000000000555111512312578270211815834045410156250'

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

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

>>> format(0.1 + 0.1 + 0.1 - 0.3, '.56f') '0.00000000000000005551115123125782702118158340454101562500'

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

>>> 0.15 + 0.15 == 0.3 True >>> 0.1 + 0.15 + 0.05 == 0.1 + 0.1 + 0.1 False >>> 0.1 + 0.15 + 0.05 0.3 >>> 0.1 + 0.1 + 0.1 0.30000000000000004

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

>>> sum([0.1] * 10) == 1.0 False >>> math.fsum([0.1] * 10) == 1.0 True # не тут то было! >>> math.fsum([0.1] * 3) == 0.3 False

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

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

Как работать с числами с плавающей точкой в Python

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

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

>>> 0.1 + 0.2 == 0.3 False

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

Компьютер обманывает вас

Вы видели, что 0.1 + 0.2 не равно 0.3, но безумие на этом не заканчивается. Вот ещё пара примеров, сбивающих с толку:

>>> 0.2 + 0.2 + 0.2 == 0.6 False >>> 1.3 + 2.0 == 3.3 False >>> 1.2 + 2.4 + 3.6 == 7.2 False

Проблема касается и сравнения:

>>> 0.1 + 0.2 >> 10.4 + 20.8 > 31.2 True >>> 0.8 - 0.1 > 0.7 True

Что происходит? Когда вы вводите в интерпретатор Python число 0.1, оно сохраняется в памяти как число с плавающей точкой и происходит преобразование. 0.1 — это десятичное число с основанием 10, но числа с плавающей точкой хранятся в двоичной записи. То есть основание 0.1 преобразуется из 10 в 2.

Получающееся двоичное число может недостаточно точно представлять исходное число с основанием 10. 0.1 — один из примеров. Двоичным представлением будет 0.0(0011). То есть 0.1 — это бесконечно повторяющееся десятичное число, записанное с основанием 2. То же происходит, когда в виде десятичного числа с основанием 10 записывается дробь ⅓. Получается бесконечно повторяющееся десятичное число 0.3(3).

Память компьютера конечна, поэтому бесконечно повторяющееся представление двоичной дроби 0.1 округляется до конечной дроби. Её значение зависит от архитектуры компьютера (32- или 64-разрядная).

Увидеть значение с плавающей точкой, которое сохраняется для 0.1, можно с помощью метода .as_integer_ratio(). Представление с плавающей точкой состоит из числителя и знаменателя:

>>> numerator, denominator = (0.1).as_integer_ratio() >>> f"0.1 ≈ / " '0.1 ≈ 3602879701896397 / 36028797018963968'

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

>>> format(numerator / denominator, ".55f") '0.1000000000000000055511151231257827021181583404541015625'

Так 0.1 округляется до числа чуть больше, чем его истинное значение.

Узнайте больше о числовых методах, подобных .as_integer_ratio(), в моей статье 3 Things You Might Not Know About Numbers in Python («3 факта о числах в Python, которые вы могли не знать»).

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

Ошибка представления числа очень типична

Существуют три причины, почему число округляется при его представлении в виде числа с плавающей точкой:

1. В числе больше значащих разрядов, чем позволяет плавающая точка.
2. Это иррациональное число.
3. Число рациональное, но без конечного двоичного представления.

64-разрядные числа с плавающей точкой имеют 16 или 17 значащих разрядов. Любое число, у которого значащих разрядов больше, округляется. Иррациональные числа, такие как π и e, нельзя представить конечной дробью с целочисленным основанием. И, опять же, иррациональные числа в любом случае округляются при сохранении в виде чисел с плавающей точкой.

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

А как на счёт бесконечных рациональных чисел, например 0.1 с основанием 2? Именно здесь вам встретится большинство связанных с плавающей точкой трудностей и благодаря математике — позволяющей определять, конечная дробь или нет, — вы будете сталкиваться с ошибками представления чаще, чем думаете.

С основанием 10 дробь можно представить как конечную, если её знаменатель — произведение степеней простых множителей 10. Два простых множителя 10 — это 2 и 5, поэтому дроби ½, ¼, ⅕, ⅛ и ⅒ — конечные, а ⅓, ⅐ и ⅑ — нет. У основания 2 только один простой множитель — 2.

Конечные дроби здесь только те, знаменатель которых равен степени числа 2. В результате дроби ⅓, ⅕, ⅙, ⅐, ⅑ и ⅒ — бесконечные, когда представлены в двоичной записи.

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

>>> # -----------vvvv Display with 17 significant digits >>> format(0.1, ".17g") '0.10000000000000001' >>> format(0.2, ".17g") '0.20000000000000001' >>> format(0.3, ".17g") '0.29999999999999999'

При сложении 0.1 и 0.2 получается число чуть больше 0.3:

>>> 0.1 + 0.2 0.30000000000000004

А поскольку 0.1 + 0.2 чуть больше, чем 0.3, и 0.3 представлено числом, которое чуть меньше 0.3, выражение 0.1 + 0.2 == 0.3 оказывается False.

Об ошибке представления чисел с плавающей точкой должен знать каждый программист на любом языке — и уметь с ней справляться. Она характерна не только для Python. Результат вывода 0.1 + 0.2 на разных языках можно увидеть на сайте с подходящим названием 0.30000000000000004.com.

Как сравнивать числа с плавающей точкой в Python

Как же справляться с ошибками представления чисел с плавающей точкой при сравнении таких чисел в Python? Хитрость заключается в том, чтобы избегать проверки на равенство. Вместо ==, >= или

>>> import math >>> math.isclose(0.1 + 0.2, 0.3) True

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

>>> a = 0.1 + 0.2 >>> b = 0.3 >>> abs(a - b) 5.551115123125783e-17

Если abs(a — b) меньше некоего процента от большего значения a или b, то a считается достаточно близким к b, чтобы считаться «равным» b. Этот процент называется относительной погрешностью и указывается именованным аргументом rel_tol функции math.isclose(), который по умолчанию равен 1e-9.

То есть если abs(a — b) меньше 0.00000001 * max(abs(a), abs(b)), то a и b считаются «близкими» друг к другу. Это гарантирует, что a и b будут приблизительно с девятью знаками после запятой.

Если нужно, можно изменить относительную погрешность:

>>> math.isclose(0.1 + 0.2, 0.3, rel_tol=1e-20) False

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

>>> # Relative check fails! >>> # ---------------vvvv Relative tolerance >>> # ----------------------vvvvv max(0, 1e-10) >>> abs(0 - 1e-10) < 1e-9 * 1e-10 False >>> # Absolute check works! >>> # ---------------vvvv Absolute tolerance >>> abs(0 - 1e-10) < 1e-9 True

В math.isclose() эта проверка выполняется автоматически. Абсолютная погрешность определяется с помощью именованного аргумента abs_tol. Но abs_tol по умолчанию равен 0.0, поэтому придётся задать его вручную, если нужно проверить близость значения к нулю.

В итоге в функции math.isclose() возвращается результат следующего сравнения — с относительными и абсолютными проверками в одном выражении:

abs(a - b) 

>>> # Don't do this: >>> 0.1 + 0.2 == 0.3 False >>> # Do this instead: >>> math.isclose(0.1 + 0.2, 0.3) True

>>> a, b, c = 0.1, 0.2, 0.3 >>> # Don't do this: >>> a + b >> # Do this instead: >>> math.isclose(a + b, c) or (a + b < c) True

>>> import numpy as np >>> # Use numpy.allclose() to check if two arrays are equal >>> # to each other within a tolerance. >>> np.allclose([1e10, 1e-7], [1.00001e10, 1e-8]) False >>> np.allclose([1e10, 1e-8], [1.00001e10, 1e-9]) True >>> # Use numpy.isclose() to check if the elements of two arrays >>> # are equal to each other within a tolerance >>> np.isclose([1e10, 1e-7], [1.00001e10, 1e-8]) array([ True, False]) >>> np.isclose([1e10, 1e-8], [1.00001e10, 1e-9]) array([ True, True])

>>> import pytest >>> 0.1 + 0.2 == pytest.approx(0.3) True

>>> import numpy as np >>> np.array([0.1, 0.2]) + np.array([0.2, 0.4]) == pytest.approx(np.array([0.3, 0.6])) True

>>> == pytest.approx() True

>>> # Import the Decimal type from the decimal module >>> from decimal import Decimal >>> # Values are represented exactly so no rounding error occurs >>> Decimal("0.1") + Decimal("0.2") == Decimal("0.3") True >>> # By default 28 significant figures are preserved >>> Decimal(1) / Decimal(7) Decimal('0.1428571428571428571428571429') >>> # You can change the significant figures if needed >>> from decimal import getcontext >>> getcontext().prec = 6 # Use 6 significant figures >>> Decimal(1) / Decimal(7) Decimal('0.142857')

>>> # import the Fraction type from the fractions module >>> from fractions import Fraction >>> # Instantiate a Fraction with a numerator and denominator >>> Fraction(1, 10) Fraction(1, 10) >>> # Values are represented exactly so no rounding error occurs >>> Fraction(1, 10) + Fraction(2, 10) == Fraction(3, 10) True