Accueil

Traduction

Tutoriel Python - sommaire

Tutoriel Python - recherche

L'auteur : Patrick Darcheville

Vous pouvez me contacter via Facebook pour questions & suggestions : Page Facebook relative à mon site

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

Rappel : comment démarrer l'interpréteur python ?

Tapez la commande cmd dans la zone "Rechercher" de la barre des tâches.

J'ai lancé le terminal Windows en tapant "cmd" dans la zone de recherche de la barre d'état ; une fenêtre s'ouvre à fond noir et pour titre "invite de commandes".
À la suite de "c: ..." j'ai tapé "python" (ou "py" plus simplement) ; les triples chevrons apparaissent alors ; j'ai donc basculé en mode "console" de Python.
Je demande alors à Python de calculer 5 + (8*20) soit 165 ; les parenthèses n'étaient pas ici obligatoires ; les multiplication ont prioprité sur les additions.
Pour quitter l'interpréteur Python tapez exit(); vous pouvez alors saisir de nouveau des commandes DOS.

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()

De l'intérêt des parenthèses.

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

Les opérateurs arithmétiques

Récapitulons !

OpérationsSymbolesExemples
addition+2 + 5 donne 7
soustraction-8 - 2 donne 6
multiplication*6 * 7 donne 42
exponentiation (puissance)**5 ** 3 donne 125
division réelle/7 / 2 donne 3.5
reste de la division entière%7 % 3 donne 1
division entière//7 // 3 donne 2

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

Il existe aussi les opérateurs "in" et "not in" : voir plus loin dans ce chapitre.

Les opérateurs d'affectation

>>> x=20
>>> x+=10
>>> x
30
>>> y=15
>>> y-=5
>>> y
10
>>> z=2
>>> z*=5
>>> z
10

x+=10 est une simplification de x = x+10
y-=5 est une simplification de y = y-5
z*=5 équivaut à z= z*5

Attention les opérateurs d'affectation ++ et -- (incrémenter de 1 et décrémenter de 1) n'existent pas en Python.

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

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

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.