Vous êtes sur la page 1sur 22

PrépaVogt : Cycle IGEA

Ingénieur en Géo-sciences,
Environnement et Agro-industrie

CHAPITRE 1

L E S VA R I A B L E S E N P Y T H O N
ANNÉE 2022-2023

C H A P I T R E 1 : VA R I A B L E S E N P Y T H O N 1/22

PrépaVogt : Cycle IGEA


Ingénieur en Géo-sciences,
Environnement et Agro-industrie

Sommaire
Chapitre 1 : Les variables ...................................................................................................4

Objectifs pédagogiques .....................................................................................................4

Prérequis avant la séance ..................................................................................................4

Quelques notions sur l’architecture des ordinateurs ..........................................................5

Quelques notions sur l’architecture des ordinateurs ..............................................................................5

Hardware ..........................................................................................................................5

Modèle de Von Neumann ...................................................................................................................5


Le processeur .....................................................................................................................................6
La mémoire principale ........................................................................................................................6
Les bus ...............................................................................................................................................6

Software ............................................................................................................................6

Système d’exploitation ........................................................................................................................6


Langages de programmation ...............................................................................................................7
Les Langages compilés ........................................................................................................................8
Langages interprétés ..........................................................................................................................8
Différences entre langage compilé et langage interprété .......................................................................8

Initiation à Python ............................................................................................................10

Présentation .....................................................................................................................................10
Installation .......................................................................................................................................10
Environnement IDLE ..........................................................................................................................11
Environnement Anaconda ..................................................................................................................11
Environnement VS Code ....................................................................................................................12
Modes d’exécution ...........................................................................................................................13
Les variables dans Python .................................................................................................................13

Petit Rappel ......................................................................................................................13

Variables et Objets en Python ..........................................................................................13

Variable en Python ...........................................................................................................................13


Objet en Python ...............................................................................................................................14
Les types de données simples en python .............................................................................................14

C H A P I T R E 1 : VA R I A B L E S E N P Y T H O N 2/22



PrépaVogt : Cycle IGEA


Ingénieur en Géo-sciences,
Environnement et Agro-industrie

Les nombres .....................................................................................................................14

Les entiers ........................................................................................................................................15


Les ottants ......................................................................................................................................15
Les complexes ..................................................................................................................................16
Fonctions mathématiques supplémentaires ..........................................................................................17

Les Booléens .....................................................................................................................18

Les chaînes de caractères .................................................................................................19

Opérations sur les chaines de caractères ............................................................................................19


Accès aux caractères d'une chaîne de caractères ...............................................................................20
Quelques méthodes pratiques ............................................................................................................21
Méthodes upper et lower ..................................................................................................................22
Autres méthodes usuelles des str ........................................................................................................22

C H A P I T R E 1 : VA R I A B L E S E N P Y T H O N 3/22
fl


PrépaVogt : Cycle IGEA


Ingénieur en Géo-sciences,
Environnement et Agro-industrie

C H A P I T R E 1 : L E S VA R I A B L E S
OBJECTIFS PÉDAGOGIQUES
A la n de ce cours chaque étudiant en classe de 1ère année Agro doit-être capable de :

✓ Expliquer le fonctionnement général d’un ordinateur en moins de 5 lignes ;

✓ Présenter à l’aide d’un schéma annoté l’architecture de Von Neumann ;

✓ Citer au moins 5 langages de programmation ;

✓ Faire la différence entre un langage de programmation interprété et un langage de programmation


compilé ;

✓ Lister les types de données manipulées par Python avec une performance de 100% ;

✓ Faire la différence entre un objet et une variable Python ;

✓ Déclarer une variable ottante avec une performance de 100% ;

✓ Déclarer une variable entière avec une performance de 100% ;

✓ Déclarer une variable complexe avec une performance de 100% ;

✓ Déclarer une variable string avec une performance de 100%;

✓ Manipuler une variable string avec une performance de 100%.

P R É R E Q U I S AVA N T L A S É A N C E
✓ Installer l’environnement IDLE de python

C H A P I T R E 1 : VA R I A B L E S E N P Y T H O N 4/22
fi

fl

PrépaVogt : Cycle IGEA

Ingénieur en Géo-sciences,

Environnement et Agro-industrie

Q U E L Q U E S N O T I O N S S U R L’A R C H I T E C T U R E D E S O R D I N AT E U R S

Quelques notions sur l’architecture des ordinateurs

Hardware

Modèle de Von Neumann

Un ordinateur peut être décrit comme une machine de traitement de l’information : il est capable de faire
les quatre tâches suivantes :

1. Acquérir de l’information. Cela se fait par l’intermédiaire de périphériques d’entrées comme le


clavier, la souris, le scanner, etc.

2. Stocker de l’information. Ceci est possible grâce aux mémoires de masse (disque dur, clé USB, etc.)
destinées à un stockage persistant même en absence d’alimentation électrique, de la mémoire vive
(la RAM), aussi appelé mémoire de travail, utilisée par le processeur pour traiter les données.

3. Transformer l’information. C’est le rôle du processeur (le CPU1).

4. Restituer l’information. On dispose pour cela des périphériques de sortie, comme l’écran,
l’imprimante, les enceintes, etc.

Outre les périphériques (entrée/sortie), un ordinateur (l’unité centrale) est composé de beaucoup de
composants (carte réseau, disque dur, mémoire...) mais, pour calculer, trois entités suffisent :

1. Le processeur qui effectue des calculs sur des nombres, c’est le "cerveau" de l’ordinateur ;

2. La mémoire qui stocke ces nombres dans la mémoire ;

3. Les bus qui assurent le déplacement des données entre le processeur et la mémoire.

La figure suivante présente la représentation symbolique la plus classique (modèle de Von Neumann)

Figure 1 : Architecture de Von Neumann

1 Central Processing Unit

