Programmation Python/Opérateurs

Un livre de Wikilivres.
Aller à la navigation Aller à la recherche


Définition[modifier | modifier le wikicode]

Un opérateur est un symbole (ou un mot réservé) utilisé pour effectuer une opération entre des opérandes.

Une opérande est une variable, un littéral ou bien une expression.

Une expression est une suite valide d'opérateurs et d'opérandes.

Par exemple, dans l'expression :

x = y + 1

Il y a deux opérateurs ( = et +) et trois opérandes (x, y et 1).

Certains opérateurs peuvent avoir des comportements différents en fonction des types d'opérandes sur lesquels ils agissent : on parle alors de surcharge des opérateurs. Exemple :

  • "+" additionne des nombres, mais concatène des chaines de caractères.
  • "*" multiplie des nombres entre eux, mais duplique des chaines de caractères.

Il existe différentes catégories d'opérateur :

Présentation des différents opérateurs[modifier | modifier le wikicode]

les opérateurs d'affectation[modifier | modifier le wikicode]

  • '='
  • Affectation multiple, e.g. x = y = z = 3
  • Affectation parallèle, e.g. x, y = 1 , 0.5
  • Affectation avec opération : la variable est utilisée comme opérande de gauche et utilisée pour stocker le résultat :
a = 5
a *= 2  #  10
a += 1  #  11
a /= 4  #   2.75

les opérateurs logiques[modifier | modifier le wikicode]

Les expressions avec un opérateur logique sont évaluées à 0 ou 1 pour chaque bit des opérandes entiers. Pour chaque bit des opérandes X et Y :

  • X | Y : OU logique.
    Si le bit de X ou le bit de Y est évalué à 1, alors le bit résultant sera 1.
    Sinon, le bit résultant sera 0.
  • X ^ Y : OU exclusif logique.
    Si le bit de X est différent du bit de Y, alors le bit résultant sera 1.
    Sinon, le bit résultant sera 0.
  • X & Y : ET logique.
    Si le bit de X et le bit de Y sont tous les deux évalués à 1, alors le bit résultant sera 1.
    Sinon, le bit résultant sera 0.
  • ~ X : NON logique.
    Le bit résultant est la valeur opposée du bit de X.

les opérateurs booléens[modifier | modifier le wikicode]

Les expressions avec un opérateur booléen sont évaluées à True ou False.

  • X or Y : OU booléen.
    Si X est évalué à True, alors l'expression est True et Y n'est pas évalué.
    Sinon, l'expression est évaluée à la valeur booléenne de Y.
  • X and Y : ET booléen.
    Si X est évalué à False, alors l'expression est False et Y n'est pas évalué.
    Sinon, l'expression est évaluée à la valeur booléenne de Y.
  • not X : NON booléen.
    Evalué à la valeur booléenne opposée de X.

En fait, ces opérateurs supportent n'importe quel type d'opérandes car ils sont convertis implicitement en valeur booléenne pour l'évaluation :

  • Un entier est converti à False s'il vaut 0, et à True sinon ;
  • Une chaîne de caractère, un tableau ou un dictionnaire est converti à False si elle / s'il est vide, et à True sinon. Il s'agit du même comportement que le précédent sur les entiers en utilisant le résultat de la fonction len() donnant la taille sous la forme d'un entier.
>>> not ''      # Chaîne vide
True
>>> not 'abc'   # Chaîne non vide
False
>>> not 'False' # Chaîne non vide
False
>>> not 'True'  # Chaîne non vide
False

Pour les opérateurs or et and avec des opérandes non-booléens, le comportement est donc le suivant

  • X or Y : Retourne X si X équivaut à True, sinon retourne Y.
  • X and Y : Retourne X si X équivaut à False, sinon retourne Y.
>>> 0 or 1
1
>>> 0 and 1
0

les opérateurs de comparaisons[modifier | modifier le wikicode]

Tout comme les opérateurs logiques, les opérateurs de comparaison renvoient une valeur booléenne "True" ou "False". Les opérateurs de comparaisons s'appliquent sur tous les types de base.

  • < strictement inférieur
  • > strictement supérieur
  • <= inférieur ou égal
  • >= supérieur ou égal
  • == égal
  • != différent
  • <> différent, on utilisera de préférence !=
  • X is Y : X et Y représentent le même objet.
  • X is not Y : X et Y ne représentent pas le même objet

Il est possible d'enchaîner les opérateurs : X < Y < Z, dans ce cas, c'est Y qui est pris en compte pour la comparaison avec Z et non pas l'évaluation de (X < Y) comme on pourrait s'y attendre dans d'autres langages.

