in

¿Cuál es el resultado de% en Python?

apple touch icon@2

Una expresión como x % y evalúa el resto de x ÷ y – Bueno, técnicamente es «módulo» en lugar de «recordatorio», por lo que los resultados pueden ser diferentes si se compara con otros idiomas donde % es el operador restante. Hay algunas diferencias sutiles (si está interesado en las consecuencias prácticas, consulte también «Por qué los pisos de división de enteros de Python» a continuación).

La precedencia es la misma que los operadores / (división) y * (multiplicación).

>>> 9 / 2
4
>>> 9 % 2
1
  • 9 dividido por 2 es igual a 4.
  • 4 por 2 es 8
  • 9 menos 8 es 1, el resto.

Python te atrapó: dependiendo de la versión de Python que esté utilizando, % también es el operador de interpolación de cadenas (obsoleto), así que tenga cuidado si proviene de un lenguaje con conversión automática de tipos (como PHP o JS) donde una expresión como '12' % 2 + 3 es legal: en Python resultará en TypeError: not all arguments converted during string formatting lo que probablemente te resultará bastante confuso.

[update for Python 3]

Comentarios del usuario n00p:

9/2 es 4.5 en Python. Tienes que hacer una división de enteros así: 9 // 2 si quieres que Python te diga cuántos objetos completos quedan después de la división (4).

Para ser precisos, la división de enteros solía ser la predeterminada en Python 2 (fíjate, esta respuesta es mayor que mi hijo, que ya está en la escuela y en ese momento 2.x era la corriente principal):

$ python2.7
Python 2.7.10 (default, Oct  6 2017, 22:29:07)
[GCC 4.2.1 Compatible Apple LLVM 9.0.0 (clang-900.0.31)] on darwin
Type "help", "copyright", "credits" or "license" for more information.
>>> 9 / 2
4
>>> 9 // 2
4
>>> 9 % 2
1

En Python moderno 9 / 2 resultados 4.5 Por supuesto:

$ python3.6
Python 3.6.1 (default, Apr 27 2017, 00:15:59)
[GCC 4.2.1 Compatible Apple LLVM 8.1.0 (clang-802.0.42)] on darwin
Type "help", "copyright", "credits" or "license" for more information.
>>> 9 / 2
4.5
>>> 9 // 2
4
>>> 9 % 2
1

[update]

El usuario dahiya_boy preguntó en la sesión de comentarios:

Q. ¿Puedes explicar por qué? -11 % 5 = 4 – dahiya_boy

Esto es extraño, ¿verdad? Si prueba esto en JavaScript:

> -11 % 5
-1

Esto se debe a que en JavaScript % es el operador «resto» mientras que en Python es el operador «módulo» (matemáticas de reloj).

Puedes obtener la explicación directamente de GvR:


Editar – dahiya_boy

En Java e iOS -11 % 5 = -1 mientras que en pitón y rubí -11 % 5 = 4.

Bueno, la mitad de la razón se explica por Paulo Scardine, y el resto de la explicación está aquí abajo.

En Java e iOS, % da el resto que significa que si divide 11% 5 da Quotient = 2 and remainder = 1 y -11% 5 da Quotient = -2 and remainder = -1.

Código de muestra en iOS rápido.

ingrese la descripción de la imagen aquí

Pero cuando hablamos de Python, da un módulo de reloj. Y su trabajo con la siguiente fórmula.

mod(a,n) = a - {n * Floor(a/n)}

Significa,

mod(11,5) = 11 - {5 * Floor(11/5)} => 11 - {5 * 2}

Entonces, mod(11,5) = 1

Y

mod(-11,5) = -11 - 5 * Floor(-11/5) => -11 - {5 * (-3)}

Entonces, mod(-11,5) = 4

Código de muestra en python 3.0.

ingrese la descripción de la imagen aquí


Hoy me pidieron (nuevamente) que explicara por qué la división de enteros en Python devuelve el piso del resultado en lugar de truncar hacia cero como C.

Para números positivos, no hay sorpresa:

>>> 5//2
2

Pero si uno de los operandos es negativo, el resultado es floored, es decir, se redondea desde cero (hacia el infinito negativo):

>>> -5//2
-3
>>> 5//-2
-3

Esto molesta a algunas personas, pero hay una buena razón matemática. La operación de división de enteros (//) y su hermana, la operación de módulo (%), van juntas y satisfacen una buena relación matemática (todas las variables son enteros):

a/b = q with remainder r

tal que

b*q + r = a and 0 <= r < b

(asumiendo que ayb son> = 0).

Si desea que la relación se extienda para negativo a (manteniendo b positivo), tiene dos opciones: si trunca q hacia cero, r se volverá negativo, de modo que el invariante cambie a 0 <= abs (r)

En la teoría matemática de números, los matemáticos siempre prefieren la última opción (ver, por ejemplo, Wikipedia). Para Python, hice la misma elección porque hay algunas aplicaciones interesantes de la operación de módulo donde el signo de a no es interesante. Considere tomar una marca de tiempo POSIX (segundos desde el comienzo de 1970) y convertirla en la hora del día. Como hay 24 * 3600 = 86400 segundos en un día, este cálculo es simplemente t% 86400. Pero si tuviéramos que expresar tiempos antes de 1970 usando números negativos, la regla de «truncar hacia cero» daría un resultado sin sentido. Usando la regla del piso, todo funciona bien.

Otras aplicaciones en las que he pensado son los cálculos de las posiciones de los píxeles en los gráficos por computadora. Seguro que hay más.

Para b negativo, por cierto, todo cambia y el invariante se convierte en:

0 >= r > b.

Entonces, ¿por qué C no lo hace de esta manera? Probablemente el hardware no hizo esto en el momento en que se diseñó C. Y el hardware probablemente no lo hizo de esta manera porque en el hardware más antiguo, los números negativos se representaban como «signo + magnitud» en lugar de la representación del complemento a dos que se usa en estos días (al menos para los números enteros). Mi primera computadora fue un mainframe de Control Data y usaba el complemento de uno para enteros y flotantes. ¡Un patrón de 60 unidades significaba cero negativo!

Tim Peters, que sabe dónde están enterrados todos los esqueletos de coma flotante de Python, ha expresado cierta preocupación por mi deseo de extender estas reglas al módulo de coma flotante. Probablemente tenga razón; la regla de truncar hacia infinito negativo puede causar una pérdida de precisión para x% 1.0 cuando x es un número negativo muy pequeño. Pero eso no es suficiente para que yo rompa el módulo entero, y // está estrechamente relacionado con eso.

PD. Tenga en cuenta que estoy usando // en lugar de /: esta es la sintaxis de Python 3, y también se permite en Python 2 para enfatizar que sabe que está invocando la división de enteros. El operador / en Python 2 es ambiguo, ya que devuelve un resultado diferente para dos operandos enteros que para un int y un flotante o dos flotantes. Pero esa es una historia totalmente separada; ver PEP 238.

Publicado por Guido van Rossum en 9:49 a. M.

Deja una respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *

Método Java.lang.ClassLoader.getResourceAsStream ()

sF8rMpXn8oLKSRN7D8evPh 1200 80

Los mejores memes de PS5 para hacerte reír hasta el día del lanzamiento