round - Arrondir à 5(ou autre nombre) en python




round sup python (9)

** prochain multiple de 5 **

considérer 51 besoin de convertir en 55

 code here

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

https://code.i-harness.com

Y at-il une fonction intégrée qui peut arrondir comme ceci:

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

Au cas où quelqu'un aurait besoin d'un «arrondi financier» (0,5 rounds toujours en hausse):

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 l'infini),
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 les liens allant à l'entier pair le plus proche),
ROUND_HALF_UP (au plus proche avec des liens s'éloignant 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).


Désolé, je voulais commenter la réponse d'Alok Singhai, mais elle ne me le laissera 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 .25 ou toute autre base fractionnaire.


Et ça:

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

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 ce qui précède fonctionne. Vous voulez vous assurer que votre nombre divisé par 5 est un nombre entier, correctement arrondi. Donc, nous faisons 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 est parce que round() retourne une valeur à virgule flottante dans 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 puisque je pouvais juste faire une recherche et remplacer dans mon code pour changer "round (" à "myround (", sans avoir à changer les valeurs des paramètres.


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

Vous pouvez "tromper" int() en arrondissant au lieu d'arrondir vers le bas en ajoutant 0.5 au nombre que vous passez à int() .


def round_to_next5(n):
    return n + (5 - n) % 5




rounding