Comment arrondir un nombre en Python?

Intéressant Python 2.x question à garder à l'esprit:

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

le problème est que diviser deux ints en python produit un autre int et qui est tronqué avant l'appel de plafond. Vous devez faire une valeur un flottant (ou un moulage) pour obtenir un résultat correct.

en javascript, le même code produit un résultat différent:

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

je sais que cette réponse est pour une question depuis un certain temps, mais si vous ne voulez pas importer les mathématiques et vous voulez juste arrondir, cela fonctionne pour moi.

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

la première partie devient 4 et la seconde partie est évaluée à" True " s'il y a un reste, qui en plus True = 1; False = 0. Donc s'il n'y a pas de reste, alors il reste le même entier, mais s'il y a un reste il ajoute 1.

si vous travaillez avec des entiers, une façon d'arrondir vers le haut est de profiter du fait que // tourne vers le bas: faites juste la division sur le nombre négatif, puis nier la réponse. Aucune importation, point flottant,ou conditionnel nécessaire.

rounded_up = -(-numerator // denominator)

par exemple:

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

Vous aimerez aussi 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 à d'autres fins, vous pouvez garder votre code cohérent.

bref, juste un détail que j'ai trouvé. J'utilise souvent num PY et j'ai été surpris qu'il n'ait pas été mentionné, mais bien sûr la réponse acceptée fonctionne parfaitement.

utiliser math.ceil pour arrondir:

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

NOTE : l'entrée doit être flottante.

si vous avez besoin d'un entier, appelez int pour le convertir:

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

BTW, utiliser math.floor pour arrondir vers le bas et round pour arrondir à l'entier le plus proche.

>>> 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 syntaxe n'est peut-être pas aussi pythonique qu'on pourrait le souhaiter, mais c'est une bibliothèque puissante.

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

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

Be shure valeur arrondie devrait être float

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

mais

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

je suis étonné que personne n'a suggéré de

(numerator + denominator - 1) // denominator

pour division entière avec arrondi. C'était la voie commune pour C/C++/CUDA (cf. divup )

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

cette fonction ne nécessite aucun module.

les réponses ci-dessus sont correctes, cependant, importer le module math juste pour cette fonction me semble généralement un peu exagéré pour moi. Heureusement, il y a une autre façon de le faire:

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

True et False sont interprétés comme 1 et 0 dans une déclaration sur des nombres en python. g.is_interger() se traduit essentiellement par g.has_no_decimal() ou g == int(g) . Donc la dernière déclaration en anglais se lit round g down and add one if g has decimal .

sans importer de mathématiques / / en utilisant l'environnement de base:

A) Méthode / classe méthode

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)

essayez ceci:

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

je suis surpris que je n'ai pas encore vu cette réponse round(x + 0.4999) , donc je vais la poser. Notez que cela fonctionne avec n'importe quelle version de Python. Les changements apportés au schéma D'Arrondissement de Python ont rendu les choses difficiles. Voir ce post .

sans importation, 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

à Partir de la documentation

pour le types encastrés supportant rond(), les valeurs sont arrondies au multiple de 10 le plus proche de la puissance moins n; Si deux multiples sont également proches, l'arrondissement est fait vers le choix Pair

donc 2,5 est arrondi à 2 et 3,5 est arrondi à 4. Si tel n'était pas le cas, on pourrait arrondir les chiffres en ajoutant 0,5, mais nous voulons éviter d'arriver à mi-chemin. 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 échouera si le x + 0.4999 est égal à [n].5000 , mais c'est peu probable.

pour ceux qui veulent arrondir a / b et obtenir entier:

une autre variante utilisant la division entière est

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

De le faire sans importer:

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

je sais que c'est depuis un certain temps, mais j'ai trouvé une réponse assez intéressante, alors voici:

-round(-x-0.5)

cela fixe les cas d'arêtes et fonctionne pour les nombres positifs et négatifs, et ne nécessite aucune importation de fonction

Cheers

quand vous opérez 4500/1000 en python, le résultat sera 4, parce que par défaut python asume comme entier le résultat, logiquement: 4500/1000 = 4.5 -- > int (4.5) = 4 et le ceil de 4 est évidemment 4

par 4500/1000.0 le résultat sera de 4.5 et le ceil de 4.5 --> 5

en utilisant javascript, vous recevrez 4.5 à la suite de 4500/1000, parce que javascript asume seulement le résultat comme "type numérique" et retourner un résultat directement comme flottant

Bonne Chance!!

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)

vous pouvez utiliser floor devision et y ajouter 1. 2.3 // 2 + 1

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

int() tronque toujours les nombres décimaux si un nombre flottant est donné; tandis que round() , dans le cas de 2.5 où 2 et 3 sont tous deux à distance égale de 2.5 , Python renvoie celui qui est le plus éloigné du point 0.

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

je suis essentiellement un débutant chez Python, mais si vous êtes juste essayer de rassembler au lieu de bas pourquoi ne pas faire:

round(integer) + 1