소스 검색

Corrections suite aux relectures de Georges

master
Dimitri Merejkowsky 4 년 전
부모
커밋
ec249234c0
11개의 변경된 파일100개의 추가작업 그리고 51개의 파일을 삭제
  1. +37
    -21
      cours/source/03-variables-et-types/01-variables.rst
  2. +7
    -6
      cours/source/04-flot-de-controle/01-flot-de-contrôle.rst
  3. +2
    -2
      cours/source/05-fonctions-01/01-functions.rst
  4. +24
    -7
      cours/source/06-listes/index.rst
  5. +2
    -2
      cours/source/07-none-et-pass/01-none.rst
  6. +9
    -5
      cours/source/07-none-et-pass/02-pass.rst
  7. +7
    -2
      cours/source/10-classes-01/index.rst
  8. +6
    -3
      cours/source/12-classes-02/02-composition.rst
  9. +2
    -1
      cours/source/16-classes-03/index.rst
  10. +3
    -1
      cours/source/17-décorateurs/02-décorateurs.rst
  11. +1
    -1
      cours/source/18-exceptions/02-exceptions-natives.rst

+ 37
- 21
cours/source/03-variables-et-types/01-variables.rst 파일 보기

@@ -1,17 +1,17 @@
Expressions et variables
=========================
Expressions, instructions, et variables
=======================================

Instructions
------------

Pour l'instant, dans tous les examples de code, chaque ligne qu'on a écrit
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.

Par exemple, l'expression ``print("bonjour")`` afiche "bonjour" dasn
le terminal. On dit que l'expression est *éxécutée*.
Par exemple, l'expression ``print("bonjour")`` affiche "bonjour" dans
le terminal. On dit que l'expression est *exécutée*.

Expressions
-----------
@@ -21,16 +21,16 @@ Les instructions peuvent contenir des *expressions*.
Un expression est toujours *évaluée* pour retourner une
*valeur*

Par example, ``1 + 2`` es une expression qui renvoie la valeur ``3``
Par exemple, ``1 + 2`` es une expression qui renvoie la valeur ``3``
une fois évaluée.

Elle est constituée de 3 éléments:

* Le *litéral* 1
* Le *littéral* 1
* L'*opérateur* ``+``
* Le *litéral* 2
* Le *littéral* 2

Pour évaluer une expression, Python remplace les litéraux
Pour évaluer une expression, Python remplace les littéraux
par leur valeur, puis calcule la valeur finale en
utilisant les opérateurs.

@@ -39,7 +39,7 @@ Notez que les expressions peuvent être imbriquées ::
1 + (2 * 3)

À droite du plus, on a une expression ``2 + 3``. Quand Python
évaluera l'expression, il verra d'abord le litéral ``1`` et le ``+``,
évaluera l'expression, il verra d'abord le littéral ``1`` et le ``+``,
puis il évaluera l'expression à droite (``2*3 = 6``), et finalement
l'expression en entier (``1 + 6 = 7``).

@@ -62,6 +62,8 @@ Si plus tard dans le code, on utilise le nom de la variable,
tout se passera comme si nom de la variable avait été
remplacé par sa valeur::



a = 2
print(a)
# affiche: 2
@@ -85,14 +87,25 @@ Les expressions peuvent également contenir des variables.
Quand Python évalue une expression qui contient des noms de variables,
il remplace celles-ci par leur valeur::

a = 1
print(a + 2) # ici a a été remplacé par 1
# affiche: 3

Notez que la valeur de variable `a` n'a pas changé::

a = 1
print(a + 2)
# affiche: 3
print(a)
# affiche: 1

Autres exemples::

x = 1
y = 2
z = x + y
print(z)
print(x+y) # ici x a été remplacé par 1 et y par 2
# affiche: 3

Ici on a créé ``z`` en *évaluant* l'expression ``x+y``.

Changer la valeur d'une variable
---------------------------------

@@ -109,17 +122,16 @@ On peut aussi *changer* la valeur d'une variable en l'assignant
Combiner opération et assignation
----------------------------------

La notation ``+=`` permet de combiner addition et assignation::
La notation ``+=`` permet de combiner addition et assignation :
les deux exemples ci-dessous sont équivalents::

x = 3
x = x + 1
print(x)
# affiche :: 4
::

x = 3
x += 1
print(x)
# affiche :: 4


