Arrondissez à 5 (ou un autre nombre) dans Python
Y at-il une fonction intégrée qui peut arrondir comme suit?
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:
Python 2
def myround(x, base=5):
return int(base * round(float(x)/base))
Python3
def myround(x, base=5):
return base * round(x/base)
Il est facile de voir pourquoi cela fonctionne. Vous voulez vous assurer que votre nombre divisé par 5 est un entier bien arrondi. Donc, nous faisons d’abord exactement cela (round(float(x)/5) où float n’est nécessaire que dans Python2), puis comme nous avons divisé par 5, nous multiplions également par 5. La conversion finale en int est due au fait que round() renvoie une valeur à virgule flottante dans Python 2.
J'ai rendu la fonction plus générique en lui donnant un paramètre 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 dans mon code le changement de "round (") "par" myround ("), sans avoir à changer les valeurs des paramètres.
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
Supprimer le "reste" 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)
def round_to_next5(n):
return n + (5 - n) % 5
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
Comme 10 = 5 * 2, vous pouvez utiliser la division entière et la multiplication avec 2 plutôt que la division flottante et la multiplication avec 5.0. Non pas que cela compte beaucoup, à moins que vous n'aimiez changer un peu
def round5(x):
return int(round(x << 1, -1)) >> 1
Désolé, je voulais commenter la réponse de Alok Singhai, mais elle ne me laissera pas à cause d'un manque de réputation = /
Quoi qu'il en soit, nous pouvons généraliser un pas de plus et aller:
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
Utilisation:
>>> 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 la multiplication et ne convertira pas de/en float.
Arrondi 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 constater, cela fonctionne à la fois pour les nombres négatifs et positifs. Les égalités (par exemple -15 et 15) seront toujours arrondies vers le haut.
Un exemple similaire arrondissant au 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
Si quelqu'un a besoin d'un "arrondi financier" (0,5 arrondi toujours):
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, les autres options d'arrondi sont les suivantes:
ROUND_CEILING (vers l'infini),
ROUND_DOWN (vers zéro),
ROUND_FLOOR (vers -Infinity),
ROUND_HALF_DOWN (au plus proche avec des égalités allant vers zéro),
ROUND_HALF_EVEN (au plus proche avec des liens allant au plus proche même nombre entier),
ROUND_HALF_UP (au plus près avec des égalités qui s'éloignent de zéro), ou
ROUND_UP (loin de zéro).
ROUND_05UP (s'éloigne de zéro si le dernier chiffre après arrondi à zéro aurait été égal à 0 ou 5; sinon, vers zéro)
Par défaut Python utilise ROUND_HALF_EVEN car il présente certains avantages statistiques (les résultats arrondis ne sont pas biaisés).
prochain multiple de 5
Considérez que 51 doit être converti en 55:
code here
mark = 51;
r = 100 - mark;
a = r%5;
new_mark = mark + a;
Voici mon code C. Si je comprends bien, cela devrait être comme ça;
#include <stdio.h>
int main(){
int number;
printf("Enter number: \n");
scanf("%d" , &number);
if(number%5 == 0)
printf("It is multiple of 5\n");
else{
while(number%5 != 0)
number++;
printf("%d\n",number);
}
}
et ceci arrondit également au multiple de 5 le plus proche au lieu de simplement arrondir;
#include <stdio.h>
int main(){
int number;
printf("Enter number: \n");
scanf("%d" , &number);
if(number%5 == 0)
printf("It is multiple of 5\n");
else{
while(number%5 != 0)
if (number%5 < 3)
number--;
else
number++;
printf("nearest multiple of 5 is: %d\n",number);
}
}
Et ça:
def divround(value, step):
return divmod(value, step)[0] * step