Python : la console, les variables, les types de données, les opérateurs, les chaines

Python en mode console (ou interactif)

Le mode console de Python est un bon moyen de découvrir la syntaxe du langage : on tape des commandes et on voit immédiatement si la syntaxe est correcte (ou pas).

Lancer rapidement l'interpréteur Python ?

Démarrer le terminal Windows (le "shell") en tapant "cmd" dans la zone "rechercher" de la barre d'état.
Dans la fenêtre "invite de commandes" tapez "python" (ou "py") ; les triples chevrons apparaissent. Vous êtes dans la console Python. Utiliser Python en guise de calculatrice

Familiarisons-nous avec les opérateurs de calcul Python.
Tapez ces commandes ci-dessous dans la console :

>>> 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 "", line 1, in 
NameError: name 'sqrt' is not defined
>>>exit()

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 activé ("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é par rapport aux autres.

>>> 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 arithmétiques

Récapitulons !

Les variables

Utiliser des lettres dans les formules

Vous pouvez faire de l’algèbre c’est à dire utiliser des lettres dans vos formules à condition des les avoir déclarées et initialisées. Un informaticien dit qu'il manipule des variables.
Une variable est une adresse mémoire identifiée par un nom qui contient une donnée élementaire.

Premières variables en Python

 
>>> 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 en mode commandes mais deviennnent indispensables dans le cadre d'un programme.

Nommer des variables

Le premier caractère qui désigne une variable 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 identifier une structure de données (variable, liste, etc.)

Liste des mots réservés :

Exemple de variable mal nommée :

>>> and = 10
SyntaxError: invalid syntax

Il est interdit de nommer une variable "and" ou "in" car ces termes sont des mots réservés.
Donc rien ne vous interdit à priori de nommer une variable avec un terme correspondant à une fonction (print, range, etc.). Mais ce serait très maladroit pour la lisibilité de votre code.

Pour nommer des variables, je vous conseille d'utiliser des mots français sans lettres accentuées tels "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. Ce dernier type de notation est appelée "camelCase". La première lettre de chaque mot mais à partir du deuxième mot.

Exemples de variables : prix_ht, taux_tva, prix_ttc OU en "camelCase" : prixHt, tauxTva, prixTtc
Évitez de mélanger les deux techniques de nommage dans un même script.

Les opérateurs de comparaisons

Surtout ne confondez pas le symbole = qui est l'opérateur d'affectation avec == qui est un opérateur de comparaison.
a = 5 : affectation de 5 à la variable a
a ==5 : comparer le contenu de a à 5 ; ce test retourne true/false

Les opérateurs de comparaison :
• < 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" : voir plus loin dans ce chapitre.

La fonction type()

La fonction type retourne le type d'une variable. Le type d'une variable est fonction du contenu affecté

>>> a = 5
>>> type(a)
class 'int'
>>> id(a)
1810852309424
>>> a =True
>>> type(a)
class 'bool'
>>> id(a)
140703867295848
>>> a= "salut"
>>> type(a)
class 'str'
>>> id(a)
1810858641968
>>> a=10.5
>>> type(a)
class 'float'
>>> id(a)
1810858583440
>>> a = 10,5
>>> type(a)
class 'tuple'
>>>

Python pratique le typage dynamique. Cela signifie que le typage est réalisé et vérifié après l'exécution du code, et non avant. Ainsi, lorsqu'on définit une variable en Python, on n'est pas obligé de préciser son type, il est déduit par l'interpréteur

La variable a est successivement de type int, bool, str, float car on lui affecte successivement un entier puis un booléen puis une chaine puis un décimal.

Pour créer une variable de type "bool" il faut affecter True ou False avec la première lettre en majuscule et surtout pas de guillemets .

Par erreur, j’ai affecté à "a" la valeur 10,5 (et non pas 10.5). À la question "quel est le type de cette variable ? ", la console répond : class ‘tuple’... Je reviendrai plus tard sur ce type de donnée.

Conversion de type

>>> chiffre =125.5
>>> str(chiffre)
'125.5'
>>> chaine = '12'
>>> int(chaine)
12
>>> chaine2 ="122.54"
>>> float(chaine2)
122.54
>>>

La fonction str() convertit un numérique en chaine.
Les fonctions float() & int() convertissent une chaine respectivement en décimal et entier.

à propos de l'affectation

En Python on peut réaliser des affectations simultanées, des affectations paralèlles et des permutations.

>>> a = b = 3			# affectation simultanée
>>> a
3
>>> b
3
>>> c,d = 4,5		#affectation paralèlle
>>> c
4
>>> d
5
>>>
>>> c,d = d,c		#permutation
>>> c
5
>>> d
4
>>>

Pour les affectations paralèlles et les permutations on utilise une série de valeurs nommées tuples.
Je reviendrai plus loin sur les tuples ...

Les chaines

On désigne par chaine (ou objet "string" ou encore objet str) une suite de caractères délimitées par des guillemets simples ou doubles.
Chaque caractère a une position ou indice ou index dans la chaine. Le premier caractère à l'indice zéro !
Par extension on emploie le terme "chaine" pour désigner une variable qui contient une chaine.

Fonctions applicables à une chaine

Création d'un littéral de type str et d'une variable contenant une chaine :

>>> type("au revoir")
class 'str'
>>> voyelles ="aeiou" 
>>> type(voyelles)
class 'str'
>>>len(voyelles)
5
>>> type('voyelles')
class 'str'
>>> max(voyelles)
'u'
>>> min(voyelles)
'a'
>>> print(voyelles)
aeiou
>>> print('voyelles')
voyelles
>>>

Commentaires :
• len(voyelles) retourne la longueur de la chaine (son nombre de caractères)
• type(voyelles) indique le type de la variable
• max() & min() retournent respectivement les lettres ayant le code ASCII le plus grand et le plus petit

Ne confondez pas :
• print(voyelles) : affiche du contenu de la variable "voyelles"
• print('voyelles') ou print("voyelles") : affiche le littéral "voyelles"

Autres fonctions et méthodes applicables à un objet str

>>> texte ="Bonjour. Mon. Cher. Ami"
>>> "M" in texte
True
>>> "X" in texte
False
>>> texte[0]
'B'
>>> texte[22]
'i'
>>> texte[8:]
' Mon. Cher. Ami'
>>> texte[:8]
'Bonjour.'
>>> texte[2:6]
'njou'
>>> texte.index('M')
9
>>> texte.index('B')
0
>>> texte.count(".")
3
>>> texte.index('.')
7
>>> texte.index(';')
...
ValueError: substring not found
>>>
>>> texte[0] ='b'
...
TypeError: 'str' object does not support item assignment

• "M" in texte retourne True puisque M majuscule fait partie de la chaine
• texte[0] retourne le premier caractère de la chaine 
• texte[8:] : accès à une tranche de la chaine ; du caractère ayant l'indice 8 jusqu'à la fin
• texte[:8] : tranchage : du début jusqu'à l'indice 8 exclu
• texte[2:6] : tranchage : de l'indice 2 inclus à l'indice 6 exclu
• texte.index(‘M’) affiche l'indice du premier caractère M
• texte.count(".") affiche le nombre de points dans la chaine
• texte.index(‘.’) affiche l'indice du premier point dans la chaine
• texte.index(';') :retourne un message d'erreur car le caractère ";" n'existe pas dans la chaine
• texte[0] ='b' : message d'erreur ; une chaine ne peut être modifiée !

Attention le premier caractère d'une chaine à l'indice O !
in est un opérateur qui retourne un booléen ; il existe aussi not in.

Syntaxe

Observez que dans les commandes nous avons quatre syntaxes différentes :
1. len(texte), type(texte), max(texte), min(texte), print(texte) :
   emploi des fonctions génériques
2. texte.index(valeur), texte.count(valeur) :
   utilisation de méthodes de classe
3. texte[index] OU texte[index début : index fin] :
   accès indexé (ou tranchage ou "slicing")
4. "M" in texte :
   test d'appartenance

Méthodes .upper() & .lower()

Ces méthodes permettent de changer la "casse" d'une chaine.
En informatique, la casse désigne le fait de distinguer les lettres capitales des lettres minuscules.

>>>texte ="Bonjour. Mon. Cher. Ami"
>>> texte.upper()
'BONJOUR. MON. CHER. AMI'
>>> texte
'Bonjour. Mon. Cher. Ami'
>>> texte.lower()
'bonjour. mon. cher. ami'
>>> texte
'Bonjour. Mon. Cher. Ami'

Les méthodes .upper() & .lower() se contentent d'afficher en majuscules ou minuscules mais ne modifient pas le contenu de la variable. En effet une chaine est un objet immuable (ne peut être modifié).
Donc pour mémoriser une chaine avec une casse modifiée, il faut récréer une variable sous un nouveau nom OU le même nom (dans ce cas vous écrasez l'ancienne variable).

>>> id(texte)
1810854901040
>>> texte = texte.upper()
>>> texte
'BONJOUR. MON. CHER. AMI'
>>> id(texte)
1810854860480

Je crée une nouvelle variable "texte" à la place de l'ancienne qui récupère la nouvelle casse.
L'id de la variable "texte" à changé ; il s'agit donc d'une nouvelle variable qui écrase l'ancienne.

La méthode .replace()

>>> 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'
>>> chaine
'ave cesar, ceux qui vont mourir te salue'
>>> chaine = chaine.replace('a','z').replace('e','y').upper()
>>> chaine
'ZVY CYSZR, CYUX QUI VONT MOURIR TY SZLUY'

Vous constatez que dans chaine_cryptee les lettres "a" & "e" ont été remplacées par des chiffres 1 et 2.
Syntaxe de la méthode : chaine.replace('caractère', 'remplacé par'). les arguments de la méthode .replace() sont obligatoirement des strings (toujours des guillemets).
On peut chainer plusieurs méthodes de classe dans la même instruction comme je le montre dans la dernière commande.

Autres opérations sur les chaines

Addition de chaines ou concaténation

>>> voyelles ="aeiouy"
>>> consonnes ="bcdfghjklmopqrstvwxz"
>>> alphabet_latin = voyelles + consonnes
>>> alphabet_latin
'aeiouybcdfghjklmopqrstvwxz'

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.

Multiplication de chaines

>>> gros_mot ="Merde"
>>> gros_mot = gros_mot * 4
>>> gros_mot
'MerdeMerdeMerdeMerde'
>>>

Les caractères spéciaux dans une chaine

Saut de ligne dans une chaine

>>> unechaine ="Première ligne \n Deuxième ligne \n Troisième ligne"
>>> unechaine
'Première ligne \n Deuxième ligne \n Troisième ligne'
>>> print (unechaine)
Première ligne
 Deuxième ligne
 Troisième ligne

Le caractère spécial \n provoque un saut de ligne. Mais attention il n'est pris en compte que dans le cadre d'une instruction print().

Délimiter une chaine par une paire de guillemets triples (simples ou doubles)

Pour écrire un texte sur plusieurs lignes nous devons la délimiter par des guillemets triples (simples ou doubles).

>>> machaine =""" Première ligne
... Deuxième ligne
... Troisième ligne
... """
>>> machaine
' Première ligne\nDeuxième ligne\nTroisième ligne\n'
>>> print(machaine)
 Première ligne
Deuxième ligne
Troisième ligne

Là encore les sauts de lignes sont effectifs uniquement avec une commande print().

Le caractère d'échappement

>>> chaine ='l\'amour est dans le pré'
>>> chaine
"l'amour est dans le pré"
>>> chaine2 ="l\"apostrophe est un symbole particulier qui indique l\"élision"
>>> chaine2
'l"apostrophe est un symbole particulier qui indique l"élision'
>>>

Vous pouvez utilisez des guillemets simples/doubles dans une chaine délimitée par des guillemets simples/doubles à condition de faire précéder le guillemet du symbole \ . On l'appelle le caractère d'échappement.
Dans la pratique on délimitera une chaine contenant un apostrophe par des guillemets doubles.

Parcours d'une chaine

Une chaine est une structure itérable : peut être parcourue par une boucle.
Vous pouvez utiliser le "for ... in" basique ou le "for ... in enumerate ..." si vous voulez afficher indice et valeur de chaque élément.

>>>machaine ="Bonjour chers amis"
>>> for indice, car in enumerate(machaine) :
...     print(indice, car)
...
0 B
1 o
...
7
8 C
...

L'indice (ou index) de chaque caractère est affiché.

D'autres méthodes de la classe str

Le nombre de méthodes applicables à une chaine est impressionnant (voir chapitre 15).
Je me contente d'en présenter quelques unes supplémentaires ci-desssous :

>>> unechaine ="au revoir mes amis"
>>> unechaine.upper()
'AU REVOIR MES AMIS'
>>> unechaine
'au revoir mes amis'
>>> unechaine.capitalize()
'Au revoir mes amis'
>>> unechaine.rindex('a')
14
>>> unechaine.index('a')
0
>>> unechaine
'au revoir mes amis'
>>> unechaine = unechaine.upper() #dernière commande
>>> unechaine
'AU REVOIR MES AMIS'

Vous connaissez déjà les méthodes .lower() & .upper() ; il existe aussi la méthode .capitalize() qui affiche la première lettre en majuscule.

Vous connaissiez la méthode .index(caractère) qui recherche la première occurence en partant la gauche de la chaine; Il existe aussi .rindex(caractère) qui recherche à partir de la droite.

je vous rappelle qu'une chaine est un série non modifiable ; les méthodes .upper(), lower(), capitalize() se contentent d'afficher la chaine avec une certaine casse à moins d'affecter dans une nouvelle variable (qui peut porter le même nom que celle d'origine.