Tutoriel Python - sommaire

Python : l'interpréteur de commandes - les variables - les types de données

Lancer l'interpréteur

Sous Windows 10, pour démarrer l'interpréteur vous pouvez cliquer sur le raccourci dans la barre des tâches (si vous l'avez créé).
Autre solution : dans l'invite de commande Windows (tout en bas de l'écran à gauche et légendée "Tapez ici une recherche" vous saisissez "py".

Interpréteur utilisé comme calculatrice

L'interpréteur de commandes peut faire fonction de calculatrice.

Exemples de commandes

Tapez ces commandes ci-dessous dans l'interpréteur (qu'on appelle aussi "console interactive") !

Ne vous contentez pas de lire le tuto ; le meilleur moyen pour assimiler la syntaxe Python est de taper les commandes. >>> 3+5*4 23 >>> 10/3 3.3333333333333335 >>> 10//3 3 >>> 10%3 1 >>> 10**5 100000 >>>sqrt(25) Traceback (most recent call last): File "<stdin>", line 1, in <module> NameError: name 'sqrt' is not defined >>>exit()

Les triples chevrons apparaissent pour dire que l'interpréteur est prêt à accueillir une commande.

Analysons :
• 3+5*4 donne 23 c’est à dire (5*4) +3 ; il y a donc respect de l’ordre de priorité des opérateurs : les multiplications et divisions sont effectuées avant les additions et soustractions.
• 10/3 : division normale de 10 par 3
• 10//3 : division entière de 10 par 3 ; donne 3
• 10%3 : reste de la division entière ; donne 1
• 10**5 : 10 élevé à la puissance 5 ; donne donc 100 000
• sqrt(25) : racine carrée de 25. Message d’erreur et pas de résultat. C’est normal la fonction sqrt() fait partie du module math. Or celui n’est pas chargé ("importé" dans le jargon Python).
• exit() : commande pour fermer la console. J'aurais pu cliquer sur le bouton "X" de la fenêtre.

Si vous avez un doute concernant l'ordre de priorité des opérateurs, n'hésitez pas à employer des parenthèses. Les calculs entre parenthèses se font en priorité. >>> 12 *(4+6) 120 >>> 12*4+6 54

Grâce à ce petit exemple, vous voyez que les multiplications sont faites avant les additions sauf si on utilise des parenthèses (voir première instruction).

Les opérateurs

Dans le tableau ci-après, sont présentés les symboles utilisés pour les opérations de base.

Utiliser des lettres dans les formules

Vous pouvez faire de l’algèbre c’est à dire utiliser des lettres. Un informaticien dit qu'il manipule des variables.

Des commandes à saisir : >>> a = 10 >>> b= 15 >>> c=10.5 >>> a+c 20.5 >>> b-c 4.5 >>> a**2 100 >>> a==b # a égal à b ? False >>> b>c True >>> a!=b True

J’ai créé trois variables a,b et c et j’ai affecté à chaque variable un nombre entier ou un flottant (nombre décimal).
Je vous montre ensuite que l’on peut effectuer toutes les opérations sur des variables.
On peut aussi faire des comparaisons entre variables en utilisant les opérateurs de comparaison.
Chaque comparaison retourne un booléen : True si la comparaison est vraie et False si la comparaison est fausse.
Une commande peut être accompagnée d’un commentaire. Le commentaire est précédé du symbole #.

Les commentaires sont facultatifs dans le cadre de commandes mais deviennnent indispensables dans le cadre d'instructions de programme.

Nommer des variables

Le premier caractère doit être une lettre minuscule (a-z), une lettre majuscule (A-Z) ou un tiret de soulignement. Pour les autres caractères, on autorise en plus les chiffres ( 0-9 ).
Python est sensible à la casse , c'est-à-dire qu'il fait la différence entre minuscules et majuscules. Ainsi Age et age sont deux variables différentes !

On ne peut pas employer un mot réservé pour désigner une variable.
Liste des mots réservés ci-dessous :
>>> and = 5 +12 SyntaxError: invalid syntax >>> in = 5 **2 SyntaxError: invalid syntax

