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.

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.

Les opérateurs

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

Opérations	Symboles	Exemples
addition	+	2 + 5 donne 7
soustraction	-	8 - 2 donne 6
multiplication	*	6 * 7 donne 42
exponentiation (puissance)	**	5 ** 3 donne 125
division	/	7 / 2 donne 3.5
reste de division entière	%	7 % 3 donne 1
quotient de division entière	//	7 // 3 donne 2

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 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 facultatives dans le cadre de commandes mais deviennnent indispensables dans le cadre d'instructions de programme.

Les opérateurs de comparaisons

< 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é "==" (2 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'>

J’ai créé différentes variables nommées "a, b,c, reponse, d".
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).
Notez qu’il existe aussi les types "int" (nombre entier), "float" (nombre décimal), bool (valeur booléenne).

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 des guillemets (simples ou doubles). Une chaine peut, bien sûr, être stockée dans une variable.
Une séquence de commandes :

>>> a =125 >>> b ="125" >>> type(a) <class 'int'> >>> type(b) <class 'str'> >>>

La variable "a" est de type 'int'(contient un entier) alos que "b" est de type 'str' (chaine ici composée de chiffres).

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 + avec 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".

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 guillemets simples ou doubles) 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

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

>>> texte ="Bonjour. Mon. Cher. Ami" >>> len(texte) 23 >>> list(texte) ['B', 'o', 'n', 'j', 'o', 'u', 'r', '.', ' ', 'M', 'o', 'n', '.', ' ', 'C', 'h', 'e', 'r', '.', ' ', 'A', 'm', 'i'] >>> type(texte) <class 'str'> >>> "M" in texte True >>> "X" in texte False >>> texte[0] 'B' >>> texte[22] 'i' >>> texte.index('M') 9 >>> texte.index('B') 0 >>> texte.count(".") 3 >>> texte.index('.') 7 >>> texte.index(';') ... ValueError: substring not found >>>

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

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

>>> "x" not in texte
True
>>> "j" not in texte
False
>>> "j" in texte
True

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

>>> chaine ="ave cesar"
>>> chaine[0]
'a'
>>> chaine[1]
'v'
>>> chaine[2:]
'e cesar'
>>> chaine[:2]
'av'
>>> chaine[2:6]
'e ce'
>>>

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

>>> reponse = True #surtout un T majuscule sinon erreur >>> type(reponse) <class 'bool'> >>> entier =12 >>> type(entier) <class 'int'> >>> reel =3.14116 >>> type(reel) <class 'float'> >>> a =12,5 >>> type(a) <class 'tuple'> >>> chaine ="Bonjour" >>> type(chaine) <class 'str'> >>> premiers1 = [1,3,5,7,11] >>> type(premiers1) <class 'list'> >>> premiers2 ={1,3,5,7,11} >>> type(premiers2) <class 'set'> >>> dico ={"oui":"yes", "non":"no"} >>> type(dico) <class 'dict'> >>>

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.

Tutoriel Python - sommaire