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
Vous pouvez me contacter via Facebook pour questions & suggestions :
Page Facebook relative à mon site
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).
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.
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).
Récapitulons !
| 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 réelle | / | 7 / 2 donne 3.5 |
| reste de la division entière | % | 7 % 3 donne 1 |
| division entière | // | 7 // 3 donne 2 |
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.
>>> 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.
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.
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.
>>> 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 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.
>>> 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.
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 ...
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.
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
>>>
>>> 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.
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.
>>> 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.
>>> 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.
>>> gros_mot ="Merde" >>> gros_mot = gros_mot * 4 >>> gros_mot 'MerdeMerdeMerdeMerde' >>>
>>> 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().
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().
>>> 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.
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é.
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.