Arrondi à 5 (ou autre nombre) en python

Existe-t-il une fonction intégrée qui peut arrondir comme ceci:

10 -> 10 12 -> 10 13 -> 15 14 -> 15 16 -> 15 18 -> 20 

Je ne connais pas de fonction standard en Python, mais cela fonctionne pour moi:

 def myround(x, base=5): return int(base * round(float(x)/base)) 

Il est facile de voir pourquoi cela fonctionne. Vous voulez vous assurer que votre nombre divisé par 5 est un entier correctement arrondi. Donc, nous faisons tout d’abord exactement cela ( round(float(x)/5) ), et puis, puisque nous avons divisé par 5, nous multiplions également par 5. La conversion finale en int se produit car round() renvoie une valeur en virgule flottante en Python.

J’ai rendu la fonction plus générique en lui donnant un paramètre de base , par défaut à 5.

Pour arrondir à des valeurs non entières, telles que 0,05:

 def myround(x, prec=2, base=.05): return round(base * round(float(x)/base),prec) 

J’ai trouvé cela utile car je pouvais simplement faire une recherche et remplacer mon code pour changer “round (” en “myround (“, sans avoir à modifier les valeurs des parameters).

C’est juste une question de mise à l’échelle

 >>> a=[10,11,12,13,14,15,16,17,18,19,20] >>> for b in a: ... int(round(b/5.0)*5.0) ... 10 10 10 15 15 15 15 15 20 20 20 

Enlever le “rest” fonctionnerait:

 rounded = int(val) - int(val) % 5 

Si la valeur est déjà un entier:

 rounded = val - val % 5 

En tant que fonction:

 def roundint(value, base=5): return int(value) - int(value) % int(base) 

round (x [, n]): les valeurs sont arrondies au multiple de 10 le plus proche de la puissance moins n. Donc, si n est négatif …

 def round5(x): return int(round(x*2, -1)) / 2 

Depuis 10 = 5 * 2, vous pouvez utiliser la division et la multiplication des nombres entiers avec 2, plutôt que la division et la multiplication par flottement avec 5,0. Pas que ça compte beaucoup, à moins que tu aimes les changements

 def round5(x): return int(round(x << 1, -1)) >> 1 

Désolé, je voulais commenter la réponse d’Alok Singhai, mais cela ne me laissera pas à cause d’un manque de réputation = /

Quoi qu’il en soit, on peut généraliser une étape de plus:

 def myround(x, base=5): return base * round(float(x) / base) 

Cela nous permet d’utiliser des bases non entières, comme .25 ou toute autre base fractionnaire.

Version modifiée de divround 🙂

 def divround(value, step, barrage): result, rest = divmod(value, step) return result*step if rest < barrage else (result+1)*step 
 def round_to_next5(n): return n + (5 - n) % 5 

Je me rends compte que je suis en retard à la fête, mais il semble que cette solution n’a pas été mentionnée:

 >>> from __future__ import division # This is only needed on Python 2 >>> def round_to_nearest(n, m): r = n % m return n + m - r if r + r >= m else n - r ... 

Il n’utilise pas de multiplication et ne convertit pas à partir de / vers des flottants.

Arrondir au multiple de 10 le plus proche:

 >>> for n in range(-21, 30, 3): print('{:3d} => {:3d}'.format(n, round_to_nearest(n, 10))) -21 => -20 -18 => -20 -15 => -10 -12 => -10 -9 => -10 -6 => -10 -3 => 0 0 => 0 3 => 0 6 => 10 9 => 10 12 => 10 15 => 20 18 => 20 21 => 20 24 => 20 27 => 30 

Comme vous pouvez le voir, cela fonctionne à la fois pour les nombres négatifs et positifs. Les liens (p. Ex. -15 et 15) seront toujours arrondis.

Exemple similaire qui arrondit pas le multiple de 5 le plus proche, démontrant qu’il se comporte également comme prévu pour une “base” différente:

 >>> for n in range(-21, 30, 3): print('{:3d} => {:3d}'.format(n, round_to_nearest(n, 5))) -21 => -20 -18 => -20 -15 => -15 -12 => -10 -9 => -10 -6 => -5 -3 => -5 0 => 0 3 => 5 6 => 5 9 => 10 12 => 10 15 => 15 18 => 20 21 => 20 24 => 25 27 => 25 

Au cas où quelqu’un aurait besoin d’un “arrondi financier” (0,5 rounds toujours vers le haut):

 def myround(x, base=5): roundcontext = decimal.Context(rounding=decimal.ROUND_HALF_UP) decimal.setcontext(roundcontext) return int(base *float(decimal.Decimal(x/base).quantize(decimal.Decimal('0')))) 

Selon la documentation, d’autres options d’arrondi sont les suivantes:

ROUND_CEILING (vers Infinity),
ROUND_DOWN (vers zéro),
ROUND_FLOOR (vers -Infinity),
ROUND_HALF_DOWN (au plus proche avec des liens allant vers zéro),
ROUND_HALF_EVEN (au plus proche avec des liens allant au nombre entier pair le plus proche),
ROUND_HALF_UP (au plus proche avec des liens qui s’éloignent de zéro), ou
ROUND_UP (loin de zéro).
ROUND_05UP (loin de zéro si le dernier chiffre après l’arrondissement vers zéro aurait été 0 ou 5, sinon vers zéro)

Par défaut, Python utilise ROUND_HALF_EVEN car il présente des avantages statistiques (les résultats arrondis ne sont pas biaisés).

Et ça:

  def divround(value, step): return divmod(value, step)[0] * step 

** multiple suivant de 5 **

considérer 51 besoin de convertir en 55

  code here mark=51; r=100-mark; a=r%5; new_mark=mark+a; 

Vous pouvez «tromper» int() en arrondissant au lieu d’arrondir en ajoutant 0.5 au nombre que vous avez transmis à int() .