Arrondir à 5 (ou autre nombre) en Python

Existe-t-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 ce qui précède fonctionne. Vous voulez vous assurer que votre nombre divisé par 5 est un entier correctement arrondi. Donc, nous faisons d'abord exactement cela ( round(float(x)/5)où floatc'est seulement nécessaire dans Python2), puis puisque nous avons divisé par 5, nous multiplions également par 5. La conversion finale en intest parce que round()renvoie une valeur à virgule flottante dans Python 2.

J'ai rendu la fonction plus générique en lui donnant un baseparamètre, 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 pour changer "round (" en "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

Puisque 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. Pas que cela compte beaucoup, à moins que vous n'aimiez un peu changer

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 le permettra pas en raison d'un manque de réputation = /

Quoi qu'il en soit, nous pouvons généraliser une étape 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 .25ou 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:

>>> 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 convertira pas de / en 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 pour les nombres négatifs et positifs. Les égalités (par exemple -15 et 15) seront toujours arrondies vers le haut.

Un exemple similaire arrondi 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 supérieur):

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:

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 plus proche entier pair),
ROUND_HALF_UP (au plus proche avec des liens allant loin de zéro), ou
ROUND_UP (loin de zéro).
ROUND_05UP (loin de zéro si le dernier chiffre après arrondi vers zéro aurait été 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).

Pour les entiers et avec Python 3:

def divround_down(value, step):
    return value//step*step


def divround_up(value, step):
    return (value+step-1)//step*step

Produire:

>>> [divround_down(x,5) for x in range(20)]
[0, 0, 0, 0, 0, 5, 5, 5, 5, 5, 10, 10, 10, 10, 10, 15, 15, 15, 15, 15]
>>> [divround_up(x,5) for x in range(20)]
[0, 5, 5, 5, 5, 5, 10, 10, 10, 10, 10, 15, 15, 15, 15, 15, 20, 20, 20, 20]

Et ça:

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

Multiple suivant 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, ça devrait être quelque chose 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);
  }
}

Une autre façon de faire cela (sans multiplication explicite ou opérateurs de division):

def rnd(x, b=5):
    return round(x + min(-(x % b), b - (x % b), key=abs))

Vous pouvez «tromper» int()pour arrondir au lieu d'arrondir vers le bas en ajoutant 0.5au nombre auquel vous passez int().