C H A P I T R E 1 : VA R I A B L E S E N P Y T H O N 5/22
PrépaVogt : Cycle IGEA

Ingénieur en Géo-sciences,

Environnement et Agro-industrie

Détaillons un peu le rôle des différents composants :

Le processeur

Le processeur exécute les suites d’instructions élémentaires des programmes. Ces instructions
correspondent à des actions très simples (additionner deux nombres, lire ou écrire dans une case
mémoire, etc.), elles sont cadencées par une horloge qui assure que tous les composants agissent en
même temps. Le nombre de calculs par seconde est nommé la fréquence du processeur. Un processeur
de 3 GHz effectue par exemple 3 milliard de calculs par seconde.

Le processeur est composé de deux éléments :

✓ L’unité de commande : elle est responsable de la lecture en mémoire et du décodage des


instructions.

✓ L’unité de traitement : l’UAL2 (unité arithmétique et logique) exécute les instructions.

La mémoire principale

Bien que les informations traitées par un ordinateur soient de différents types (texte, image, son, etc.),
elles sont toujours représentées et manipulées par l’ordinateur sous forme binaire, soit une suite de 0 et
de 1 (qu’on appelle bit pour binary digit, chiffre binaire en anglais). Ces 0 et 1 proviennent des milliards
de transistors qui composent le processeur, chacun n’a que deux états de tension de sortie : 0 volt ou
bien 5 volts.

La mémoire principale d’un ordinateur est divisée en emplacements de taille fixe, en général 8 bits, soit
un octet. Chaque emplacement est repéré par un numéro qu’on appelle son adresse. Actuellement, les
adresses sont codées sur 32 ou 64 bits, ce qui autorise au maximum 232 ou 264 adresses différentes, un
processeur avec un bus d’adresses de 32 bits ne peut donc pas gérer plus de 4 Go de mémoire vive en
théorie (Ceci explique la généralisation actuelle des processeurs 64 bits pour accompagner
l’augmentation de la mémoire vive associée à un ordinateur).

Les bus

La circulation de l’information entre ces différents éléments est assurée par des connexions appelées bus
(bus de données et bus d’adresse) ; il s’agit tout simplement de fils conducteurs utilisés pour
transmettre des signaux binaires.

Software

Système d’exploitation

Le système d’exploitation est un programme chargé en mémoire vive dès le démarrage de l’ordinateur et
qui reste en mémoire jusqu’à son extinction. Il gère le lancement des applications, identifie les utilisateurs,
organise le disque dur, contrôle les accès aux ressources de l’ordinateur, isole les programmes des détails
du matériel. Un système d’exploitation sait comment fonctionne le disque dur ou comment marche une

2 ALU : Arithmetic and Logic Unit (en langue anglaise)

C H A P I T R E 1 : VA R I A B L E S E N P Y T H O N 6/22
PrépaVogt : Cycle IGEA

Ingénieur en Géo-sciences,

Environnement et Agro-industrie
carte graphique (grâce aux pilotes logiciels) : ainsi, quand un logiciel veut afficher une image, il va
demander au système d’exploitation de le faire.

