Как вы округляете число в 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

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

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

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

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.

без импорта math / / с использованием basic envionment:

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)

б) лямбда:

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, усложнили ситуацию. Смотрите это post.

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

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

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