Browse Source

Correction de l'ordre des mots, pour de bon cette fois ci

master
Dimitri Merejkowsky 4 years ago
parent
commit
ce052d5477
9 changed files with 39 additions and 38 deletions
  1. +13
    -13
      cours/source/03-variables-et-types/01-variables.rst
  2. +1
    -1
      cours/source/03-variables-et-types/04-booléens.rst
  3. +4
    -3
      cours/source/05-fonctions-01/01-functions.rst
  4. +1
    -1
      cours/source/05-fonctions-01/06-return.rst
  5. +2
    -2
      cours/source/06-listes/index.rst
  6. +3
    -2
      cours/source/08-dictionnaires/index.rst
  7. +1
    -1
      cours/source/10-classes-01/index.rst
  8. +3
    -3
      cours/source/11-modules-01/index.rst
  9. +11
    -12
      cours/source/17-décorateurs/01-introduction.rst

+ 13
- 13
cours/source/03-variables-et-types/01-variables.rst View File

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


+ 1
- 1
cours/source/03-variables-et-types/04-booléens.rst View File

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


+ 4
- 3
cours/source/05-fonctions-01/01-functions.rst View File

@@ -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")


+ 1
- 1
cours/source/05-fonctions-01/06-return.rst View File

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



+ 2
- 2
cours/source/06-listes/index.rst View File

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


+ 3
- 2
cours/source/08-dictionnaires/index.rst View File

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


+ 1
- 1
cours/source/10-classes-01/index.rst View File

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


+ 3
- 3
cours/source/11-modules-01/index.rst View File

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


+ 11
- 12
cours/source/17-décorateurs/01-introduction.rst View File

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