Académique Documents
Professionnel Documents
Culture Documents
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
Sommaire
Chapitre 1 : Les variables ...................................................................................................4
Hardware ..........................................................................................................................5
Software ............................................................................................................................6
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
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
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
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 :
✓ Lister les types de données manipulées par Python 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
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
Hardware
Un ordinateur peut être décrit comme une machine de traitement de l’information : il est capable de faire
les quatre tâches suivantes :
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.
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 ;
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)
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
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.
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
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 …😉 ) :
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
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 :
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)
✓ 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
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
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.
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
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
😌 !)
Environnement 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
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).
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
Modes d’exécution
Un programme python peut être exécuter de plusieurs façons. Il peut être soit :
✓ 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é.
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
✓ 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».
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é.
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 :
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
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! 😏 ).
>>> 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
>>> 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» .
Relation Mathématique Égalité Différence Inférieur strict Supérieur strict Inférieur Supérieur
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
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
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
>>> 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 :
Opération avec les chaînes Égalité Concaténation Répétition n fois Longueur Appartenance
Nous allons pas rappeler les tables de vérités des opérateurs logiques ici.
Comme pour les autres types de données, on dispose de commandes opérant sur les chaînes de
caractères :
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
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"
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
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.
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.
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
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 :
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