C’est le système d’exploitation qui doit connaître les détails du matériel (dans ce cas le type de carte
graphique et les instructions qu’elle comprend) et c’est le seul programme à pouvoir autoriser un logiciel
à écrire sur le disque dur ou à accéder à la mémoire ou au processeur. Le système d’exploitation est donc
l’intermédiaire entre les logiciels, l’utilisateur et le matériel (chez les ingénieurs comme vous on dit
«interface» .

Cette répartition des rôles simplifie grandement l’écriture des programmes d’application, Actuellement,
les systèmes d’exploitation les plus connus appartiennent à l’une des trois familles suivantes : la famille
MAC (Mac OS X), la famille Linux et la famille Windows (Bien sur il y'a aussi Chrome OS de Google,
Android 🤖 , ou Harmony OS de Huawei 😌 ).

Langages de programmation

Un programme informatique n’est qu’une suite d’instructions, autrement dit un certain nombre de mots
mémoire écrits en binaire (Je sais déjà que vous le savez 😌 , mais la répétition n’est-elle pas la mère des
sciences?) . L’ensemble de ces instructions s’appelle le langage machine. Le langage machine n’est pas
compréhensible par l’être humain (mis à part quelques informaticiens! Nécessairement plus «chelou»
que le professeur d’informatique), c’est pourquoi a été inventé l’assembleur, un langage proche du
langage machine mais un peu plus lisible . Voici un exemple de programme en assembleur (Nous allons
pas nous attarder sur l’assembleur, l’exemple c’est juste pour permettre aux étudiants de IGEA de se
venter auprès de ceux d’INGE. Cela peut constituer un atout non négligeable pour …😉 ) :

loadn 2 R1 # plac l n o m b r e dans le registre R1


storer R1 R2 # c o p i l c o n t e n u de R1 dans R2
add R0 R2 # p l a c l r é s u l t a de l'addition de R0 et de R2 dans R2
store R1 1 # place le contenu de R1 à l'adresse mémoire @1

Coder en assembleur est donc plus rapide, mais manipuler les données et les placer octet par octet dans
la mémoire ou dans les registres3 est bien trop long (donc fastidieux 🤨 ). De plus, ce langage a un
énorme défaut, il n’est pas portable (car chaque processeur possède son propre jeux d’instructions4,
c’est-à-dire un ensemble fini d’instructions différents que le processeur peu exécuter)  ! Un programme
écrit en assembleur, dans le jeu d’instruction d’un processeur Intel pentium IV, ne sera pas
compréhensible par un processeur Intel Core i5 (Et oui!). Pour ne pas écrire des programmes qui
fonctionnent sur le processeur A, et ne fonctionne pas sur le processeur B, il fallut mettre sur pied des
langages de programmation plus évolués : les langages haut niveau (C’est ce type de langage que nous
allons manipulé pendant le cours d’informatique!).

Les langages de haut niveau ont été inventés pour palier à ces inconvénients. Le code écrit dans ce type
de langage est proche du langage humain (Ce n'est pas dans ce cours que vous allez apprendre les

3 Petite mémoire rapide, interne au processeur.


4 Le jeu d’instruction (Instruction Set Architecture, en langue anglaise) d’un processeur représente, l’ensemble finis d’instruction que le processeur peut
comprendre, et exécuter.

C H A P I T R E 1 : VA R I A B L E S E N P Y T H O N 7/22
PrépaVogt : Cycle IGEA
Ingénieur en Géo-sciences,
Environnement et Agro-industrie

choses compliquées de Chloé O’Brian de la série 24h Chrono😉 ). Il est donc plus facile de les utiliser. Les
langages de programmation de haut niveau se divise en deux groupes :

✓ Les langages compilés

✓ Les langages interprétés

Les Langages compilés


Dans ces langages, le code source (le programme écrit par le programmeur, il est parfois nécessaire de le
rappeler on ne sait jamais avec les T.O.T.O) est tout d’abord transformé entièrement en langage machine
(un code binaire) et sauvegardé dans un chier exécutable (les fameux chiers .exe, .msi, .com, bien sur,
ceux qui ont installé IDLE, et Anaconda savent de quoi il s’agit!). Cette opération est appelée
«compilation» et est effectuée par un programme appelé compilateur (ça n’a rient à voir avec les
compile musicale où les compilations musicales, que vous avez dans vos téléphones. Comme on ne sait
jamais avec les T.O.T.O, la remarque en vaut la peine 😌 ). Un programme compilé est donc fortement lié à
la machine et au système d’exploitation où il a été compilé. L’opération est effectuée une fois, et à chaque
fois le chier exécutable est utilisé à l’exécution du programme. Il existe plusieurs langages de ce type :
C, C++, Pascal, etc.

Langages interprétés
A la différence des langages compilés, pour les langages interprétés, aucun chier exécutable n’est
produit. Le code source est interprété par un programme, appelé «interpréteur» (On a bien dit
«interpréteur», parce que certains T.O.T.O peuvent comprendre interprète🤨 ). Ce dernier va utiliser le
code source et les données d’entrée pour calculer les données de sortie. L’interprétation s’effectue ainsi
« pas à pas », l’interpréteur va exécuter les lignes de code une par une, en décidant à chaque étape ce
qu’il va faire ensuite. Pour exécuter un tel programme, l’interpréteur est donc nécessaire à chaque
lancement dudit programme. Les langages de ce type sont multiples : PHP, SQL, Perl, SQL, Tcl, JavaScript,
Python, etc (Je sais que vous avez reconnu beaucoup d’entre eux même les T.O.T.O. En effet,
l’informatique cette année c’est surtout pour les T.O.T.O)

Différences entre langage compilé et langage interprété


On pourrait discuter très longtemps des avantages et inconvénients des différents types de langages (Je
vous épargne la bible sur les différences 😌 ) mais les deux points qui sont les plus intéressants sont les
suivants :

✓ Dans un langage interprété, le même code source pourra marcher directement sur tout ordinateur.
Avec un langage compilé, il faudra (en général) tout recompiler à chaque fois ce qui pose parfois des
soucis.

✓ Dans un langage compilé, le programme est directement exécuté sur l'ordinateur, donc il sera en
général plus rapide que le même programme dans un langage interprété.

Aujourd’hui, les performances des processeurs est venue à bout du problème d’extrême lenteur des
langages interprétés (À une époque c’était dans la bouche de tous les programmeurs). Les besoins

C H A P I T R E 1 : VA R I A B L E S E N P Y T H O N 8/22

fi

fi

fi

fi
PrépaVogt : Cycle IGEA
Ingénieur en Géo-sciences,
Environnement et Agro-industrie

Figure 2: Langage compilé vs langage interprété


d’inter-opérabilités et de performances des programmes ont ouvert la voie à un troisième type de
langage qui réunit les qualités des langages interprétés et compilés : les langages compilés en langage
intermédiaire (généralement appelé byte code). Les exemples les plus populaires de ce type sont Java
(J’ai bien dit Java et non JavaScript, car c’est deux langages totalement différent. C’est une remarque pour
les T.O.T.O) et les langages de la plateforme .Net de Microsoft comme C#, J# etc.

Figure 3 : Langage interprété et compilé (C# et Java)

C H A P I T R E 1 : VA R I A B L E S E N P Y T H O N 9/22

PrépaVogt : Cycle IGEA


Ingénieur en Géo-sciences,
Environnement et Agro-industrie

INITIATION À PY THON

Présentation
Python est un langage de programmation très polyvalent et utilisé dans de très nombreux domaines
(Business Intelligence, BIG DATA, etc.) et par nombres d’acteurs importants (Google, Nasa, Dropbox, etc.),
scienti ques ou non (Certains pensent qu’il n’y a que les scienti ques qui peuvent programmer en Python
😅 . Python c’est pour tout le monde, ne soyez pas surpris que votre grand-mère soit meilleur que vous!
😏 ). Créé en 1989, le langage Python trouve l’origine de son nom dans la célèbre troupe d’humoristes
anglais des Monty Python. Python est caractérisé par une syntaxe simple et aérée, des types de données
variés, des bibliothèques extensives abondantes (Voilà pourquoi on l’aime😍 ). C’est un langage
interprété (par opposition à un langage compilé, nous n’allons pas revenir dessus 😌 , mais la répétition
reste la mère des sciences !), c’est à dire que l’exécution d’un programme ne passe pas par une phase de
compilation, mais s’exécute directement. En partie pour cette raison, il est d’apprentissage rapide et
portable mais est, en revanche, relativement lent à l’exécution.Bon comme on l’a déjà souligné, c’était
surtout vrai il y’a 20 ans avec les ressources des ordinateurs de l’époque qui étaient limités (Une machine
avec 5 Mo de mémoire vive et un disque de 1Go, à l’époque c’était le paradis 😌 . Le paradis change
chaque jour en informatique😎 ), depuis les machines ont beaucoup évolués. Toutefois, c’est pas
pourquoi python sera utilisé partout pour faire tout en même temps. Chaque langage à son domaine de
prédilection 😏 .

Le langage Python est placé sous une licence libre et est très largement multiplateforme (Windows, Linux,
Mac, Unix, etc.). Aujourd’hui, Python est développé par la Python Software Foundation qui fait évoluer le
langage (Version 3 actuellement) et rassemble les différentes contributions riches de la communauté des
développeurs Python.

Installation
Il existe de multiples installations possibles de Python. L’utilisateur débutant comme vous peut donc se
sentir dérouté par l’absence d’une référence unique pour Python (Pas de panique 😏 ).

Les IDE (environnement de développement intégré, c’est un logiciel qui permet à la fois d’écrire des
programmes dans un éditeur adapté au langage, d’exécuter les programmes que l’on a écrits, de corriger
des erreurs dans ces programmes et de consulter de la documentation) les plus classiques sont Spyder,
Winpython, IPython, Wing, IDLE, Gvim.

Dans ce cours, nous allons utiliser IDLE, Visual Studio Code et Anaconda. Je vous invite donc à:

✓ Télécharger la dernière version de IDLE (à ce jour la version 3.10) via le lien suivant  : https://
www.python.org/downloads/, et à l’installer.

✓ Télécharger la dernière version d’Anaconda via le le lien suivant https://www.anaconda.com/


products/distribution

C H A P I T R E 1 : VA R I A B L E S E N P Y T H O N 10/22
fi

fi

PrépaVogt : Cycle IGEA


Ingénieur en Géo-sciences,
Environnement et Agro-industrie
✓ Télécharger la dernière version de Visual Studio Code. vous pouvez utiliser le lien suivant https://
code.visualstudio.com/download

Environnement IDLE
Une fois l’installation terminée, on peut lancer IDLE. On a alors une fenêtre de ce type (Voir image ci-
dessus ). Oui, le prof utiliser une vielle version de python, la version 3.7 (Elle fait encore très bien le taf
😌 !)

Figure 4 : Interface IDLE

Environnement Anaconda

Figure 2: Interface Anaconda

C H A P I T R E 1 : VA R I A B L E S E N P Y T H O N 11 / 2 2

PrépaVogt : Cycle IGEA


Ingénieur en Géo-sciences,
Environnement et Agro-industrie
Anaconda est une distribution libre et open source des langages de programmation Python et R (On
prépare déjà l’année prochaine 😎 ) appliqué au développement d'applications dédiées à la science des
données et à l'apprentissage automatique (traitement de données à grande échelle, analyse prédictive,
calcul scienti que, bref les choses compliquées que les ingénieurs comme vous adorent😕 ), qui vise à
simpli er la gestion des paquets (nous allons appeler cela bibliothèque par la suite) et de
déploiement.  Les versions de paquetages sont gérées par le système de gestion de paquets (ou de
bibliothèques) coda. La gure ci-dessus, présente l’interface d'Anaconda après installation.

Environnement VS Code
Visual Studio Code (VS Code) est un éditeur de code extensible qui a été développé par Microsoft et qui
offre certaines fonctionnalités très intéressantes comme le débogage (C’est l'un des outils le plus
important de VS Code. En effet, elle offre la capacité de déboguer les applications directement sur
l'éditeur sans même avoir recours aux navigateurs, grâce à un système de points d'arrêt et une console
de débogage intégrée qui permet de résoudre les problèmes directement dans l’éditeur. Pour les T.O.T.O
comme vous, disons que c’est outil qui permet d’exécuter son code pas à pas en corrigeant les erreurs
éventuelles quand elles existent ), la mise en évidence de la syntaxe, la complétion intelligente du code,
les snippets, la refactorisation du code et Git intégré. Que de choses compliquées comme fonctionnalités
😰 ! Pas de panique nous allons apprendre quelques unes pendant les TP et mêmes pendant les CM).

