truncar trabajar simbolo significa que porcentajes porcentaje elevado con como colocar python operators modulo

trabajar - que significa el simbolo de porcentaje en python



Qué significa el signo de porcentaje en Python (8)

¿Qué significa el signo de porcentaje?

Es un operador en Python que puede significar varias cosas dependiendo del contexto. Mucho de lo que sigue ya fue mencionado (o insinuado) en las otras respuestas, pero pensé que podría ser útil proporcionar un resumen más extenso.

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

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

x % y remainder of x / y

Entonces te da el resto / resto que queda si "suelo dividir" x entre y. En general (al menos en Python) dado un número x un divisor y :

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

Por ejemplo, si divide 5 por 2:

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

En general, utilizas la operación de módulo para comprobar si un número se divide de manera uniforme por otro número, eso es porque los múltiplos de un número de módulo ese número devuelve 0:

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

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

if n % x == 0: break

Si considera que n % x == 0 no es muy descriptivo, puede 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 lugar de is_multiple , también podría llamarse evenly_divides o algo similar. Eso es lo que se prueba aquí.

Similar a eso, se usa a menudo para determinar si un número es "impar" o "par":

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

Y en algunos casos también se utiliza para la indexación de matriz / lista cuando se desea el comportamiento de envolvente (ciclo), entonces simplemente modula el "índice" por la "longitud de la matriz" para lograr eso:

>>> 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 para este operador en la biblioteca estándar operator.mod (y el operator.__mod__ alias operator.__mod__ ):

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

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

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

% para cadenas: printf -style String Formatting

Para cadenas el significado es completamente diferente, hay una forma (en mi opinión, la más limitada y fea) para hacer el formato de 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, utilicé %s que significa que espera una cadena. Luego, la cadena es seguida por un % que indica que la cadena en el lado izquierdo estará formateada por el lado derecho. En este caso, el primer %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 opiniones) para formatear cadenas:

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

% en Jupyter / IPython: comandos mágicos

Para citar los docs :

Para los usuarios de Jupyter: los mágicos son específicos y proporcionados por el kernel de IPython. Si los magics están disponibles en un kernel es una decisión que toma el desarrollador kernel por núcleo. 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 elemento de sintaxis % para magias ya que % no es un operador unario válido en Python. Mientras, el elemento de sintaxis tiene significado en otros idiomas.

Esto se usa regularmente en los 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)

El operador % en matrices (en el ecosistema NumPy / Pandas)

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 en 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])

Personalizando el operador % para tus propias clases

Por supuesto, puede personalizar cómo funcionan sus propias clases cuando se aplica el operador % . ¡En general , solo debe usarlo para implementar operaciones de módulo! Pero eso es una guía, no una regla dura.

Solo para proporcionar un ejemplo simple que muestre 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 y luego delega el operador al valor almacenado, pero muestra que se llama a __mod__ 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 %= sin necesidad explícita de implementar __imod__ :

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

Sin embargo, también podría implementar __imod__ explícitamente para sobrescribir la asignación aumentada:

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 __imod__(self, other): print("__imod__ called on ''{!r}''".format(self)) self.value %= other return self def __repr__(self): return "{self.__class__.__name__}({self.value!r})".format(self=self)

Ahora %= se sobrescribe explícitamente para trabajar in situ:

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

En el tutorial hay un ejemplo para encontrar números primos:

>>> for n in range(2, 10): ... for x in range(2, n): ... if n % x == 0: ... print(n, ''equals'', x, ''*'', n//x) ... break ... else: ... # loop fell through without finding a factor ... print(n, ''is a prime number'') ...

Entiendo que el doble == es una prueba de igualdad, pero no entiendo la parte if n % x . Como puedo recorrer verbalmente cada parte y decir lo que hace la afirmación para el ejemplo. Pero no entiendo cómo cae el signo de porcentaje.

¿Qué significa if n % x realmente dice?

Blockquote x% n == 0 lo que significa que x / ny el valor del recordatorio se tomarán como resultado y se compararán con cero ....

ejemplo: 4/5 == 0

4/5 recordatorio es 1

1 == 0 (Falso)

Comprueba si el módulo de la división. Por ejemplo, en el caso, está iterando sobre todos los números de 2 a n y verificando si n es divisible por cualquiera de los números intermedios. En pocas palabras, está comprobando si un número dado n es primo. (Sugerencia: puede verificar hasta n / 2).

El operador de módulo. El resto cuando divide dos números.

Por ejemplo:

>>> 5 % 2 = 1 # remainder of 5 divided by 2 is 1 >>> 7 % 3 = 1 # remainer of 7 divided by 3 is 1 >>> 3 % 1 = 0 # because 1 divides evenly into 3

El% hace dos cosas, dependiendo de sus argumentos. En este caso, actúa como el operador de módulo, lo que significa que cuando sus argumentos son números, divide el primero por el segundo y devuelve el resto . 34 % 10 == 4 ya que 34 dividido por 10 es tres, con un resto de cuatro.

Si el primer argumento es una cadena, lo formatea utilizando el segundo argumento. Esto es un poco complicado, así que me referiré a la documentation , pero solo a modo de ejemplo:

>>> "foo %d bar"%5 ''foo 5 bar''

Sin embargo, el comportamiento del formato de cadena se complementa a partir de Python 3.1 a favor del mecanismo de cadena .format() :

Las operaciones de formateo descritas aquí exhiben una variedad de peculiaridades que conducen a una serie de errores comunes (como la falla al visualizar tuplas y diccionarios correctamente). El uso de la nueva interfaz str.format() ayuda a evitar estos errores, y también proporciona un enfoque generalmente más potente, flexible y extensible para formatear texto.

Y afortunadamente, casi todas las nuevas características también están disponibles desde python 2.6 en adelante.

En Python 2.6, el operador ''%'' realizó un módulo. No creo que lo hayan cambiado en 3.0.1

El operador de módulo le dice el resto de una división de dos números.

Operador de módulo; da el resto del valor izquierdo dividido por el valor correcto. Me gusta:

3 % 1 equivaldría a cero (ya que 3 se divide equitativamente por 1)

3 % 2 equivaldría a 1 (ya que dividir 3 por 2 resulta en un resto de 1).