El operador % (módulo) produce el resto de la división del primer argumento por el segundo. Los argumentos numéricos se convierten primero a un tipo común. Un argumento cero a la derecha genera la excepción ZeroDivisionError. Los argumentos pueden ser números de punto flotante, por ejemplo, 3.14%0.7 es igual a 0.34 (ya que 3.14 es igual a 4*0.7 + 0.34.) El operador modulo siempre produce un resultado con el mismo signo que su segundo operando (o cero); el valor absoluto del resultado es estrictamente menor que el valor absoluto del segundo operando [2].

Tomado de http://docs.python.org/reference/expressions.html

Ejemplo 1: 6%2 se evalúa como 0 porque no hay resto si se divide 6 entre 2 ( 3 veces ).

Ejemplo 2: 7%2 se evalúa como 1 porque hay un resto de 1 cuando 7 se divide por 2 ( 3 veces ).

Así que para resumir, devuelve el resto de una operación de división, o 0 si no hay resto. Así que 6%2 significa encontrar el resto de 6 dividido por 2.

Una expresión como x % y evalúa al 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 lenguajes donde % es el operador de resto. Hay algunas diferencias sutiles (si está interesado en las consecuencias prácticas vea también "Por qué Python's Integer Division Floors" abajo). La precedencia es la misma que la de 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. Asunto de Python: dependiendo de la versión de Python que utilices, % es también el operador de interpolación de cadenas (obsoleto), así que ten cuidado si vienes 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 confundirá bastante. [actualización para Python 3] Comentarios del usuario n00p: 9/2 es 4.5 en python. Tienes que hacer la división de enteros así: 9//2 si quieres que python te diga cuántos objetos enteros quedan después de la división(4). Para ser precisos, la división entera solía ser la predeterminada en Python 2 (ojo, esta respuesta es más antigua que mi hijo que ya está en el colegio y en la época 2.x eran 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 el Python moderno 9 / 2 da como resultado 4,5 efectivamente:

$ 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

[actualización] El usuario dahiya_boy preguntó en la sesión de comentarios: Q. ¿Puedes explicar por qué -11 % 5 = 4 - dahiya_boy Esto es raro, ¿verdad? Si intentas 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" (reloj matemático).
Puedes obtener la explicación directamente de GvR:

Edición - dahiya_boy En Java y iOS -11 % 5 = -1 mientras que en python y ruby -11 % 5 = 4. Bueno, la mitad de la razón es explicada por el Paulo Scardine, y el resto de la explicación está aquí abajo En Java e iOS, % da el resto, es decir, si divides 11 % 5 da Cuento = 2 y resto = 1 y -11 % 5 da Cuento = -2 y resto = -1. Código de ejemplo en swift iOS. [![introduzca la descripción de la imagen aquí][1]][1] Pero cuando hablamos en python su da módulo de reloj. Y su trabajo con la siguiente fórmula mod(a,n) = a - {n * Floor(a/n)} Eso significa, mod(11,5) = 11 - {5 * Floor(11/5)} => 11 - {5 * 2}. Así que, mod(11,5) = 1 Y mod(-11,5) = -11 - 5 Suelo(11/5) => -11 - {5 (-3)} Entonces,mod(-11,5) = 4` Código de ejemplo en python 3.0. [![introduzca aquí la descripción de la imagen][2]]

Por qué Python's Integer Division Floors

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

Para los números positivos, no hay ninguna sorpresa:

>>> 5//2
2

Pero si uno de los operandos es negativo, el resultado se reduce, es decir, se redondea a partir de 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 bonita relación matemática (todas las variables son enteras):

a/b = q with remainder r

tal que

b*q + r = a and 0  (suponiendo que a y b son >= 0).
>
> Si quieres que la relación se extienda para a negativo (manteniendo b positivo), tienes dos opciones: si truncas q hacia cero, r se convertirá en negativo, por lo que la invariante cambia a 0  En la teoría matemática de números, los matemáticos siempre prefieren la última opción (ver, por ejemplo, [Wikipedia][3]). Para Python, hice la misma elección porque hay algunas aplicaciones interesantes de la operación 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 los tiempos antes de 1970 utilizando números negativos, la regla de "truncamiento hacia el 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 ordenador. Estoy seguro de que hay más.
>
> Para b negativo, por cierto, todo simplemente se voltea, y el invariante se convierte:

0 >= r > b.

Entonces, ¿por qué C no lo hace así? Probablemente el hardware no lo hacía en la época en que se diseñó C. Y el hardware probablemente no lo hacía así porque en el hardware más antiguo, los números negativos se representaban como "signo + magnitud" en lugar de la representación de complemento a dos' que se utiliza hoy en día (al menos para los enteros). Mi primer ordenador era un mainframe de Control Data y utilizaba el complemento a uno para los enteros y los flotantes. Un patrón de 60 unos significaba un cero negativo.
>
Tim Peters, que sabe dónde están enterrados todos los esqueletos de punto flotante de Python, ha expresado cierta preocupación por mi deseo de extender estas reglas al módulo de punto flotante. Probablemente tenga razón; la regla de truncar hacia el 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 mí para romper el módulo de enteros, y // está estrechamente acoplado a eso.
>
PS. Observe que estoy usando // en lugar de / -- esta es la sintaxis de Python 3, y también se permite en Python 2 para enfatizar que usted 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 float o dos floats. Pero eso'es una historia totalmente separada; ver PEP 238.
>
> Publicado por Guido van Rossum a las 9:49 AM
  [1]: https://i.stack.imgur.com/33rAl.png
  [2]: https://i.stack.imgur.com/A9Q0C.png
  [3]: https://en.wikipedia.org/wiki/Modulo_operation

Operador de módulo, se utiliza para la división del resto en los enteros, por lo general, pero en Python se puede utilizar para los números de punto flotante.

http://docs.python.org/reference/expressions.html El operador % (módulo) produce el resto de la división del primer argumento por el segundo. Los argumentos numéricos se convierten primero a un tipo común. Un argumento cero a la derecha genera la excepción ZeroDivisionError. Los argumentos pueden ser números de punto flotante, por ejemplo, 3.14%0.7 es igual a 0.34 (ya que 3.14 es igual a 4*0.7 + 0.34.) El operador modulo siempre produce un resultado con el mismo signo que su segundo operando (o cero); el valor absoluto del resultado es estrictamente menor que el valor absoluto del segundo operando [2].