Donc rien ne vous interdit à priori de nommer une variable "print, round, input, range, ... " puisqu'il ne s'agit pas de mots réservés. Mais ce serait très maladroit pour la lisibilité de votre code d'employer comme nom de variable un nom de fonction générique ...

Pour nommer des variables, je vous conseille d'utiliser des mots français : compteur, points, cumuls, resultat, ...
S'il s'agit de mots composés, utilisez un trait de soulignement entre les mots OU coller les mots avec une majuscule en début de chaque mot : "camel case".
Le "camel case" est une notation consistant à écrire un ensemble de mots en les collant et en mettant en capitale la première lettre de chaque mot à partir du deuxième mot.
Exemples de variables : prix_ht, taux_tva, prix_ttc OU (camel case) : prixHt, tauxTva, prixTtc
Ne mélangez pas les deux techniques de nommage !

Les opérateurs de comparaisons

Ce sont :
• < strictement inférieur
• > strictement supérieur
• <= inférieur ou égal
• >= supérieur ou égal
• == égal
• != différent

Il existe aussi les opérateurs "in" et "not in".

Attention il ne faut pas confondre affectation (d’une valeur à une variable) qui se réalise avec le signe "=" avec le test d’égalité (deux signes "=" collés).

La fonction type()

Une variable a un type en fonction de son contenu.
Exemples de commandes : >>> a = 10.5 >>> type(a) <class 'float'> >>> b = 20,5 >>> type(b) <class 'tuple'> >>> c ="bonjour" >>> type(c) <class 'str'> >>> reponse = false Traceback (most recent call last): File "<stdin>", line 1, in <module> NameError: name 'false' is not defined >>> reponse2 = True >>> type(reponse2) <class 'bool'> >>> d = 5 >>> type(d) <class 'int'> >>> q =10/3 >>> type(q) <class 'float'> >>> q 3.3333333333333335 >>>

J’ai créé différentes variables nommées "a, b,c, reponse, d, q".
Par erreur j’ai affecté à la variable "b" 20,5 (et non pas 20.5). À la question "quel est le type de cette variable ? " l'interpréteur répond : class ‘tuple’... Je reviendrais plus tard sur le type "tuple".
La variable "c" est de type 'str' ('str' abréviation de 'string' ou chaine de caractères en français).
Les variables "a e & q" sont de type "float" (ou "flottant" en français). La variable de type "float" q contient une valeur approchée de 10/3. Vous verrez plus tard qu'il est possible de sauvegarder en Python une valeur sous forme d'une fraction.
"reponse2" est de type bool. Par contre "reponse" n'est pas définie ; pour créer une variable booléenne il faut lui affecter True / False avec un T ou F majuscule !
Et oui il faut toujours faire très attention à la casse en Python.

Commandes à saisir : >>> b="125" >>> type(b) <class 'str'> >>> a ='125' >>> type(a) <class 'str'> >>> c=125 >>> type(c) <class 'int'> >>> chaineML ="""chaine sur ... deux lignes""" >>> type(chaineML) <class 'str'> >>> instant ="aujourd'hui" >>> type(instant) <class 'str'> >>> instant2 ='aujourd\'hui' >>> instant2 "aujourd'hui" >>>

Un suite de chiffres délimitée par des guillemets (simples ou doubles) est une chaine (et non pas une valeur numérique).

La variable c est de type 'int'(contient un entier) alors que les variables a & b sont de type 'str' (chaines composées ici de caractères numériques).
chaineML contient une chaine multilignes. Une chaine multilignes (un paragraphe, par exemple) doit être délimitée par trois guillemets (simples ou doubles)
Pour créer la chaine instant2 délimitée par des guillemets simples, l'apostrophe a du être échappée. Pour éviter l'échappement j'aurais pu écrire : instant2 ="aujourdh'hui" (emploi de guillemets doubles).

L'opérateur + n'a pas le même sens selon qu'on manipule des nombres ou des chaines

Séquence de commandes : >>> a=12 >>> b=24 >>> c="12" >>> d='24' >>> a+b 36 >>> c+d '1224' >>> a+d ... TypeError: unsupported operand type(s) for +: 'int' and 'str' >>>

L'opérateur + utilisé avec des "strings" provoque la concaténation (chaines mises bout à bout).
On ne peut pas utiliser directement l'opérateur + entre un nombre et une chaine (même si celle-ci est composée uniquement de chiffres).