Figure 3: Interface du logiciel Visual Studio Code (VS Code)

C H A P I T R E 1 : VA R I A B L E S E N P Y T H O N 12 / 2 2
fi
fi

fi

PrépaVogt : Cycle IGEA


Ingénieur en Géo-sciences,
Environnement et Agro-industrie
La gure suivant présente l’interface de l’éditeur VS Code après installation (Si votre interface est blanche
et bleu, pas de panique, c’est tout à fait normal. C’est juste que le prof à déjà changer l’aspect visuel de la
sienne la sienne. Comment on le fait, je sais que vous êtes intelligents et que vous allez trouver! 😌 )

Modes d’exécution
Un programme python peut être exécuter de plusieurs façons. Il peut être soit :

✓ Via un chier (.py)

✓ En mode interactif avec IDLE (C’est la raison principale pour laquelle nous avons télécharger IDLE).
Grace à l’intégrateur, à chaque fois qu’on saisie une ligne, le résultat est interprété ou calculé (on dit
aussi évalué) puis le résultat est af ché.

✓ Par fragment dans un notebook5

Les variables dans Python


Petit Rappel
Tous les jours nous manipulons les objets, stylos, sel, sucre, café, etc. Parmi ces objets certains peuvent
varier, d’autre pas. Pour manipuler ces objets, on utilise généralement des contenants (un sceau par
exemple pour contenir de l’eau). En informatique, particulièrement en algorithmique et programmation,
ce contenant est appelé variable, si le contenu peut varier et constante sinon (C’est juste un rappel pour
T.O.T.O). La variable n’est donc qu’un nom donné à un objet a n de pouvoir le manipuler. Ceci nous
permet donc de distinguer l’objet de sa variable. On dit alors qu’une variable référence un objet.

