From ce052d54779ea169fe4a8daaa7fdf7c21cd95b1a Mon Sep 17 00:00:00 2001 From: Dimitri Merejkowsky Date: Sat, 18 Apr 2020 12:31:01 +0200 Subject: [PATCH] Correction de l'ordre des mots, pour de bon cette fois ci --- .../03-variables-et-types/01-variables.rst | 26 +++++++++---------- .../03-variables-et-types/04-booléens.rst | 2 +- cours/source/05-fonctions-01/01-functions.rst | 7 ++--- cours/source/05-fonctions-01/06-return.rst | 2 +- cours/source/06-listes/index.rst | 4 +-- cours/source/08-dictionnaires/index.rst | 5 ++-- cours/source/10-classes-01/index.rst | 2 +- cours/source/11-modules-01/index.rst | 6 ++--- .../17-décorateurs/01-introduction.rst | 23 ++++++++-------- 9 files changed, 39 insertions(+), 38 deletions(-) diff --git a/cours/source/03-variables-et-types/01-variables.rst b/cours/source/03-variables-et-types/01-variables.rst index 2d34435..8c2e24b 100644 --- a/cours/source/03-variables-et-types/01-variables.rst +++ b/cours/source/03-variables-et-types/01-variables.rst @@ -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 diff --git a/cours/source/03-variables-et-types/04-booléens.rst b/cours/source/03-variables-et-types/04-booléens.rst index 830cba9..db5ceb6 100644 --- a/cours/source/03-variables-et-types/04-booléens.rst +++ b/cours/source/03-variables-et-types/04-booléens.rst @@ -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 ----------------------------- diff --git a/cours/source/05-fonctions-01/01-functions.rst b/cours/source/05-fonctions-01/01-functions.rst index a7ba495..bc0b2ed 100644 --- a/cours/source/05-fonctions-01/01-functions.rst +++ b/cours/source/05-fonctions-01/01-functions.rst @@ -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") diff --git a/cours/source/05-fonctions-01/06-return.rst b/cours/source/05-fonctions-01/06-return.rst index e0f691b..96270a6 100644 --- a/cours/source/05-fonctions-01/06-return.rst +++ b/cours/source/05-fonctions-01/06-return.rst @@ -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 diff --git a/cours/source/06-listes/index.rst b/cours/source/06-listes/index.rst index 67b8eee..18b7a98 100644 --- a/cours/source/06-listes/index.rst +++ b/cours/source/06-listes/index.rst @@ -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 diff --git a/cours/source/08-dictionnaires/index.rst b/cours/source/08-dictionnaires/index.rst index 18e3d64..a54722a 100644 --- a/cours/source/08-dictionnaires/index.rst +++ b/cours/source/08-dictionnaires/index.rst @@ -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:: diff --git a/cours/source/10-classes-01/index.rst b/cours/source/10-classes-01/index.rst index 7925161..405381d 100644 --- a/cours/source/10-classes-01/index.rst +++ b/cours/source/10-classes-01/index.rst @@ -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 ---------------------- diff --git a/cours/source/11-modules-01/index.rst b/cours/source/11-modules-01/index.rst index eae8721..1b40134 100644 --- a/cours/source/11-modules-01/index.rst +++ b/cours/source/11-modules-01/index.rst @@ -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 diff --git a/cours/source/17-décorateurs/01-introduction.rst b/cours/source/17-décorateurs/01-introduction.rst index d8018fe..2e168e4 100644 --- a/cours/source/17-décorateurs/01-introduction.rst +++ b/cours/source/17-décorateurs/01-introduction.rst @@ -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::