Programmation Python/Opérateurs

Un livre de Wikilivres.
Sauter à la navigation Sauter à 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

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

Les expressions avec un opérateur logique sont évaluées à "True" ou "False".

  • X or Y : OU logique.
    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 logique.
    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 logique.
    Evalué à la valeur booléenne opposée de X.

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 types exemples
+ entier, réel

chaîne de caractères

6+4 == 10

"s" + "s"== "ss"

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

réel

chaîne de caractères

6*4 == 24

1.2 * 1 == 1.2

3 * "s" == "sss"

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

réel

6/4 == 1 (*)

6./4 == 1.5

// entier, réel 6//4 == 1
% entier, réel 6%4 == 2

(*) Attention à la division en Python 2.7 et Python 3.5

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. Si la division était effectuée en premier, le résultat serait 59.0 (rappelez-vous ici encore qu'il s'agit d'une division classique).
  • A et S pour addition et soustraction.
Précédence des opérateurs (du plus au moins prioritaire[1])
Symbole Nom
{} Dictionnaire
() Argument
[] Partie (opérateur d'indiçage)
. Attribut
** Puissance
~ inversion de bit
+ Positif
- Négatif
* Multiplier
/ Diviser
// Résultat entier d'une division
% Modulo
Plus
Moins
<< Décalage à gauche
>> Décalage à droite
& et logique
^ ou exclusif
| ou logique
< inférieur
> supérieur
<= inférieur ou égal
>= supérieur ou égal
== est égal
!= est différent
is est
in appartient
not non booléen
and et booléen
or ou booléen
lambda 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.