web-dev-qa-db-fra.com

Que signifient ces opérateurs (**, ^,%, //)?

Autres que les opérateurs +, -, * et / standard; mais qu'est-ce que cela signifie (**, ^, %, //)?

>>> 9+float(2) # addition
11.0
>>> 9-float(2) # subtraction
7.0
>>> 9*float(2) # multiplication
18.0
>>> 9/float(2) # division
4.5
>>>
>>> 9**float(2) # This looks like a square, (i.e. power 2) 
81.0
>>> 9**float(3) # So ** is equivalent to `math.pow(x,p)` ?
729.0

que diriez-vous de l'opérateur ^?

>>> 9^int(2) # What is `^` in `x^u` , it only allows `int` for `u`
11
>>> 9^int(3)
10
>>> 9^int(4)
13
>>> 9^int(5)
12
>>> 9^int(6)
15
>>> 9^int(7)
14
>>> 9^int(8)
1
>>> 9^int(9)
0
>>> 9^int(10)
3
>>> 9^int(11)
2
>>> 9^int(12)
5

% dans x%m renvoie un module de reste normal, mais uniquement si m < x, pourquoi en est-il ainsi? Qu'est-ce que % fait?

>>> 9%float(2)
1.0
>>> 9%float(3)
0.0
>>> 9%float(4)
1.0
>>> 9%float(5)
4.0
>>> 9%float(6)
3.0
>>> 9%float(7)
2.0
>>> 9%float(8)
1.0
>>> 9%float(9)
0.0
>>> 9%float(10)
9.0
>>> 9%float(11)
9.0
>>> 9%float(12)
9.0

que diriez-vous de l'opérateur //? Que fait-il?

>>> 9//float(2)
4.0
>>> 9//float(3)
3.0
>>> 9//float(4)
2.0
>>> 9//float(5)
1.0
>>> 9//float(6)
1.0
>>> 9//float(7)
1.0
>>> 9//float(8)
1.0
>>> 9//float(9)
1.0
>>> 9//float(1)
9.0
>>> 9//float(0.5)
18.0
pythonmathoperatorsnative
38
alvas
  • **: exponentiation
  • ^: exclusif-ou (au niveau du bit)
  • %: module
  • //: diviser avec le résultat intégral (reste restant)
83
John Zwinck

Vous pouvez trouver tous ces opérateurs dans le référence du langage Python , mais vous devrez faire défiler un peu pour les trouver tous. Comme d'autres réponses l'ont dit:

  • L'opérateur ** effectue une exponentiation. a ** b est a élevé à la puissance b. Le même symbole ** est également utilisé dans les arguments de fonction et les notations d'appel, avec une signification différente (transmission et réception d'arguments de mots clés arbitraires).
  • L'opérateur ^ effectue un xor binaire. a ^ b renverra une valeur avec uniquement les bits définis dans a ou dans b, mais pas les deux. Celui-ci est simple!
  • L'opérateur % sert principalement à trouver le module de deux entiers. a % b renvoie le reste après avoir divisé a par b. Contrairement aux opérateurs de module de certains langages de programmation (tels que C), dans Python un module, il aura le même signe que b, plutôt que le même signe que a. Le même opérateur est également utilisé pour le "vieux" style de formatage de chaîne. a % b peut donc renvoyer une chaîne si a est une chaîne de format et b est une valeur (ou un nuage de valeurs). ) qui peut être inséré dans a.
  • L'opérateur // exécute la version Python de la division entière. La division entière de Python n'est pas exactement la même que la division entière offerte par d'autres langages (comme C), car elle arrondit à l'infini négatif plutôt qu'à zéro. Avec l'opérateur de module, vous pouvez dire que a == (a // b)*b + (a % b). Dans Python 2, la division de plancher est le comportement par défaut lorsque vous divisez deux entiers (à l'aide de l'opérateur de division normal /). Comme cela peut être inattendu (surtout lorsque vous n'êtes pas précis sur les types de nombres que vous obtenez comme arguments d'une fonction), Python 3 a été modifié pour que la division "true" (virgule flottante) devienne la norme la division serait arrondie sinon, et elle ne fera la division "plancher" que sur demande explicite. (Vous pouvez également obtenir le nouveau comportement dans Python 2 en plaçant from __future__ import division en haut de vos fichiers. Je le recommande vivement!)
22
Blckknght

Vous avez raison de dire que ** est la fonction d'alimentation.

^ est XOR au niveau du bit.

% est bien l'opération de module, mais notez que pour les nombres positifs, x % m = x à chaque fois m > x. Cela découle de la définition du module. (De plus, Python spécifie que x % m doit avoir le signe de m.)

// est une opération de division qui renvoie un entier en ignorant le reste. C'est la forme standard de division utilisant le / dans la plupart des langages de programmation. Cependant, Python 3 a modifié le comportement de / pour effectuer une division en virgule flottante . même si les arguments sont des entiers . L'opérateur // a été introduit dans Python 2.6 et Python 3 pour fournir un opérateur de division entière qui se comporterait de manière cohérente entre Python 2 et Python 3. Cela signifie:

| context                                | `/` behavior   | `//` behavior |
---------------------------------------------------------------------------
| floating-point arguments, Python 2 & 3 | float division | int divison   |
---------------------------------------------------------------------------
| integer arguments, python 2            | int division   | int division  |
---------------------------------------------------------------------------
| integer arguments, python 3            | float division | int division  |

Pour plus de détails, voir cette question: Division in Python 2.7. Et 3.

3
Kyle Strand