Comment arrondissez-vous un nombre en Python?

Ce problème me tue. Comment arrondit-on un nombre UP en Python?

J'ai essayé d'arrondir (nombre) mais il arrondit le nombre. Exemple:

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

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

int(2.3 + .5) = 2

Ensuite, j'ai essayé le tour (numéro + 0,5) mais cela ne fonctionnera pas dans les cas de bord. Exemple:

WAIT! THIS WORKED!

S'il vous plaît donnez votre avis.

La ceil fonction (plafond):

import math
print(math.ceil(4.2))

Je sais que cette réponse est pour une question de tout à l'heure, mais si vous ne voulez pas importer de mathématiques et que vous voulez simplement 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, 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.

Problème intéressant de 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 en python produit un autre entier et qui est tronqué avant l'appel du plafond. Vous devez faire une valeur flottante (ou cast) pour obtenir un résultat correct.

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

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

Si vous travaillez avec des nombres entiers, une façon d'arrondir est de tirer parti du fait que l'arrondi est //bas: Faites simplement la division sur le nombre négatif, puis annulez la réponse. Aucune importation, virgule flottante ou conditionnelle 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 mathématiques, mais si vous utilisiez déjà numpy à d'autres fins, vous pouvez garder votre code cohérent.

Quoi qu'il en soit, juste un détail que j'ai rencontré. J'utilise beaucoup numpy et j'ai été surpris qu'il ne soit pas mentionné, mais bien sûr, la réponse acceptée fonctionne parfaitement.

Utilisezmath.ceil pour arrondir:

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

REMARQUE : L'entrée doit être flottante.

Si vous avez besoin d'un entier, appelez-le intpour le convertir:

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

BTW, utilisez math.floorpour arrondir vers le bas et roundarrondir à 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)))

Je suis surpris que personne ne l'ait suggéré

(numerator + denominator - 1) // denominator

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

La valeur arrondie doit être flottante

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

mais

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

Essaye ça:

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

Cette fonction ne nécessite aucun module.

Les réponses ci-dessus sont correctes, cependant, importer le mathmodule juste pour cette seule fonction me semble généralement un peu exagéré. Heureusement, il existe une autre façon de procéder:

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

Trueet Falsesont interprétés comme 1et 0dans une déclaration impliquant des nombres en python. g.is_interger()se traduit essentiellement par g.has_no_decimal()ou g == int(g). La dernière déclaration en anglais se lit donc round g down and add one if g has decimal.

Sans importer math // en utilisant l'environnement de base:

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)

Pour ceux qui veulent arrondir a / bet 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

Si quelqu'un souhaite arrondir à une décimale spécifique:

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

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'arrondi Python ont rendu les choses difficiles. Voir cet article .

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

À partir des documents

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 également proches, l'arrondi est effectué vers le choix pair

Par conséquent, 2,5 est arrondi à 2 et 3,5 est arrondi à 4. Si ce n'était pas le cas, l'arrondi pourrait être effectué en ajoutant 0,5, mais nous voulons éviter d'arriver à mi-chemin. Donc, si vous ajoutez 0,4999, vous vous rapprocherez, mais avec suffisamment de marge pour être arrondi à ce que vous attendez normalement. Bien sûr, cela échouera si le x + 0.4999est égal à [n].5000, mais cela est peu probable.

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

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 de bords et fonctionne pour les nombres positifs et négatifs, et ne nécessite aucune importation de fonction

À votre santé

lorsque vous utilisez 4500/1000 en python, le résultat sera 4, car pour le python par défaut, asume comme entier le résultat, logiquement: 4500/1000 = 4.5 -> int (4.5) = 4 et le plafond de 4 est évidemment 4

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

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

Bonne chance!!

Si vous ne voulez rien importer, 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 la déviation du sol et y ajouter 1. 2,3 // 2 + 1

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

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

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

Mon partage

J'ai testé l' print(-(-101 // 5)) = 21exemple donné ci-dessus.

Maintenant pour arrondir:

101 * 19% = 19.19

Je ne peux pas utiliser **donc je répartis le multiplier en division:

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

Je suis fondamentalement un débutant chez Python, mais si vous essayez simplement d'arrondir au lieu de descendre, pourquoi ne pas le faire:

round(integer) + 1