Variables et Objets en Python


Variable en Python
Une variable est une zone de la mémoire de l'ordinateur dans laquelle une valeur est stockée. Aux yeux
du programmeur, cette variable est dé nie par un nom, alors que pour l'ordinateur, il s'agit en fait d'une
adresse, c'est-à-dire d'une zone particulière de la mémoire.

En Python, la déclaration d'une variable et son initialisation (c'est-à-dire la première valeur que l'on va
stocker dans la variable) se font en même temps. Pour vous en convaincre, testez les instructions
suivantes après avoir lancé l'interpréteur IDLE :

>>> x = 2
>>> x
2

Dans cet exemple, nous avons déclaré, puis initialisé la variable «x» avec la valeur 2. Notez bien qu'en
réalité, il s'est passé plusieurs choses :

5 Les notebooks sont des programmes permettant de rendre un document interactif. Il est donc possible de lire le document et d’exécuter
directement le code qui s’y trouve via le navigateur sans utiliser un autre logiciel que son navigateur. C’est possible en utilisant Jupyter, ceux qui ont
été attentifs ont peut-être remarqué jupyter comme application installée par défaut dans Anaconda. Jupyter permet de créer des notebook

C H A P I T R E 1 : VA R I A B L E S E N P Y T H O N 13 / 2 2

fi

fi

fi

fi

fi

PrépaVogt : Cycle IGEA


Ingénieur en Géo-sciences,
Environnement et Agro-industrie
✓ Python a « deviné » que la variable était un entier. On dit que Python est un langage au typage
dynamique.

✓ Python a alloué (réservé) l'espace en mémoire pour y accueillir un entier. Chaque type de variable
prend plus ou moins d'espace en mémoire. Python a aussi fait en sorte qu'on puisse retrouver la
variable sous le nom «x».

✓ En n, Python a assigné la valeur 2 à la variable «x».

Dans d'autres langages (en C par exemple) et même en algorithmique, il faut coder ces différentes
étapes une par une (c’est à dire déclarer la variable, ensuite initialiser la variable). Python étant un
langage «soft», la simple instruction x = 2 a suf à réaliser les 3 étapes en une fois ! (N’est ce pas
magni que!)

L'interpréteur nous a permis de connaître le contenu de la variable juste en tapant son nom. Retenez ceci
car c'est une spéci cité de l'interpréteur Python, très pratique pour chasser (debugger) les erreurs dans
un programme. Par contre, la ligne d'un script Python qui contient seulement le nom d'une variable (sans
aucune autre indication) n'af chera pas la valeur de la variable à l'écran lors de l'exécution (pour autant,
cette instruction reste valide et ne générera pas d’erreur). Sachez par ailleurs que l'opérateur d'affectation
= s'utilise dans un certain sens (Nous allons y revenir). Par exemple, l'instruction x = 2 signi e qu'on
attribue la valeur située à droite de l'opérateur = (ici, 2) à la variable située à gauche (ici, x).

Objet en Python
En Python, tout est objet, un objet ne se limite pas uniquement à son contenu (ses données ou sa valeur
comme une simple variable en algorithmique), mais il renseigne également sur :

✓ Ses méthodes, qui représentent l’ensemble de mécanismes permettant de manipuler cet objet.

✓ Son type, qui dé nit l’ensemble des données possible d’un objet, ainsi que ses méthodes par
défaut. Pour mieux comprendre la notion de type, faisons une analogie avec une usine de fabrique
de voiture. L’usine dé nit un ensemble de comportement des voitures qui vont sortir d’une chaine
de montage (par exemple : puissance du moteur, couleur des voitures, nombres de clignotant, etc.).
On peut donc dire que la chaîne de montage dé nit le type de voiture qui va sortir de cette chaîne
de montage et que la voiture désigne un objet de ce type.

Attention, en Python, un objet existe indépendant de son contenant. Les objets en python sont stockés
dans l’espace des objets et les variables dans l’espaces des variables communément appelé espace de
nommage. Ceci permet d’assigner une même variable à plusieurs objets. Le contenu d’une variable
dépendant donc du dernier objet qui y a été assigné.

Les types de données simples en python


Les nombres
Python utilise trois types de nombres : les entiers (relatifs) dont le type est int, les nombres réel
habituellement appelés ottants en informatique (pas de panique, ces nombres ne ottent pas et ne

C H A P I T R E 1 : VA R I A B L E S E N P Y T H O N 14 / 2 2
fi
fi

fi

fi

fi

fl
fi
fi

fi

fl

fi
PrépaVogt : Cycle IGEA
Ingénieur en Géo-sciences,
Environnement et Agro-industrie
volent pas, l’expression découle de la manière avec laquelle la partie décimale d'un nombre est géré en
binaire tout simplement) dont le type est oat et les nombres complexes dont le type est complex.

Les entiers
On peut effectuer plusieurs opérations avec les entiers :

Tableau 2 : Opérations qu’on peut e ectuer avec le type «int»


Les nombres Les nombres
Addition +
Soustraction -
Division /
Elévation à la puissance **
Quotient //
Modulo %

Exemple : Tapez les opérations suivantes l'interpréteur IDLE (C’est pourquoi vous l’avez télécharger! C’est
pas fait pour orner votre machine ou blaser vos camarades d’INGE) et observez les résultats (Attention
les trois signes «>» représente le «prompt6» de l’interpréteur) :

>>> 10 -3 * 2
>>> 2*3**2
>>> 58//5
>>> 48%5
>>> 8/5
>>> 2 * 2 # Derrière un dièse , on peut commenter
>>> print (5+6) # print produit un affichage mais n'a pas retourné de résultat: il
n'y a pas de Out.
>>> 6 ** 3 # Libre à vous de gérer les espaces
>>> 2 + 3 * 5

