Python-Chap1-Part1

1. Chapitre 1 : Notions de base¶

Contenu du chapitre

1. Chapitre 1 : Notions de base
   1.1. Utilisation de Python
   1.1.1. En ligne de commande
   1.1.2. Utilisation de Python avec un IDE
   1.2. Entrée/Sortie en console
   1.2.1. La fonction print
   1.2.2. Fonction input
   1.3. Les commentaires
   1.4. Notion de variable
   1.4.1. Déclaration de variables
   1.4.2. Syntaxe d'une affectation
   1.4.3. Types de variables
   1.4.4. Transtypage de variables
   1.4.5. Extremes des valeurs numériques
   1.5. Opérateurs en Python
   1.5.1. Les opérateurs arithmétiques
   1.5.2. Les opérateurs d'assignation
   1.5.3. Les opérateurs de comparaison
   1.5.4. Les opérateurs logiques
   1.5.5. Les opérateurs d'identité
   1.5.6. Opérateurs binaires
   1.5.7. Priorité des opérateurs

1.1. Utilisation de Python¶

1.1.1. En ligne de commande¶

Pour lancer python en ligne de commande, il faut utiliser la fenêtre Terminal sous linux ou la fenêtre des commandes sous Windows.

Sous Linux, il faut taper python3 en ligne de commande, ce qui va donner ce qui va ressembler à :

user@station:~$ python3
Python 3.12.3 (main, Aug 14 2025, 17:47:21) [GCC 13.3.0] on Linux
Type "help", "copyright", "credits" or "license" for more information.
>>>

Sous windows on peut utiliser soit cmd, soit PowerShell. Taper Touche Widows + R puis taper cmd dans le champ Ouvrir, ensuite taper Entrer.

La fenêtre de commande s'affiche avec un prompt C:\Users\nom_user> en attente de commande.
nom_user est le nom d'utilisateur de la machine.

On peut ensuite taper python sur la ligne de commande, et on aura quelque chose qui ressemble à :

C:\Users\nom_user> python
Python 3.12.3 (tags/v3.12.3:f6650f9, Apr 9 2024, 14:05:25) [MSC v.1938 64 bit (AMD64)] on win32
Type "help", "copyright", "credits" or "license" for more information.
>>>

Le signe des trois symboles "supérieurs" >>> indique que le python est en mode interactif et en attente de commandes. On peut alors l'utiliser comme calculatrice, exemple :

>>> 1 + 2 + 4 + 7 + 14
28
>>> 1/28 + 1/2 + 1/4 + 1/7 + 1/14
1.0
>>>

Pour sortir de ce mode interactif et fermer l'interpréteur, on tape :
>>> exit()

Il est aussi possible de lancer Pyton en lui fournissant un fichier de commandes d'extension .py où sont stockés des lignes de commandes. Si le fichier est nommé fichierscript.py, il faut alors lancer la commande :
>>> ptyhon fichiersript.py

1.1.2. Utilisation de Python avec un IDE¶

Un IDE (Environnement de Développement Intégré / Integrated Development Environment) pour Python est un logiciel qui réunit tous les outils nécessaires pour écrire, déboguer, tester et gérer du code Python dans une seule interface. Son utilisation simplifie le processus de développement grâce à des fonctionnalités comme l'édition de code avec coloration syntaxique, l'autocomplétion, un débogueur intégré, la gestion de projets, et l'intégration avec des systèmes de contrôle de version.

Les IDEs les plus utilisés pour Python sont :

PyCharm :
Connu pour ses fonctionnalités avancées, comme l'autocomplétion et le débogage, c'est l'un des IDE les plus recommandés pour le développement Python, en particulier pour les projets professionnels et complexes.

Visual Studio Code (VS Code) :
Un éditeur de code polyvalent très populaire et gratuit, personnalisable grâce à un vaste écosystème d'extensions, offrant une excellente expérience pour le développement Python.

Jupyter Lab et Jupyter Notebook :
Idéal pour le prototypage rapide, l'analyse de données et l'enseignement, grâce à son interface interactive qui permet d'exécuter du code par blocs et d'intégrer du texte et des visualisations.

