У меня два целых значения a и b, но мне нужно их соотношение в плавающей точке. Я знаю, что a < b и я хочу вычислить a/b, поэтому, если я использую целочисленное деление, я всегда получаю 0 с остатком a.
Как я могу заставить c быть числом с плавающей запятой в Python в следующем?
c = a / b
В Python 2 деление двух целых дает int. В Python 3 он создает плавающее число. Мы можем получить новое поведение, импортируя из __future__.
>>> from __future__ import division
>>> a = 4
>>> b = 6
>>> c = a / b
>>> c
0.66666666666666663
Вы можете использовать float, выполнив c = a / float(b). Если числитель или знаменатель является поплавком, то результат будет также.
Оговорка: как отмечали комментаторы, это не сработает, если b может быть чем-то иным, чем целым числом или числом с плавающей запятой (или строкой, представляющей один). Если вы имеете дело с другими типами (например, с комплексными числами), вам нужно либо проверить их, либо использовать другой метод.
Как я могу заставить деление быть плавающей точкой в Python?
У меня два целых значения a и b, но мне нужно их соотношение в плавающей точке. Я знаю, что a <b, и я хочу вычислить a/b, поэтому, если я использую целочисленное деление, я всегда получаю 0 с остатком a.
Как я могу заставить c быть числом с плавающей запятой в Python в следующем?
c = a / b
Что действительно задается здесь:
"Как заставить истинное деление, чтобы a/b вернул часть?"
В Python 3, чтобы получить истинное деление, вы просто делаете a/b.
>>> 1/2
0.5
Разделение полов, классическое поведение деления для целых чисел, теперь равно a//b:
>>> 1//2
0
>>> 1//2.0
0.0
Однако вы можете застрять с помощью Python 2, или вы можете писать код, который должен работать как в 2, так и в 3.
В Python 2 это не так просто. Некоторые способы борьбы с классическим разделом Python 2 лучше и надежнее других.
Вы можете получить поведение Python 3 в любом данном модуле со следующим импортом вверху:
from __future__ import division
который затем применяет разделение стиля Python 3 ко всему модулю. Он также работает в оболочке python в любой заданной точке. В Python 2:
>>> from __future__ import division
>>> 1/2
0.5
>>> 1//2
0
>>> 1//2.0
0.0
Это действительно лучшее решение, так как оно гарантирует, что код в вашем модуле более совместим с Python 3.
Если вы не хотите применять это ко всему модулю, вы ограничены несколькими обходными решениями. Наиболее популярным является принуждение одного из операндов к float. Одним надежным решением является a/(b * 1.0). В новой оболочке Python:
>>> 1/(2 * 1.0)
0.5
Также надежным является truediv из operator модуля operator.truediv(a, b), но это, вероятно, медленнее, потому что это вызов функции:
>>> from operator import truediv
>>> truediv(1, 2)
0.5
Обычно рассматривается a/float(b). Это вызовет TypeError, если b - комплексное число. Поскольку определено деление с комплексными числами, для меня имеет смысл не иметь сбой деления при передаче комплексного числа для делителя.
>>> 1 / float(2)
0.5
>>> 1 / float(2j)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: can't convert complex to float
Для меня не имеет смысла целенаправленно делать ваш код более хрупким.
Вы также можете запустить Python с флагом -Qnew, но это имеет недостаток в выполнении всех модулей с новым поведением Python 3, а некоторые из ваших модулей могут ожидать классического деления, поэтому я не рекомендую это, кроме тестирования. Но чтобы продемонстрировать:
$ python -Qnew -c 'print 1/2'
0.5
$ python -Qnew -c 'print 1/2j'
-0.5j
c = a / (b * 1.0)
В Python 3.x единственная косая черта (/) всегда означает истинное (не обрезающее) деление. (Оператор // используется для усечения деления.) В Python 2.x(2.2 и выше) вы можете получить такое же поведение, поставив
from __future__ import division
в верхней части вашего модуля.
Простое выполнение любого из параметров для деления в формате с плавающей запятой также выводит результат в плавающей точке.
Пример:
>>> 4.0/3
1.3333333333333333
или,
>>> 4 / 3.0
1.3333333333333333
или,
>>> 4 / float(3)
1.3333333333333333
или,
>>> float(4) / 3
1.3333333333333333
Добавьте точку (.) Для обозначения чисел с плавающей точкой
>>> 4/3.
1.3333333333333333
Это тоже будет работать
>>> u=1./5
>>> print u
0.2
Если вы выполняете разделение двух целых чисел, python вернет вам целое число, то вам нужно сделать:
c = float(a)/b
или
c = a/float(b)
а затем получите c как тип float
Если вы хотите использовать деление "true" (с плавающей запятой) по умолчанию, есть флаг командной строки:
python -Q new foo.py
Есть некоторые недостатки (из PEP):
Утверждается, что параметр командной строки для изменения default - зло. Это может быть опасно в неправильном руки: например, было бы невозможно объединить третий пакет Party Library, который требует -Qnew с другим, который требует -Qold.
Вы можете узнать больше о других значениях флагов, которые изменяют/предупреждают о поведении деления, просматривая страницу руководства python.
Подробнее о изменениях разделов читайте: PEP 238 - Изменение оператора отдела
from operator import truediv
c = truediv(a, b)
from operator import truediv
c = truediv(a, b)
где a - дивиденд, а b - делитель. Эта функция удобна, когда фактор после деления двух целых чисел является float.
Это тоже будет работать
>>> u=1./5 >>> print u 0.2ответил 24 дек. 13 в 19:58 Гаурав Агарвал 6,7172279140
Спасибо Gauraw, это делает трюк и является довольно аккуратным решением. Если и числитель, и знаменатель являются переменными, "решением" может быть умножение 1. на частное.
Пример:
aa = 2
bb = 3
aa / bb = 0
1. * aa / bb = 0.6666666666666666
С помощью
типажей
одна из ваших переменных может сделать магию.
Python способствует преобразованию более низкого типа данных (целочисленного) в более высокий тип данных (float), чтобы избежать потери данных.
Используя явное преобразование типов, также называемое typecasting, вы получите желаемый результат
если вы выполняете разделение двух целых чисел, python вернет вам целое число, но если вы выполняете деление с одним типом lower (int) и другим более высоким типом (float), тогда вам нужно сделать typecast:
output = float (a)/b
или
output = a/float (b)
Примеры:
>>> output= 5/2
>>> output
2
>>> output= 5/float(2)
>>> output
2.5
>>> output= float(5)/2
>>> output
2.5