>>> (2 + 3) * 5
>>> type (5)
>>> type (5.)
>>> type (‘5')On note que les calculs sont hiérarchisés suivant les conventions mathématiques
usuelles. Comme on peut s’y attendre, les parenthèses permettent de préciser l’ordre des
calculs souhaités.

Les ottants
En Python (comme en informatique en général), on distingue les nombres entiers des nombres décimaux.
Pour ces derniers, le séparateur décimal qu’on représente usuellement par une virgule est ici représenté
par un point « . ».

6désigne l'invite de commande (caractère indiquant que l'ordinateur est prêt à recevoir une saisie au clavier). désigne par extension le
message (qui peut être complexe) qui s'af che en bas de l'écran avant l'entrée d'une commande.

C H A P I T R E 1 : VA R I A B L E S E N P Y T H O N 15 / 2 2
fl

fi
ff
fl

PrépaVogt : Cycle IGEA


Ingénieur en Géo-sciences,
Environnement et Agro-industrie
On peut effectuer plusieurs opérations avec des objets ottants :

Tableau 3 : Opérations qu’on peut effectuer avec le type oat

Opérations Symboles
Addition +
Soustraction -
Division /
Elévation à la puissance **

Exemple : Taper les opérations suivantes dans l’interprète de commande et interpréter les résultats :

>>> 10.5-3**2
>>> 2.4*3.7**2.14
>>> 60200-60.2e3
>>> type (2.31)
>>> type (4/2)
>>> type (4./2)

Les opérations addition, soustraction et multiplication se notent donc de la même façon que pour les
entiers : +, − et ∗. On note au passage la manière de représenter en Python la notation scienti que d’un
nombre décimal à l’aide de la lettre e (qui n’est pas le nombre de Néper) et on remarque qu’il suf t que
l’un des opérandes d’un calcul soit ottant pour que le résultat soit donné en ottant.

Remarque : Le résultat des opérations avec des décimaux est le plus souvent inexact. Retenons pour
l’instant que dans les bons cas, on obtient une bonne approximation du résultat mais pas forcément le
résultat exact au sens mathématique. Ceci est dû aux contraintes liées à la représentation informatique des
nombres décimaux.

Les complexes
La syntaxe pour écrire le nombre complexe a + ib est a+ bj. On constate ainsi que le symbole de
l’imaginaire « i » mathématiques s’écrit «j» (Oui, on veut faire la différence avec les matheux 😌 ). On peut
aussi utiliser la fonction complex, on écrit alors complex(a,b) pour créer le complexe. Nous reviendrons
sur les fonctions dans les prochains cours (Pas de panique! 😏 ).

Tableau 4 : Fonctions mathématiques usuelles en Python

Fonction exp ln sin cos tan |.| Racine carré !

Instruction exp log sin cos tan abs sqrt factorial


Python

Taper les commandes suivantes via votre interpréteur IDLE  :

>>> j**2
>>> 1j**2

C H A P I T R E 1 : VA R I A B L E S E N P Y T H O N 16 / 2 2

fl
fl
fl

fl

fi
fi

PrépaVogt : Cycle IGEA


Ingénieur en Géo-sciences,
Environnement et Agro-industrie

>>> complex(5,2)+complex(7,3)
>>> 3*(7+2j)
>>> 3*(7+2*j)
>>> 3*complex(7,2)
>>> 5+4j/23
>>> 5+j4/23 #Il faut mettre dans le bon ordre!
>>> 4j+5/23
>>> 5+j/23
>>> type (1j)
>>> type (1j**2)

Aussi, pour entrer un nombre complexe, il faut toujours le faire précéder de l’imaginaire d’un nombre,
donc ne pas entrer simplement « j » (qui serait compris comme un nom de variable) mais plutôt «1j» ou
encore «1.j» .

Fonctions mathématiques supplémentaires


Lorsqu’on utilise le langage python de base, seul un nombre très limité de fonctions est disponible.
Heureusement, il existe une multitude de modules additionnels (les fameuses bibliothèques que nous
avons appelées paquets) que l’utilisateur peut ajouter en fonction de ses besoins, qui lui fournissent des
fonctions supplémentaires. Python possède évidemment toutes les fonctionnalités d’une calculatrice
scienti que, à condition de lui faire importer la bonne bibliothèque. Pour importer une bibliothèque en
Python, on utilise le mot clé import. La majorité des fonctions mathématiques se retrouvent dans
bibliothèque math.

Tableau 5 : Opérateurs de comparaison

Relation Mathématique Égalité Différence Inférieur strict Supérieur strict Inférieur Supérieur

Instruction Python «==» != < > <= >=

Voyons tout cela avec les exemples suivants :

import math # voilà comment importer la bibliothèque ou le module math


math.pi +math.e
math.cos(0)
math.sin(pi/2) #Tiens , cela ne marche pas! Que faut-il faire pour corriger cette
import math as m
m.log(m.e)
from math import *
exp(0) #La bibliothèque math est totalement importée!

On note que la fonction log désigne le logarithme népérien (la notation ln n’existe pas pour Python 😏 ).
Pour le logarithme décimal, on utilise log10.
Avec la bibliothèque math, Python connaît alors les constantes classiques que sont «e» et «π» ainsi que
les fonctions mathématiques usuelles :

C H A P I T R E 1 : VA R I A B L E S E N P Y T H O N 17 / 2 2
fi

PrépaVogt : Cycle IGEA


Ingénieur en Géo-sciences,
Environnement et Agro-industrie
D’autres fonctions sont à connaître comme les fonctions trunc, round, oor et ceil. Tester les pour les
valeurs suivantes pour déduire comment ça fonctionne (j’ai toute con ance en vous! T.O.T.O ou pas!) :

Tableau 6: Autres fonctions mathématiques


Valeurs -1.9 -1.5 -1.1 1.1 1.5 1.9

