web-dev-qa-db-fra.com

Comment arrondis-tu un nombre en Python?

Ce problème me tue. Comment arrondir un nombre UP en Python?

J'ai essayé arrondi (nombre) mais arrondi le nombre. Exemple:

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

Le j'ai essayé int (nombre + .5), mais il arrondit à nouveau le nombre! Exemple:

int(2.3 + .5) = 2

Ensuite, j'ai essayé round (nombre + .5) mais cela ne fonctionnera pas dans les cas Edge. Exemple:

WAIT! THIS WORKED!

S'il vous plaît donnez votre avis.

pythonfloating-pointintegerroundingpython-2.x
415
bodacydo

La fonction ceil (ceiling):

import math
print(math.ceil(4.2))
754
Steve Tjoa

Problème intéressant Python 2.x à garder à l'esprit:

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

Le problème est que la division de deux ints dans python produit un autre int qui est tronqué avant l'appel de plafond. Vous devez créer une valeur float (ou cast) 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
152
TrophyGeek

Je sais que cette réponse concerne une question posée de temps en temps, mais si vous ne voulez pas importer de maths et que 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 deuxième partie est évaluée à "True" s'il y a un reste, lequel en plus True = 1; False = 0. Donc, s'il n'y a pas de reste, il reste le même entier, mais s'il y a un reste, il ajoute 1.

144
user3074620

Si vous travaillez avec des nombres entiers, une façon d'arrondir est de tirer parti du fait que // arrondit à: arrondissez simplement la division sur le nombre négatif, puis annulez la réponse. Aucune importation, virgule flottante ou conditionnelle n'est nécessaire.

rounded_up = -(-numerator // denominator)

Par exemple:

>>> print(-(-101 // 5))
21
84
David Bau

Vous pourriez aussi aimer numpy:

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

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

En tout cas, juste un détail que je suis tombé sur. J'utilise beaucoup numpy et j'ai été surpris de ne pas l'avoir mentionné, mais bien sûr, la réponse acceptée fonctionne parfaitement.

49
Lisa

tilisez 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, utilisez 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)
25
kennytm

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

Je suis surpris que personne n'ait suggéré

(numerator + denominator - 1) // denominator

pour la division entière avec arrondi. Utilisé pour être le moyen commun pour C/C++/CUDA (cf. divup)

10
Andreas Schuh

Soyez sûr que la valeur arrondie doit être float

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

mais

print math.ceil(float(a) / b)
>>> 1.0
7
Alexey
>>> def roundup(number):
...     return round(number+.5)
>>> roundup(2.3)
3
>>> roundup(19.00000000001)
20

Cette fonction ne nécessite aucun module.

7
PonasM

Essaye ça:

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

Les réponses ci-dessus sont correctes, toutefois, importer le module math uniquement pour cette fonction est généralement un peu exagéré pour moi. Heureusement, il existe 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 instruction impliquant des nombres en python. g.is_interger() se traduit essentiellement par g.has_no_decimal() ou g == int(g). Ainsi, la dernière déclaration en anglais se lit round g down and add one if g has decimal.

5
Nearoo

Sans importer math // en utilisant un 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)
5
Kuřátko Zvyk

Pour ceux qui veulent arrondir a / b et obtenir un 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
3
Pavel

Je suis surpris de ne pas avoir encore vu cette réponse round(x + 0.4999), alors je vais la poser. Notez que cela fonctionne avec n’importe quelle version de Python. Les modifications apportées au schéma d'arrondissement Python ont rendu les choses difficiles. Voir ceci 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 ça marche

De la docs

Pour les types intégrés prenant en charge round (), les valeurs sont arrondies au multiple de 10 le plus proche de la puissance moins n; si deux multiples sont égaux, l'arrondi est fait vers le même choix

Par conséquent, 2,5 est arrondi à 2 et 3,5 à 4. Si ce n’était pas le cas, l’arrondi pourrait se faire en ajoutant 0,5, mais nous voulons éviter d’atteindre le point médian. Donc, si vous ajoutez 0,4999, vous vous rapprocherez, mais avec une marge suffisante pour être arrondi à ce que vous attendez normalement. Bien sûr, cela échouera si le x + 0.4999 est égal à [n].5000, mais cela est peu probable.

2
Klik

Pour le faire sans aucune importation:

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

Je sais que cela remonte à un certain temps, mais j’ai trouvé une réponse assez intéressante, alors voici:

-round(-x-0.5)

Cela corrige les cas extrêmes et fonctionne pour les nombres positifs et négatifs, et ne nécessite aucune importation de fonction

À votre santé

0
Fenmaz

Si vous ne souhaitez rien importer, vous pouvez toujours écrire votre propre fonction simple en tant que:

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

0
Sebin

si vous utilisez 4500/1000 en python, le résultat sera 4, car par défaut python asume sous forme d'entier le résultat, logiquement: 4500/1000 = 4.5 -> int (4.5) = 4 et ceil de 4 évidemment 4

en utilisant 4500/1000.0, le résultat sera 4,5 et le plafond de 4,5 -> 5

En utilisant javascript, vous recevrez 4.5 en tant que résultat de 4500/1000, car javascript n'utilise que le résultat sous forme de "type numérique" et renvoie un résultat directement en tant que float

Bonne chance!!

0
erick vicente