Отдел Python

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

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

Плавающее подразделение не работает:

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

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

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

Каждая сторона в первом примере оценивается как int, что означает, что окончательный ответ будет передан в int. Поскольку 0.111 меньше, чем 0,5, он округляется до 0. Это, по-моему, непрозрачно, но я думаю, что так оно и есть.

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

  • Почему id () несвязанного метода в Python 2 изменяется для каждого доступа
  • Как предотвратить публикацию совместно используемой библиотеки C на stdout в python?
  • `pip install pandas` дает UnicodeDecodeError: кодек ascii не может декодировать байт 0xe2 в позиции 41: порядковый номер не в диапазоне (128)
  • Должен ли я использовать «я» для определения переменных / объектов класса instanced, которые мне не нужно будет получать извне?
  • Получить полный список всех возможных атрибутов класса
  • Как проверить, является ли объект экземпляром пользовательского класса нового стиля?
  • Обработка \ r \ n vs \ n новых строк в python на Mac и Windows
  • передача строки в функцию открытия файла в python
  • 10 Solutions collect form web for “Отдел Python”

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

     >>> 1 / 2 0 

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

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

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

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

    Вы помещаете целые числа, поэтому Python дает вам целое число :

     >>> 10 / 90 0 

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

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

     >>> 10 / 90.0 0.1111111111111111 

    Итак, в вашем случае:

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

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

     float(20 - 10) / (100 - 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, результат будет желательным, так как начиная с первого деления, то есть самого левого, мы используем float.

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

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

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

    В 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 мы будем использовать оператор // .

    Оператор // является оператором целочисленного деления как в 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, просто потому, что / является поплавковым делением.

    Сделайте хотя бы один из них float, тогда это будет float-деление, а не целое число:

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

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

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

     >>> 1 / 2 0 >>> 1. / 2. 0.5 

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

    Попробуйте отличить один из операндов «/» как float:

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

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

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

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

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

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

    Python - лучший язык программирования в мире.