Come arrotoli un numero in Python?

Questo problema mi sta uccidendo. Come si fa a raccogliere un numero UP in Python?

Ho provato a arrotondare (numero) ma ha arrotondato il numero verso il basso. Esempio:

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

Ho provato int (numero + .5) ma ha arrotondato di nuovo il numero! Esempio:

int(2.3 + .5) = 2

Poi ho provato a arrotondare (numero + .5) ma non funzionerà in casi limite. Esempio:

WAIT! THIS WORKED!

Si prega di avvisare.

La funzione ceil (soffitto):

import math
print(math.ceil(4.2))

So che questa risposta è per una domanda di qualche tempo fa, ma se non vuoi importare la matematica e vuoi solo arrotondare, questo funziona per me.

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

La prima parte diventa 4 e la seconda parte viene valutata "True" se è presente un resto, che in aggiunta True = 1; False = 0. Quindi se non c'è resto, rimane lo stesso numero intero, ma se c'è un resto aggiunge 1.

Interessante problema di Python 2.x da tenere a mente:

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

Il problema è che la divisione di due in Python produce un altro int e viene troncato prima della chiamata sul soffitto. Devi fare di un valore un float (o cast) per ottenere un risultato corretto.

In javascript, lo stesso codice esatto produce un risultato diverso:

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

Se si lavora con numeri interi, un modo per arrotondare per eccesso è sfruttare il fatto che arrotonda per difetto //: basta fare la divisione sul numero negativo, quindi negare la risposta. Nessuna importazione, virgola mobile o condizionale necessaria.

rounded_up = -(-numerator // denominator)

Per esempio:

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

Potrebbe interessarti anche numpy:

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

Non sto dicendo che è meglio della matematica, ma se stavi già usando numpy per altri scopi, puoi mantenere coerente il tuo codice.

Ad ogni modo, ho trovato solo un dettaglio. Uso parecchio numpy e sono rimasto sorpreso dal fatto che non sia stato menzionato, ma ovviamente la risposta accettata funziona perfettamente.

Utilizzaremath.ceil per arrotondare:

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

NOTA : l'ingresso deve essere float.

Se hai bisogno di un numero intero, chiama intper convertirlo:

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

A proposito, usare math.floorper arrotondare per difetto e roundper arrotondare al numero intero più vicino.

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

La sintassi potrebbe non essere pitonica come si potrebbe desiderare, ma è una libreria potente.

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

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

Sono sorpreso che nessuno abbia suggerito

(numerator + denominator - 1) // denominator

per la divisione di numeri interi con arrotondamento per eccesso. Usato per essere il modo comune per C / C ++ / CUDA (cfr. divup)

Il valore arrotondato deve essere float

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

ma

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

Prova questo:

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

Questa funzione non richiede moduli.

Le risposte di cui sopra sono corrette, tuttavia, importare il mathmodulo solo per questa funzione di solito mi sembra un po 'eccessivo. Fortunatamente, c'è un altro modo per farlo:

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

Truee Falsesono interpretati come 1e 0in una dichiarazione che coinvolge numeri in Python. g.is_interger()fondamentalmente si traduce in g.has_no_decimal()o g == int(g). Quindi si legge l'ultima affermazione in inglese round g down and add one if g has decimal.

Senza importare la matematica // usando l'ambiente di base:

a) metodo / metodo di 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)

Per coloro che vogliono arrotondare a / be ottenere numeri interi:

Un'altra variante che utilizza la divisione di interi è

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

Nel caso in cui qualcuno stia cercando di arrotondare per eccesso a un decimale specifico:

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

Sono sorpreso di non aver ancora visto questa risposta round(x + 0.4999), quindi la metterò giù. Nota che funziona con qualsiasi versione di Python. Le modifiche apportate allo schema di arrotondamento di Python hanno reso le cose difficili. Vedi questo post .

Senza importare, utilizzo:

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

Perché questo funziona

Dai documenti

Per i tipi predefiniti che supportano round (), i valori sono arrotondati al multiplo più vicino di 10 alla potenza meno n; se due multipli sono ugualmente vicini, l'arrotondamento viene effettuato verso la scelta pari

Pertanto 2.5 viene arrotondato a 2 e 3.5 viene arrotondato a 4. In caso contrario, è possibile arrotondare per eccesso aggiungendo 0,5, ma vogliamo evitare di arrivare a metà. Quindi, se aggiungi 0,4999 ti avvicinerai, ma con abbastanza margine da arrotondare a quello che ti aspetteresti normalmente. Naturalmente, ciò fallirà se x + 0.4999è uguale a [n].5000, ma è improbabile.

Per farlo senza alcuna importazione:

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

So che risale a un bel po 'di tempo fa, ma ho trovato una risposta abbastanza interessante, quindi ecco qui:

-round(-x-0.5)

Questo risolve i casi di bordi e funziona sia per i numeri positivi che per quelli negativi e non richiede l'importazione di alcuna funzione

Saluti

quando si opera 4500/1000 in Python, il risultato sarà 4, perché per Python predefinito si assume come intero il risultato, logicamente: 4500/1000 = 4.5 -> int (4.5) = 4 e il ceil di 4 ovviamente è 4

usando 4500 / 1000.0 il risultato sarà 4.5 e ceil di 4,5 -> 5

Usando javascript riceverai 4.5 come risultato di 4500/1000, perché javascript assume solo il risultato come "tipo numerico" e restituisce un risultato direttamente come float

In bocca al lupo!!

Se non vuoi importare nulla, puoi sempre scrivere la tua semplice funzione come:

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

È possibile utilizzare la progettazione del piano e aggiungerne 1. 2.3 // 2 + 1

Penso che stai confondendo i meccanismi di funzionamento tra int()e round().

int()tronca sempre i numeri decimali se viene fornito un numero mobile; mentre round(), nel caso di 2.5dove 2e 3siano entrambi a uguale distanza da 2.5, Python ritorna qualunque sia più lontano dal punto 0.

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

Mia condivisione

Ho testato l' print(-(-101 // 5)) = 21esempio sopra.

Ora per arrotondare per eccesso:

101 * 19% = 19.19

Non posso usare, **quindi ho diffuso il moltiplicare per divisione:

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

Sono fondamentalmente un principiante in Python, ma se stai solo cercando di arrotondare invece di giù perché non farlo:

round(integer) + 1