Cela fonctionne aussi pour ``-=``, ``/=`` etc.
@@ -133,7 +145,11 @@ mais il est préférable d'avoir des noms longs et descriptifs
Aussi, la convention est de:

* Les écrire en minuscules
* De séparer les mots par des tirest bas (*underscore*)::
* De séparer les mots par des tirets bas (*underscore*)::

score = 42
age_moyen = 22
âge_moyen = 22

Notez que certains noms ne peuvent être utilisés comme nom
de variables. On les appelle des *mots-clés*. La liste
est disponible ici: https://docs.python.org/fr/3/reference/lexical_analysis.html#keywords

+ 7
- 6
cours/source/04-flot-de-controle/01-flot-de-contrôle.rst 파일 보기

@@ -14,7 +14,7 @@ contrôle, et c'est l'essence de la programmation!
if
++

On peut utiliser le mot ``if`` pour autoriser ou empécher
On peut utiliser le mot-clé ``if`` pour autoriser ou empécher
l'éxcution des instructions suivantes::

a = 3
@@ -71,7 +71,7 @@ Ce code n'affiche pas "a et b sont égaux", mais affiche bien "on continue".
if / else
---------

On peut utiliser le mot ``else`` après un condition en ``if``
On peut utiliser le mot-clé ``else`` après un condition en ``if``
pour éxécutér un bloc si la condition est fausse::

a = 3
@@ -104,7 +104,7 @@ conditions::
while
-----

On peut utiliser ``while`` pour répéter un bloc tant qu'une condition
On peut utiliser le mot-clé ``while`` pour répéter un bloc tant qu'une condition
est vraie::

i = 0
@@ -132,10 +132,10 @@ Dans ce cas, il faut appuyer sur ``CTRL-C`` pour interrompre
le programme.


Combiner while et if
--------------------
Combiner while, if, et break
-----------------------------

On peut "sortir" de la boucle ``while`` avec ``break``::
On peut "sortir" de la boucle ``while`` avec le mot-clé ``break``::

i = 0
while True:
@@ -151,3 +151,4 @@ On peut "sortir" de la boucle ``while`` avec ``break``::
3
4



+ 2
- 2
cours/source/05-fonctions-01/01-functions.rst 파일 보기

@@ -10,7 +10,7 @@ Définition::
print("Bonjour")


* avec `def`
* avec le mot-clé `def`
* avec un `:` à la fin et un *bloc indenté* (appelé *le corps de la fonction*).

Appel::
@@ -24,7 +24,7 @@ Example complet::
def dire_bonjour():
print("Bonjour")

bonjour()
dire_bonjour()
# Affiche: bonjour'




+ 24
- 7
cours/source/06-listes/index.rst 파일 보기

@@ -1,17 +1,15 @@
Listes
======

// TODO: split in pages

Définition
----------

Une liste est une *suite ordonée* d'éléments.
Une liste est une *suite ordonnée* d'éléments.

Créer une liste
---------------

Avec des crochets: ``[``, ``]``, et les élements séparés par des virgules::
Avec des crochets: ``[``, ``]``, et les éléments séparés par des virgules::

liste_vide = []
trois_entiers = [1, 2, 3]
@@ -76,10 +74,10 @@ Avec ``in``::
print("Charlie" in prénoms)
# affiche: False

Itérer sur les élements d'une liste
Itérer sur les éléments d'une liste
------------------------------------

Avec ``for ... in``::
Avec les mots-clés ``for`` et `` in``::

prénoms = ["Alice", "Bob", "Charlie"]
for prénom in prénoms:
@@ -93,6 +91,25 @@ Avec ``for ... in``::
Bonjour Bob
Bonjour Charlie


Continue
--------

On peut interrompre l'exécution du bloc courant avec le mot-clé
``continue``::

prénoms = ["Alice", "Bob", "Charlie"]
for prénom in prénoms:
if prénom == "Bob":
continue
print("Bonjour", prénom)

.. code-block:: text

Bonjour Alice
Bonjour Charlie


Indéxer une liste
------------------

@@ -150,7 +167,7 @@ On peut tester si un caractère est présent::
# affiche: False


Mais on neut peut pas modifier une string::
Mais on ne peut pas modifier une string::

prénom = "Charlotte"
l = prénom[0]


+ 2
- 2
cours/source/07-none-et-pass/01-none.rst 파일 보기

@@ -4,9 +4,9 @@ None
Définition
-----------

