Accueil

Tutoriel Python - sommaire

Python : l'interpréteur de commandes - les variables - les chaines

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

Pour assimiler la syntaxe Python, tapez ces commandes dans l'interpréteur !

>>> 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.

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érationsSymbolesExemples
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 que l’on utilise des variables.

Une batterie de 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 (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 ne sont pas utiles dans le cadre de commandes (qui ne seront pas sauvegardées).
Par contre dans le cadre de l’IDLE (éditeur de scripts) il est recommandé de commenter les programmes : objet du programme, explication des astuces, etc.

Les opérateurs de comparaisons

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 : a, b,c, reponse, d.
Par erreur j’ai affecté à la variable B 20,5 (et non pas 20.5). A la question quel est le type de cette variable l'interpréteur répond : class ‘tuple’... Je reviendrais plus tard sur ce type de données.
La variable c est de type 'str' ('str' comme 'string' ou chaine de caractères).
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 ! Si vous ouvrez avec des guillemets doubles, fermez avec des guillemets doubles !
Une chaine peut contenir des apostrophes (tel un 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. Une chaine peut, bien sûr, être stockée dans une variable.
Quelques commandes :

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

La variable a contient un numérique (et plus précisément un entier) alos que b contient une chaine ("string" en anglais).

Création et manipulation d'une chaine

Commandes à saisir dans l'interpréteur :

>>> 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.

Attention ! print(voyelles) affiche le contenu de la variable nommée "voyelles" alors que print('voyelles') 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 ...

Exemple de commande print avec un paramètre complexe :

>>> a = 9 >>> print("le carré de ", a, " est ", a**2) le carré de 9 est 81

N'oubliez pas des espaces autour de " est " sinon tout est collé.
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.lower() 'bonjour. mon. cher. ami' >>> texte.upper() 'BONJOUR. MON. CHER. AMI' >>> texte 'Bonjour. Mon. Cher. Ami' >>> texte.count(".") 3 >>> texte.index('.') 7

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

Syntaxe

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(string)
Dans le deuxième cas il s'agit de méthodes c'est à dire de fonctions spécifiques aux chaines. Il faut donc écrire la commande sous la forme : string.méthode(paramètres éventuels)

* string : une donnée de type string : une chaine ou une variable contenant une chaine.

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_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 mourrir te salue" >>> chaine_cryptee = chaine.replace('a','1') >>> chaine 'ave cesar, ceux qui vont mourrir te salue' >>> chaine_cryptee '1ve ces1r, ceux qui vont mourrir te s1lue' >>> chaine_cryptee2 =chaine_cryptee.replace('e','2') >>> chaine_cryptee2 '1v2 c2s1r, c2ux qui vont mourrir t2 s1lu2'

Dans "text_minus" toutes les lettres sont en minuscules.
Dans "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 chaine de destination.
Vous constatez que dans "chaine_cryptee2" les lettres "ae" ont été remplacées par des chiffres. C'est donc l'amorce d'un cryptage, certes bien insuffisant.
Syntaxe de la méthode : nouvelle_chaine = chaine.replace('old', 'new').

Opérateur in

Exemples de commande avec cet opérateur :

>>> 'B' in texte True >>> 'b' in texte False

L'interpréteur fait bien la distinction entre une lettre minuscule et son équivalent majuscule.

Extraction d'une partie de chaine

Exemple 1

>>> chaine ="ave cesar"
>>> len(chaine)
9
>>> chaine[0]
'a'
>>> chaine[1]
'v'
>>> chaine[-1]
'r'
>>> chaine[-2]
'a'
>>> chaine[2:]
'e cesar'
>>>
>>> chaine[:2]
'av'
>>> chaine[2:5]
'e c'

Exemple 2

Connaissez le cryptage dit de César ?
Si la clé de cryptage est 2 à droite, cela signifie que dans le message codé, les lettes "a" sont remplacées par "c", les lettres "b" par "d', etc.

>>> alphabet ="abcdefgh"
>>> alphabet_bis = alphabet[2:] + alphabet[:2]
>>> alphabet_bis
'cdefghab'

En supposant un alphabet réduit à 8 lettres, on obtient le tableau de conversion dans la chaine "alphabet_bis".
On a supposé un décalage vers la droite de 2.
Donc "c" remplace "a", "d" remplace "b" et "a" remplace "g" , "b" remplace "h".

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.

Quelques commandes :

>>> 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 liste de ces différents 'mots'.

>>> texte ="uN deuX Trois Quatre Cinq" >>> liste_chaine = texte.lower().split() >>> liste_chaine ['un', 'deux', 'trois', 'quatre', 'cinq']

A partir de la chaine nommée "texte" une liste de chaines est créée grâce à la méthode split(). Il faut que la chaine initiale comprenne des espaces.
Toutes les lettres sont transformées en minuscules grâce à la méthode lower().

Tirage au sort d'un caractère dans une chaine

Commandes à saisir dans l'interpréteur :

>>> from random import *
>>> chaine ="abcdefghijklmopqrstuvwxyz"
>>> choice(chaine)
'x'
>>> choice(chaine)
'f'
>>> list(chaine)
['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'o', 'p', 'q', 'r', 's', 't', 'u', 
'v', 'w', 'x', 'y', 'z']
>>> liste = list(chaine)
>>> liste
['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'o', 'p', 'q', 'r', 's', 't', 'u',
 'v', 'w', 'x', 'y', 'z']

Pour un tirage au sort, il faut utiliser la fonction choice() qui ne fait pas partie du module standard mais du module random.
Il faut donc importer ce module.
La fonction choice() extrait de façon aléatoire un caractère de la chaine.
Avec la fonction list() on peut afficher une chaine de caractères sous forme d'une liste de caractères. On peut aussi créer une liste.

Nous avons vu que l'on peut transformer une chaine en liste.
Le prochain chapitre portera justement sur les listes.