@@ -7,12 +7,13 @@ Instructions | |||
Pour l'instant, dans tous les exemples de code, chaque ligne qu'on a écrit | |||
contenait une *instruction*. | |||
Un instruction ne renvoie pas de valeur, mais a un | |||
effet sur le programme. | |||
Un instruction a un effet sur le programe dans lequel elle est présented | |||
Par exemple, l'expression ``print("bonjour")`` affiche "bonjour" dans | |||
le terminal. On dit que l'expression est *exécutée*. | |||
En règle générale, les expressions sont éxécutées une par une, de haut en bas. | |||
Expressions | |||
----------- | |||
@@ -48,15 +49,14 @@ Variables et valeurs | |||
On peut associer des *variables* à des *valeurs* en les plaçant | |||
de part et d'autre du signe ``=`` : on appelle cette opération | |||
une *assignation*:: | |||
une *affectation*:: | |||
a = 2 | |||
Notez qu'une assignation *n'est pas* une expression, c'est une | |||
*instruction*. | |||
Ici on assigne l'entier 2 à la variable ``a``. | |||
On dit aussi que ``a`` est une *référence* vers la valeur ``2``. | |||
Notez qu'une affectation *n'est pas* une expression, c'est une | |||
*instruction*. | |||
Si plus tard dans le code, on utilise le nom de la variable, | |||
tout se passera comme si nom de la variable avait été | |||
@@ -71,8 +71,8 @@ remplacé par sa valeur:: | |||
Variables et expressions | |||
------------------------- | |||
En fait, on peut assigner une variable à n'importe quelle | |||
*expression*, et pas simplement des littéraux:: | |||
En fait, on peut assigner n'importe qu'elle *expression* à une variable, | |||
et pas simplement des littéraux:: | |||
a = 1 + 2 | |||
print(a) | |||
@@ -109,8 +109,8 @@ Autres exemples:: | |||
Changer la valeur d'une variable | |||
--------------------------------- | |||
On peut aussi *changer* la valeur d'une variable en l'assignant | |||
à une nouvelle valeur:: | |||
On peut aussi *changer* la valeur d'une variable en affectant | |||
une nouvelle valeur à celle-ci:: | |||
a = 2 | |||
@@ -119,10 +119,10 @@ On peut aussi *changer* la valeur d'une variable en l'assignant | |||
print(a) | |||
# affiche: 2, puis 3 | |||
Combiner opération et assignation | |||
Combiner opération et affectation | |||
---------------------------------- | |||
La notation ``+=`` permet de combiner addition et assignation : | |||
La notation ``+=`` permet de combiner addition et affectation : | |||
les deux exemples ci-dessous sont équivalents:: | |||
x = 3 | |||
@@ -41,7 +41,7 @@ Par exemple:: | |||
.. warning:: | |||
Ne pas confondre: ``==`` pour la comparaison et ``=`` pour l'assignation | |||
Ne pas confondre: ``==`` pour la comparaison et ``=`` pour l'affectation | |||
Autres opérations booléennes | |||
----------------------------- | |||
@@ -54,9 +54,10 @@ Appel: en passant une variable ou une valeur dans les parenthèses:: | |||
dire_bonjour("Germaine") | |||
L'éxécution de l'appel à une foctionne exactement comme si on assignait | |||
les arguments de la fonction avant d'éxécuter le code | |||
dans le corps:: | |||
Pour évaluer une expression qui contient l'appel a une fonction, on: | |||
* assigne le contenu des parenthèses aux arguments de la fonction | |||
* puis on éxécute les instructions dans le corps de la fonction | |||
# Ceci: | |||
dire_bonjour("Dimitri") | |||
@@ -10,7 +10,7 @@ Récupérer la valeur de retour:: | |||
a = 3 | |||
b = 4 | |||
c = additionner(a, b) # encore une assignation | |||
c = additionner(a, b) # encore une affectation | |||
print(c) | |||
# Affche: 7 | |||
@@ -81,8 +81,8 @@ Avec les mots-clés ``for`` et `` in``:: | |||
prénoms = ["Alice", "Bob", "Charlie"] | |||
for prénom in prénoms: | |||
# La variable 'prénom" est assignée à chaque | |||
# élément de la liste | |||
# Chaque élément de la liste est assigné tour à tour | |||
# à la variable 'prénom" | |||
print("Bonjour", prénom) | |||
.. code-block:: text | |||
@@ -90,9 +90,10 @@ Avec ``for ... in ...``, comme pour les listes:: | |||
scores = {"john": 10, "bob": 42} | |||
for nom in scores: | |||
# `nom` est assigné à "john" puis "bob" | |||
# on assigne la valeur "john" à la variable `nom`, puis "bob" | |||
score_associé_au_nom = scores[nom] | |||
# score_associé_au_nom est assigné à '10' puis '42' | |||
# on assigne la valeur 10 puis la valeur 42 à la variable | |||
# score_associé_au_nom | |||
print(nom, score_associé_au_nom) | |||
.. code-block:: | |||
@@ -114,7 +114,7 @@ On peut *créer* des attributs dans *n'importe quel instance*, en utilisant l'*a | |||
print(mon_instance.x) | |||
# affiche: 42 | |||
Ici l'attribut ``mon_attribut`` de l'instance ``mon_instance`` à la valeur de l'entier ``42``. | |||
Ici on assigne la valeur ``42`` à l'attribut ``x`` de l'instance ``mon_instance`` | |||
Méthodes - définition | |||
---------------------- | |||
@@ -17,7 +17,7 @@ Importer un module | |||
Ou: accéder à du code provenant d'un *autre* fichier source. | |||
Créons un fichier `bonjour.py` contenant seulement une assignation | |||
d'une variable `a` à l'entier 42 :: | |||
de l'entier 42 à la variable `a`:: | |||
# Dans bonjour.py | |||
a = 42 | |||
@@ -38,7 +38,7 @@ on peut accéder à cette variable en *important* le module:: | |||
Le nom du module est écrit directement, ce n'est *pas* une | |||
chaîne de caractères. | |||
On voit que l'assignation de la variable `a` dans `bonjour.py` est devenue | |||
On voit que la variable `a` dans `bonjour.py` est devenue | |||
un *attribut* du module `bonjour` lorsque `bonjour` a été importé | |||
@@ -66,7 +66,7 @@ Il est important de noter que: | |||
* mais il n'est *pas* ré-éxécuté si le module a déjà été importé auparavant. | |||
On peut le voir en mettant du code dans `bonjour.py`, | |||
en plus des simples définitions de fonctions et assignations | |||
en plus des simples définitions de fonctions et de créations | |||
de variables:: | |||
# Dans bonjour.py | |||
@@ -6,14 +6,11 @@ Introduction | |||
Reprenons ce qu'on a vu jusqu'ici. | |||
D'une part, on peut créer des variables en les assignant à une valeur:: | |||
D'une part, on peut créer des variables en assignant des valeurs à celles-ci:: | |||
# Création d'une variable `x` avec la valeur 4 | |||
x = 4 | |||
On dit aussi que ``x`` *référence* la valeur ``4`` | |||
D'autre part, on peut définir et appeler des fonctions:: | |||
# Définition de la fonction: | |||
@@ -29,7 +26,9 @@ D'autre part, on peut définir et appeler des fonctions:: | |||
Fonctions en tant que variables | |||
------------------------------- | |||
Il se trouve qu'en Python, on peut assigner des variables à ... des fonctions | |||
Il se trouve qu'en Python, on peut assigner des fonctions à des | |||
variables. C'est différent d'assigner le résultat de l'appel à une | |||
fonction à une variable, et ça permet de retarder l'appel: | |||
.. code-block:: python | |||
@@ -41,10 +40,11 @@ Il se trouve qu'en Python, on peut assigner des variables à ... des fonctions | |||
def dire_bonjour_en_anglais(nom): | |||
print("Hello " + nom) | |||
# Création d'une variable qui référence la fonction française: | |||
# Assigne une fonction à la variable - aucune fonction | |||
# n'est appelée à ce stade. | |||
ma_fonction_qui_dit_bonjour = dire_bonjour_en_français | |||
# Appel de la fonction: | |||
# Appel de la fonction (retardé) | |||
ma_fonction_qui_dit_bonjour("Max") | |||
# Affiche: Bonjour Max | |||
@@ -53,11 +53,11 @@ Il se trouve qu'en Python, on peut assigner des variables à ... des fonctions | |||
De façon cruciale, notez que l'on n'a *pas* mis de parenthèses à droite | |||
lorsqu'on a créé la variable `ma_fonction_qui_dit_bonjour`. | |||
On peut donc dire que lorsqu'on définit une fonction avec `def()` et un corps | |||
On peut donc dire que lorsqu'on définit une fonction avec ``def ma_fonction()`` et un corps: | |||
il y a en réalité deux étapes: | |||
1. Python stocke le corps de la fonction quelque part | |||
2. Il crée une variable qui référence ce corps | |||
2. Il assigne le corps de celle-ci à une variable dont le nom est ``ma_fonction``. | |||
En Python, il est assez fréquent d'utiliser de code tel que celui-ci, souvent avec un dictionnaire:: | |||
@@ -79,10 +79,9 @@ En Python, il est assez fréquent d'utiliser de code tel que celui-ci, souvent a | |||
Fonctions en tant qu'argement d'autres fonctions | |||
------------------------------------------------ | |||
On a vu en début de chapitre qu'on peut créé des variables qui référencent | |||
des fonctions. | |||
On a vu en début de chapitre qu'on peut assigner des fonctions à des variables. | |||
Du coup, rien n'empêche de les passer en *argument* d'autres fonctions. | |||
Du coup, rien n'empêche de passer des fonctions en *argument* d'autres fonctions. | |||
Par exemple:: | |||