``None`` est une "valeur magique" natif en python. il est toujours présent, et il est unique.
``None`` est un mot-clé qui sert à représenter l'absence.

Un peu comme ``True`` et ``False`` qui sont deux valeurs qui servent à représenter tous les booléens.
Un peu comme ``True`` et ``False`` qui sonts des mot-clés qui réprésentent des booléens.

Retourner None
----------------


+ 9
- 5
cours/source/07-none-et-pass/02-pass.rst 파일 보기

@@ -1,12 +1,14 @@
pass
====

En Python, à cause de l'organisation en blocs indentés, on ne
peut pas vraiment avoir de blocs vides. Mais parfois, on
a besoin d'un bloc qui ne fasse rien.

Dans ce cas, on peut utiliser le mot-clé `pass`, par exemple
après un if::
À cause de l'organisation du flot de contrôle en blocs indentés, on ne
peut pas vraiment avoir de blocs vides. Mais parfois, on a besoin d'un bloc
qui ne fasse rien - c'est là que le mot-clé `pass` rentre en jeu.

`pass` représente une instruction qui ne fait rien.

Un exemple::

une_condition = False
if une_condition:
@@ -19,3 +21,5 @@ définir une fonction qui ne fait rien::

def ne_fait_rien():
pass



+ 7
- 2
cours/source/10-classes-01/index.rst 파일 보기

@@ -68,7 +68,7 @@ Les classes sont utilisées pour construire des *instances*.
Créons des instances
---------------------

On peut faire un plan de construction vide avec le mot clé pass::
On peut faire un plan de construction vide avec le mot-clé pass::

class MaClasse:
pass
@@ -111,9 +111,11 @@ On peut *créer* des attributs dans *n'importe quel instance*, en utilisant l'*a
mon_instance.x = 42

# Accés à l'attribut `x` dans `mon_instance`
print(mon_instance.mon_attribut)
print(mon_instance.x)
# affiche: 42

Ici l'attribut ``mon_attribut`` de l'instance ``mon_instance`` à la valeur de l'entier ``42``.

Méthodes - définition
----------------------

@@ -126,6 +128,9 @@ moins un argument appelé `self`, et être à l'intérieur du bloc de la classe:
def ma_méthode(self):
return 42

Notez que les méthodes *sont aussi des attributs*. Leur valeur est une *fonction* qui prend
en argument l'instance courante.

Méthodes - appel
----------------



+ 6
- 3
cours/source/12-classes-02/02-composition.rst 파일 보기

@@ -102,12 +102,15 @@ qui va:
def console(self):
self.chat.caresse()


Si on combine ces deux classes dans le même morceau de code et qu'on
exécute les instructions suivantes::

boule_de_poils = Chat("Boule de Poils")
alice = Enfant("Alice", boule_de_poils)
# Alice est triste, on la console
alice.console()
# affiche: Boule de Poils fait "prrrrr"
# Alice est consolée :)
On afffichera ```Boule de Poils fait "prrr"`` et alice sera consolée.

On dit parfois qu'on a *délégué* l'implémentation de la méthode ``console()`` de la classe Enfant
à la méthode ``caresse()`` de la classe Chat.

+ 2
- 1
cours/source/16-classes-03/index.rst 파일 보기

@@ -4,7 +4,8 @@ Héritage
Rappel - composition
---------------------

Dans le chapitre 13 on a parlé de *composition* qui décrit une relation entre deux classes.
Dans un chapitre précédent on a parlé de *composition* qui décrit une classe à l'intérieur
d'une autre classe.

Pour rappel::



+ 3
- 1
cours/source/17-décorateurs/02-décorateurs.rst 파일 보기

@@ -11,7 +11,9 @@ de la fonction décorée::

def mon_décorateur(fonction):
def fonction_retournée():
# fais quelque chose avec fonction
# fait quelque chose l'argument `fonction`, par exemple
# l'appeler avec un argument:
fonction(42)
return fonction_retournée

@mon_décorateur


+ 1
- 1
cours/source/18-exceptions/02-exceptions-natives.rst 파일 보기

@@ -55,7 +55,7 @@ ValueError
``ValueError`` est levée (entre autres) quand on tente une maunvaise conversions::

entrée_utilisateur = "pas un nombre"
valeu = int(entrée_utilisateur)
valeur = int(entrée_utilisateur)


KeyboardInterrupt