Pour programmer en python, vous allez utiliser un logiciel appelé environnement de développement, Pyzo ou Spyder, par exemple.
Un environnement de développement réunit entre autres un éditeur de texte (pour écrire des programmes et algorithmes) et un interpréteur python (pour exécuter directement des programmes et des commandes simples).
L’éditeur se trouve à gauche et l’interpréteur se trouve à droite.
Voici ce que vous voyez si vous utilisez Spyder:
et ce que vous voyez si vous utilisez Capytale via l'ENT:
Losqu'on exécute plusieurs lignes d'instructions celle-ci sont exécutées de haut en bas et toujours dans cet ordre.
On crée une variable en Python avec une instruction de la forme:
Cette instruction s'appelle l'affectation. La valeur Valeur
est alors rangée (ou stockée) dans une case mémoire identifiée par le nom NomDeVariable
(il est plus beaucoup plus simple de manipuler des noms de variables que des adresse mémoires physiques du type 0x0C1000407FFFEFFC
).
Il faut respecter l'ordre: le nom de variable est à gauche du =
et la valeur est à droite.
x=2
va donner la valeur $2$ à la variable x
.
❌❌ 2=x
donne une erreur d'exécution. ❌❌
Que donne x=2
suivi de x=x+1
? L'interpréteur Python commence par évaluer la quantité à droite du =
donc il évalue x+1
à $3$. Ensuite il stocke la valeur $3$ dans la variable x
. On dit qu'on a incrémenté de $1$ la valeur de x
. Noter que l'ancienne valeur de x
(ici $2$) a été perdue, on dit qu'elle a été écrasée par la nouvelle valeur.
Le
=
n'a donc pas le même sens qu'en mathématiques: en maths $x=x+1$ donne l'absurdité $0=1$ puisque le $x$ est le même des deux côtés.
En informatique dans l'instruction
x=x+1
on trouve deuxx
différents: celui à droite du=
est l'ancienx
et celui à gauche est le nouveaux
. Il faut la comprendre dans le sensxnouveau = xancien + 1
.
Les noms de variables sont des suites de caractères choisis parmi les lettres (minuscules ou majuscules, mais non accentuées), les chiffres et le caractère underscore _
(touche $8$ sur le clavier).
Contrairement aux maths on peut avoir des noms de variables de plus d'une lettre: il faut en profiter pour utiliser des noms pertinents pour la lisibilité du code comme compteur
, temperature
ou stock
. Il ne faut donc pas appeler toutes vos variables x
ou y
.
Noter que compteur
, Compteur
et COMPTEUR
sont trois noms différents en Python.
La valeur qu'on donne à une variable peut être de différents types que nous présentons ici.
Le type n'a pas besoin d'être précisé, l'interpréteur Python le gère tout seul en fonction du contexte: c'est le typage dynamique.
Ce sont les booléens (du nom de Georges Bool). Ils n'ont que deux valeurs qui sont True
et False
.
Ce type est utilisé pour des calculs avec les entiers. Les calculs sont exacts et les entiers utilisés peuvent être aussi grands qu'on le souhaite (ou presque).
Les opérateurs sont:
+
addition (2+3
donne 5
)
-
soutraction (5-3
donne 2
)
*
multiplication (2*3
donne 6
)
//
division entière = quotient de la division euclidienne (7//2
donne 3
)
%
reste de la division euclidienne (14%4
donne 2
)
**
puissance (2**3
donne 8
)
Ce type est utilisé pour des calculs avec les flottants qui sont une représentation approchée des nombres réels. Les calculs sont faits de manière approchée. Les flottants sont notés avec un .
qui correspond à la virgule: 12.43
-0.38
-.38
4.
.27
.
On dispose des opérateurs +
-
*
/
et **
.
Lorsqu'on demande une opération avec une opérande de type int
et l'autre de type float
l'interpréteur convertit les deux en float
: c'est le transtypage automatique.
Par exemple 2+2
donne 4
alors que 2+2.
donne 4.
.
On peut forcer une valeur à être de type int
avec l'instruction int()
, et à être de type float
avec l'instruction float()
.
La valeur absolue s'obtient avec abs()
et la partie entière avec floor()
.
Ce type est utilisé pour manipuler des chaînes de caractères, cest-à-dire du texte. Les chaînes de caractères sont délimitées par des apostrophes '
(touche 4
du clavier) ou des doubles appostrophes "
(touche 3
du clavier):
'Bonjour tout le monde'
"Hello world"
"Je visite l'Allemagne"
La chaîne de caractères vide s'obtient avec ""
ou ''
.
On peut forcer une valeur à être de type string
avec l'instruction str()
.
Par exemple str(2)
donne '2'
.
L'opérateur +
permet de concaténer deux chaînes de caractères: 'Bonjour'+' tout le monde'
donne 'Bonjour tout le monde'
.
Si c
est une chaîne de caractères et n
un entier alors c*n
donne c+c+...+c
(avec n
termes):
'abc'*3
donne 'abcabcabc'
.
len(c)
donne la longueur de la chaîne de caractères c
: len("Bonjour")
donne 7
.
On peut extraire le (k+1)
-ième caractère de la chaîne de caractères c
avec la syntaxe c[k]
.
Attention: les caractères sont numérotées de 0
à len(c)-1
.
Si c='Bonjour tout le monde'
alors c[0]
donne 'B'
et c[5]
donne 'u'
.
Le dernier caractère s'obtient avec c[len(c)-1]
qu'on peut abréger en c[-1]
.
On peut extraire une sous-chaîne avec la syntaxe c[k:j]
qui va donner les caractères entre les positions k
et j-1
.
Si k
n'est pas précisé il vaut 0.
Si j
n'est pas précisé il vaut len(c)-1
. c[:]
donne toute la chaîne c
.
c[1:5]
donne ici 'onjo'
et c[:8]
donne 'Bonjour'
.
On peut aussi préviser un pas avec la syntaxe c[k:j:p]
qui va donner les caractères entre les positions k
et j-1
avec un pas de p
entre 2 caractères.
c[1:9:3]
donne ici 'oo '
.
Noter que c[::-1]
va donner la chaîne miroir de c
.
Si c='Hello world'
alors c[::-1]
donne 'dlrow olleH'
.
❌❌On ne peut pas modifier une variable de type string
: ❌❌
c[6]='W'
donne l'erreur 'str' object does not support item assignment
.
Si on veut un W
majuscule on doit écraser la variable c
:
c=c[:6]+'W'+c[7:]
va donner 'Hello World'
.
Ce sont des tableaux dont les éléments peuvent être de n'importe quel type. Il sont notés entre crochets [
et ]
et séparés par des virgules ,
:
[1, 2, 3, 4]
['Bonjour','tout','le','monde']
[[1, 2], [3, 4], [5, 6]]
La liste vide s'obtient avec []
.
On dispose des mêmes opérateurs que pour les chaînes de caractères à savoir +
*
len(L)
et L[k:j:p]
:
[1, 2, 3, 4]+['Bonjour','tout','le','monde']
donne [1, 2, 3, 4, 'Bonjour','tout','le','monde']
[0]*4
donne [0,0,0,0]
.
L=[1, 2, 3, 4]
puis L[1:3]
donne [2, 3]
.
Ajout d'une élément dans une liste
Pour ajouter x
à la fin de liste L
on peut exécuter:
L = L + [x]
Sur l'exemple précédent L = L +[5]
va donner [1, 2, 3, 4, 5]
.
On peut aussi utilise la méthode append()
dont la syntaxe est la suivante L.append(x)
(sans le L=
).
Par exemple si L=[1, 2, 3, 4]
alors L.append(5)
va donner la valeur [1, 2, 3, 4, 5]
à L
.
Au niveau de la mémoire il est préférable d'utiliser L.append(x)
que L=L+[x]
.
Par contre si veut ajouter deux éléments x
et y
on ne peut pas utiliser append()
mais L = L + [x, y]
.
Par exemple si L=[1, 2, 3, 4]
alors L = L + [5, 6]
va donner [1, 2, 3, 4, 5, 6]
.
De même si on veut ajouter x
en début de liste on utilise L = [x] + L
.
Par exemple si L=[1, 2, 3, 4]
alors L = [0] + L
va donner [0, 1, 2, 3, 4]
.
On peut modifier les éléments d'une liste (contrairement aux chaînes de caractères).
L[k] = x
va remplacer le (k+1)
-ième élément de L
par x
.
Par exemple si L=[1, 2, 3, 4]
alors L[1] = -2.35
va donner [0, -2.35, 2, 3, 4]
.
Supprimer le dernier élément d'une liste
Pour supprimer le dernier élément de la liste L
on peut exécuter:
L = L[:len(L)-1]
Par exemple si L=[1, 2, 3, 4]
alors L = L[:len(L)-1]
va donner [1, 2, 3]
.
On peut aussi utilise la méthode pop()
dont la syntaxe est la suivante L.pop()
(sans le L=
).
Par exemple si L=[1, 2, 3, 4]
alors L.pop()
va donner la valeur [1, 2, 3]
à L
.
Au niveau de la mémoire il est préférable d'utiliser L.pop()
que L = L[:len(L)-1]
.
Autre avantage: on peut récupérer ce dernier élément en exécutant x = L.pop()
.
Par exemple si L=[1, 2, 3, 4]
alors x = L.pop()
va donner la valeur 4
à x
et la valeur [1, 2, 3]
à L
.
On obtiendrait le même résultat en exécutant successivement x = L[-1]
puis L = L[:len(L)-1]
.
Par contre si veut enlever les deux derniers on ne peut pas utiliser pop()
mais L = L[:-2]
.
Par exemple si L=[1, 2, 3, 4]
alors L = L[:-2]
va donner [1, 2]
.
De même si on veut enlever le premier élément de la liste on utilise L = L[1:]
.
Par exemple si L=[1, 2, 3, 4]
alors L = L[1:]
va donner [2, 3, 4]
.
Plus généralement si on veut enlever le (k+1)
-ième élément on exécute L = L[:k] + L[k+1:]
.
Par exemple si L=[1, 2, 3, 4]
alors L = L[:2]+L[3:]
va donner [1, 3, 4]
.
Les tuples sont comme des listes mais sont séparés par des parenthèses (
et )
et on ne peut pas modifier leurs éléments (comme pour les chaînes de caractères). Les méthodes append()
et pop()
ne sont donc pas utilisables.
Les parenthèses sont facultatives.
On peut les utiliser pour échanger les valeurs de deux variables.
Si a
a la valeur de 2
et b
a la valeur 3
comme faire pour que a
ait la valeur de 3
et b
ait la valeur 2
?
Exécuter a=b
puis b=a
va donner la valeur 3
à a
puis la valeur 3
à b
ce qui n'est pas ce qu'on veut.
La solution est d'utiliser une troisième variable: on exécute x=a
puis a=b
puis b=x
. x
prend la valeur 2
puis a
la valeur 3
puis b
la valeur 2
.
Une solution plus élégante est d'utiliser des tuples: on exécute (a,b) = (b,a)
.
Comme les parenthèses sont facultatives on l'écrit: a,b = b,a
.
Cette technique est appellée affectation simultanée.
Comme nous l'avons dit les instructions sont exécutées de haut en bas les unes après les autres. Il est possible de modifier ce flot, afin de répéter certaines instructions ou d'en ignorer certaines dans des cas précis.
La boucle for
en Python est utilisée pour effectuer une itération sur une collection d’objets. Une collection peut être une liste, un tuple ou une chaine de caractère. A chaque itération des instructions sont exécutées: la boucle for permet donc de répéter des instructions, souvent un très très grand nombre de fois (c'es tout l'intérêt de l'ordinateur!).
La syntaxe de la boucle for en Python est la suivante :
instructionsAvant
for element in collection :
instructions
instructionsApres
Ici, collection
est la collection que nous allons parcourir. La variable element
est la variable qui recevra l’élément de la séquence traité. Et instructions
est l’ensemble des manipulations que nous allons effectuer pour l’élément element
.
instructionsAvant
et instructionsApres
sont respectivement les instructions exécutées avant (respectivement après) la boucle for. Elles sont toujours exécutées.
Noter que ce qui sépare
instructions
deinstructionsApres
est simplement l'indentation. C'est comme cela que l'interpréteur reconnaît le bloc d'instructions qui est dans la boucle for de celui qui se trouve après.
Voici un premier exemple où on itère sur une liste. L'instruction print(NomVariable)
affiche à l'écran la valeur enregistrée dans la variable NomVariable
.
MaListe = [1, 2, 3, 4]
for element in MaListe:
print(element)
1 2 3 4
Un autre exemple avec une liste mais dont les éléments sont des chaînes de caractères.
MaListe = ["toto", "tata", "titi"]
for chaine in MaListe:
print(chaine)
toto tata titi
Un troisième exemple où on parcourt une chaîne de caractères, caractère par caractère.
for i in "bouclE":
print (i)
b o u c l E
Voici deux exemples à connaître par coeur, tant ils sont souvent utiles. Le premier consiste à calculer la somme des termes d'une liste de nombres. On initialise une variable somme
à la valeur $0$ puis on lui ajoute à chaque itération l'élément courant de la liste.
L = [1, 2, 3, 4]
somme = 0
for element in L:
somme = somme + element
print(somme)
10
Le second consiste à calculer le produit des termes d'une liste de nombres. On utilise cette fois une variable produit
qu'on initialise à $1$.
L = [1, 2, 3, 4]
produit = 1
for element in L:
produit = produit * element
print(produit)
24
Très souvent notre collection sera la liste des entiers de $0$ à $n-1$ ($n$ est alors le nombre d'itérations).
Cette liste s'obtient en Python avec l'intruction
range(n)
.
Elle a deux variantes. Si on veut itérer sur les entiers de $m$ à $n-1$ on utilise
range(m,n)
. Enfin si on veut préciser un pas $p$ on utiliserange(m,n,p)
.
Voici par exemple comme calculer la somme des $1\,000\,000$ premiers entiers (toujours penser à ajouter 1 à la borne!).
somme = 0
for nombre in range(10000001):
somme = somme + nombre
print(somme)
50000005000000
On dispose alors d'une autre façon d'itérer sur les éléments d'une liste en utlisant les indices (ie la position de ses éléments). Pour cela il faut se rappeler que si une liste L
a $n$ éléments, ceux-ci sont indicés de $0$ à $n-1$.
La boucle
for x in L :
faire un truc avec x
peut donc être réécrite:
n=len(L)
for k in range(n):
x = L[k]
faire un truc avec x
Cette nouvelle version est plus compliquée mais plus précise: on dispose à la fois de l'élément x
et son indice k
dans la liste.
On peut faire de même avec une chaîne de caractères.
Voici comment construire la chaîne de caractères miroir d'une chaîne de caractères c
sans utiliser l'instruction c[::-1]
.
c = "hebuociouq"
miroir = ''
n = len(c)
for k in range(n-1,-1,-1):
miroir = miroir + c[k]
print(miroir)
quoicoubeh
Nous présentons d'abord comment effectuer des tests en Python. Un test est une instruction qui renvoie un booléen: True
ou False
.
Si x
et y
sont deux variables de type int
ou float
on peut leur appliquer un des opérateurs de comparaison:
OPERATEUR | SYNTAXE | |
---|---|---|
== | égalité (ne pas confondre avec l'affectation = ) | x == y |
!= | non égalité | x != y |
> | strictement plus grand | x>y |
< | strictement plus petit | x |
>= | supérieur ou égal | x>=y |
<= | inférieur ou égal | x<=y |
and | opérateur logique ET | x>y |
or | opérateur logique OU | x>y |
not | opérateur logique NON | x>y |
Attention le test d'égalité
==
n'a pas vraiment de sens six
ety
sont des flottants. On préfère tester six
ety
sont à peu près égales, par exemple avecabs(x-y) < 10**(-8)
.
Ces opérations sont possibles avec des variables de type
string
: dans ce cas les opérateurs<
>
<=
et>=
utilisent l'ordre lexicographique (celui du dictionnaire).
Si test
est une variable booléenne (donc qui a la valeur True
ou False
), la syntaxe du branchement conditionnel if en Python est la suivante :
instructionsAvant
if test :
instructions
instructionsApres
instructions
ne sera exécuté sitest
a la valeurTrue
.
Alors que instructionsAvant
et instructionsApres
sont toujours exécutées.
Donc si test
a la valeur True
alors sont exécutées instructionsAvant
puis instructions
puis instructionsApres
.
Et si test
a la valeur False
alors sont exécutées instructionsAvant
puis instructionsApres
.
Noter que ce qui sépare
instructions
deinstructionsApres
est simplement l'indentation.
Si on veut spécifier des instructions lorsque test
est False
peut utiliser else
:
instructionsAvant
if test :
instructions
else :
instructionsElse
instructionsApres
Si test
a la valeur True
alors sont exécutées instructionsAvant
puis instructions
puis instructionsApres
.
Si test
a la valeur False
alors sont exécutées instructionsAvant
puis instructionsElse
puis instructionsApres
.
On peut envisager un branchement multiple avec elif
(contraction de << else if >>):
if test1 :
instructions1
elif test2 :
instructions2
elif test3 :
instructions3
.........
.........
elif testn:
instructionsn
else:
instructionsElse
instructionsApres
Si test1
a la valeur True
alors sont exécutées instructionsAvant
puis instructions1
puis instructionsApres
.
Si test1
a la valeur False
et test2
la valeur True
alors sont exécutées instructionsAvant
puis instructions2
puis instructionsApres
.
Si test1
et test2
ont la valeur False
et test3
la valeur True
alors sont exécutées instructionsAvant
puis instructions3
puis instructionsApres
.
Etc ...
Si tous les tests ont la valeur False
alors sont exécutées instructionsAvant
puis instructionsElse
puis instructionsApres
.
Voici un exemple:
a = 1
b = 2
c = 2
Delta = b**2 - 4*a*c
print("Pour notre équation du second degré : ")
if Delta > 0 :
print('Delta >0 donc deux solutions réelles.')
elif Delta == 0:
print('Delta =0 donc une unique racine réelle.')
else:
print('Delta < 0 donc pas de racine réelle mais deux racines complexes.')
print('Attention seul les optionnés maths expertes comprendront le cas Delta < 0.')
Pour notre équation du second degré : Delta < 0 donc pas de racine réelle mais deux racines complexes. Attention seul les optionnés maths expertes comprendront le cas Delta < 0.
Nous donnons ensuite des exemples à bien connaître. Le premier consiste à rechercher un élément dans une liste. Nous utilise une variable booléenne drapeau
initialisée à False
. Ensuite on itère sur la liste avec une boucle for. Si on trouve un élément égal à celui qu'on cherche on donne la valeur True
à la variable drapeau
. A la fin de la boucle, si drapeau
a la valeur True
c'est que l'élément cherché a été trouvé, si elle a gardé la valeur False
c'est que l'élément n'a pas été trouvé après avoir parcouru toute la liste. Voici le code:
x = 6
L = [3, 5, 1, -7, -2, 6, 0, 4]
drapeau = False
for element in L :
if element == x :
drapeau = True
print(drapeau)
True
Noter qu'on peut réaliser ce test simplement en Python avec l'instruction x in L
.
Le second exemple permet de compter le nombre d'occurences d'un élément dans un liste. On utilise cette fois une variable compteur qu'on initialise à $0$. Ensuite on itère sur les éléments de la liste avec une boucle for. A chaque fois que l'élément courant est égal à l'élément cherché on incrémente de $1$ la variable compteur
. En sortie de boucle, cette variable compteur
nous donnera donc le nombre d'occurences de l'élément cherché. Voici le code:
x = 6
L = [3, 5, 6, 1, -7, 6, -2, 6, 0, 4, 6]
compteur = 0
for element in L :
if element == x :
compteur = compteur + 1
print(compteur)
4
L'exemple suivant consiste à chercher l'élément maximal dans une liste. On utlise une variable maximum
(le nom max
est déjà utilisé par le langage Python) qu'on initialise à la valeur du premier élément de la liste. Ensuite on itère sur les éléments de la liste avec une boucle for. Si l'élement courant a une valeur strictement plus grande que celle de la variable maximum
alors on donne à la variable maximum
cette nouvelle valeur. En sortie de boucle la valeur de maximum
sera la plus grande valeur de la liste. Voici le code:
L = [3, 5, 6, 1, -7, 6, -2, 16, 0, 4, 6]
maximum = L[0]
for element in L :
if element > maximum :
maximum = element
print(maximum)
16
Le dernier exemple est un raffinement du précédent. On cherche cette fois la position de l'élément maximal dans une liste. On doit donc utiliser une boucle for où on itère sur les indices: for k in range(len(L))
. Ensuite au moment on utilise une variable supplémentaire nommée position
initialisée à $0$ (premier indice possible dans une liste). Dans la boucle for, au moment où on met à jour la valeur de la variable maximum
, on met aussi à jour la valeur de la variable position
. Voici le code:
L = [3, 5, 6, 1, -7, 6, -2, 16, 0, 4, 6]
maximum = L[0]
position = 0
for k in range(len(L)) :
if L[k] > maximum :
maximum = L[k]
position = k
print(position)
7
La boucle while
en Python est utilisée pour répéter des opérations tant qu'une condition est vraie.
Si test
est une variable booléenne, la syntaxe de la boucle while en Python est la suivante :
instructionsAvant
while test :
instructions
instructionsApres
Si test
a la valeur True
alors instructions
est exécutée. Ensuite l'interpréteur réévalue test
: si elle a la valeur True
, instructions
sont exécutées à nouveau. Puis test
est réévaluée etc etc...
C'est seulement une fois que test
a la valeur False
que instructionsApres
est exécutée.
Noter que ce qui sépare
instructions
deinstructionsApres
est simplement l'indentation.
Quelle est la principale différence entre la boucle for et la boucle while? Pour la boucle for on sait à l'avance combien d'itérations vont être effectuées: ce nombre est égal au nombre d'éléments de la collection.
Par contre pour la boucle while ce nombre n'est pas connu et n'est pas fixé: il va dépendre des résultats des instructions.
On parle donc de boucle bornée pour la boucle for, et de boucle non bornée pour la boucle while.
❌❌ instructions
doit modifier la valeur de test
afin que celle-ci prenne à un moment la valeur False
. ❌❌
❌❌ Sinon la boucle est infinie: elle ne s'arrêtera jamais! ❌❌
Reprenons l'exemple de recherche d'un élément dans une liste. On peut l'optimiser: si on trouve l'élément cherché il n'est plus nécessaire de continuer à le chercher dans la fin de la liste. Ceci est possible en remplaçant la boucle for par une boucle while.
Par contre on va devoir raisonner sur les indices
k
et gérer dans la boucle l'incrémentationk = k + 1
.
Voici le code:
x = 6
L = [3, 5, 1, -7, -2, 6, 0, 4]
drapeau = False
k = 0
while k < len(L) and not(drapeau) :
if L[k] == x :
drapeau = True
k = k + 1
print(drapeau)
True
En général si
L
est une liste on a vu que la boucle for:
for x in L :
faire un truc avec x
peut être remplacé par:
for k in range(len(L)) :
x = L[k]
faire un truc avec x
On peut aussi la remplacer par une boucle while mais dans laquelle on doit gérer l'incrémentation de
k
de0
àlen(L)-1
:
k = 0
while k < len(L) :
x = L[k]
faire un truc avec x
k = k + 1
Cette version est plus compliquée mais peut être plus performante comme on l'a vu dans l'exemple précédent.
Comme on peut le voir dans les paragraphes ci-dessus, on est très souvent amené à réutiliser du code et il n'est pas vraiment envisageable de le recopier à chaque fois.
La solution va être d'encapsuler nos portions de code dans des fonctions. Nous communiquerons avec une fonction en lui passant des valeurs en entrée et après exécution celle-ci nous passera des valeurs en sortie. Notez bien que (pour le moment) ce ne sont pas des variables que nous passons et récupérons mais leur valeur.
La syntaxe générale d'une fonction est la suivante:
def nomFonction(entree_1,entree_2,...,entree_p):
...............
instructions
...............
sortie = ....
return sortie
Les variables entree_1
, entree_2
, ..., entree_p
sont appelées arguments d'entrée. Il est possible de ne pas en avoir dans ce cas la syntaxe est def nomFonction():
.
Losqu'on exécute notre fonction on doit lui donner $p$ valeurs valeur_1
, valeur_2
, ..., valeur_p
. Pour cela on exécute l'instruction:
nomFonction(valeur_1, valeur_2, ..., valeur_p)
L'interpréteur Python crée alors les variables
entree_1
,entree_2
, ...,entree_p
pour enregistrer dans la mémoire les valeursvaleur_1
,valeur_2
, ...,valeur_p
.
Ces variables sont dites locales car elles vont être effacées de la mémoire dès que la fonction aura fini de s'exécuter.
A la fin de l'exécution on arrive à la ligne sortie = ....
. Cette ligne est une affectation: elle crée une variable sortie
et lui donne une valeur.
Ensuite la dernière ligne return sortie
la fonction renvoie la valeur de la variable sortie. Cela signifie que cette valeur est affichée (comme avec print(sortie)
) mais en plus de cette affichage la valeur peut-être utilisée dans un calcul ou enregistrée dans une variable.
❌❌ C'est tout la différence entre print
et return
. ❌❌
❌❌ print
permet un affichage à l'écran mais la valeur affichée ne peut pas être réutilisée. ❌❌
❌❌ Il ne faut donc pas confondre ces deux instructions. ❌❌
Comme pour les variables d'entrée notre variable
sortie
est locale: elle est donc détruite après exécution de la fonction.
Voici un premier exemple: une fonction qui renvoie le carré d'un nombre.
def carre(x):
sortie = x**2
return sortie
Une fois ce bloc exécuté on ne voit rien à l'écran mais la fonction a été créée dans la mémoire de l'ordinateur.
On peut l'appeler ainsi:
carre(2)
4
Le résultat est affiché à l'écran.
❌❌ Vérifions que x
n'existe pas dans la mémoire après cette exécution: ❌❌
print(x)
6
❌❌ De même avec sortie
: ❌❌
print(sortie)
--------------------------------------------------------------------------- NameError Traceback (most recent call last) Cell In[17], line 1 ----> 1 print(sortie) NameError: name 'sortie' is not defined
Vérifions que grâce à l'instruction
return
on peut utiliser le résultat de notre fonction dans un calcul:
2.5 + carre(1.2)
3.94
❌❌ Vérifions que ceci aurait donné une erreur si on avait utilisé print
à la place de return
: ❌❌
def carreFaux(x) :
sortie = x**2
print(sortie)
2.5 + carreFaux(1.2)
1.44
--------------------------------------------------------------------------- TypeError Traceback (most recent call last) Cell In[20], line 1 ----> 1 2.5 + carreFaux(1.2) TypeError: unsupported operand type(s) for +: 'float' and 'NoneType'
Vérifions que grâce à l'instruction
return
on peut enregistrer le résultat de notre fonction dans une variable. Habituellement on donne le même nom à cette variable que celui de la variable locale de la fonction, donc ici on l'appelle encoresortie
.
sortie = carre(3.14)
print(sortie)
9.8596
❌❌ Vérifions que ceci aurait donné une erreur avec la fonction carreFaux
où on a utilisé print
à la place de return
: ❌❌
sortie = carreFaux(3.14)
9.8596
print(sortie)
None
❌❌ La variable sortie
a bien été créée, mais elle n'a pas enregistré la valeur renvoyée par la fonction ! ❌❌
En fait on peut se passer de la variable sortie
dans l'écriture du code. On ne l'a utilisée que pour mieux expliquer ce qu'il se passe.
def carre(x):
return x**2
Elle a quand mếmé été créée mais on ne sait pas quel nom lui a donné l'interpréteur Python. Ce n'est pas important car elle est de toute façon détruite à chaque fin d'exécution de la fonction.
On peut vérifier que la variable locale x
existe bien lorsque la fonction est en cours d'exécution:
def carreTest(x):
print("Fonction en cours d'exécution, la valeur de x est : ")
print(x)
return x**2
carreTest(3)
Fonction en cours d'exécution, la valeur de x est : 3
9
Bien sûr le choix de x
comme nom de variable est arbitraire. La fonction carre
peut aussi être définie comme ceci:
def carre(hippopotame):
return hippopotame**2
Voici un exemple de fonction qui a deux arguments en entrée:
def somme(hippopotame, zebre):
return hippopotame + zebre
somme(6.4, -1.3)
5.1000000000000005
❌❌ On vous avit prévenu: les calculs avec les flottants ne sont pas exacts ! ❌❌
Voici un exemple de fonction qui renvoie deux valeurs:
def carreCube(hippopotame) :
return hippopotame**2, hippopotame**3
carreCube(3)
(9, 27)
Comme est-ce possible alors qu'on expliqué ci-dessus qu'une fonction renvoie une seule valeur ?
La règle est respectée: la fonction a renvoyé une seule valeur mais de type tuple.
Pour récupérer séparemment les deux éléments du tuple, on utilise donc la syntaxe des tuples.
valeurs = carreCube(3)
valeurs[0]
9
valeurs[1]
27
On peut ajouter des commentaires pour expliquer aux utilisateurs qui lisent le code (ou à soi-même) les instructions de la fonction.
Il suffit de commencer le commentaire par un dièse #
. L'interpréteur saura que ce n'est pas du code à exécuter.
Si le commentaire va tenir sur plusieurs lignes, on l'entoure avec """
.
def ParcoursProfondeur(G, s):
""" Parcours en profondeur du graphe G donné sous forme
d’un dictionnaire des liste d’adjacences depuis un sommet s.
Cette fonction renvoi None. """
visite = { x: False for x in G } # pour marquer les sommets visités
pile = [s]
liste_visite = [] # liste des sommets qu'on visite
while len(pile) != 0:
x = pile.pop()
if not visite[x]:
liste_visite.append(x) # on ajoute le sommet à a liste
visite[x] = True
for y in G[x]:
pile.append(y)
return liste_visite # on renvoie la liste des sommets visités
Pour ajouter des fonctions au langage Python les développeurs utilisent des modules.
Il existe 4 manières de procéder pour utiliser la fonction fonction
du module module
.
import module
va mettre en mémoire toutes les fonctions du module module
. Pour les utiliser il va falloir préfixer leur nom avec module.
, par exemple module.fonction
.
Cela peut être pénible si le nom du module est long. Par exemple pour utiliser la fonction fsolve
du module scipy.integrate
on doit écrire scipy.integrate.fsolve
.
On a la possibilité de renommer le module pour raccourcir son nom dans le préfixe: import module as alias
. On écrit alors alias.fonction
.
C'est cette méthode que nous vous recommandons.
On peut aussi importer le module sans préfixe mais dans ce cas on ne sait pas de quel module vient la fonction utilisée dans notre code, ce qui est déconseillé: from module import *
.
Avec cette méthode on peut n'importer que certaines fonctions du module: from module import fonction1, fonction2
.
Par exemple pour utiliser les fonctions disponibles sur votre calculatrice on utilise le module math
.
import math as m
m.sqrt(2) # racine carrée, on peut aussi l'avoir avec 2**(1/2)
1.4142135623730951
m.pi
3.141592653589793
m.cos(m.pi/2)
6.123233995736766e-17
m.sin(m.pi/2)
1.0
m.exp(1)
2.718281828459045
m.log(2) # ln(2)
0.6931471805599453
On donne ici des commandes qui ne sont pas au programme. Il ne faut pas les apprendre par coeur, elles seront données si il faut les utiliser dans un sujet de concours.
L = [8, 4, 2, 3, 1, 4, 7]
Je veux savoir combien de fois apparait la valeur 4 dans cette liste.
L.count(4)
2
Quel est l'indice (la position) de la valeur 3 ?
L.index(3)
3
Je peux insérer un élément qui vaut 5 à l'indice 3, ce qui décalera les éléments suivants.
L.insert(3, 5)
print(L)
[8, 4, 2, 5, 3, 1, 4, 7]
Je supprime le premier élément rencontré qui vaut 1.
L.remove(1)
print(L)
[8, 4, 2, 5, 3, 4, 7]
Je supprime l'élément d'indice 2, sans demander de retour.
del L[2] # pas de parenthèse
print(L)
[8, 4, 5, 3, 4, 7]
Je peux aussi en supprimer plusieurs d'un coup : faites très attention aux indices !
Le symbôle [1 : 3] se comporte comme un intervalle semi-ouvert, 1 inclus, 3 exclus.
del L[1:3]
print(L)
[8, 3, 4, 7]
On peut trier la liste.
L = [8, 4, 2, 5, 3, 4, 7]
L.sort()
print(L)
[2, 3, 4, 4, 5, 7, 8]
Inversion de l'ordre des éléments de la liste.
L.reverse()
print(L)
[8, 7, 5, 4, 4, 3, 2]
Souvent on récupère des données sous forme d'une chaîne de caractères, les données étant séparées par ':'
ou ','
. Par exemple:
donnees = "1.234:1.213:4.324:2.543:1.983"
On alors besoin de découper cette chaîne de caractères pour récupérer les données. Pour cela on utilise la méthode split()
:
L = donnees.split(':')
print(L)
['1.234', '1.213', '4.324', '2.543', '1.983']
Ensuite il faut transformer les valeurs (qui sont de type string
) en flottants avec la fonction float()
:
LL = []
for element in L:
LL.append(float(element))
print(LL)
[1.234, 1.213, 4.324, 2.543, 1.983]