Spyder :
Particulièrement apprécié par les scientifiques des données, car il est inclus dans la distribution Anaconda et offre un environnement de développement avec des outils spécifiques pour l'analyse de données et les expériences scientifiques.

Atom :
Un éditeur de texte gratuit, hautement personnalisable grâce à de nombreux plugins, ce qui le rend attrayant pour les développeurs qui aiment adapter leur environnement de travail.

Remarque : Même si Python peut aussi être utilisé avec m'importe quel éditeur de texte, il est préférable d'utiliser un IDE ou au moins un éditeur dédié à la programmation comme Sublime Text ou Notepad++

1.2. Entrée/Sortie en console¶

1.2.1. La fonction print¶

La fonction print permet d'afficher à la console la valeur d'une ou de plusieurs expressions. Elle permet aussi avec toute sorte d'options de spécifier la façon dont cette ou ces valeurs seront affichées. Plus de details seront donnés ultérieurement. Pour l'instant nous avons besoin de cette fonction pour afficher des résultats et mieux comprendre les commandes.

Pour afficher la valeur d'une expression, il suffit de la placer entre parenthèses à la droite de l'identifieur print :

In [3]:

print(2 * 3.141592653589793 * 10)
print(" Hi HU + OH")

62.83185307179586
 Hi HU + OH

Cet énoncé Python provoque le calcul de l'expression entre parenthèses et la valeur correspondante est simplement passée à la fonction print qui se charge de l'afficher à la console. En fait, cet énoncé précise à l'interpréteur Python d'appeler la fonction print en lui passant comme argument la valeur de l'expression entre parenthèses.

On peut passer un nombre variable d'arguments à la fonction print, en les séparant simplement par des virgules. Par défaut, print affichera chaque valeur à la console en les séparant par un espace, et en ajoutant à la fin un retour à la ligne.

