Как вы обмениваете число в Python?

Ответ 1

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

import math
print(math.ceil(4.2))

Ответ 2

Интересная проблема 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

Ответ 3

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

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

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

Ответ 4

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

rounded_up = -(-numerator // denominator)

Например:

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

Ответ 5

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

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

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

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

Ответ 6

Используйте math.ceil для округления:

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

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

Если вам нужно целое число, вызовите int для его преобразования:

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

BTW, используйте 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)

Ответ 7

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

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

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

Ответ 8

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

(numerator + denominator - 1) // denominator

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

Ответ 9

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

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

но

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

Ответ 10

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

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

Ответ 11

Вышеприведенные ответы верны, однако, импортируя модуль 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.

Ответ 12

Без импорта математики//с использованием основного 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)

b) lambda:

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

Ответ 13

Попробуйте следующее:

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

Ответ 14

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

Ответ 15

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

Ответ 16

Сделать это без импорта:

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

Ответ 17

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

-round(-x-0.5)

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

Приветствия

Ответ 18

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

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

Ответ 19

когда вы используете 4500/1000 в python, результат будет равен 4, поскольку для python по умолчанию, как целочисленный результат, логически: 4500/1000 = 4,5 → int (4,5) = 4 и число из 4 очевидно составляет 4

используя 4500/1000.0, результат будет 4,5 и ceil 4,5 → 5

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

Удачи!!

Ответ 20

WTF! Python 3.6.4 (v3.6.4: d48eceb, 19.12.2017, 06:04:45) [MSC v.1900 32 bit (Intel)] для win32 Тип "help", "copyright", "credits" или "license" для дополнительной информации.

раунд (5,5) 6 раунд (6,5) 6 раунд (7,5) 8 раунд (15,5) 16 раунд (16,5) 16 раунд (17,5) 18 раунд (1235,5) 1236 раунд (1236,5) 1236 раунд (1237,5) 1238

6 магическое число????

Ответ 21

int() всегда будет принимать целое число значения и, следовательно, всегда "округлять", поэтому для округления до целых можно использовать:

int(x) + 1

Как было предложено ранее, функция math.ceil будет называть слово, более того, numpy.ceil также существует, когда вы предпочитаете работать с numpy.

Ответ 22

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

Ответ 23

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

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

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

Ответ 24

Моя доля

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

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

101 * 19% = 19.19

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

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

Ответ 25

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

round(integer) + 1