Création et manipulation d'une chaine

Saisissez dans l'interpréteur les commandes suivantes : >>> voyelles ="aeiouy" >>> len(voyelles) 6 >>> voyelles 'aeiouy' >>> list(voyelles) ['a', 'e', 'i', 'o', 'u', 'y'] >>> type(voyelles) <class 'str'> >>> print(voyelles) aeiouy >>> print('voyelles') voyelles

J'affecte une chaine à une variable nommée "voyelles".

j'applique ensuite à cette variable, quatre fonctions :
• len(voyelles) : retourne la longueur de la chaine (son nombre de caractères)
• list(voyelles) : affiche la chaîne sous forme d'une liste ; la notion de liste sera abordée prochainement.
• type(voyelles) : indique le type de la variable, ici 'str' ('str' commme 'string')
• La commande print(voyelles) affichage du contenu de la variable nommée voyelles
• print('voyelles') : affichage de la chaine 'voyelles'.

Aller plus loin avec la fonction print()

Nous venons de voir que la commande print(nomVariable) n'apportait rien par rapport à la commande nomVariable. Mais à l'intérieur des parenthèses de cette fonction on peut écrire une expression complexe ...
De plus en mode programmé, vous êtes obligé d'utiliser la fonction print().

Exemple de commande print() avec un argument complexe : >>> a = 9 >>> print("le carré de ", a, " est ", a**2) le carré de 9 est 81

Dans une seule commande j'affiche :
• la chaine "le carré de "
• le contenu de la variable a
• la chaine " est "
• le résultat de la formule a**2

N'oubliez pas des espaces autour du mot " est " sinon tout sera collé et donc illisible.
N'oubliez pas non plus les virgules pour que tout s'affiche sur la même ligne.

Manipulation de chaines

Exemple

Une chaine de caractères est stockée dans une variable nommée texte. Puis je manipule cette variable chaine avec différentes commandes :

• len(texte) : retourne la longueur de la chaine (nombre de signes : espaces, points et caractères)
• list(texte) : affiche la chaine sous forme d'une liste à raison d'un élément par caractère
• type(texte) : retourne le type de la variable 'texte'
• "M" in texte : retourne True puisque M majuscule fait partie de la chaine. J’ai donc introduit un nouvel opérateur de comparaison.
• texte[0] : retourne le premier caractère de la chaine ; je signale que le premier caractère d’une chaine a la position zéro (et non pas 1)
  Attention l'indice doit être entouré par des crochets (et non pas des parenthèses) !
• texte.index(‘M’) : retourne la position du premier caractère M
• texte.count(".") : affiche le nombre de points dans la chaine
• texte.index(‘.’) : affiche la position du premier point dans la chaine ; recherche dans la chaine à partir de la gauche
• texte.index(';') : retourne un message d'erreur car le caractère ";" n'existe pas dans la chaine.

Syntaxe

Observez que dans les commandes, nous avons deux syntaxes différentes :
• len(texte), type(texte), list(texte), print(texte), etc.
• texte.index(), texte.count(), etc.

Dans un premier cas il s'agit de fonctions génériques (peuvent s'appliquer à plusieurs types de données). Il faut donc écrire la commmande sous la forme : fonction(nomObjet)
Dans le deuxième cas il s'agit de méthodes de la classe "str" c'est à dire des fonctions spécifiques aux chaines. Il faut alors écrire la commande sous la forme :objet_string.méthode(arguments éventuels). On parle de notation pointée.

Utiliser les méthodes pour construire de nouvelles chaines

Si vous souhaitez des textes homogènes (tout en minuscules ou tout en majuscules) il faut créer de nouvelles variables de type string comme ci-dessous : >>>texte ="Bonjour. Mon. Cher. Ami" >>> texte_minus = texte.lower() >>> texte_minus 'bonjour. mon. cher. ami' >>> texte_majus = texte.upper() >>> texte_majus 'BONJOUR. MON. CHER. AMI' >>> chaine ="ave cesar, ceux qui vont mourir te salue" >>> chaine_cryptee = chaine.replace('a','1').replace('e','2') >>> chaine_cryptee '1v2 c2s1r, c2ux qui vont mourir t2 s1lu2'