Trunc

Round

Floor

Ceil

Une commande simple permet de savoir ce qu’il y a dans une bibliothèque comme «math», il suf t de
taper :

>>> dir(math)
>>> dir (int) # pour les entiers
>>> dir (float) # pour les flottants

La bibliothèque math ne permet pas d’utiliser les nombres complexes. Pour cela, il faut charger la
bibliothèque cmath (Vous l'avez deviner, le «c» du début signi e «complexe») à la place de math. Les
fonctions classiques sont alors étendues aux nombres complexes (dans la bibliothèque cmath exp
désigne l’exponentielle complexe, abs désigne le module, etc) et l’on accède aux fonctions liées aux
nombres complexes avec la fonction dir(cmath).

Les Booléens
Les booléens, ou valeurs de vérité, peuvent prendre deux valeurs : True (vrai) ou False (faux). Ils

Tableau 7 : Opérateurs logiques

Opérateur logique Conjonction et Disjonction ou Négation non

Instruction Python != <

permettent d’indiquer si une assertion (que l’on peut construire à l’aide des différentes relations de
comparaison détaillées dans le tableau ci-dessous) est vraie ou non et seront très utilisés dans les tests et
les boucles while que l’on verra plus tard. Les opérateurs de comparaison sont :

En particulier, on notera bien que la relation d’égalité se note == et non avec un seul symbole =. a == b
ne signi e pas que a vaut b mais correspond à une question, a vaut-il b ?
Taper les opérations suivantes dans l’interprète de commande IDLE:

>>>true
>>> True
>>> type(False)
>>> 2=3
>>> 2 == 3

C H A P I T R E 1 : VA R I A B L E S E N P Y T H O N 18 / 2 2

fi

fi

fi
fl

fi

PrépaVogt : Cycle IGEA


Ingénieur en Géo-sciences,
Environnement et Agro-industrie

>>> 3*6==6
>>> 3>2
>>> 1>2.
>>> 2<5<6
>>> 2<5<3
>>> (1+1)!= 2
>>> (1+1)!= 3
>>> 0.1+0.2==0.3

On remarque que Python refuse d’utiliser = pour comparer deux quantités mais veut ==. On note aussi
qu’en raison d’erreurs d’arrondi, Python peut déclarer faux des inégalités qui ne le sont pas ! Python est
capable de combiner les booléens avec les opérateurs logiques :

Tableau 8 : Opérateurs de comparaison-1

Opération avec les chaînes Égalité Concaténation Répétition n fois Longueur Appartenance

Instruction Python «==» + n* len in

Taper les opérations suivantes dans l’interprète de commande:

>>> (8>-4) and (4>-4)


>>> (8>-4) or (4>-4)
>>> (8>14) and (4>-4)
>>> (8>14) or (4>-4)
>>> not(8>-4)
>>> not(4>5)

Nous allons pas rappeler les tables de vérités des opérateurs logiques ici.

Les chaînes de caractères


Opérations sur les chaines de caractères
Outre les types numériques, Python permet la manipulation de données alphanumériques, qu’on appelle
des chaînes de caractères, et qui correspondent au type «str» (string en anglais). Une chaîne de
caractères se note entre cotes simples ou cotes doubles et peut contenir n’importe quel symbole de
votre clavier. Les cotes doubles étant " et les cotes simples étant ’ (l’apostrophe), ces caractères ne faisant
pas partie de la chaîne (le choix est souvent imposé par le contenu : une chaîne contenant une cote
simple sera encadré par des cotes doubles et réciproquement).

Comme pour les autres types de données, on dispose de commandes opérant sur les chaînes de
caractères :

Taper les opérations suivantes dans l’interprète de commande IDLE:

>>> 'ajourd'hui' #Attention, certains caractères sont interdits!

C H A P I T R E 1 : VA R I A B L E S E N P Y T H O N 19 / 2 2

PrépaVogt : Cycle IGEA


Ingénieur en Géo-sciences,
Environnement et Agro-industrie

>>> "ajourd'hui" #C'est mieux!


>>>'a'
>>> a
>>> type("BCPST1")
>>>"BCPST1" == "BCPST1"
>>>"BCPST 1" == "BCPST1"
>>> "bon" + "jour"
>>> 4 * "cot! " + "codec!"
>>> len("Capucine et Mado")
>>> len("CapucineetMado") # Les espaces comptent
>>>"aku" in "Akumà"
>>>"akue" in "Akumà"

On note que les espaces sont comptées dans la fonction «len» et que, lorsqu’il compare deux chaînes,
Python est intransigeant, la moindre différence (espace, accent, virgule, majuscule, . . . ) est détectée et le
sens de la phrase n’est pas pris en compte (Les T.O.T.O je vous vois déjà venir 😏 ).
Contrairement à ce que nous avons pu observer entre le type int et le type oat, il n’existe pas ici de
conversion automatique de type entre le type int et le type str (J'attire votre attention ici, parce que les
T.O.T.O, hmm! 😏 ). Comme vous avez pu le constater (si vous avez taper les commandes 😌 ) Python
refuse de faire l’addition d'un nombre et une chaîne de caractères. Pour insérer un nombre dans une
phrase, il faut au préalable le transformer en chaîne de caractères. Pour cela, on peut ou bien mettre le
nombre entre les guillemets, ou bien utiliser la commande de conversion str qui convertit les nombres en
chaîne de caractères et permet d’effectuer une opération sur des nombres avant d’inclure le résultat dans
une phrase. La fonctions int permet de convertir une donnée adéquate (nombre ottant ou chaîne de
caractères) en un entier, oat, permet de convertir une donnée adéquate en un nombre ottant. Taper les
opérations suivantes dans l’interprète de commande :

>>> type(5)
>>> type(‘5')
>>> type(str(5))
>>> type(int('5'))
>>> 5='5'
>>>'a'<'b'
>>>'a'>'b'
>>>"Capucine a " + (2019-2007) + " ans" "J'ai 2019-1984 ans "
>>>"Mado a " + str(2019-2010) + " ans "
>>> "5" + "6"
>>> int("5") + int("6")
>>> 5+"6"

Accès aux caractères d'une chaîne de caractères


On peut accéder individuellement aux caractères d’une chaîne caractères, il suf t pour cela de l’affecter à
une variable (ch dans notre exemple) puis d’écrire l’instruction suivante : ch[k] pour accéder au (k + 1)
ième caractère de ch. Quelques remarques :

1. Python numérote les caractères de la chaîne à partir de 0 et augmente de 1 au fur et à mesure, il


comptabilise même les espaces. Par conséquent, le caractère ch[k] est le (k + 1)ième de la chaîne.

C H A P I T R E 1 : VA R I A B L E S E N P Y T H O N 20/22

fl


fl
fi

fl
fl

PrépaVogt : Cycle IGEA


Ingénieur en Géo-sciences,
Environnement et Agro-industrie
2. On peut utiliser des indices négatifs, cela permet d’accéder aux caractères à partir de la n de la
chaîne. ch[−1] désigne le dernier élément d’une chaîne, ch[−2] l’avant dernier, etc.

3. ch[i : j] désigne la chaîne constituée des caractères de ch dont les numéros sont entre i et j − 1
(Technique appelée slicing). A noter que ch[: j] donne la même chose que ch[0 : j], ch[i :] donne la
même chose que ch[i : len(ch)].

4. ch[i : j : p] donne tous les caractères de la chaîne dont les index sont compris entre i et j − 1 et
espacés d’un pas égal à «p». En particulier, ch[−1 : 0 : −1]+ch[0] inverse les éléments de la chaîne.

Taper les opérations suivantes dans l’interprète de commande :

>>> ch = "Python est un super langage"


>>> ch2= "Pythonestunsuperlangage"
>>> len(ch)
>>> len(ch2) # Les espaces comptent! print(ch[3])
>>> ch[8]
>>> ch[-2]
>>> ch[len(ch)] #On rappelle qu'on indice à partir de 0
>>> ch[len(ch)-1]==ch[-1] # Pratique ce ch[-1] si on ne connaît pas la longueur de la chaîne!
>>> ch[4:13]
>>> ch[4:-1:2]
>>> ch[-1:0:-1]+ch[0]
>>> ch[:8]+ch[12:]

Remarque: Attention, Python commence la numérotation des caractères au numéro 0 (C’est une
remarque pour les T.O.T.O, pour le reste je sais que c'est déjà enregistré dans le «tibia» 😏 ). Par
conséquent, Le dernier caractère d’une chaîne contenu dans une variable «ch» est len(ch)-1 et écrire
ch[len(ch)] provoque une erreur.

Quelques méthodes pratiques


Les méthodes sont des sortes des fonctions particulières associées à un type d’objet (comme des
chaînes de caractères, des listes...). Lorsque «obj» est un représentant de la bonne catégorie d’objet et
«meth» une méthode associée, on applique cette dernière à l’objet en suivant la syntaxe suivante :

obj.meth()

Nous allons voir maintenant quelques méthodes classiques des chaînes de caractères. Il en existe
beaucoup et il est totalement inutile de les apprendre (une bonne partie est d’ailleurs facile à recréer
avec des boucles for ou while que nous allons voir plus tard pas besoin de pleurer. On ne pleure pas...).
Par contre, il est bon de connaître leur existence et de savoir les retrouver. Pour avoir une liste exhaustive
de l’ensemble des méthodes associées à un objet particulier, il suf t d’utiliser la commande dir(). Utiliser
votre interpréteur IDLE pour tester :

>>> c = «blabla"
>>> dir(c )

C H A P I T R E 1 : VA R I A B L E S E N P Y T H O N 21 / 2 2



fi

fi

PrépaVogt : Cycle IGEA


Ingénieur en Géo-sciences,
Environnement et Agro-industrie
Méthodes upper et lower
Si «ch» est une variable qui contient une chaine de caractère, alors en tapant ch.lower(), on obtient la
même chaîne de caractères «ch» mais en minusucule. ch.upper(ch), donne la chaîne de caractères «ch»
mais en majusucule. On remarque que l’utilisation de ces méthodes n’altèrent pas la chaîne de caractères
de départ mais renvoie la chaîne transformée. Testons-les :

>>> x = "j'aime Python"


>>> x.upper()
>>> x
>>> "PYTHON".lower()
>>> x[0].upper() + x[1:] # La méthode x.capitalize() fait la même chose! Tester la vous même

Autres méthodes usuelles des str


D’autres méthodes classiques :

1. En tapant ch.replace(ch1,ch2), on obtient la chaîne de caractères ch dans laquelle on a remplacé


toutes les chaînes de caractères ch1 par la chaîne de caractères ch2.

2. En tapant ch.count(ch1), on obtient le nombre d’occurrences d’une chaîne de caractère ch1 dans la
chaîne de caractères ch.

3. En tapant ch. nd(ch1), on obtient l’indice de la première occurence de la chaîne de caractère ch1
dans la chaîne de caractères ch. Si l’élément n’est pas trouvé, alors la valeur −1 est renvoyée. On
peut les tester :

>>> profs = "Atin Akumà VOUNDI"


>>> profs.find(«a")
>>> profs.find(«z")
>>> profs.find(‘ac')
>>> profs.count("queli")
>>> profs.count("a")
>>> profs.count("z")
>>> profs.replace("Atin", "")
>>> profs.replace("V", "B")
>>> profs #replace ne modifie pas la la chaîne de caractères de départ.
#On peut faire la même remarque avec count et find

C H A P I T R E 1 : VA R I A B L E S E N P Y T H O N 22/22

fi

Vous aimerez peut-être aussi