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.

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 multiplication et division avant les addition 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 et celui n’est pas chargé.
Nous verrons la solution plus tard.
Exit() : commande pour fermer l’interpréteur ; les commandes sont effacées. 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 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

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

len(voyelles) : longueur de la chaine (nombre de caractères)
list(voyelles) : affiche la chaîne sous forme d'une liste (de caractères) ; 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) équivaut à la commande voyelles : affichage du contenu de la variable nommée "voyelles"

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

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

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).
texte.index(‘M’) : retourne la position du premier caractère M.
texte.lower() : affiche toutes les lettres en minuscules.
texte.upper() : affiche toutes les lettres en majuscules. Dans les deux cas le contenu de la variable "texte" n’est pas modifié par les deux dernières commandes ; incidence seulement au niveau de l’affichage.
Texte.count(‘.’) : affiche le nombre de points dans la chaine.
Texte.index(‘.’) : affiche la position du premier point dans la chaine.

Syntaxe

len(texte), type(texte), list(texte), print(texte), ...
texte.upper(), texte.lower(), 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(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'

chaine[-1] : récupère le dernier caractère d'une chaine
chaine[-2] : récupère l'avant dernier caractère
chaine[2:] : fin de chaine à partir du caractère de position 2
chaine[:2] : début de chaine jusqu'au caratère de rang 2 exclu
chaine[2:5] : milieu de chaine du caractère de rang 2 jusqu'à celui de rang 5 exclu

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