les opérateurs mathématiques[modifier | modifier le wikicode]

symbole opération types exemples
+ Addition entier, réel

chaîne de caractères

6+4 == 10

"a" + "b"== "ab"

- Soustraction entier, réel 6-4 == 2
* Multiplication entier

réel

chaîne de caractères

6*4 == 24

1.2 * 1 == 1.2

3 * "s" == "sss"

** Puissance entier, réel 12**2 == 144
/ Division entier

réel

6/4 == 1 (Python 2) 1.5 (Python 3)

6./4 == 1.5

// Division entière entier, réel 6//4 == 1
% Modulo entier, réel 6%4 == 2

La division entre deux entiers produit un entier en Python 2, et un nombre à virgule flottante en Python 3.

>>> 8/4
2.0
>>> 8//4
2
Comportement de la division entière et du modulo selon le signe des opérandes
>>> 7 // 4
1
>>> -7 // 4
-2
>>> 7 // -4
-2
>>> -7 // -4
1
>>> 7 % 4
3
>>> -7 % 4
1
>>> 7 % -4
-1
>>> -7 % -4
-3


Priorité des opérations[modifier | modifier le wikicode]

Lorsqu'il y a plus d'un opérateur dans une expression, l'ordre dans lequel les opérations doivent être effectuées dépend de règles de priorité. Sous Python, les règles de priorité sont les mêmes que celles qui vous ont été enseignées au cours de mathématique. Vous pouvez les mémoriser aisément à l'aide d'un « truc » mnémotechnique, l'acronyme PEMDAS :

  • P pour parenthèses. Ce sont elles qui ont la plus haute priorité. Elles vous permettent donc de « forcer » l'évaluation d'une expression dans l'ordre que vous voulez.
    Ainsi 2*(3-1) = 4, et (1+1)**(5-2) = 8.
  • E pour exposants. Les exposants sont évalués ensuite, avant les autres opérations.
    Ainsi 2**1+1 = 3 (et non 4), et 3*1**10 = 3 (et non 59049 !).
  • M et D pour multiplication et division, qui ont la même priorité. Elles sont évaluées avant l'addition A et la soustraction S, lesquelles sont donc effectuées en dernier lieu.
    Ainsi 2-2*2 renvoie -2 et non 0 !Et 2+4/2 renvoie 4.0 et non 3.0 (Rappelez-vous que / est l'opérateur de la division décimale).
    Si deux opérateurs ont la même priorité, l'évaluation est effectuée de gauche à droite.
    Ainsi dans l'expression 59*100/60, la multiplication est effectuée en premier, et la machine doit donc ensuite effectuer 5900/60, ce qui donne 98.0.
  • A et S pour addition et soustraction.

Dans le tableau ci-dessous :

  • les opérateurs regroupés entre deux lignes épaisses ont la même priorité.
  • le sens d'évaluation indique l'ordre d'évaluation des opérations dans une expression :
    • → pour une évaluation de gauche à droite : a OP1 b OP2 c == (a OP1 b) OP2 c ;
    • ← pour une évaluation de droite à gauche : a OP1 b OP2 c == a OP1 (b OP2 c).
  • le type peut être :
    • « groupe » pour un couple de caractères encadrant une ou plusieurs expressions,
    • « binaire » pour un opérateur situé entre ses deux opérandes,
    • « ternaire » pour un opérateur utilisant trois opérandes,
    • « unaire » pour un opérateur précédant son unique opérande.
Précédence des opérateurs du plus au moins prioritaire[1]
Symbole Type Évaluation Nom
{} Groupe Agencement de dictionnaire
() Groupe Agencement de n-uplet
[] Groupe Agencement de liste
. Binaire Attribut
() Groupe Argument de fonction
[] Groupe Partie (opérateur d'indiçage)
await Unaire Attente de résultat
** Binaire Puissance
~ Unaire inversion de bit
+ Unaire Positif
- Unaire Négatif
* Binaire Multiplier
@ Binaire Multiplication de matrices
/ Binaire Diviser
// Binaire Résultat entier d'une division
% Binaire Modulo
+ Binaire Addition
- Binaire Soustraction
<< Binaire Décalage à gauche
>> Binaire Décalage à droite
& Binaire et logique
^ Binaire ou exclusif
| Binaire ou logique
in Binaire Test d'appartenance
not in Binaire Test de non appartenance
is Binaire Test d'égalité type
is not Binaire Test de non égalité de type
< Binaire inférieur
> Binaire supérieur
<= Binaire inférieur ou égal
>= Binaire supérieur ou égal
== Binaire est égal
!= Binaire est différent
not Unaire non booléen
and Binaire et booléen
or Binaire ou booléen
if ... else ... Ternaire expression conditionnelle
lambda Binaire expression lambda

Références[modifier | modifier le wikicode]

Opérateurs et expressions[modifier | modifier le wikicode]

On manipule les valeurs et les variables qui les référencent, en les combinant avec des opérateurs pour former des expressions. Exemple :

a, b = 7.3, 12
y = 3*a + b/5

Dans cet exemple, nous commençons par affecter aux variables "a" et "b" les valeurs "7,3" et "12". Python assigne automatiquement le type « réel » à la variable "a", et le type « entier » à la variable "b".

La seconde ligne de l'exemple consiste à affecter à une nouvelle variable "y" le résultat d'une expression qui combine les opérateurs "*", "+" et "/" avec les opérandes "a", "b", "3" et "5". Les opérateurs sont les symboles spéciaux utilisés pour représenter des opérations mathématiques simples, telles l'addition ou la multiplication. Les opérandes sont les valeurs combinées à l'aide des opérateurs.

Python évalue chaque expression qu'on lui soumet, aussi compliquée soit-elle, et le résultat de cette évaluation est toujours lui-même une valeur. A cette valeur, il attribue automatiquement un type, lequel dépend de ce qu'il y a dans l'expression. Dans l'exemple ci-dessus, la variable "y" sera du type réel, parce que l'expression évaluée pour déterminer sa valeur contient elle-même au moins un réel.

Les opérateurs Python ne sont pas seulement les quatre opérateurs mathématiques de base. Il faut leur ajouter l'opérateur "**" pour l'exponentiation, ainsi qu'un certain nombre d'opérateurs logiques, des opérateurs agissant sur les chaînes de caractères, des opérateurs effectuant des tests d'identité ou d'appartenance, etc.

Signalons au passage la disponibilité de l'opérateur modulo, représenté par le symbole "%". Cet opérateur fournit le reste de la division entière d'un nombre par un autre. Essayez par exemple :

>>> 10 % 3  # 1
>>> 10 % 5  # 0

Cet opérateur pourra être utile notamment pour tester si un nombre "a" est divisible par un nombre "b". Il suffira en effet de vérifier que "a % b" donne un résultat égal à zéro.

Exercices

  1. Testez les lignes d'instructions suivantes :
    >>>  r , pi = 12, 3.14159
    >>>  s = pi * r**2
    >>>  print(s)
    452.38896
    >>>print(type(r), type(pi), type(s))
    <type 'int'>, <type 'float'>, <type 'float'>
    

    Solution On constate qu'une variable appartenant à l'ensemble des nombres entiers, multipliée par un nombre décimal, donne un décimal.

Composition[modifier | modifier le wikicode]

Jusqu'ici nous avons examiné les différents éléments d'un langage de programmation, à savoir : les variables, les expressions et les instructions, mais sans traiter de la manière dont nous pouvons les combiner les unes avec les autres.

Or l'une des grandes forces d'un langage de programmation de haut niveau est qu'il permet de construire des instructions complexes par assemblage de fragments divers. Ainsi par exemple, si vous savez comment additionner deux nombres et comment afficher une valeur, vous pouvez combiner ces deux instructions en une seule :

>>> print(17 + 3)
20

Cela n'a l'air de rien, mais cette fonctionnalité qui paraît si évidente va vous permettre de programmer des algorithmes complexes de façon claire et concise. Exemple :

>>> h, m, s = 15, 27, 34
>>> print("nombre de secondes écoulées depuis minuit = ", h*3600 + m*60 + s)

Attention :

Il y a une limite à ce que vous pouvez combiner ainsi. Le symbole pour l'égalité en mathématique est '='. Le symbole pour l'égalité en programmation Python est '=='

Ainsi par exemple,

  • En mathématique : a + 1 = b ( '=' est symbole de l'égalité et ici on a une équation). m + 1 = b et a * x = b sont ici des équations mathématiques. Cette forme d’écriture est inutilisable pour modifier une variable en programmation.
  • En programmation (Python et dans d'autres langages) : on peut écrire a = a + 1 ( '=' est l'opérateur d'affectation, symbole d'affectation). On affecte à la variable a, à gauche, un nouveau contenu. Cela signifie ici (en programmation uniquement) que la nouvelle valeur de a ( à gauche du signe d'affectation) va être remplacée par l'ancienne valeur de a ( à droite du signe d'affectation) incrémentée ici de la valeur 1. Avec a = a - 2 on décrémente la variable a de la valeur 2.

Nous aurons l'occasion de revenir bientôt sur ce sujet. Mais auparavant, il nous faut encore aborder un autre concept de grande importance.