[2021] Operadores: ¿Qué significa el signo de porcentaje en Python? {DH}

¿Qué significa el signo de porcentaje?

Es un operador en Python que puede tener diferentes significados según el contexto. Gran parte de lo que sigue ya se ha mencionado (o insinuado) en las otras respuestas, pero pensé que podría ser útil proporcionar un resumen más extenso.

% para números: módulo / resto / operación restante

El signo de porcentaje es un operador en Python. Descrito como:

x % y       remainder of x / y

Luego te da el resto de eso. restos si «dividir el piso» x por y. Generalmente (al menos en Python) dado un número x y un divisor y:

x == y * (x // y) + (x % y)

Por ejemplo, si divides 5 entre 2:

>>> 5 // 2
2
>>> 5 % 2
1

>>> 2 * (5 // 2) + (5 % 2)
5

En general, use la operación módulo para probar si un número se divide por igual entre otro número, ya que los múltiplos de un número módulo ese número devuelven 0:

>>> 15 % 5  # 15 is 3 * 5
0

>>> 81 % 9  # 81 is 9 * 9
0

Así es como se usa en tu ejemplo, no puede ser primo si es un múltiplo de algún otro número (además de sí mismo y uno), eso es lo que hace esto:

if n % x == 0:
    break

si sientes eso n % x == 0 no es muy descriptivo, podría ponerlo en otra función con un nombre más descriptivo:

def is_multiple(number, divisor):
    return number % divisor == 0

...

if is_multiple(n, x):
    break

En vez de is_multiple también podría llamarse evenly_divides o algo similar. Esto se prueba aquí.

De manera similar, a menudo se usa para determinar si un número es «par» o «impar»:

def is_odd(number):
    return number % 2 == 1

def is_even(number):
    return number % 2 == 0

Y en algunos casos también se usa para la indexación de matrices/listas, si se desea un comportamiento envolvente (bucle), simplemente module «índice» por «longitud de matriz» para lograr esto:

>>> l = [0, 1, 2]
>>> length = len(l)
>>> for index in range(10):
...     print(l[index % length])
0
1
2
0
1
2
0
1
2
0

Tenga en cuenta que también hay una función en la biblioteca estándar para este operador operator.mod (y los seudónimos operator.__mod__):

>>> import operator
>>> operator.mod(5, 2)  # equivalent to 5 % 2
1

Pero también está el aumento de la asignación %= que asigna el resultado a la variable:

>>> a = 5
>>> a %= 2  # identical to: a = a % 2
>>> a
1

Con cadenas el significado es bastante diferente, ahí está desechable (el más limitado y feo en mi opinión) para formatear cadenas:

>>> "%s is %s." % ("this", "good") 
'this is good'

Aquí el % en la cadena representa un marcador de posición seguido de una especificación de formato. En este caso usé %s lo que significa que se espera una cadena. A continuación, la cadena va seguida de una % indicando que la cadena de la izquierda está formateada desde la derecha. En este caso la primera %s se reemplaza por el primer argumento this y el segundo %s se reemplaza por el segundo argumento (good).

Tenga en cuenta que hay formas mucho mejores (probablemente basadas en la opinión) para formatear cadenas:

>>> "{} is {}.".format("this", "good")
'this is good.'

% en Jupyter/IPython: comandos mágicos

Para citar los documentos:

Para usuarios de Jupyter: la magia es específica y proporcionada por el kernel de IPython. Que Magic esté disponible en un kernel es una decisión del desarrollador kernel por kernel. Para funcionar correctamente, Magics debe usar un elemento de sintaxis que no sea válido en el idioma subyacente. Por ejemplo, el kernel de IPython usa el % Sintaxis de elementos para Magic Like % no es un operador unario válido en Python. Mientras que el elemento de sintaxis tiene significado en otros idiomas.

Esto se usa regularmente en cuadernos Jupyter y similares:

In [1]:  a = 10
         b = 20
         %timeit a + b   # one % -> line-magic

54.6 ns ± 2.7 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each)

In [2]:  %%timeit  # two %% -> cell magic 
         a ** b

362 ns ± 8.4 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)

la % Operador en arreglos (en el ecosistema NumPy/Pandas)

la % El operador sigue siendo el operador de módulo cuando se aplica a estas matrices, pero devuelve una matriz que contiene el resto de cada elemento de la matriz:

>>> import numpy as np
>>> a = np.arange(10)
>>> a
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])

>>> a % 2
array([0, 1, 0, 1, 0, 1, 0, 1, 0, 1])

Personaliza el % operador para tus propias clases

Por supuesto, puede personalizar cómo funcionan sus propias clases si eso % se les aplica el operador. usualmente tu Ellos deberían ¡Úselo solo para implementar operaciones de módulo! Pero eso es una guía, no una regla estricta y rápida.

Solo para dar un ejemplo simple que muestra cómo funciona:

class MyNumber(object):
    def __init__(self, value):
        self.value = value

    def __mod__(self, other):
        print("__mod__ called on '{!r}'".format(self))
        return self.value % other

    def __repr__(self):
        return "{self.__class__.__name__}({self.value!r})".format(self=self)

Este ejemplo no es realmente útil, simplemente imprime el operador y luego lo delega al valor almacenado, pero muestra que __mod__ significa cuando % se aplica a una instancia:

>>> a = MyNumber(10)
>>> a % 2
__mod__ called on 'MyNumber(10)'
0

Tenga en cuenta que también funciona para %= no hay necesidad explícita de implementar __imod__:

>>> a = MyNumber(10)
>>> a %= 2
__mod__ called on...