Como você arredondar para cima um número em Python?

Este problema está me matando. Como um arredondamento para um número UP em Python?

Eu tentei arredondar (número), mas arredondar o número para baixo. Exemplo:

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

O que eu tentei int (número + 0,5), mas arredondar o número novamente! Exemplo:

int(2.3 + .5) = 2

Então tentei a rodada (número + 0,5), mas não funcionaria em casos extremos. Exemplo:

WAIT! THIS WORKED!

Por favor informar.

O ceil função (teto):

import math
print(math.ceil(4.2))

Sei que essa resposta é para uma pergunta há algum tempo, mas se você não deseja importar matemática e deseja arredondar, isso funciona para mim.

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

A primeira parte se torna 4 e a segunda parte é avaliada como "True" se houver um restante, que além disso True = 1; False = 0. Portanto, se não houver resto, ele permanecerá o mesmo número inteiro, mas se houver um restante, ele adicionará 1.

Problema interessante sobre o Python 2.x a ser lembrado:

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

O problema é que dividir duas entradas em python produz outra int e isso é truncado antes da chamada do teto. Você precisa transformar um valor em um valor flutuante (ou convertido) para obter um resultado correto.

Em javascript, exatamente o mesmo código produz um resultado diferente:

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

Se estiver trabalhando com números inteiros, uma maneira de arredondar para cima é aproveitar o fato de //arredondamentos: basta fazer a divisão no número negativo e negar a resposta. Nenhuma importação, ponto flutuante ou condicional necessário.

rounded_up = -(-numerator // denominator)

Por exemplo:

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

Você também pode gostar de numpy:

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

Não estou dizendo que é melhor que matemática, mas se você já estava usando o numpy para outros fins, pode manter seu código consistente.

Enfim, apenas um detalhe que me deparei. Eu uso muito o numpy e fiquei surpreso por não ter sido mencionado, mas é claro que a resposta aceita funciona perfeitamente bem.

Usemath.ceil para arredondar para cima:

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

NOTA : A entrada deve ser flutuante.

Se você precisar de um número inteiro, ligue intpara convertê-lo:

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

Entre, use math.floorpara arredondar para baixo e roundpara o número inteiro mais próximo.

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

A sintaxe pode não ser tão pitônica quanto se possa gostar, mas é uma biblioteca poderosa.

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

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

Estou surpreso que ninguém sugeriu

(numerator + denominator - 1) // denominator

para divisão inteira com arredondamento para cima. Costumava ser o caminho comum para C / C ++ / CUDA (cf. divup)

O valor arredondado Shure deve ser flutuante

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

mas

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

Tente o seguinte:

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

Esta função não requer módulos.

As respostas acima estão corretas, no entanto, importar o mathmódulo apenas para essa função geralmente parece um pouco exagero para mim. Felizmente, há outra maneira de fazer isso:

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

Truee Falsesão interpretados como 1e 0em uma declaração envolvendo números em python. g.is_interger()traduz basicamente para g.has_no_decimal()ou g == int(g). Assim, a última declaração em Inglês lê round g down and add one if g has decimal.

Sem importar matemática // usando o ambiente básico:

a) método / método de classe

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)

Para quem deseja arredondar a / be obter um número inteiro:

Outra variante que usa divisão inteira é

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

Caso alguém esteja procurando arredondar para uma casa decimal específica:

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

Estou surpreso por não ter visto essa resposta ainda round(x + 0.4999), então vou anotá-la. Observe que isso funciona com qualquer versão do Python. As alterações feitas no esquema de arredondamento do Python tornaram as coisas difíceis. Veja este post .

Sem importar, eu uso:

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

Por que isso funciona

Dos documentos

Para os tipos internos que suportam round (), os valores são arredondados para o múltiplo mais próximo de 10 para a potência menos n; se dois múltiplos estão igualmente próximos, o arredondamento é feito para a escolha uniforme

Portanto, 2,5 é arredondado para 2 e 3,5 é arredondado para 4. Se esse não fosse o caso, o arredondamento poderia ser feito adicionando 0,5, mas queremos evitar chegar ao ponto intermediário. Portanto, se você adicionar 0,4999, você se aproximará, mas com margem suficiente para ser arredondado para o que você normalmente esperaria. Obviamente, isso falhará se o x + 0.4999for igual a [n].5000, mas isso é improvável.

Para fazer isso sem qualquer importação:

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

Eu sei que isso já faz um bom tempo, mas achei uma resposta bastante interessante, então aqui vai:

-round(-x-0.5)

Isso corrige os casos de arestas e funciona para números positivos e negativos e não requer nenhuma importação de função

Felicidades

quando você opera 4500/1000 em python, o resultado será 4, porque, para o python padrão, asume como número inteiro, logicamente: 4500/1000 = 4.5 -> int (4.5) = 4 e o teto de 4 obviamente é 4

usando 4500 / 1000.0, o resultado será 4,5 e o teto de 4,5 -> 5

Usando javascript, você receberá 4,5 como resultado de 4500/1000, porque o javascript assume apenas o resultado como "tipo numérico" e retorna um resultado diretamente como float

Boa sorte!!

Se você não deseja importar nada, sempre pode escrever sua própria função simples como:

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

Você pode usar a disposição do piso e adicionar 1 a ela. 2,3 // 2 + 1

Eu acho que você está confundindo os mecanismos de trabalho entre int()e round().

int()sempre trunca os números decimais se um número flutuante for fornecido; enquanto que round(), no caso de 2.5onde 2e 3ambos estão a uma distância igual 2.5, o Python retorna o que estiver mais distante do ponto 0.

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

Minha parte

Eu testei print(-(-101 // 5)) = 21dado o exemplo acima.

Agora, para arredondar para cima:

101 * 19% = 19.19

Eu não posso usar, **então eu espalhei a multiplicação para divisão:

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

Eu sou basicamente iniciante no Python, mas se você está apenas tentando arredondar em vez de diminuir, por que não:

round(integer) + 1