# Programmation Python/Opérateurs
## Partie 1 - Introduction

* Avant-propos à l'attention des non-programmeurs
* Introduction
* Installation
* Éditeurs
* Programmer en deux minutes
** une messagerie instantanée
** un programme interfacé avec Wikipédia
** un serveur Web

## Partie 2 - Le langage

* Afficher un texte
* Structure d'un programme
* Variables
* Opérateurs
* Structures de contrôle
* Instructions répétitives
* Types
** Numériques
** Booléens
** Chaines de caractères
** Listes
** Tuples
** Dictionnaires
** Dates
** Ensembles
* Fonctions
* Modules
* Exercices
** Palindrome
* Regex
* Programmation orientée objet pour les non-programmeurs
* Classes
* Classes et Interfaces graphiques
* Fichiers
* Exceptions
* Bases de données
** Gestion
* L'interface CGI
* Applications web
* Réseau
* Threads

## Partie 3 - Les bibliothèques

* Bibliothèques pour Python
* L'interface graphique
* Utilisation de fenêtres et de graphismes
** Tkinter
** Widgets
** Turtle
* Les threads
* XML
* JSON
* Tests
* Analyse statique de programmes
* Fabric
* Le Web
** Django
** Karrigell
** Aiohttp

## Partie 1 - Introduction

* Avant-propos à l'attention des non-programmeurs
* Introduction
* Installation
* Éditeurs
* Programmer en deux minutes
** une messagerie instantanée
** un programme interfacé avec Wikipédia
** un serveur Web

## Partie 2 - Le langage

* Afficher un texte
* Structure d'un programme
* Variables
* Opérateurs
* Structures de contrôle
* Instructions répétitives
* Types
** Numériques
** Booléens
** Chaines de caractères
** Listes
** Tuples
** Dictionnaires
** Dates
** Ensembles
* Fonctions
* Modules
* Exercices
** Palindrome
* Regex
* Programmation orientée objet pour les non-programmeurs
* Classes
* Classes et Interfaces graphiques
* Fichiers
* Exceptions
* Bases de données
** Gestion
* L'interface CGI
* Applications web
* Réseau
* Threads

## Partie 3 - Les bibliothèques

* Bibliothèques pour Python
* L'interface graphique
* Utilisation de fenêtres et de graphismes
** Tkinter
** Widgets
** Turtle
* Les threads
* XML
* JSON
* Tests
* Analyse statique de programmes
* Fabric
* Le Web
** Django
** Karrigell
** Aiohttp
[ Modifier le sommaire ]

## Définition

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 :
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 chaînes de caractères.
* "*" multiplie des nombres entre eux, mais duplique des chaînes de caractères.
Il existe différentes catégories d'opérateur :

## Présentation des différents opérateurs
### les opérateurs d'affectation

* 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
Depuis Python 3.8, l'opérateur morse réalise une affectation dans une expression.

### les opérateurs logiques

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

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

### les opérateurs de comparaisons

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

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

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

## Opérateurs et expressions

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. À 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 :
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
* Testez les lignes d'instructions suivantes :
Solution On constate qu'une variable appartenant à l'ensemble des nombres entiers, multipliée par un nombre décimal, donne un décimal.

## Composition

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

## Références

* ↑ https://docs.python.org/fr/3.6/reference/expressions.html#operator-precedence