Как вы округляете число в Python?

Интересный Python 2.X вопрос, чтобы иметь в виду:

>>> import math
>>> math.ceil(4500/1000)
4.0
>>> math.ceil(4500/1000.0)
5.0

проблема в том, что разделение двух ints в python создает другой int, и это усекается перед вызовом потолка. Вы должны сделать одно значение float (или cast), чтобы получить правильный результат.

в javascript тот же самый код дает другой результат:

console.log(Math.ceil(4500/1000));
5

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

>>> int(21 / 5)
4
>>> int(21 / 5) + (21 % 5 > 0)
5

первая часть становится 4, а вторая часть оценивается как "True", если есть остаток, который, кроме того, True = 1; False = 0. Поэтому, если нет остатка, он остается тем же целым числом, но если есть остаток, он добавляет 1.

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

rounded_up = -(-numerator // denominator)

например:

>>> print(-(-101 // 5))
21

вам также может понравиться numpy:

>>> import numpy as np
>>> np.ceil(2.3)
3.0

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

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

использовать math.ceil сгонять:

>>> import math
>>> math.ceil(5.4)
6.0

Примечание: вход должен быть float.

Если вам нужно целое число, называют int преобразовать это:

>>> int(math.ceil(5.4))
6

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

>>> math.floor(4.4), math.floor(4.5), math.floor(5.4), math.floor(5.5)
(4.0, 4.0, 5.0, 5.0)
>>> round(4.4), round(4.5), round(5.4), round(5.5)
(4.0, 5.0, 5.0, 6.0)
>>> math.ceil(4.4), math.ceil(4.5), math.ceil(5.4), math.ceil(5.5)
(5.0, 5.0, 6.0, 6.0)

синтаксис не может быть, как весть, как хотелось бы, но это мощная библиотека.

https://docs.python.org/2/library/decimal.html

from decimal import *
print(int(Decimal(2.3).quantize(Decimal('1.'), rounding=ROUND_UP)))

be Shure округленное значение должно быть float

a = 8 
b = 21
print math.ceil(a / b)
>>> 0

но

print math.ceil(float(a) / b)
>>> 1.0

Я удивлен, что никто не предложил

(numerator + denominator - 1) // denominator

для целочисленного деления с округлением. Раньше был распространенным способом для C / C++ / CUDA (см. divup)

>>> def roundup(number):
...     return round(number+.5)
>>> roundup(2.3)
3
>>> roundup(19.00000000001)
20

эта функция не требует никаких модулей.

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

g = 7/5
g = int(g) + (not g.is_integer())

True и False интерпретируются как 1 и 0 в инструкции, включающей числа в python. g.is_interger() в принципе переводится как g.has_no_decimal() или g == int(g). Итак, последнее утверждение на английском языке гласит:round g down and add one if g has decimal.

без импорта математики / / с использованием базовой среды:

a) метод / метод класса

def ceil(fl): 
  return int(fl) + (1 if fl-int(fl) else 0)

def ceil(self, fl): 
  return int(fl) + (1 if fl-int(fl) else 0)

b) лямбда:

ceil = lambda fl:int(fl)+(1 if fl-int(fl) else 0)

попробуйте это:

a = 211.0
print(int(a) + ((int(a) - a) != 0))

Я удивлен, что еще не видел этого ответа round(x + 0.4999), поэтому я собираюсь положить его. Обратите внимание, что это работает с любой версии Python. Изменения, внесенные в схему округления Python, затруднили работу. Смотрите это в должности.

без импорта, я использую:

def roundUp(num):
    return round(num + 0.49)

testCases = list(x*0.1 for x in range(0, 50))

print(testCases)
for test in testCases:
    print("{:5.2f}  -> {:5.2f}".format(test, roundUp(test)))

почему это работает

документы

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

поэтому 2.5 округляется до 2 и 3.5 округляется до 4. Если бы это было не так, округление можно было бы сделать, добавив 0.5, но мы хотим избежать попадания на полпути. Итак, если вы добавите 0.4999, вы приблизитесь, но с достаточным запасом, чтобы округлить до того, что вы обычно ожидаете. Конечно, это не удастся, если x + 0.4999 равна [n].5000, но это едва ли.

для тех, кто хочет сгонять a / b и получаем целое число:

другой вариант с использованием целочисленного деления -

def int_ceil(a, b):
    return (a - 1) // b + 1

>>> int_ceil(19, 5)
4
>>> int_ceil(20, 5)
4
>>> int_ceil(21, 5)
5

чтобы сделать это без импорта:

>>> round_up = lambda num: int(num + 1) if int(num) != num else int(num)
>>> round_up(2.0)
2
>>> round_up(2.1)
3

Я знаю это довольно давно, но я нашел довольно интересный ответ, Так вот:

-round(-x-0.5)

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

Ура

когда вы работаете 4500/1000 в python, результат будет 4, потому что по умолчанию python asume как целое число результат, логически: 4500/1000 = 4.5 --> int (4.5) = 4 и ceil из 4 obviouslly составляет 4

используя 4500/1000.0 результат будет 4.5 и ceil 4.5 --> 5

используя javascript, вы получите 4.5 в результате 4500/1000, потому что javascript asume только результат как "числовой тип" и возвращает результат непосредственно как float

Удачи!!

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

def RoundUP(num): if num== int(num): return num return int(num + 1)

вы можете использовать floor devision и добавить 1 к нему. 2.3 // 2 + 1

Я думаю, вы путаете рабочие механизмы между int() и round().

int() всегда усекает десятичные числа, если задано плавающее число; тогда как round() в случае 2.5 здесь 2 и 3 находятся на равном расстоянии от 2.5, Python возвращает то, что больше от 0 точки.

round(2.5) = 3
int(2.5) = 2

Я в принципе новичок в Python, но если вы просто пытаетесь округлить, а не вниз, почему бы не сделать:

round(integer) + 1