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

Эта проблема убивает меня. Как собрать число UP в Python?

Я попытался округлить (число), но оно округлило число вниз. Пример:

round(2.3) = 2.0 and not 3, what I would like

Я попробовал int (число + .5), но он снова округлил число вниз! Пример:

int(2.3 + .5) = 2

Затем я попытался раунд (число + .5), но он не будет работать в крайних случаях. Пример:

WAIT! THIS WORKED!

Пожалуйста, порекомендуйте.

CEIL функция (потолок):

import math
print(math.ceil(4.2))

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

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

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

Интересная проблема Python 2.x, о которой следует помнить:

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

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

В javascript точно такой же код дает другой результат:

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

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

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

ПРИМЕЧАНИЕ : ввод должен быть плавающим.

Если вам нужно целое число, позвоните, 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)))

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

(numerator + denominator - 1) // denominator

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

Будьте уверены, округленное значение должно быть плавающим

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

но

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

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

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

>>> 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.

Без импорта математики // используя базовые условия:

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

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)

б) лямбда:

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

Для тех, кто хочет округлить 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

В случае, если кто-то хочет округлить до определенного десятичного знака:

import math
def round_up(n, decimals=0):
    multiplier = 10 ** decimals
    return math.ceil(n * multiplier) / multiplier

Я удивлен, что еще не видел этот ответ 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, но это маловероятно.

Чтобы сделать это без какого-либо импорта:

>>> 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 по умолчанию в качестве целочисленного значения присваивается логическое значение: 4500/1000 = 4.5 -> int (4.5) = 4, а ceil of 4, очевидно, равен 4

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

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

Удачи!!

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

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

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

Моя доля

Я проверил print(-(-101 // 5)) = 21приведенный пример выше.

Теперь для округления:

101 * 19% = 19.19

Я не могу использовать, **поэтому я распространяю умножение на деление:

(-(-101 //(1/0.19))) = 20

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

round(integer) + 1