Dans la variable "text_minus" toutes les lettres sont en minuscules.
Dans la variable "texte_majus" toutes les lettres sont en majuscules.

Dans la deuxième partie je teste la méthode replace() que l'on peut appliquer à une chaine.
Attention cette méthode ne modifie pas le contenu de la chaine d'origine mais celui de la variable de destination.
Vous constatez que dans "chaine_cryptee" les lettres "a" & "e" ont été remplacées par des chiffres. C'est donc l'amorce d'un cryptage ...
Syntaxe de la méthode : nouvelle_chaine = chaine.replace('old', 'new'). On peut chainer plusieurs replace() dans la même commande !

Opérateur in

Exemples de commande avec cet opérateur : >>>texte ="Bonjour" >>> 'B' in texte True >>> 'b' in texte False

L'interpréteur fait bien la distinction entre une lettre minuscule et son équivalent majuscule. On dit qu'il tient compte de la casse.

Opérateur not in

Oui "x" n'est pas contenu dans la variable texte. Une double négation vaut une affirmation.

Extraction d'une partie de chaine

Pour extraire une sous-chaine d'une chaine nous allons pratiquer le "slicing" (tranchage) !

Quelques extractions

L'expression entre crochets peut laisser dubatatif ...

• [0] : extraire le caractère d'indice zéro , [1] : d'indice 1, etc.
• [2:] : extraire à partir de la position 2 jusqu'au bout
• :[:2] : extraire du début jusqu'à la position 2 exclue
• [2:6] : extraire de 2 jusqu'à 6 exclu

Le petit tableau ci-dessous va vous aider ; il indique pour chaque caractère de la chaine son indice (ou position): caractère A V E C E S A R indice 0 1 2 3 4 5 6 7 8

Astuce : quand vous voyez ":" comprenez "jusqu'à".

Concaténer des chaines

Attention l'opérateur "+" n'a pas le même sens entre deux nombres et deux chaines.
Dans le premier cas il signifie addition et dans le second cas : concaténétion.
L'opérateur "+" entre une chaine et un numérique aboutit à une erreur d'exécution.

Quelques commandes à tester : >>> voyelles ="aeiouy" >>> consonnes ="bcdfghjklmopqrstvwxz" >>> alphabet_latin = voyelles + consonnes >>> alphabet_latin 'aeiouybcdfghjklmopqrstvwxz' >>> lettres_latines = list(alphabet_latin) >>> lettres_latines ['a', 'e', 'i', 'o', 'u', 'y', 'b', 'c', 'd', 'f', 'g', 'h', 'j', 'k', 'l', 'm', 'o', 'p', 'q', 'r', 's', 't', 'v', 'w', 'x', 'z']

Je crée deux chaines contenant respectivement les voyelles et les consonnes de l'alphabet latin.
A partir de ces deux chaines j'en crée une troisième qui est la concaténation des deux premières.
A partir de la nouvelle chaine je peux, avec la fonction générique list(), créer une liste. Chaque lettre de la chaine d'origine devient un élément de la liste.

Transformer une chaine de mots en une liste de mots

Si une chaine comprend différents groupes de lettres séparés par des espaces, il est facile de produire une liste de ces différents mots. >>> texte ="uN deuX Trois Quatre Cinq" >>> liste_chaine = texte.lower().split() >>> liste_chaine ['un', 'deux', 'trois', 'quatre', 'cinq'] >>> type(liste_chaine) <class 'list'>

Avec la méthode split() c'est chaque mot de la chaine qui dévient un élément d'une liste.
Notez que j'ai chainé la méthode split() avec la méthode lower().
La méthode split() crée une liste de mots à partir d'une chaine. Vous pouvez spécifier le séparateur, le séparateur par défaut est un espace. >>> texte2 ="un-deux-trois-quatre" >>> liste_mots = texte2.split('-') >>> liste_mots ['un', 'deux', 'trois', 'quatre']

Dans la chaine d'origine les mots sont séparés par des tirets ; je dois alors spécifier ce séparateur.

Je viens de vous montrer comment créer des listes à partir de chaines.
Cette notion de liste qui est fondamentale en python, va être approfondie dans le chapitre suivant.