Tutoriel Python - sommaire

Contenu de la page à la suite du sommaire.

Vous pouvez me contacter via Facebook (questions, critiques constructives) : Page Facebook relative à mon site

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

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 dira qu'il manipule des variables.

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

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 de désigner une variable par un nom de fonction native ...

Pour nommer des variables, utilisez 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 en les collant 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 liant sans espace ni ponctuation, et en mettant en capitale la première lettre de chaque mot.
Exemples : prix_ht, taux_tva, prix_ttc OU prixHt, tauxTva, prixTtc
Ne mélanger 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 = True >>> type(reponse) <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).
a et 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.

Une chaine de caractères doit être délimitée par une paire de guillemets simples ou une paire de guillemets doubles.
Mais surtour ne mélangez pas les deux !
Une chaine peut contenir des apostrophes (apostrophe = guillemet simple) à condition d'être délimitée par des guillemets doubles.

Chaine de caractères

Une chaine est une séquence de caractères délimitée par une paire d'apostrophes ou de guillemets . Une chaine peut, bien sûr, être stockée dans une variable.
Une chaine multilignes (un paragraphe, par exemple) doit être délimitée par une paire de trois guillemets.
Une chaine délimitée par des guillemets peut contenir des apostrophes.
Une chaine délimitée par des apostrophes peut contenir des apostrophes échappés : précédés de "\"

Une séquence de commandes : >>> a =125 >>> b ="125" >>> type(a) <class 'int'> >>> type(b) <class 'str'> >>> chaineML ="""chaine sur ... deux lignes""" >>> type(chaineML) <class 'str'> >>> instant ="aujourd'hui" >>> type(instant) <class 'str'> >>> instant2 ='aujourd\'hui' >>> instant2 "aujourd'hui" >>>

a est de type 'int'(contient un entier) alos que b est de type 'str' (chaine composée ici de caractères numériques).
chaineML contient une chaine multilignes.
instant et instant2 contiennent chacune une apostrophe.

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 chaines provoque la concaténation (chaines mises bout à bout).
On ne peut utiliser directement l'opérateur + entre des nombres et des chaines.

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 plus tard.
• 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

La commande print(voyelles) affiche le contenu de la variable voyelles alors que la commande print('voyelles') (donc avec des apostrophes ou guillemets) affiche 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), ...
• texte.index(), texte.count(), ...

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(nomChaine)
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 :chaine.méthode(paramètres é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_cryptee2 '1v2 c2s1r, c2ux qui vont mourrir 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_cryptee2" 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
• [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 : traduisez ":" par "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 list(), créer la liste des toutes les lettres de l'alphabet latin.

Transformer une chaine en une liste

Si une chaine comprend différents groupes de lettres séparés par des espaces, il est facile de produire une énumération 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() pour convertir dans la variable de destination, les majuscules en minuscules.

Les autres types de données

Vous connaissez déjà différents types de données : int, bool, str, float mais il en existe d'autres ...

Commandes à saisir dans la console

Remarques importantes

Dans l'exemple ci-dessus certaines variables contiennent non pas une donnée mais une série de données séparées par des virgules.
Si cette série n'est pas délimitée (ou délimitée par des parenthèses) on parle de tuple.
Si la série est délimitée par des crochets il s'agit d'une liste.
Si la série est délimitée par des accolades il s'agit d'un ensemble (ou "set").
Si la série est délimitée par des accolades mais composée de paires (clé : valeur) il s'agit d'un dictionnaire.

Pour initialiser une variable avec un flottant (nombre décimal) le séparateur décimal est le point !
Si par erreur vous utilisez la virgule, vous créez de facto un tuple.

Liste, tuple, ensemble et dictionnaires

Dans les chapitres suivants, ces différentes "séries de données" seront abordées. Sachez cependant que le type de séquences le plus fréquent est la liste ! Les tuples sont d'un usage restreint. Les ensembles (ou "set") ont été introduits récemment (version 3 de Python).

Dans le chapitre suivant : les listes.