On peut aussi afficher un texte en le mettant entre deux guillemets (") ou deux apostrophes (').

Une commande print() avec rien entre les parenthèses insère une ligne vide

In [1]:

print(2, 1.5,"a", 'b', 'r')
print()
print('périmètre =', 2 * 3.141592653589793 *10)

2 1.5 a b r

périmètre = 62.83185307179586

Dans l'exemple précédent, un retour à la ligne est automatiquement effectué par le premier print qui affiche 2 1.5 a b r. Puis, le second print sans argument effectue un second retour à la ligne qui engendre une ligne blanche et, finalement, le troisième print affiche d'abord la chaîne de caractères périmètre =, suivi de la valeur de l'expression du périmètre.

Nous reviendrons plus à fond sur cette fonction importante tout au long du cours

1.2.2. Fonction input¶

La seconde fonction Entrée/Sortie est input. Elle utile pour la saisi en lignes et permet de lire ce qu'on entre au clavier et stocke le résultat sous la forme d'une chaîne de caractères. Nous étudierons en détail les chaînes de caractères dans la suite. Pour l'instant, on se contente de savoir qu'une chaîne de caractères n'est rien d'autre qu'une séquence de caractères. Par exemple :

In [6]:

réponse = input("Pourquoi apprendre le Python ? : ")
print("Votre réponse est : ", réponse)

Votre réponse est :  C'est utile et c'est amusant

La fonction input reçoit l'argument "Pourquoi apprendre le Python ? : ", qu'elle affiche d'abord à la console, puis elle enregistre toutes les frappes de l'utilisateur jusqu'à la touche de retour (celle qui porte typiquement le symbole ⏎ sur le clavier), et retourne sous forme de chaîne de caractères ce que l'utilisateur a entré au clavier.

Le 2ème énoncé de l'exemple ci-dessus affiche à la console "Votre réponse est " suivi d'un espace, suivi de la valeur associée à la variable réponse (le résultat de l'appel à la fonction input).

1.3. Les commentaires¶

Les commentaires sont très importants en programmation. Ils permettent d'améliorer la lisibilité du code, le rendre maintenable, fournir de la documentation, faciliter la collaboration.

En python, on peut insérer un commentaire avec le symbole dièse (#) en une seule ligne :
Soit en début de ligne : toute la ligne sera ignorée
Soit en fin de commande : la commande sera exécutée et le reste qui va suivre # sera ignoré

Pour une documentation détaillée sur plusieurs lignes, on utilise trois guillemets doubles (""") ou simples (''') pour créer un docstring et qu'il faut donc insérer avant et à la fin de ce commentaire.

In [7]:

"""
Toute cette partie du code
ne sera par prise en compte par le Python
"""
# Voici un commentaire sur une ligne
print("Les commentaires sont tout aussi importants que les commandes") # Là en fin de commande

Les commentaires sont tout aussi importants que les commandes

1.4. Notion de variable¶

1.4.1. Déclaration de variables¶

Dans un programme, on réfère aux données en utilisant des variables.

Par exemple, pour stocker en mémoire et faire référence à la valeur de $\pi$, on nomme cette pi et on écrit :

In [8]:

pi = 3.141592653589793

On peut ensuite utiliser cette variable dans le code, l'afficher par exemple par la commande print

In [12]:

print(pi)

3.141592653589793

Les variables sont créées lors de l'assignation d'une valeur

On n'a pas besoin de la déclaration explicite du type de la variable crée.

Les noms de variables doivent :

• commencer par une lettre (a-z) ou un underscore ( _ ) : a = 2, _G = 9.81
• contenir uniquement des lettres, des chiffres et des underscores
• sont sensibles à la casse (Majuscule / Minuscule).
• ne pas être des mots-clés réservés

Les mots-clés réservés peuvent être listés par la commande : print(keyword.kwlist ) du package keyword

In [14]:

import keyword
print(keyword.kwlist)

['False', 'None', 'True', 'and', 'as', 'assert', 'async', 'await', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']

Les caractères dits spéciaux du clavier, tels

\ ! @ # $ % ? & * ( ) { } [ ] - + = /

ne peuvent être utilisés, ni aucun des symboles de ponctuation.

Par contre, depuis la version 3 de Python, les lettres minuscules et majuscules peuvent inclure des accents afin de créer des identifieurs en français.

Voici quelques exemples d'identifieurs (noms de variables ) valides :

In [ ]:

a = 1
b = 28
b2 = 1.2
b2c = 7e5
constante = 3
Constante = 17  # Différente de constante

10

Lorsqu'un identifieur est invalide, Python affiche un message d'erreur en précisant que la syntaxe est invalide. Par exemple la commande :

>>> 2a = 4

provoquera : SyntaxError: invalid decimal literal

Python va indiquer que le nom de la variable qui commence par un chiffre n'est pas valide (SyntaxError: invalid decimal literal) et précise l'emplacement de l'erreur en positionnant le caractère ^ sous l'endroit où il détecte le problème de syntaxe.

Si on tente d'affecter une valeur à un identifieur mot clé réservé, Python affiche un message d'erreur qui précise que cette opération n'est pas permise. Exemple :

>>>False = 2

   File "/tmp/ipython-input-3827885557.py", line 1
    False = 2
    ^
SyntaxError: cannot assign to False

1.4.2. Syntaxe d'une affectation¶

Affectation simple¶

De façon générale, une affectation simple s'écrit sur une seule ligne : une variable suivie du signe égale (=) et d'une expression composée de constantes, d'identifieurs et d'opérateurs.

L'expression est évaluée par l'interpréteur Python et sa valeur est associée à la variable située à la gauche du signe = :

variable = expression

Une expression est elle-même constituée de constantes, d'identifieurs et d'opérateurs. On peut résumer la syntaxe d'une expression en énumérant différents cas de figure représentant les différentes formes (récursives) d'expressions valides :

1. une constante seule, par exemple 2 ;
2. une variable seule, par exemple pi ;
3. une expression suivie d'un opérateur suivi d'une expression, par exemple 2*pi, où 2 est une expression valide, pi est une autre expression valide et * est un opérateur de multiplication ;
4. une expression entourée de parenthèses, par exemple (2*pi), où 2*pi est une expression valide.

Ainsi, on peut construire des expressions de diverses formes :

In [22]:

# Affectation de constantes

pi = 3.141592653589793           
diamètre = 150

# Affectation de valeurs des expressions 
périmètre = pi*diamètre          
surface = (pi*diamètre ** 2)/4

rayon_hydraulique = surface/périmètre
rayon_conduite = diamètre / 2

# Affichage des résultats
print("Périmètre de la conduite = ", périmètre)
print("Surface de la conduite   = ", surface)
print("Rayon de la conduite     = ", rayon_conduite)
print("Rayon hydraulique        = ", rayon_hydraulique)

Périmètre de la conduite =  471.23889803846896
Surface de la conduite   =  17671.458676442588
Rayon de la conduite     =  75.0
Rayon hydraulique        =  37.5

Noter les accents dans les identifieurs périmètre et diamètre qui sont permis par Python3. En réalité cette pratique n'est pas conseillée, c'est plutôt à éviter.

Aussi, nous avons deux expressions dans l'exemple précédent, où nous avons utilisé trois opérateurs arithmétiques *, / et **. Ces opérateurs seront détaillés avec d'autres dans une sections à part.

En plus des accents, Python permet aussi de définir des variables en caractères Unicode comme les lettre grecs souvent utilisées en maths ($\omega$, $\pi$, $\alpha$, ... etc.)

In [ ]:

T = 0.25
π = 3.1415926535 
ω = 2 * π / T 
print("ω =", ω, "(rad/s)" )

ω = 25.132741228 (rad/s)

Affectation multiple¶

Python permet aussi de réaliser plusieurs affectations en une seule commande et de définir en même temps plusieurs variables comme suit :

var_1, var_2, ... , ..., var_n = val_1, val_2, ... , ..., val_n

Il affect ainsi à chaque var_i une valeur val_i. Les valeurs peuvent êtres des constantes ou des expressions.

In [18]:

pi = 3.141592653589793
e =  2.718281828459045

a, b, c = 1.5, 2*pi, e/2

print("a = ", a, ", b = ", b, ", c =",c)

a =  1.5 , b =  6.283185307179586 , c = 1.3591409142295225

1.4.3. Types de variables¶

Les principaux types de variables dans Python sont :

• Les nombres entiers (int)
• les nombres décimaux ou flottants (floats),
• les nombre complexes (complex)
• les variables booléennes (bool)
• les caractères et chaînes de caractères (str)

Ces types de variables peuvent être regroupés en :

• Variables numériques (int, float, complex)
• Variables textuelles (str)
• Variables logiques (bool)
• Variables de séquence composées d'une ensemble de variables précédentes. Elles contiennent les listes (list) et tuples (tuple). Les chaînes de caractères peuvent également être considérées comme des séquences de caractères.

On se concentre, dans un premier temps, sur les variables numériques, textuelles et logiques. On donne quelques exemples et on utilise la fonction type pour afficher le type de chaque variable déclarée.

In [12]:

n = 100         # un nombre entier (int)
alpha = 0.25    # un nombre réel (float)
z = 2.5 + 1.3j  # un nombre complexe (complex)
univ = "Béjaia" # une chaîne de caractères (str)
rep = True  # une variable booléenne (bool)

print("n ="    , n    , "\t: Cette variable est de type ",type(n))
print("alpha =", alpha, "\t: Cette variable est de type ",type(alpha))
print("z ="    , z    , "\t: Cette variable est de type ",type(z))
print("univ =" , univ , "\t: Cette variable est de type ",type(univ))
print("rep ="  , rep  , "\t: Cette variable est de type ",type(rep))

n = 100 	: Cette variable est de type  <class 'int'>
alpha = 0.25 	: Cette variable est de type  <class 'float'>
z = (2.5+1.3j) 	: Cette variable est de type  <class 'complex'>
univ = Béjaia 	: Cette variable est de type  <class 'str'>
rep = True 	: Cette variable est de type  <class 'bool'>

Remarque 1 : Python permet de préciser explicitement le type d'une variable lors de sa déclaration ou initialisation, on écrit alors : variable : type = valeur. Par exemple :n : int = 100, ou a : float = 1.25.

Cette pratique n'a pas vraiment d'intérêt que pour la lisibilité du code, elle n'interdit pas l'écriture par exemple n : int = 0.25. Cela ne provoque pas d'erreur mais apporte une ambiguïté à la lecture et la maintenance du code.

In [ ]:

n : int = 100
a : float = 1.25
b : int = 5.34         # python va basculer au type float à cause de la valeur

c : str = "du texte"
d : str = 12345         # python va basculer au type int

print("n =", n, type(n))
print("a =", a, type(a))
print("b =", b, type(b))
print("c =", c, type(c))
print("d =", d, type(d))

n = 100 <class 'int'>
a = 1.25 <class 'float'>
b = 5.34 <class 'float'>
c = du texte <class 'str'>
d = 12345 <class 'int'>

Remarque 2
Python permet aussi de déclarer une variable sans lui assigner de valeur, elle est dite de type ou de classe nulle (<class none>).

• None est une classe unique en Python qui représente un état indéfini ou l'absence de valeur.
• None est utile surtout dans les tests de comparaisons pour voir si la valeur d’une variable est vide.
• Elle s'utilise aussi pour initialiser une variable à une valeur vide avec l’intention de la remplir après sur tout dans un processus répétitif (boucle).

Exemple :

In [ ]:

x = None
print("x = ", x, ", elle est de type: ",type(x))

x= None , elle est de type:  <class 'NoneType'>

1.4.4. Transtypage de variables¶

Sauf dans quelques cas particuliers, Python permet de convertir une variable d'un type à un autre, comme par exemple transformer un entier en chaîne de caractères ou une chaîne en entier pour effectuer des calculs.

Cette conversion est appelée transtypage (ou casting), elle est très importante dans le traitement de données et la lecture de fichiers, car elle permet de convertir notamment une chaîne de caractères en nombres.

Pour convertir une variable, on la met entre parenthèses précédées du nom de la classe du type vers lequel on veut la convertir. Par exemple, pour convertir un entier en chaîne de caractères, on écrit : char = str(entier).

Il faut faire attention lorsque la conversion se fait vers un type plus petit, une perte d'information est possible. Par exemple, convertir un nombre à virgule flottante en entier, on perd de la précision par arrondissement ou par troncature.

Voici quelques exemples:

In [ ]:

# une variable lecture de type str est convertie en un entier
lecture = "1234"
entier = int(lecture)

#calcul des doubles
d_entier  = 2*entier    # Fait un calcul arithmétique
d_lecture = 2*lecture   # Attention ! ici la chaîne est dédoublée

# affichage du nombre récupéré et de son double
print("Le nombre récupéré est  :", entier)
print("Le double du nombre est :", d_entier)

# affichage de la lecture et de son double
print("La chaîne de caractère lecture est :", lecture)
print("Le double de lecture est :", d_lecture)

Le nombre récupéré est  : 1234
Le double du nombre est : 2468
La chaine de caractère lecture est : 1234
Le double de lecture est : 12341234

In [5]:

# On reprend l'exemple précédent avec une lecture d'un réel
# une variable lecture de type str est convertie en un entier
lecture = "123.785432"
reel = float(lecture)
entier = int(reel)
arrondi = round(reel, 2)

print("Le nombre reel et son double :" , reel, 2*reel)
print("Le nombre reel converti en nombre entier :", entier)
print("Le nombre reel arrondi à 2 chiffres :", arrondi)

Le nombre reel et son double : 123.785432 247.570864
Le nombre reel converti en nombre entier : 123
Le nombre reel arrondi à 2 chiffres : 123.79

Remarques :

1. La conversion d'un réel en entier le fait tronquer. Pour l'arrondir on utilise la fonction round qui prend en donnée le flottant et le nombre de chiffres après la virgule.

2. Dans le code précédent, si on utilise la commande : entier = int(lecture), elle provoquera une erreur de conversion

3. La conversion en booléen (bool), d'une variable nulle, ou None, ou vide donnera False. Voici quelques exemples :

In [122]:

a = None              # variable en étét indéfini
b = False             # Variable logique
c = 0                 # Entier ou réel, ou complexe : c = 0.0 et c = 0+0j
d, e = '', ""         # cahine de caractère vide
f,g,h = [], (), {}    # variables de séquence

print("  a =", a, " \t ", type(a), "\t bool(a) = ", bool(a))
print("  b =", b, " \t ", type(b), "\t bool(b) = ", bool(b))
print("  c =", c, " \t ", type(c), "\t bool(c) = ", bool(c))
print("  d =", d, " \t ", type(d), "\t bool(d) = ", bool(d))
print("  e =", e, " \t ", type(e), "\t bool(e) = ", bool(e))
print("  f =", f, " \t ", type(f), "\t bool(f) = ", bool(f))
print("  g =", g, " \t ", type(g), "\t bool(g) = ", bool(g))
print("  h =", h, " \t ", type(h), "\t bool(h) = ", bool(h))

  a = None  	  <class 'NoneType'> 	 bool(a) =  False
  b = False  	  <class 'bool'> 	 bool(b) =  False
  c = 0  	  <class 'int'> 	 bool(c) =  False
  d =   	  <class 'str'> 	 bool(d) =  False
  e =   	  <class 'str'> 	 bool(e) =  False
  f = []  	  <class 'list'> 	 bool(f) =  False
  g = ()  	  <class 'tuple'> 	 bool(g) =  False
  h = {}  	  <class 'dict'> 	 bool(h) =  False

1.4.5. Extremes des valeurs numériques¶

Les valeurs max et min des variables numériques (int et float) ainsi que les précisions des calculs et sont accessibles en consultant sys.int_info et sys.float_info

In [26]:

import sys
alpha = sys.float_info.max
print("le plus grand nombre réel est", alpha)
print("un tout petit peu plus_grand . . . :", alpha*1.00000000000001)  #donne `inf`

# print("plus d'informations : sys.int_info) et sys.float_info")

le plus grand nombre réel est 1.7976931348623157e+308
un tout petit peu plus_grand . . . : inf

1.5. Opérateurs en Python¶

1.5.1. Les opérateurs arithmétiques¶

Python possède plusieurs types d'opérateurs permettant d'assembler des expressions. Les opérateurs arithmétiques de base sont les suivants :

• + (addition) ;
• - (soustraction) ;
• * (multiplication) ;
• / (division régulière) ;
• // (division entière) ;
• % (reste de la division entière); 
• ** (exponentiation).

La cellule ci-dessous montre quelques exemples de calculs avec ces différents opérateurs (on peut se servir de Python comme d'une calculatrice).

A bien comprendre notamment la distinction entre la division régulière (/) qui produit toujours un nombre à virgule flottante, et la division entière (//) qui produit toujours un nombre entier, en tronquant s'il y a lieu la partie fractionnaire du résultat.

In [5]:

print("19/7 =", 19/7)
print("19 = 7 *", 19//7, "+", 19%7)

19/7 = 2.7142857142857144
19 = 7 * 2 + 5

In [21]:

a : int = 12.3
print("a = ", a, "   type de a :", type(a))

a =  12.3    type de a : <class 'float'>

1.5.2. Les opérateurs d'assignation¶

Ils servent à affecter (assigner) des valeurs à des variables et sont regroupés dans le tableau qui suit.

Opérateur	Exemple	Opération	Signification
=	x = y	Affectation	x = y : affecte la valeur de y à x
+=	x += y	Incrémentation	x = x + y : augemente x de y
-=	x -= y	Décrémentation	x = x - y : réduit x de y
*=	x *= y	Multiplication	x = x * y : multiplie x par y
/=	x /= y	Division	x = x / y : divise x sur y
**=	x **= y	Puissance	x = x**y : éléve x à la puissance y
%=	x %= y	Modulo	x = x % y : affecte à x le reste de la division de x sur y
//=	x //= y	Quotient	x = x // y : divise x sur y avec troncature

In [110]:

x = 7     # opération d'assignement 
y = 4
print(x)  # affiche x avant de le modifier
x += y    # modifie x en l'incrémentant de y
print(x)  # affiche x modifié

7
11

1.5.3. Les opérateurs de comparaison¶

Ils servent à comparer deux variables et réaliser des testes logiques, appelés aussi condition :

Opérateur	Exemple	Signification
==	x == y	égalité : teste si x et y sont égaux. Ne pas confondre avec l'affectation
!=	x != y	différent : teste si x et y sont différents
>	x > y	supérieur : teste si x est supérieur à y
<	x < y	inférieur : teste si x est inférieur à y
>=	x >= y	supérieur ou égale : teste si x est supérieur ou égale à y
<=	x <= y	inférieur ou égale : teste si x est inférieur ou égaleà y

Le résultat d'une opération de comparaison peut être affecté (assigné) à une variable booléeen. Ils prennet la valeur True (1) si la condition est vraie et False (0) sinon.

In [16]:

x = 1.5
y = 2.4
A = x == y   # on crée la variable A et on lui affecte le résultat du test x égale y 
print("A =", A, "  ;   Type de A :", type(A))

A = False   ;   Type de A : <class 'bool'>

1.5.4. Les opérateurs logiques¶

Les opérateurs logiques s'appliquent sur les variables booléennes, ils servent aussi à la combinaison des opérateurs de comparaison.

Opérateur	Exemple	Signification
and	C = A and B	'et' logique : C est vraie si A et B sont vraies, sinon C est fausse
or	C = A or B	'ou' logique : C est vraie si l'une des A ou B est vraie, sinon C est fausse
not	C = not A	'négation' : C est vraie si A est fausse, sinon C est fausse

A et B sont deux variables booléennes.

In [113]:

x = 12      # x et y sont des floats    
y = 12.0 

A = x < y    #A et B sont des booléens
B = x == y

print("A =", A, " type(A) =", type(A))        
print("B =", B, " type(B) =", type(B))

print("A et B :", A and B)
print("A ou B :", A or  B)
print("A égale à B :", A == B)
print("Non (A égale à B) :",not A==B )
print("A égale (Non B) :", A==(not B))   # A == not B provoque une erreur

A = False  type(A) = <class 'bool'>
B = True  type(B) = <class 'bool'>
A et B : False
A ou B : True
A égale à B : False
Non (A égale à B) : True
A égale (Non B) : True

1.5.5. Les opérateurs d'identité¶

Les opérateurs d'identité sont : is et is not

Ils sont utilisés pour vérifier si deux variables font référence au même objet, et non pour comparer leurs valeurs.

• is renvoie True si les objets sont identiques (ont le même identifiant en mémoire)
• is not renvoie True si les objets sont différents.

Cette distinction est importante car deux objets peuvent avoir la même valeur (être égaux) mais ne pas être le même objet.

In [ ]:

x = 2.0 + 1.2j
y = 2.0 + 1.2j

print("x égale à y         :", x == y)   # rend True si x égale à y 
print("x est le même que y :", x is y)   # rend True uniquement si x et y sont identiques

print("id(x) =", id(x)) # affiche les ids 
print("id(y) =", id(y))  

# on peut tester si x est un complexe de deux manières
print("x est un complexe :", type(x) is complex)    # avec is
print("x est un complexe :", isinstance(x,complex)) # avec isinstance, qui est la plus utilisé 

x égale à y         : True
x est le même que y : False
id(x) = 1586380643216
id(y) = 1586380642384
x est un complexe : True
x est un complexe : True

1.5.6. Opérateurs binaires¶

Python permet d'exprimer la valeur des entiers via différentes bases numériques (le binaire, le décimal et l'hexadécimal). Les opérateurs binaires s'appliquent dans le système binaire. Ils ne nous intéressent pas dans ce cours, ils seront donc iniquement cités sans plus de détails:

Opérateurs binaires Python : & (AND) | (OR) ^ (XOR) ~ (NOT)

1.5.7. Priorité des opérateurs¶

La priorité d'exécution sous Python des opérateurs est comme suit:

Opérateur de arithmétiques : ** , +x , -x , ~x , * , / , // , % , + ,-

Les opérateurs logiques (de comparaison) : ==,!=,>,>=,<,<=,is,is not,in,not in,not,and,or.

En cas de doute ou lorsqu'on veut isoler une operation, on utilise les parenthèses () qui passe en priorité.