Питон отдела

Я пытался нормализовать набор чисел от -100 до 0 в диапазоне 10-100 и были проблемы только заметить, что даже без переменных вообще, это не оценит так, как я бы ожидал, что это:

>>> (20-10) / (100-10)
0

Float division тоже не работает:

>>> float((20-10) / (100-10))
0.0

Если любая сторона деления будет брошена в поплавок, он будет работать:

>>> (20-10) / float((100-10))
0.1111111111111111

каждая сторона в первом примере оценивается как int, что означает, что окончательный ответ будет приведен в int. Так как 0,111 меньше .5, то округляется до 0. На мой взгляд, это непрозрачно, но я думаю, что так оно и есть.

каково объяснение?

12 110
python mathjax python-2.x

12 ответов:

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

>>> 1 / 2
0

вы должны сделать один из них float:

>>> float(10 - 20) / (100 - 10)
-0.1111111111111111

или from __future__ import division, которому силы / принять Python 3.поведение x, которое всегда возвращает поплавок.

>>> from __future__ import division
>>> (10 - 20) / (100 - 10)
-0.1111111111111111
223

ты положить целые числа в так Python дает вам целое число обратно:

>>> 10 / 90
0

Если вы приведете это к поплавку после того, как округление будет уже сделано, другими словами, 0 integer всегда будет 0 float.

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

>>> 10 / 90.0
0.1111111111111111

Так что в вашем случае:

>>> float(20-10) / (100-10)
0.1111111111111111
>>> (20-10) / float(100-10)
0.1111111111111111
19

вам нужно изменить его на поплавок, прежде чем делать деление. То есть:

float(20 - 10) / (100 - 10)
10

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

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

>>> a = 1/2/3/4/5/4/3
>>> a
0

когда мы делим целые числа, неудивительно, что он становится ниже округляется.

>>> a = 1/2/3/4/5/4/float(3)
>>> a
0.0

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

>>> a = 1/2/3/float(4)/5/4/3
>>> a
0.0

тот же сценарий, что и выше, но смещение типа float немного ближе к левой стороне.

>>> a = float(1)/2/3/4/5/4/3
>>> a
0.0006944444444444445

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

Extra 1: Если вы пытаетесь ответить, что для улучшения арифметической оценки, вы должны проверить этой

дополнительно 2: Пожалуйста, будьте осторожны в следующем сценарии:

>>> a = float(1/2/3/4/5/4/3)
>>> a
0.0
8

в Python 2.7,/ оператор является целочисленным делением, если входные данные являются целыми числами:

>>>20/15
1

>>>20.0/15.0
1.33333333333

>>>20.0/15
1.33333333333

в Python 3.3,/ оператор-это разделение поплавка, даже если входные данные целое число.

>>> 20/15
1.33333333333

>>>20.0/15
1.33333333333

для целочисленного деления в Python 3 мы будем использовать // оператора.

The // оператор является целочисленным оператором деления как в Python 2.7, так и в Python 3.3.

в Python 2.7 и Python 3.3:

>>>20//15
1

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

>>>a = 7.0/4.0
>>>b = 7/4
>>>print a == b

для приведенной выше программы вывод будет False в Python 2.7 и True в Python 3.3.

в Python 2.7 a = 1.75 и b = 1.

в Python 3.3 a = 1.75 и b = 1.75, просто потому, что / - это разделение поплавка.

6

указание поплавка путем размещения '.'после того, как число также заставит его по умолчанию плавать. 

>>> 1 / 2
0

>>> 1. / 2.
0.5
3

сделайте хотя бы один из них float, тогда это будет float division, а не integer:

>>> (20.0-10) / (100-10)
0.1111111111111111

приведение результата к плаванию слишком поздно.

2

в python cv2 не обновлен расчет деления. Итак, вы должны включить from __future__ import division в первой строке программы.

1

в любом случае, это целочисленное деление. 10/90 = 0. Во втором случае вы просто бросаете 0 в поплавок.

попробуйте привести один из операндов "/" к float:

float(20-10) / (100-10)
0

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

float(20-10) / float(100-10)
0

Я несколько удивлен, что никто не упомянул, что оригинальный плакат мог бы рациональный цифры в результате. Если вы заинтересованы в этом, программа на основе Python Сейдж прикрывает твою спину. (В настоящее время все еще на основе Python 2.x, хотя 3.х ведется.)

sage: (20-10) / (100-10)
1/9

Это не решение для всех, потому что он делает некоторые приготовления, так что эти цифры не int s, но Sage Integer элементы класса. Тем не менее, стоит упомянуть как часть экосистемы Python.

0

лично я предпочел вставить 1. * в самом начале. Поэтому выражение становится примерно таким:

1. * (20-10) / (100-10)

как я всегда делаю деление для какой-то формулы, как:

accuracy = 1. * (len(y_val) - sum(y_val)) / len(y_val)

так что нельзя просто добавить .0 как 20.0. И в моем случае, обертывание с float() может немного потерять читаемость.

0