Que signifie le signe pourcentage en Python

Le % fait deux choses, selon ses arguments. Dans ce cas, il agit comme l'opérateur modulo, sens lorsque ses arguments sont des nombres, il divise la première par la seconde et retourne le reste. 34 % 10 == 4 puisque 34 divisé par 10 est trois, avec un reste de quatre.

si le premier argument est une chaîne, il le formate en utilisant le second argument. C'est un peu complexe, donc je vais voir la documentation, mais seulement comme un exemple:

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

cependant, le comportement de formatage des chaînes est complété à partir de Python 3.1 en faveur de l' chaîne.format() mécanisme:

les opérations de formatage décrites ici montrent une variété de bizarreries qui conduisent à un certain nombre d'erreurs communes (telles que le défaut d'afficher les tuples et les dictionnaires correctement). À l'aide de la plus récente str.format() interface permet d'éviter ces erreurs, et fournit également un généralement plus approche puissante, flexible et extensible pour formater le texte.

et heureusement, presque toutes les nouvelles fonctionnalités sont également disponibles à partir de python 2.6.

bien que cela soit légèrement hors sujet, puisque les gens trouveront cela en cherchant "percentage sign in Python" (comme je l'ai fait), je voulais noter que le signe % est également utilisé pour préfixer une fonction "magic" dans iPython:https://ipython.org/ipython-doc/3/interactive/tutorial.html#magic-functions

que signifie le signe pourcentage?

C'est un opérateur en Python qui peut signifier plusieurs choses, selon le contexte. Une grande partie de ce qui suit a déjà été mentionné (ou suggéré) dans les autres réponses, mais j'ai pensé qu'il pourrait être utile de fournir un résumé plus complet.

% pour les Nombres: Modulo / Reste / le Reste

le signe pourcentage est un opérateur en Python. Il est décrit comme:

x % y       remainder of x / y

donc il vous donne le reste/reste quereste si vous "divisez" x par Y. Généralement (au moins en Python) donné un nombre x et un diviseur y:

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

Par exemple, si vous divisez 5 par 2:

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

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

en général vous utilisez l'opération modulo pour tester si un nombre divise également par un autre nombre, c'est parce que les multiples d'un nombre modulo que le nombre retourne 0:

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

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

C'est comme ça qu'il est utilisé dans votre exemple, il ne peut pas être un premier si c'est un multiple d'un autre nombre (sauf pour lui-même et un), c'est ce que cela fait:

if n % x == 0:
    break

Si vous vous sentez que n % x == 0 n'est pas très descriptif vous pourriez le mettre dans une autre fonction avec un nom plus descriptif:

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

...

if is_multiple(n, x):
    break

au Lieu de is_multiple il pourrait aussi être nommé evenly_divides ou quelque chose de similaire. C'est ce qui est testé ici.

semblable à cela, il est souvent utilisé pour déterminer si un nombre est "bizarre" ou "même":

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

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

et dans certains cas, il est également utilisé pour l'indexation tableau/liste lorsque le comportement wrap-around (cycling) est voulu, alors vous modulez simplement l ' "index" par la "longueur du tableau" pour obtenir cela:

>>> 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

Notez qu'il existe également une fonction pour cet opérateur dans la bibliothèque standard operator.mod (et l'alias operator.__mod__):

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

Mais il y a aussi le affectation augmentée %= qui affecte le résultat à la variable:

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

% pour les chaînes: printfstyle de mise en forme de Chaîne

pour les cordes le sens est complètement différent, là c'est (à mon avis la plus limitée et vilaine) pour la réalisation de la chaîne de mise en forme:

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

voici le % dans la chaîne de caractères représente un conteneur suivi d'une spécification de formatage. Dans ce cas J'ai utilisé %s ce qui signifie qu'il attend une chaîne. Alors la chaîne est suivie par un % qui indique que la chaîne sur le côté gauche sera formaté par le côté droit. Dans ce cas, le premier %s est remplacé par le premier argument this et le deuxième %s est remplacé par le deuxième argument (good).

notez qu'il existe de bien meilleures façons (probablement basées sur l'opinion) de formater les chaînes:

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

% dans Jupyter / IPython: commandes magiques

citation docs:

pour les utilisateurs de Jupyter: la magie est spécifique et fournie par le noyau IPython. Si les magies sont disponibles sur un noyau est une décision qui est prise par le développeur du noyau sur un noyau de base. Pour fonctionner correctement, Magics doit utiliser un élément de syntaxe qui n'est pas valide dans la langue sous-jacente. Par exemple, le noyau IPython utilise le % la syntaxe de l'élément de la magie % n'est pas un opérateur unaire valide en Python. Tandis que l'élément syntaxe a un sens dans d'autres langues.

il est régulièrement utilisé dans les carnets Jupyter et similaires:

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)

% opérateur sur les tableaux (dans le NumPy / Pandas de l'écosystème)

% opérateur est toujours l'opérateur modulo lorsqu'il est appliqué à ces tableaux, mais elle renvoie un tableau contenant le reste de chaque élément dans le tableau:

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

Personnalisation % opérateur pour vos propres classes

bien sûr, vous pouvez personnaliser comment vos propres classes fonctionnent lorsque le % opérateur est appliqué. Généralement vous devrait ne l'utilisez que pour implémenter les opérations modulo! Mais c'est une recommandation, pas une règle absolue.

Juste pour donner un exemple simple qui montre comment cela fonctionne:

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)

Cet exemple n'est pas vraiment utile, il imprime juste et puis délègue l'opérateur à la valeur stockée, mais il montre que __mod__ est appelé quand % s'applique à une instance:

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

notez que cela fonctionne aussi pour %= sans qu'il soit explicitement nécessaire de mettre en œuvre __imod__:

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

>>> a
0

cependant vous pouvez aussi implémenter __imod__ explicitement pour remplacer l'affectation augmentée:

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)

%= est explicitement remplacé en place:

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

>>> a
MyNumber(0)

en python 2.6 l'opérateur ' % ' exécute un module. Je ne pense pas qu'ils l'ont changé en 3.0.1

l'opérateur modulo vous indique le reste d'une division de deux nombres.

Il vérifie si le modulo de la division. Par exemple, dans le cas où vous itérez sur tous les nombres de 2 à n et vérifiez si n est divisible par l'un des nombres entre les deux. Simplement dit, vous vérifiez si un nombre donné n est premier. (Indice: Vous pouvez vérifier jusqu'à n/2).

l'opérateur du module. Le reste quand vous divisez deux nombres.

Par Exemple:

>>> 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

Blockquote x % n = = 0 ce qui signifie que le x/n et la valeur de rappel seront pris comme un résultat et comparer avec zéro....

exemple: 4/5= = 0

4/5 rappel est 1

1= = 0 (False)