Come si fa a turno un numero in Python?

Question

Questo problema mi sta uccidendo.Come si fa la raccolta di un numero in Python?

Ho provato round(numero) ma giro il numero in basso.Esempio:

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

L'ho provato int(numero + .5) ma giro il numero giù di nuovo!Esempio:

int(2.3 + .5) = 2

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

WAIT! THIS WORKED!

Si prega di avvisare.

Answer 1

Il ceil (soffitto) la funzione:

import math
print(math.ceil(4.2))

Answer 2

Interessante problema 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 divide due int in pitone produce un altro int e che è troncato prima della chiamata soffitto. Devi fare un valore un galleggiante (o lanciare) per ottenere un risultato corretto.

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

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

Answer 3

So che questa risposta è per una domanda da un po 'indietro, ma se non si desidera importare la matematica e si desidera solo per 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 restituisce "True" se v'è un residuo, che oltre Vero = 1; False = 0. Quindi, se non v'è alcun resto, allora rimane lo stesso intero, ma se c'è un resto si aggiunge 1.

Answer 4

Se si lavora con numeri interi, un modo di arrotondamento è quello di approfittare del fatto che // arrotonda per difetto: Basta fare la divisione del numero negativo, quindi negare la risposta. No importazione, in virgola mobile, o condizionale necessario.

rounded_up = -(-numerator // denominator)

Ad esempio:

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

Answer 5

Ti potrebbe piacere anche NumPy:

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

Non sto dicendo che è meglio che la matematica, ma se si sta già utilizzando NumPy per altri scopi, è possibile mantenere il vostro codice coerente.

In ogni caso, solo un dettaglio mi sono imbattuto. Io uso NumPy molto e sono rimasto sorpreso che non mi sono detto, ma ovviamente la risposta accettata funziona perfettamente bene.

Answer 6

Utilizzare math.ceil per concludere:

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

NOTA:L'ingresso dovrebbe essere di tipo float.

Se avete bisogno di un numero intero, chiamata int per la conversione è:

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

BTW, utilizzare math.floor a turno giù e round 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)

Answer 7

La sintassi potrebbe non essere così divinatorio come si potrebbe piacere, ma è una potente libreria.

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

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

Answer 8

Sono sorpreso nessuno ha chiesto

(numerator + denominator - 1) // denominator

per la divisione intero con arrotondamento. Usato per essere il modo comune per C / C ++ / CUDA (cfr divup)

Answer 9

Be shure valore arrotondato dovrebbe essere float

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

ma

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

Answer 10

Prova questo:

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

Answer 11

Le risposte di cui sopra sono corrette, tuttavia, importando il modulo math proprio per questo una funzione di solito si sente come un po 'di un peso inutile per me. Per fortuna, c'è un altro modo per farlo:

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

True e False sono interpretati come 1 e 0 in una dichiarazione che coinvolge numeri in Python. g.is_interger() traduce fondamentalmente per g.has_no_decimal() o g == int(g). Così l'ultima istruzione in lingua inglese si legge round g down and add one if g has decimal.

Answer 12

senza importare la matematica // utilizzando envionment di base:

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

Answer 13

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

Questa funzione richiede nessun modulo.

Answer 14

Per chi vuole radunare a / b e ottenere intero:

Un'altra variante utilizzando 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

Answer 15

Sono sorpreso che non ho visto questa risposta ancora round(x + 0.4999), quindi ho intenzione di metterlo giù. Si noti che questo funziona con qualsiasi versione di Python. Le modifiche apportate allo schema di arrotondamento Python ha reso le cose difficili. Vedi questo messaggio .

Senza importazione, io 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)))

Perché questo funziona

Dalla documentazione

  

Per incorporati nei tipi di supporto tondo (), i valori sono arrotondati al più vicino multiplo di 10 alla potenza meno n; se due multipli sono ugualmente vicini, l'arrotondamento avviene verso la scelta ancora

Quindi 2.5 ottiene arrotondato a 2 e 3.5 ottiene arrotondato a 4. Se questo non era il caso, allora arrotondamento potrebbe essere fatto con l'aggiunta di 0,5, ma vogliamo evitare di arrivare al punto a metà strada. Quindi, se si aggiunge 0,4999 otterrete vicino, ma con un margine sufficiente per essere arrotondato a quello che normalmente si aspetta. Naturalmente, questo non riuscirà se la x + 0.4999 è uguale a [n].5000, ma questo è improbabile.

Answer 16

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

Answer 17

So che questo è da un bel po 'indietro, ma ho trovato una risposta molto interessante, quindi ecco qui:

-round(-x-0.5)

Questo consente di risolvere i casi bordi e funziona sia per i numeri positivi e negativi, e non richiede alcuna funzione di importazione

Saluti

Answer 18

quando si opera 4500/1000 in python, risultato sarà 4, perché per asume python di default come intero risultato, logicamente: 4500/1000 = 4,5 -> int (4.5) = 4 e Ceil di 4 obviouslly è 4

utilizzando 4500 / 1000.0 il risultato sarà 4,5 e Ceil di 4.5 -> 5

Utilizzo di javascript riceverete 4.5 come risultato del 4500/1000, perché JavaScript asume solo il risultato come "tipo numerico" e restituire un risultato direttamente come float

Buona fortuna !!

Answer 19

Se non si desidera importare qualsiasi cosa, si può sempre scrivere la propria funzione semplice:

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

Answer 20

È possibile utilizzare la divisione piano e aggiungere 1 ad esso. 2.3 // 2 + 1

Answer 21

Penso che si sta confondendo i meccanismi di lavoro tra int() e round().

int() tronca sempre i numeri decimali se è dato un numero variabile; che round(), nel caso in cui 2.5 2 e 3 sono entrambi a uguale distanza da 2.5, ritorna Python qualsiasi che è più lontano dal punto 0.

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

Answer 22

La mia parte

Ho testato print(-(-101 // 5)) = 21 dato esempio di cui sopra.

Ora, per arrotondamento:

101 * 19% = 19.19

Non riesco a usare in modo ** ho diffondere la moltiplicano per divisione:

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

Answer 23

https://docs.python.org/2/library/math.html cercare Math.ceil

"Ritorno soffitto di x come un galleggiante, il più piccolo valore intero maggiore o uguale a x."

Answer 24

Sono fondamentalmente un principiante in Python, ma se si sta solo cercando di arrotondare anziché verso il basso perché non fare:

round(integer) + 1