imprimir - Cómo redondear enteros en python

redondear a entero python

Question

Estoy tratando de redondear enteros en Python. Miré la función round () incorporada pero parece que esa ronda flota.

Mi objetivo es redondear números enteros al múltiplo más cercano de 10. es decir: 5-> 10, 4-> 0, 95-> 100, etc.

5 y más deben redondearse, 4 y más deben redondearse hacia abajo.

Este es el código que tengo que hace esto:

def round_int(x):
    last_dig = int(str(x)[-1])
    if last_dig >= 5:
        x += 10
    return (x/10) * 10

¿Es esta la mejor manera de lograr lo que quiero lograr? ¿Hay una función incorporada que hace esto? Además, si esta es la mejor manera, ¿hay algo mal con el código que me perdí en las pruebas?

Answer 1

Acerca de la función round(..) que devuelve un flotador

Esa flotación (precisión doble en Python) es siempre una representación perfecta de un entero, siempre y cuando esté en el rango [-2 ⁵³ ..2 ⁵³ ]. (Los subordinados prestan atención: no es un complemento de dos en dobles, por lo que el rango es simétrico alrededor de cero).

Vea la discusión aquí para más detalles.

Answer 2

En realidad, aún puedes usar la función de ronda:

>>> print round(1123.456789, -1)
1120.0

Esto redondearía al múltiplo más cercano de 10. A 100 sería -2 como el segundo argumento y así sucesivamente.

Answer 3

Esta función redondeará ya sea de orden de magnitud (de derecha a izquierda) o por dígitos de la misma manera que el formato trata los lugares decimales de coma flotante (de izquierda a derecha:

def intround(n, p):
    '''''' rounds an intger. if "p"<0, p is a exponent of 10; if p>0, left to right digits ''''''
    if p==0: return n
    if p>0:  
        ln=len(str(n))  
        p=p-ln+1 if n<0 else p-ln
    return (n + 5 * 10**(-p-1)) // 10**-p * 10**-p

>>> tgt=5555555
>>> d=2
>>> print(''/t{} rounded to {} places:/n/t{} right to left /n/t{} left to right''.format(
        tgt,d,intround(tgt,-d), intround(tgt,d))) 

Huellas dactilares

5555555 rounded to 2 places:
5555600 right to left 
5600000 left to right

También puedes usar la clase Decimal:

import decimal
import sys

def ri(i, prec=6):
    ic=long if sys.version_info.major<3 else int
    with decimal.localcontext() as lct:
        if prec>0:
            lct.prec=prec
        else:
            lct.prec=len(str(decimal.Decimal(i)))+prec  
        n=ic(decimal.Decimal(i)+decimal.Decimal(''0''))
    return n

En Python 3 puedes usar de forma confiable la ronda con lugares negativos y obtener un entero redondeado:

def intround2(n, p):
    '''''' will fail with larger floating point numbers on Py2 and require a cast to an int ''''''
    if p>0:
        return round(n, p-len(str(n))+1)
    else:
        return round(n, p)    

En Python 2, round no devolverá un entero redondeado adecuado en números más grandes porque round siempre devuelve un float:

>>> round(2**34, -5)
17179900000.0                     # OK
>>> round(2**64, -5)
1.84467440737096e+19              # wrong 

Las otras 2 funciones funcionan en Python 2 y 3

Answer 4

Ligeramente más simple:

def round_int(x):
    return 10 * ((x + 5) // 10)

Answer 5

Quería hacer lo mismo, pero con 5 en lugar de 10, y se me ocurrió una función simple. Espero que sea útil:

def roundToFive(num):
    remaining = num % 5
    if remaining in range(0, 3):
        return num - remaining
    return num + (5 - remaining)

Answer 6

round () puede tomar números enteros y negativos para los lugares, que giran a la izquierda del decimal. El valor de retorno sigue siendo flotante, pero un molde simple corrige que:

>>> int(round(5678,-1))
5680
>>> int(round(5678,-2))
5700
>>> int(round(5678,-3))
6000

Answer 7

si quieres la forma algebrica y aún utilizas la ronda para ella, es difícil ser más simple que:

interval = 5
n = 4
print(round(n/interval))*interval