Comment arrondir un nombre en Python?

La ceil (plafond) fonction:

import math
print(math.ceil(4.2))

Je sais que cette réponse est pour une question à partir d'un certain temps, mais si vous ne voulez pas importer les maths et vous voulez juste pour finir, cela fonctionne pour moi.

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

La première partie devient 4 et la deuxième partie correspond à la valeur "Vrai" si il y a un reste, qui, en outre, Vrai = 1; Faux = 0. Donc, si il n'y a pas de reste, alors il reste le même entier, mais si il y a un reste, il ajoute 1.

Vous pouvez également numpy:

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

Je ne dis pas que c'est mieux que les maths, mais si vous utilisiez déjà numpy pour d'autres fins, vous pouvez conserver votre code cohérent.

De toute façon, juste un détail, je suis venu à travers. Je utiliser numpy beaucoup et était surpris, il n'a pas mentionné, mais bien sûr accepté de répondre fonctionne parfaitement bien.

La syntaxe ne peut être que pythonic qu'on le souhaiterait, mais il est un puissant bibliothèque.

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

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

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

Cette fonction nécessite pas de modules.

Essayez ceci:

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

Sans import math //utilisation de la base envionment:

a) méthode /méthode 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)

Je suis surpris, je n'ai pas vu cette réponse encore round(x + 0.4999), donc je vais la mettre vers le bas. Notez que cela fonctionne avec n'importe quelle version de Python. Les modifications apportées à l'Python arrondissement régime a rendu les choses difficiles. Voir ce post.

Sans importer, j'utilise:

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

Pourquoi cela fonctionne

De la documentation

Pour les types intégrés de soutien round(), les valeurs sont arrondies au plus proche multiple de 10 puissance moins n; si deux multiples sont également à proximité, l'arrondi se fait vers le même choix

Donc 2.5 obtient arrondie à 2 et 3,5 obtient arrondi à 4. Si ce n'était pas le cas, alors arrondissement qui pourrait être fait par l'ajout de 0,5, mais nous voulons éviter de tomber à la mi-course. Donc, si vous ajoutez 0.4999 vous arriverez près, mais avec assez de marge pour être arrondie à ce que vous auriez normalement s'attendre. Bien sûr, cela ne fonctionnera pas si l' x + 0.4999 est égal à [n].5000, mais c'est peu probable.

Je sais que c'est à partir d'un certain temps en arrière, mais j'ai trouvé une très intéressante réponse, voilà:

-round(-x-0.5)

Cela corrige les bords de cas et de travaux pour les deux nombres positifs et négatifs, et ne nécessite pas de n'importe quelle fonction d'importation

Acclamations

Si vous ne voulez pas importer quoi que ce soit, vous pouvez toujours écrire votre propre fonction simple comme:

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


Je pense que vous confondez les mécanismes de travail entre int() et round().

int() toujours tronque les nombres décimaux si un nombre flottant est donné; considérant que round(), en cas de 2.5 où 2 et 3 sont à égale distance de 2.5, Python renvoie selon ce qui est le plus loin du point 0.

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

Je suis fondamentalement un débutant en Python, mais si vous êtes juste essayer de tour vers le haut au lieu de vers le bas pourquoi ne pas le faire:

round(integer) + 1