From a3f9c40fa69660aa98f07185141a71fb065e9baa Mon Sep 17 00:00:00 2001 From: Dimitri Merejkowsky Date: Sun, 16 Feb 2020 16:04:58 +0100 Subject: [PATCH] =?UTF-8?q?R=C3=A9=C3=A9criture=20de=20tous=20les=20exampl?= =?UTF-8?q?es=20avec=20print()?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Bien plus compréhensible qu'avec `>>>` --- cours/TODO | 3 + .../02-premiers-pas/04-maths-simples.rst | 15 ++ cours/source/04-booléens/index.rst | 72 +++++++ cours/source/04-code-source/index.rst | 98 ---------- .../01-flot-de-contrôle.rst | 64 +++++-- cours/source/06-fonctions/01-functions.rst | 41 ++-- .../06-fonctions/02-portée-des-variables.rst | 6 +- cours/source/06-fonctions/04-par-défaut.rst | 14 +- .../06-fonctions/05-fonctions-natives.rst | 26 ++- cours/source/06-fonctions/06-return.rst | 12 +- cours/source/07-listes/index.rst | 131 ++++++++----- cours/source/08-none-et-pass/01-none.rst | 73 +++----- cours/source/09-dictionnaires/index.rst | 146 ++++++--------- cours/source/10-tuples/index.rst | 74 ++++---- cours/source/11-classes-01/index.rst | 72 +++---- cours/source/12-modules-01/index.rst | 89 ++++----- .../{02-couplage.rst => 01-couplage.rst} | 29 +-- cours/source/13-classes-02/01-rappels.rst | 176 ------------------ ...{03-composition.rst => 02-composition.rst} | 50 ++--- cours/source/13-classes-02/index.rst | 5 +- .../14-bibliothèques-01/02-sys.path.rst | 2 +- .../01-données-binaires.rst | 13 +- cours/source/index.rst | 2 +- 23 files changed, 542 insertions(+), 671 deletions(-) create mode 100644 cours/source/04-booléens/index.rst delete mode 100644 cours/source/04-code-source/index.rst rename cours/source/13-classes-02/{02-couplage.rst => 01-couplage.rst} (79%) delete mode 100644 cours/source/13-classes-02/01-rappels.rst rename cours/source/13-classes-02/{03-composition.rst => 02-composition.rst} (67%) diff --git a/cours/TODO b/cours/TODO index 7ccfccb..497bd9c 100644 --- a/cours/TODO +++ b/cours/TODO @@ -1,2 +1,5 @@ explication des exercices insérer exercices pour chaque épisode de la saison 2 + + +Explications sur `globals()` et `locals()` diff --git a/cours/source/02-premiers-pas/04-maths-simples.rst b/cours/source/02-premiers-pas/04-maths-simples.rst index e1c57a8..1ffadc5 100644 --- a/cours/source/02-premiers-pas/04-maths-simples.rst +++ b/cours/source/02-premiers-pas/04-maths-simples.rst @@ -74,3 +74,18 @@ et on peut utiliser des parenthèses pour grouper les opérations:: print((1 + 2) * 3) # affiche: 9 + +Combiner opération et assignation +---------------------------------- + +La notation ``+=`` permet de combiner addition et assignation:: + + x = 3 + x = x + 1 + print(x) + # affiche :: 4 + + x = 3 + x += 1 + print(x) + # affiche :: 4 diff --git a/cours/source/04-booléens/index.rst b/cours/source/04-booléens/index.rst new file mode 100644 index 0000000..b38c5fe --- /dev/null +++ b/cours/source/04-booléens/index.rst @@ -0,0 +1,72 @@ +Chapitre 4 - Booléens et conditions +=================================== + +En Python, les variables ``True`` et ``False`` sont toujours définies +et servent à représenter une valeur vraie ou fausse. + +(Notez qu'elles commencent par une majuscule) + +Assignation +----------- + +On peut assigner des variables à True ou False:: + + + la_terre_est_plate = False + python_c_est_genial = True + + +Comparaisons +------------ + +Certaines opérations renvoient des booléens: + ++------+-----------------------------+ +|``=`` | égal | ++------+-----------------------------+ +|``!=``| différent | ++------+-----------------------------+ +|``>`` | strictement supérieur | ++------+-----------------------------+ +|``>=``| supérieur ou égal | ++------+-----------------------------+ +|``<`` | strictement inférieur | ++------+-----------------------------+ +|``<=``| inférieur | ++------+-----------------------------+ + +Par example:: + + a = 2 + b = 3 + print(a > b) + # affiche: False + + print(2 + 2 == 4) + # affiche: True + +.. warning:: + + Ne pas confondre: ``==`` pour la comparaison et ``=`` pour l'assignation + + +Enfin, on peut écrire des encadrements:: + + a = 3 + print(2 <= a < 4) + # affiche: True + + +not +--- + +Enfin, on peut utiliser ``not`` pour inverser une condition:: + + a = 3 + if not a == 4: + print("a est différent de 4") + # affiche: a est différent de 4 + + la_terre_est_plate = False + print(not la_terre_est_plate) + # affiche: True diff --git a/cours/source/04-code-source/index.rst b/cours/source/04-code-source/index.rst deleted file mode 100644 index 0c4f642..0000000 --- a/cours/source/04-code-source/index.rst +++ /dev/null @@ -1,98 +0,0 @@ -Chapitre 4 - code source -======================== - -Non persistance des variables ------------------------------- - -.. code-block:: console - - $ python3 - >>> a = 2 - >>> quit() - ``` - -.. code-block:: console - - $ python3 - >>> a - Traceback (most recent call last): - File "", line 1, in - NameError: name 'a' is not defined - - -Du code dans un fichier ------------------------ - -Aussi appelé: "code source", ou "source". - -L'essence du logiciel libre :) - - - -Installation d'un éditeur de texte simple ------------------------------------------- - -* Linux; ``gedit``, ``kate``, ... -* macOS: ``CotEditor`` -* Windows: ``Notepad++`` - -J'insiste sur **simple**. Inutile d'installer un IDE pour le moment. - - -Configuration -------------- - -* Police de caractères à chasse fixe -* Indentation de *4 espaces* -* Remplacer tabulation par des espaces -* Activer la coloration syntaxique - - - -Notre premier fichier source ------------------------------ - - -Insérez le code suivant dans votre éditeur de texte - -.. code-block:: python - - # Affiche un message - print("Bonjour, monde") - - -Sauvegardez dans un fichier `bonjour.py` dans `Documents/e2l/python` par exemple - - -Lancer du code en ligne de commande ------------------------------------ - - -.. code-block:: console - - cd Documents/e2l/python/ - python3 bonjour.py - Bonjour, monde - -* Les lignes commençant par dièse (``#``) ont été ignorées - ce sont des *commentaires*. -* ``print()`` affiche la valeur, comme dans le REPL. - - -Note importante ---------------- - -Vous avez juste besoin: - -* d'un éditeur de texte -* de Python3 installé -* d'une ligne de commande - -Pas la peine d'installer quoique ce soit de plus pour le moment - - -1. *Recopiez* le code affiché dans votre éditeur, à la suite du code - déjà écrit -2. Lancez le code depuis la ligne de commande -3. Réparez les erreurs éventuelles -4. Recommencez - diff --git a/cours/source/05-flot-de-controle/01-flot-de-contrôle.rst b/cours/source/05-flot-de-controle/01-flot-de-contrôle.rst index 2be92d0..20bddb8 100644 --- a/cours/source/05-flot-de-controle/01-flot-de-contrôle.rst +++ b/cours/source/05-flot-de-controle/01-flot-de-contrôle.rst @@ -1,25 +1,36 @@ Flot de contrôle ================ -L'essence de la programmation! +Pour l'instant, toutes les instructions que nous avons +écrites ont été exécutée une par une et dans l'ordre +d'apparition dans le code source. + +Modifier l'ordre d'exécution de ces lignes s'appelle modifier le flot de +contrôle, et c'est l'essence de la programmation! if --- +++ -.. code-block:: python +On peut utiliser le mot ``if`` pour autoriser ou empécher +l'éxcution du code en-dessous:: a = 3 b = 4 if a == b: print("a et b sont égaux") print("on continue") + # affiche juste + # on continue +La 4ème ligne n'est pas éxécutée parce la condition +est fausse. Notes: -* deux points à la fin de la ligne -* indentation après les deux points +* il y a le caractère ``:`` (deux points) à la fin de la ligne +* le code en-dessous du ``if`` commence par 4 espaces: on appelle + cela une *indentation* * si la condition n'est pas vraie, rien ne se passe Notez qu'on peut mettre uniquement une variable ou une valeur @@ -27,14 +38,25 @@ après le if. Ceci ne fonctionne pas:: if a = 3: print("a égale 3") + # affiche: SyntaxError + +On parle aussi de "bloc" si plusieurs lignes sont identées:: -et fait une erreur de syntaxe + a = 3 + b = 4 + if a == b: + # début du bloc + print("a et b sont égaux") + c = 2 * a + # fin du block + print("on continue") if / else --------- -.. code-block:: +On peut utiliser le mot ``else`` après un condition en ``if`` +pour éxécutér un bloc si la condition est fausse:: a = 3 b = 4 @@ -42,52 +64,58 @@ if / else print("a et b sont égaux") else: print("a et b sont différent") + # affiche: a et b sont différents if / elif --------- -.. code-block:: +On peut utiliser ``if``, ``elif`` et ``else`` pour enchaîner plusieurs +conditions:: + age = 23 if age < 10: - print("inférieur à dix") + print("âge inférieur à dix") elif 10 <= age < 20: print("âge entre 10 et 20") elif 20 <= age < 40: print("âge entre 20 et 40") else: print("âge supérieur à 40") - -On peut mettre autont de `elif` qu'on veut! -Le derier `else` s'éxécute en dernier + # affiche: âge entre 20 et 40 while ----- -Répéter tant qu'une condition est vraie:: +On peut utiliser ``while`` pour répéter un bloc tant qu'une condition +est vraie:: i = 0 while i < 3: print(i) i = i + 1 -.. code-block:: console +.. code-block:: text 0 1 2 +Notez que la variable ``i`` passe par plusieurs valeurs différentes. -Notre première boucle infinie ------------------------------ +Boucle infinie +-------------- -.. code-block:: +On parle de *boucle infinie* si la condition ne devient jamais fausse:: while True: print("spam!") -CTRL-C pour interrompre +Dans ce cas, il faut appuyer sur ``CTRL-C`` pour interrompre +le programme. + +Notez ici qu'on a mis directement la valeur ``True``, et non une comparaison. Combiner while et if diff --git a/cours/source/06-fonctions/01-functions.rst b/cours/source/06-fonctions/01-functions.rst index ccfc890..911fc87 100644 --- a/cours/source/06-fonctions/01-functions.rst +++ b/cours/source/06-fonctions/01-functions.rst @@ -11,15 +11,23 @@ Définition:: * avec `def` -* avec un `:` à la fin et un *bloc indenté* (appelé le "corps") +* avec un `:` à la fin et un *bloc indenté* (appelé *le corps de la fonction*). Appel:: - >>> dire_bonjour() - Bonjour + dire_bonjour() * avec le nom de la fonction et des parenthèses +Example complet:: + + def dire_bonjour(): + print("Bonjour") + + bonjour() + # Affiche: bonjour' + + Le pouvoir des fonctions ------------------------ @@ -35,6 +43,7 @@ programmation. Fonction avec un argument +-------------------------- Définition: avec l'argument à l'intérieur des parenthèses:: @@ -43,17 +52,10 @@ Définition: avec l'argument à l'intérieur des parenthèses:: Appel: en passant une variable ou une valeur dans les parenthèses:: - >>> dire_bonjour("Germaine") - Bonjour Germaine - - >>> prénom_de_charlotte = "Charlotte" - >>> dire_bonjour(prénom_de_charlotte) - Bonjour Charlotte - -Exécution d'une fonction ------------------------- + dire_bonjour("Germaine") -C'est exatement comme si on assignait les arguments de la fonction avant d'éxécuter le code +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:: # Ceci: @@ -65,3 +67,16 @@ dans le corps:: # Lui-même équivalent à: print("Bonjour " + "Dimitri") + +Example complet:: + + + def dire_bonjour(prénom): + print("Bonjour " + prénom) + dire_bonjour("Germaine") + # affiche: Bonjour Germaine + + prénom_de_charlotte = "Charlotte" + dire_bonjour(prénom_de_charlotte) + # affiche: Bonjour Charlotte + diff --git a/cours/source/06-fonctions/02-portée-des-variables.rst b/cours/source/06-fonctions/02-portée-des-variables.rst index 4e53c27..4dc09a0 100644 --- a/cours/source/06-fonctions/02-portée-des-variables.rst +++ b/cours/source/06-fonctions/02-portée-des-variables.rst @@ -22,8 +22,8 @@ Les variables en dehors des fonctions sont disponibles partout:: Une variable peut avoir en "cacher" une autre si elle a une portée différente:: def dire_bonjour(prénom): - print("Bonjour " + prénom) # portée: uniquement dans - # le corps dire_bonjour + print("Bonjour " + prénom) # portée: uniquement dans + # le corps dire_bonjour - prénom = "Dimitri" # portée: dans tout le programme + prénom = "Dimitri" # portée: dans tout le programme dire_bonjour(prénom) # Ok diff --git a/cours/source/06-fonctions/04-par-défaut.rst b/cours/source/06-fonctions/04-par-défaut.rst index 77b5ee6..2de3e95 100644 --- a/cours/source/06-fonctions/04-par-défaut.rst +++ b/cours/source/06-fonctions/04-par-défaut.rst @@ -11,9 +11,11 @@ On peut aussi mettre des valeurs par défaut:: Appel:: - >>> dire_bonjour("Thomas", enthousiaste=True) - Bonjour Thomas! - >>> dire_bonjour("Thomas", enthousiaste=False) - Bonjour Thomas - >>> dire_bonjour("Thomas") - Bonjour Thomas + dire_bonjour("Thomas", enthousiaste=True) + # affiche: Bonjour Thomas! + + dire_bonjour("Thomas", enthousiaste=False) + # affiche: Bonjour Thomas + + dire_bonjour("Thomas") + # affiche: Bonjour Thomas diff --git a/cours/source/06-fonctions/05-fonctions-natives.rst b/cours/source/06-fonctions/05-fonctions-natives.rst index 536a243..9e59e1a 100644 --- a/cours/source/06-fonctions/05-fonctions-natives.rst +++ b/cours/source/06-fonctions/05-fonctions-natives.rst @@ -18,19 +18,31 @@ On peut passer autant d'arguments qu'on veut à ``print`` et: * Il les sépare par des espaces * Ajoute un retour à la ligne à la fin:: - >>> prénom = "Charlotte" + prénom = "Charlotte" print("Bonjour", pŕenom) + print("Ça va ?") + +.. code-block:: text + Bonjour Charlotte + Ça va ? + On peut demander à `print` de changer son séparateur:: - >>> a = "chauve" - >>> b = "souris" - >>> print(a, b, sep="-") + a = "chauve" + b = "souris" + print(a, b, sep="-") + +.. code-block:: text + chauve-souris Ou de changer le caractère de fin:: - >>> print("Ceci tient", end="") - >>> print("sur une seule ligne") - Ceci tient sur une seule ligne + print("Ceci tient", end="") + print("sur une seule ligne") + +.. code-block:: text + + Ceci tient sur une seule ligne diff --git a/cours/source/06-fonctions/06-return.rst b/cours/source/06-fonctions/06-return.rst index 682008f..e0f691b 100644 --- a/cours/source/06-fonctions/06-return.rst +++ b/cours/source/06-fonctions/06-return.rst @@ -26,9 +26,17 @@ corps de la fonction:: return print("Heureux de faire votre connaissance") - >>> dire_bonjour("Dimitri", première_fois=True) + dire_bonjour("Dimitri", première_fois=True) + +.. code-block:: text + Bonjour Dimitri Heureux de faire votre connaissance - >>> dire_bonjour("Dimitri", première_fois=False) +.. code-block:: python + + dire_bonjour("Dimitri", première_fois=False) + +.. code-block:: text + Bonjour Dimitri diff --git a/cours/source/07-listes/index.rst b/cours/source/07-listes/index.rst index 98aa53a..d5338da 100644 --- a/cours/source/07-listes/index.rst +++ b/cours/source/07-listes/index.rst @@ -33,41 +33,48 @@ Connaître la taille d'une liste Avec ``len()`` - encore une fonction native:: - >>> liste_vide = [] - >>> len(liste_vide) - 0 - >>> trois_entiers = [1, 2, 3] - >>> len(trois_entiers) - 3 + liste_vide = [] + taille = len(liste_vide) + print(taille) + # affiche: 0 + + trois_entiers = [1, 2, 3] + taille = len(trois_entiers) + print(taille) + # affiche: 3 Concaténation de listes ----------------------- Avec ``+``:: - >>> prénoms = ["Alice", "Bob"] - >>> prénoms += ["Charlie", "Eve"] - >>> prénoms - ['Alice', 'Bob', "Charlie", 'Eve'] + prénoms = ["Alice", "Bob"] + prénoms += ["Charlie", "Eve"] + print(prénoms) + # affiche: ['Alice', 'Bob', "Charlie", 'Eve'] On ne peut concaténer des listes que avec d'autres listes:: - >>> scores = [1, 2, 3] - >>> scores += 4 # TypeError - >>> scores += [4] # OK + scores = [1, 2, 3] + scores += 4 + # erreur + + scores += [4] + print(scores) + # affiche: [1,2,3,4] Test d'appartenance ------------------- Avec ``in``:: - >>> prénoms = ["Alice", "Bob"] - >>> "Alice" in prénoms - True + prénoms = ["Alice", "Bob"] + print("Alice" in prénoms) + # affiche: True - >>> prénoms = ["Alice", "Bob"] - >>> "Charlie" in prénoms - False + prénoms = ["Alice", "Bob"] + print("Charlie" in prénoms) + # affiche: False Itérer sur les élements d'une liste ------------------------------------ @@ -80,35 +87,43 @@ Avec ``for ... in``:: # élément de la liste print("Bonjour", prénom) +.. code-block:: text + Bonjour Alice Bonjour Bob Bonjour Charlie -## Indéxer une liste +Indéxer une liste +------------------ -* Avec `[]` et un entier +* Avec ``[]`` et un entier -* Les index valides vont de 0 à `n-1` où `n` est la +* Les index valides vont de 0 à ``n-1`` où ``n`` est la taille de la liste:: - >>> fruits = ["pomme", "orange", "poire"] - >>> fruits[0] - "pomme" - >>> fruits[1] - "orange" - >>> list[2] - "poire" - >>> fruits[3] # IndexError + fruits = ["pomme", "orange", "poire"] + + print(fruits[0]) + # affiche: "pomme" + + print(fruits[1]) + # affiche: "orange" + + print(list[2]) + # affiche: "poire" + + fruits[3] + # erreur: IndexError Modifier une liste ------------------- Encore une assignation:: - >>> fruits = ["pomme", "orange", "poire"] - >>> fruits[0] = "abricot" - >>> fruits - ["abricot", "orange", "poire"] + fruits = ["pomme", "orange", "poire"] + fruits[0] = "abricot" + print(fruits) + # affiche: ["abricot", "orange", "poire"] Les strings sont aussi des listes (presque) -------------------------------------------- @@ -128,17 +143,45 @@ On peut itérer sur les caractères d'une string:: On peut tester si un caractère est présent:: - >>> "e" in "vache" - True - >>> "x" in "vache" - False + print("e" in "vache") + # affiche: True + + print(x" in "vache") + # affiche: False Mais on neut peut pas modifier une string:: - >>> prénom = "Charlotte" - >>> prénom[0] - "C" - >>> prénom[3] - "r" - >>> prénom[0] = "X" # TypeError + prénom = "Charlotte" + l = prénom[0] + print(l) + # affiche: "C" + + l = prénom[3] + print(l) + # affiche: "r" + + prénom[0] = "X" + # erreur: TypeError + + +Falsy et truthy +---------------- + + +En réalité on peut mettre autre chose qu'une comparaison ou une variable booléenne après le if. + +Si on met une liste vide, ``if`` se comportera comme si on avait mis une valeur fausse, et si +la liste n'est pas vide , ``if`` se comportera comme si on avait mis une valeur vraie.:: + + ma_liste = [1, 2, 3] + if ma_liste: + print("ma_liste n'est pas vide") + # affiche: ma_liste n'est pas vide + + mon_autre_liste = [] + if not mon_autre_liste: + print("mon_autre_liste est vide") + # affiche: mon_autre_liste est vide + +On dit que les listes vides sont *Falsy* et les listes non-vides *Truthy* diff --git a/cours/source/08-none-et-pass/01-none.rst b/cours/source/08-none-et-pass/01-none.rst index db96ae2..ccdc4bc 100644 --- a/cours/source/08-none-et-pass/01-none.rst +++ b/cours/source/08-none-et-pass/01-none.rst @@ -8,17 +8,6 @@ Définition Un peu comme ``True`` et ``False`` qui sont deux valeurs qui servent à représenter tous les booléens. -Représenter l'absence ----------------------- - -L'interpréteur intéractif n'affiche rien quand la valeur est None:: - - >>> a = 42 - >>> a - 42 - >>> b = None - >>> b - Retourner None ---------------- @@ -26,11 +15,12 @@ En réalité, *toutes* les fonctions pythons retournent *quelque chose*, même q elle ne contiennent pas le mot-clé ``return``.:: def ne_renvoie_rien(): - print("je ne fais qu'afficher quelque chose") + x = 2 - >>> resultat = ne_renvoie_rien() - "je ne fais qu'afficher quelque chose" - >>> resultat + resultat = ne_renvoie_rien() + + print(resultat) + # affiche: None Opérations avec None --------------------- @@ -38,17 +28,26 @@ Opérations avec None La plupart des fonctions que nous avons vues échouent si on leur passe ``None`` en argument:: - >>> len(None) - TypeError: object of type 'NoneType' has no len() - >>> None < 3 - TypeError: '<' not supported between instances of - 'NoneType' and 'int' - >>> int(None) - TypeError: int() argument must be a string, - a bytes-like object or a number, - not 'NoneType' - >>> str(None) - 'None' + x = len(None) + # erreur: TypeError + + x = None < 3 + # erreur: TypeError + + x = int(None) + # erreur: TypeError + +Mais ``str`` fonctionne:: + + x = str(None) + print(x) + # affiche: 'None' + +On peut vérifier si une variable vaut ``None`` avec ``is None``:: + + x = ne_renvoie_rien() + print(x is None) + # affiche: True Example d'utilisation ---------------------- @@ -61,20 +60,10 @@ Example d'utilisation return element return None - >>> trouve_dans_liste(2, [1, 2, 3]) - 2 - >>> trouve_dans_liste(False, [True, False]) - False - >>> trouve_dans_liste(1, [3, 4]) - - -None est Falsy, et on peut vérifier si une variable vaut ``None`` avec ``is None``:: + x = trouve_dans_liste(2, [1, 2, 3]) + print(x) + # affiche: 2 - # hypothèse: `ma_valeur` n'est pas None - mon_element = trouve_dans_liste(ma_valeur, ma_liste) - if mon_element is None: - print("élément absent de la liste") - if not mon_element: - # Peut-être que l'élément n'était pas dans la liste, - # ou peut-être y était-il, mais avec une valeur falsy - ... + x = trouve_dans_liste(1, [3, 4]) + print(x) + # affiche: None diff --git a/cours/source/09-dictionnaires/index.rst b/cours/source/09-dictionnaires/index.rst index a256d1f..77d7e7a 100644 --- a/cours/source/09-dictionnaires/index.rst +++ b/cours/source/09-dictionnaires/index.rst @@ -31,49 +31,57 @@ Accès aux valeurs Avec ``[]``, comme pour les listes, mais avec une *clé* à la place d'un *index*:: - >>> scores = {"john": 10, "bob": 42} - >>> scores["john"] - 10 - >>> scores["bob"] - 42 - >>> scores["charlie"] - KeyError + scores = {"john": 10, "bob": 42} + + print(scores["john"]) + # affiche: 10 + + print(scores["bob"]) + # affiche: 42 + + print(scores["charlie"]) + # erreur: KeyError Test d'appartenance --------------------- Avec ``in``, comme le listes:: - >>> scores = {"john": 10, "bob": 42} - >>> "charlie" in scores - False + scores = {"john": 10, "bob": 42} + print("charlie" in scores) + # affiche: False Modifier la valeur d'une clé ----------------------------- Comme pour les listes, avec une assignation:: - >>> scores = {"john": 10, "bob": 42} - >>> scores["john"] = 20 - >>> scores - {"john": 20, "bob": 42} + scores = {"john": 10, "bob": 42} + scores["john"] = 20 + print(scores) + # affiche: {"john": 20, "bob": 42} Créer une nouvelle clé ----------------------- -Même méchanisme que pour la modification des clés existantes:: +Même mécanisme que pour la modification des clés existantes:: + + scores = {"john": 10, "bob": 42} + scores["charlie"] = 30 + print(scores) + # affiche: {"john": 20, "bob": 42, "charlie": 30} - >>> scores = {"john": 10, "bob": 42} - >>> scores["charlie"] = 30 - >>> scores - {"john": 20, "bob": 42, "charlie": 30} +*rappel*: ceci ne fonctionne pas avec les listes: on ne peut +pas "créer" de nouveaux éléments dans la liste juste +avec un index:: -*rappel*: ceci ne fonctionne pas avec les listes!:: - >>> ma_liste = ["a", "b"] - >>> ma_liste[1] = "c" # ok - ["a", "c"] - >>> ma_liste[3] = "d" - IndexError + ma_liste = ["a", "b"] + ma_liste[1] = "c" + print(ma_liste) + # affiche: ["a", "c"] + + ma_liste[3] = "d" + # erreur: IndexError Itérer sur les clés ------------------- @@ -84,8 +92,14 @@ Avec ``for ... in ...``, comme pour les listes:: for nom in scores: # `nom` est assigné à "john" puis "bob" score_associé_au_nom = scores[nom] + # score_associé_au_nom est assigné à '10' puis '42' print(nom, score_associé_au_nom) +.. code-block:: + + john 10 + bob 42 + del --- @@ -94,83 +108,31 @@ Détruire une clé Avec ``del`` - un nouveau mot-clé:: - >>> scores = {"john": 10, "bob": 42} - >>> del scores["bob"] - >>> scores - {"john": 10} + scores = {"john": 10, "bob": 42} + del scores["bob"] + print(scores) + # affiche: {"john": 10} Détruire un élément d'une liste ++++++++++++++++++++++++++++++++ Aussi avec ``del``:: - >>> fruits = ["pomme", "banane", "poire"] - >>> del fruits[1] - >>> fruits - ["pomme", "poire"] + fruits = ["pomme", "banane", "poire"] + del fruits[1] + print(fruits) + # affiche: ["pomme", "poire"] Détruire une variable +++++++++++++++++++++ Encore et toujours ``del``:: - >>> mon_entier = 42 - >>> mon_entier += 3 - >>> mon_entier - 45 - >>> del mon_entier - >>> mon_entier == 45 - NameError: name 'mon_entier' is not defined - -Des dictionnaires partout ---------------------------- - -Les variables globales d'un programme Python sont dans un dictionnaire, -accessible avec la fonction native `globals()`:: - - $ python3 - >>> globals() - { - ... - '__doc__': None, - '__name__': '__main__', - ... - } - -On reparlera de `__doc__` et `__name__` un autre jour ...:: - - - $ python3 - >>> a = 42 - >>> globals() - { - ... - '__doc__': None, - '__name__': '__main__', - ... - 'a': 42 - } - ``` - -.. code-block:: - - python - $ python3 - >>> a = 42 - >>> del globals()["a"] - >>> a - NameError: name 'a' is not defined - - -On peut accéder aux variables locales d'une fonction avec ``locals()``:: - - def ma_fonction(): - a = 42 - b = 3 - c = a + b - print(locals()) - - >>> ma_fonction() - {'a': 42, 'b': 3, 'c': 45} + mon_entier = 42 + mon_entier += 3 + print(mon_entier) + # affiche: 45 -En revanche, il n'est pas conseillé de modifier le dictionaire renvoyé par ``locals()`` ... + del mon_entier + mon_entier += 1 + # erreur: NameError diff --git a/cours/source/10-tuples/index.rst b/cours/source/10-tuples/index.rst index c666360..b68577d 100644 --- a/cours/source/10-tuples/index.rst +++ b/cours/source/10-tuples/index.rst @@ -35,10 +35,11 @@ Accès Avec ``[]`` et l'index de l'élément dans le tuple:: mon_tuple = (42, "bonjour") - mon_tuple[0] - 42 - mon_tuple[1] - "bonjour" + print(mon_tuple[0]) + # affiche: 42 + + print(mon_tuple[1]) + # affiche: "bonjour" Modification ------------ @@ -47,7 +48,7 @@ Interdit:: mon_tuple = (42, "bonjour") mon_tuple[0] = 44 - TypeError: 'tuple' object does not support item assignment + # erreur: TypeError: 'tuple' object does not support item assignment Test d'appartenance @@ -55,26 +56,28 @@ Test d'appartenance Avec ``in``: - >>> mon_tuple = (42, 14) - >>> 42 in mon_tuple - True + mon_tuple = (42, 14) + print(42 in mon_tuple) + # affiche: True + + print(14 in mon_tuple) + # affiche: True - >>> 14 in mon_tuple - True - >>> 13 in mon_tuple - False + print(13 in mon_tuple) + # affiche: False Déstructuration ---------------- Créer plusieurs variables en une seule ligne:: - >>> couple = ("Batman", "Robin") - >>> héros, side_kick = couple - >>> héros - 'Batman' - >>> side_kick - 'Robin' + couple = ("Batman", "Robin") + héros, side_kick = couple + print(héros) + # affiche: Batman + + print(side_kick) + # affiche: Robin Quelques erreurs classiques @@ -82,15 +85,15 @@ Quelques erreurs classiques .. code-block:: python - >>> héros, side_kick, ennemi = couple - ValueError (3 != 2) + héros, side_kick, ennemi = couple + # erreur: ValueError (3 != 2) - >>> (héros,) = couple - ValueError (1 != 2) + (héros,) = couple + # erreur: ValueError (1 != 2) # Gare à la virgule: - >>> héros, = couple - ValueError (1 != 2) + héros, = couple + # erreur: ValueError (1 != 2) Pièges ------ @@ -110,16 +113,19 @@ Pièges On peut aussi déstructurer des listes:: - >>> fruits = ["pomme", "banane", "orange"] - >>> premier, deuxième, troisième = fruits - >>> premier - "pomme" - >>> deuxième - "banane" - >>> troisième - "orange" + fruits = ["pomme", "banane", "orange"] + premier, deuxième, troisième = fruits + + print(premier) + # affiche: pomme + + print(deuxième) + # affiche: banane + + print(troisième) + # affiche: orange -On dit aussi: unpacking +On dit aussi: *unpacking* Utilisations des tuples ------------------------ @@ -147,6 +153,6 @@ Pour retourner plusieurs valeurs:: v, c = tire_carte() print(v, "de", c) - # 10 de trèfle + # affiche: 10 de trèfle Ce n'est pas une nouvelle syntaxe, juste de la manipulation de tuples! diff --git a/cours/source/11-classes-01/index.rst b/cours/source/11-classes-01/index.rst index a195fd6..1a11365 100644 --- a/cours/source/11-classes-01/index.rst +++ b/cours/source/11-classes-01/index.rst @@ -105,14 +105,14 @@ Le code suivant fait exactement la même chose, mais avec une ligne de moins:: On peut *créer* des attributs dans *n'importe quel instance*, en utilisant l'*assignation*:: - >>> mon_instance = MaClasse() + mon_instance = MaClasse() # Création de l'attribut `x` dans `mon_instance` - >>> mon_instance.x = 42 + mon_instance.x = 42 # Accés à l'attribut `x` dans `mon_instance` - >>> mon_instance.mon_attribut - 42 + print(mon_instance.mon_attribut) + # affiche: 42 Méthodes - définition ---------------------- @@ -135,12 +135,14 @@ la classe:: class MaClasse: def ma_méthode(self): return 42 - >>> ma_méthode() - Erreur - >>> mon_instance = MaClasse() - >>> mon_instance.ma_méthode() - 42 + ma_méthode() + # erreur: NameError + + mon_instance = MaClasse() + résultat = mon_instance.ma_méthode() + print(résultat) + # affiche: 42 Notez qu'on ne passe *pas* d'argument quand on apelle `ma_méthode` depuis l'instance. @@ -158,10 +160,10 @@ On peut le voir en utilisant des attributs:: print(self.x) - >>> mon_instance = MaClasse() - >>> mon_instance.x = 42 - >>> mon_instance.affiche_attribut_x() - 42 + mon_instance = MaClasse() + mon_instance.x = 42 + mon_instance.affiche_attribut_x() + # Affiche: 42 On peut aussi *créer* des attributs dans une méthode:: @@ -171,13 +173,13 @@ On peut aussi *créer* des attributs dans une méthode:: def affiche_attribut_x(self): print(self.x) - >>> mon_instance = MaClasse() - >>> mon_instance.affiche_attribut_x() - # Erreur: `mon_instance` n'a pas d'attribut `x` + mon_instance = MaClasse() + mon_instance.affiche_attribut_x() + # erreur: `mon_instance` n'a pas d'attribut `x` - >>> mon_instance.crée_attribut_x() - >>> mon_instance.affiche_attribut_x() - 42 + mon_instance.crée_attribut_x() + mon_instance.affiche_attribut_x() + # affiche: 42 Les méthodes peuveunt aussi prendre plusieurs arguments, en plus de ``self`` - mais ``self`` doit toujours être le premier argument. @@ -192,10 +194,10 @@ Par example, pour créer un attribut avec une certaine valeur:: def affiche_attribut_x(self); print(self.x) - >>> mon_instance = MaClasse() - >>> mon_instance.crée_attribut_x(42) - >>> mon_instance.affiche_attribut_x() - 42 + mon_instance = MaClasse() + mon_instance.crée_attribut_x(42) + mon_instance.affiche_attribut_x() + # affiche: 42 Méthodes appelant d'autres méthodes ------------------------------------ @@ -217,8 +219,8 @@ les unes les autres:: print("fin de la méthode 2") - >>> mon_instance = MaClasse() - >>> mon_instance.méthode_2() + mon_instance = MaClasse() + mon_instance.méthode_2() .. code-block:: @@ -246,13 +248,13 @@ On utilise souvent ``__init__`` pour créer des attributs:: self.x = 1 self.y = 2 - >>> mon_instance = MaClasse() + mon_instance = MaClasse() # __init__ est appelée automatiquement! - >>> mon_instance.x - 1 - >>> mon_instance.y - 2 + print(mon_instance.x) + # affiche: 1 + print(mon_instance.y) + # affiche: 2 On prend souvent les *valeurs* des attributs à créer en arguments de la méthode ``__init__``:: @@ -264,11 +266,11 @@ On prend souvent les *valeurs* des attributs à créer en arguments de la métho Dans ce cas, les arguments de la méthode ``__init__`` apparaissent à l'intérieur des parenthèses après le nom de la classe:: - >>> mon_instance = MaClasse(3, 4) - >>> mon_instance.x - 3 - >>> mon_instance.y - 4 + mon_instance = MaClasse(3, 4) + print(mon_instance.x) + # affiche: 3 + print(mon_instance.y) + # affiche: 4 .. note:: diff --git a/cours/source/12-modules-01/index.rst b/cours/source/12-modules-01/index.rst index dea7cad..bad1782 100644 --- a/cours/source/12-modules-01/index.rst +++ b/cours/source/12-modules-01/index.rst @@ -16,27 +16,27 @@ Importer un module Ou: accéder à du code provenant d'un *autre* fichier source. -Imaginons un fichier `bonjour.py` contenant seulement une assignation +Créons un fichier `bonjour.py` contenant seulement une assignation d'une variable `a` à l'entier 42 :: # Dans bonjour.py a = 42 -On peut accéder à cette variable en important le module, par -exemple depuis l'interpréteur, en utilisant le mot-clé `import` -suivi du nom du module:: +Comme un fichier = un module, on vient de crée un module ``bonjour`` contenant une variable ``a``. - $ python - >>> import bonjour - >>> bonjour.a - 42 +Si maintenant on crée un fichier ``salutations.py`` dans le même répertoire, +on peut accéder à cette variable en *important* le module:: -Notez que pour que cela fonctionne: + # Dans salutations.py + import bonjour + print(bonjour.a) + # affiche: 42 -* Le nom du module est écrit directement, ce n'est *pas* une + +.. note:: + + Le nom du module est écrit directement, ce n'est *pas* une chaîne de caractères. -* Il faut lancer la commande `python` sans argument -* Il faut la lancer depuis le répertoire qui contient `bonjour.py`. On voit que l'assignation de la variable `a` dans `bonjour.py` est devenue un *attribut* du module `bonjour` lorsque `bonjour` a été importé @@ -44,52 +44,26 @@ un *attribut* du module `bonjour` lorsque `bonjour` a été importé Si maintenant on rajoute une fonction ``dire_bonjour`` dans ``bonjour.py``:: - # toujours dans bonjour.py + # Dans bonjour.py a = 42 def dire_bonjour(): print("Bonjour!") -On peut appeler la fonction ``dire_bonjour`` depuis l'interpréteur en accédant -à l'attribut ``dire_bonjour`` du module ``bonjour``:: - - >>> import bonjour - >>> bonjour.dire_bonjour() - Bonjour! - -Différence avec la commande python ------------------------------------ - -Notez bien que lancer l'interpréteur et taper `import bonjour` dedans n'est pas -la même chose que lancer `python bonjour.py`. - -Dans le deuxième cas, tout le code dans `bonjour.py` est exécuté, puis la commande python -se termine. - -Dans le cas de l'interpréteur, on peut utiliser tous les attributs du module et appeler -les fonctions autant de fois qu'on veut:: - - >>> import bonjour - >>> bonjour.dire_bonjour() - Bonjour! - >>> bonjour.dire_bonjour() - Bonjour! - -On peut aussi modifier les valeurs des attributs:: - - >>> import bonjour - >>> bonjour.a - 42 - >>> bonjour.a = 36 - >>> bonjour.a - 36 +On peut appeler la fonction ``dire_bonjour`` depuis ``salutations.py`` +en utilisant l'attribut ``dire_bonjour`` du module ``bonjour``:: + # Dans salutations.py + import bonjour + bonjour.dire_bonjour() + # affiche: Bonjour! Les imports ne sont faits qu'une seule fois ------------------------------------------- -Il est important de noter que le code à l'intérieur d'un -module n'est *pas* ré-éxécuté si le module a déjà été -importé auparavant. +Il est important de noter que: + +* **tout** le code à l'intérieur d'un module est éxécuté lors du premier import +* 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 @@ -97,15 +71,20 @@ de variables:: # Dans bonjour.py print("Je suis le module bonjour et tu viens de m’importer") + def dire_bonjour(): + .... + +.. code-block:: python + + # Dans salutation.py + import bonjour + # affiche: Je suis le module bonjour et tu viens de m’importer - >>> import bonjour - Je suis le module foo et tu viens de m’importer - >>> import bonjour - + import bojour + # n'affiche rien -Il faudra donc redémarrer l'interpréteur à chaque fois que le code dans `bonjour.py` change. -a bibliothèque standard +La bibliothèque standard ------------------------ La bibliothèque standard est une collection de modules directement utilisables fournis à l'installation de Python. diff --git a/cours/source/13-classes-02/02-couplage.rst b/cours/source/13-classes-02/01-couplage.rst similarity index 79% rename from cours/source/13-classes-02/02-couplage.rst rename to cours/source/13-classes-02/01-couplage.rst index 0852c30..162e95e 100644 --- a/cours/source/13-classes-02/02-couplage.rst +++ b/cours/source/13-classes-02/01-couplage.rst @@ -18,16 +18,17 @@ On peut utiliser pour cela deux classes: `Chat` et `Humain`:: def __init__(self, nom): self.nom = nom - >>> chat = Chat("Monsieur Moustaches") - >>> chat.nom - 'Monsieur Moustaches' + chat = Chat("Monsieur Moustaches") + prin(chat.nom) + # affiche: Monsieur Moustaches class Humain: def __init__(self, prénom): self.prénom = prénom - >>> alice = Humain(prénom="Alice") - >>> alice.prénom - "Alice" + + alice = Humain(prénom="Alice") + print(alice.prénom) + # affiche: Alice Maintenant on veut que les humains puissent adopter des chats. Pour cela, on peut rajouter la méthode ``adopte`` dans la classe @@ -43,10 +44,10 @@ classe ``Chat``:: def adopte(self, chat): print(self.prénom, "adopte un chat") - >>> boule_de_poils = Chat("Boule de Poils") - >>> alice = Humain("Alice") - >>> alice.adopte(boule_de_poils) - "Alice adopte un chat" + boule_de_poils = Chat("Boule de Poils") + alice = Humain("Alice") + alice.adopte(boule_de_poils) + # affiche: "Alice adopte un chat" On peut accéder au nom du chat depuis la méthode ``adopte``, en utilisant la syntaxe ``nom.attribut`` vue précédemment:: @@ -58,10 +59,10 @@ en utilisant la syntaxe ``nom.attribut`` vue précédemment:: def adopte(self, chat): print(self.prénom, "adopte", chat.nom) - >>> boule_de_poils = Chat("Boule de Poils") - >>> alice = Humain("Alice") - >>> alice.adopte(boule_de_poils) - "Alice adopte Boule de Poils" + boule_de_poils = Chat("Boule de Poils") + alice = Humain("Alice") + alice.adopte(boule_de_poils) + # affiche: Alice adopte Boule de Poils Couplage -------- diff --git a/cours/source/13-classes-02/01-rappels.rst b/cours/source/13-classes-02/01-rappels.rst deleted file mode 100644 index 1e42dff..0000000 --- a/cours/source/13-classes-02/01-rappels.rst +++ /dev/null @@ -1,176 +0,0 @@ -Rappels -======= - -// TODO: drop? - -.. note:: - - ceci est surtout un rappel du chapitre 11. N'hésitez pas à vous y - reporter si les exemples de code ne vous paraissent pas clairs. - - -Classes vides -------------- - -Définition:: - - class MaClasse: - pass - -Instanciation:: - - instance_1 = MaClasse() - -Attributs ---------- - -Un attribut est une variable *à l'intérieur* d'autre chose (par exemple une instance de classe). - -La syntaxe consiste en l'instance à gauche et l'attribut à droite après un point:: - - >>> mon_instance = MaClasse() - # création de l'attribut `x` dans mon_instance: - >>> mon_instance.x = 42 - # accès à l'attribut `x` dans mon_instance: - >>> mon_instance.x - 42 - -Méthodes --------- - -Une méthode est une fonction définie à l'intérieur d'une classe: - -Définition:: - - class MaClasse: - def ma_méthode(self): - return 42 - -Les méthodes sont des attributs des instances de classes:: - - class MaClasse: - def ma_méthode(self): - return 42 - >>> ma_méthode() - Erreur - >>> mon_instance = MaClasse() - >>> mon_instance.ma_méthode() - 42 - - -self ----- - -`self` *prend la valeur de l'instance courante* quand la méthode est appelée.:: - - class MaClasse: - def affiche_attribut_x(self): - print(self.x) - - >>> mon_instance = MaClasse() - >>> mon_instance.x = 42 - >>> mon_instance.affiche_attribut_x() - 42 - -On peut aussi *créer* des attributs dans une méthode:: - - class MaClasse: - def crée_attribut_x(self): - self.x = 42 - def affiche_attribut_x(self): - print(self.x) - - >>> mon_instance = MaClasse() - >>> mon_instance.affiche_attribut_x() - # Erreur: `mon_instance` n'a pas d'attribut `x` - - >>> mon_instance.crée_attribut_x() - >>> mon_instance.affiche_attribut_x() - 42 - -Méthodes avec arguments ------------------------- - -.. code-block:: - - class MaClasse - def crée_attribut_x(self, valeur_de_x): - self.x = valeur_de_x - - def affiche_attribut_x(self); - print(self.x) - - >>> mon_instance = MaClasse() - >>> mon_instance.crée_attribut_x(42) - >>> mon_instance.affiche_attribut_x() - 42 - -Méthodes appelant d'autres méthodes ------------------------------------- - -.. code-block:: - - class MaClasse: - def méthode_1(self): - print("démarrage de la méthode 1") - print("la méthode 1 affiche bonjour") - print("bonjour") - print("fin de la méthode 1") - - - def méthode_2(self): - print("la méthode 2 appelle la méthode 1") - self.méthode_1() - print("fin de la méthode 2") - - - >>> mon_instance = MaClasse() - >>> mon_instance.méthode_2() - -.. code-block:: - - la méthode 2 appelle la méthode 1 - démarrage de la méthode 1 - la méthode 1 affiche bonjour - bonjour - fin de la méthode 1 - fin de la méthode 2 - -Constructeur sans arguments ---------------------------- - -Un constructeur en Python désigne la méthode nomée ``__init__``, -quand celle-ci existe. - -La méthode ``__init__`` est appelée automatiquement quand la -classe est instanciée:: - - class MaClasse: - def __init__(self): - self.x = 1 - self.y = 2 - - >>> mon_instance = MaClasse() - >>> mon_instance.x - 1 - >>> mon_instance.y - 2 - -Constructeur avec arguments ----------------------------- - -La méthode ``__init__`` peut avoir des arguments, -dans ce cas, ceux ci doivent être fournis -lors de l'instanciation:: - - class MaClasse: - def __init__(self, x, y): - self.x = x - self.y = y - - >>> mon_instance = MaClasse(3, 4) - >>> mon_instance.x - 3 - - >>> mon_instance.y - 4 diff --git a/cours/source/13-classes-02/03-composition.rst b/cours/source/13-classes-02/02-composition.rst similarity index 67% rename from cours/source/13-classes-02/03-composition.rst rename to cours/source/13-classes-02/02-composition.rst index e546d36..e811c4c 100644 --- a/cours/source/13-classes-02/03-composition.rst +++ b/cours/source/13-classes-02/02-composition.rst @@ -10,20 +10,26 @@ Une classe à l'intérieur d'une autre classe. Dépendances entre fonctions ----------------------------- -Exemple: on veut dessiner un sapin dans le terminal:: +Exemple :: - def main(): - largeur = demander_largeur() - dessine_sapin(largeur) + def calcule_x(): + ... + # du code ici - main() + def fait_un_truc_avec_x(x): + ... + # du code ici + x = calcule_x() + fait_un_truc_avec_x(x) -On voit que la fonction ``dessine_sapin()`` prend un argument ``largeur``, qui est retourné -par la fonction ``demander_largeur()``. -``dessine_sapin()`` doit donc être appelée *après* ``demander_largeur()``. On dit que ``dessine_sapin()`` -_dépend_ de ``demander_largeur()``. + +On voit que la fonction ``fait_un_truc_avec_x()`` prend un argument ``x``, qui est retourné +par la fonction ``calcule_x()``. + +``fait_un_truc_avec_x()`` doit donc être appelée *après* ``calcule_x()``. On dit que ``fait_un_truc_avec_x()`` +*dépend* de ``calcule_x()``. Dépendances entre classes ------------------------- @@ -39,8 +45,8 @@ Revoyons la classe Chat:: Comme le constructeur de la classe Chat prend un nom en argument, il est impossible de construire des chats sans nom:: - >>> chat = Chat() - TypeError: __init__() missing 1 required positional argument: 'nom' + chat = Chat() + # erreur: TypeError: __init__() missing 1 required positional argument: 'nom' De la même façon, si on veut que tous les enfants aient un chat (pourquoi pas, après tout), on peut avoir une classe Enfant, dont le constructeur prend une instance de chat en plus du prénom:: @@ -50,11 +56,11 @@ avoir une classe Enfant, dont le constructeur prend une instance de chat en plus self.prénom = prénom self.chat = chat - >>> alice = Enfant("Alice") - TypeError: __init__() missing 1 required positional argument: 'chat' + alice = Enfant("Alice") + # erreur: TypeError: __init__() missing 1 required positional argument: 'chat' - >>> boule_de_poils = Chat("Boule de Poils") - >>> alice = Enfant("Alice", boule_de_poils) + boule_de_poils = Chat("Boule de Poils") + alice = Enfant("Alice", boule_de_poils) # OK! Utilisation de la composition @@ -78,9 +84,9 @@ et ``ronronne()`` dans la classe chat:: self.ronronne() - >>> boule_de_poils = Chat("Boule de Poils") - >>> boule_de_poils.caresse() - Boule de Poils fait "prrrrr" + boule_de_poils = Chat("Boule de Poils") + boule_de_poils.caresse() + # affiche: Boule de Poils fait "prrrrr" Ensuite, on peut rajouter la méthode ``console()`` dans la classe Enfant, qui va: @@ -95,11 +101,11 @@ qui va: def console(self): self.chat.caresse() - >>> boule_de_poils = Chat("Boule de Poils") - >>> alice = Enfant("Alice", boule_de_poils) + boule_de_poils = Chat("Boule de Poils") + alice = Enfant("Alice", boule_de_poils) # Alice est triste, on la console - >>> alice.console() - Boule de Poils fait "prrrrr" + alice.console() + # affiche: Boule de Poils fait "prrrrr" # Alice est consolée :) On dit parfois qu'on a *délégué* l'implémentation de la méthode ``console()`` de la classe Enfant diff --git a/cours/source/13-classes-02/index.rst b/cours/source/13-classes-02/index.rst index 67d6b37..daeb2fa 100644 --- a/cours/source/13-classes-02/index.rst +++ b/cours/source/13-classes-02/index.rst @@ -4,6 +4,5 @@ Chapitre 13 - Classes (2ème partie) .. toctree:: :maxdepth: 1 - 01-rappels - 02-couplage - 03-composition + 01-couplage + 02-composition diff --git a/cours/source/14-bibliothèques-01/02-sys.path.rst b/cours/source/14-bibliothèques-01/02-sys.path.rst index c5cbd80..eed3d7d 100644 --- a/cours/source/14-bibliothèques-01/02-sys.path.rst +++ b/cours/source/14-bibliothèques-01/02-sys.path.rst @@ -4,7 +4,7 @@ sys.path En Python, il existe une variable ``path`` prédéfinie dans le module ``sys`` qui fonctionne de manière similaire à la variable d'environnement ``PATH``. -Si j'essaye de l'afficher sur ma machine, voici ce que j'obtiens: +Si j'essaye de l'afficher sur ma machine, voici ce que j'obtiens:: import sys print(sys.path) diff --git a/cours/source/15-fichiers-et-données-binaires/01-données-binaires.rst b/cours/source/15-fichiers-et-données-binaires/01-données-binaires.rst index e5545fe..2388718 100644 --- a/cours/source/15-fichiers-et-données-binaires/01-données-binaires.rst +++ b/cours/source/15-fichiers-et-données-binaires/01-données-binaires.rst @@ -147,6 +147,9 @@ On peut aussi interpréter des octets comme du texte - c'est la table ASCII .. image:: ../img/ascii-table.png +La table se lit ainsi: si on veut connaître la suite de 0 et de 1 qui correspond à `B`: on lit +les 3 premiers bits de haut en bas sur la colonne: `100`, puis les 4 bits sur la ligne: `0010`. +Du coup 'B' en s'écrit en 7 bits: `1000010`, soit 66 en décimal, et 42 en héxadécimal ASCII - remarques ----------------- @@ -155,20 +158,20 @@ ASCII - remarques * Le A est pour American * Ça sert à *envoyer* du texte sur des terminaux d'où les "caractères" non-imprimables dans la liste * Mais c'est une convention *très* utilisée -* Techniquement, on n'a besoin que de 7 bits, mais on préfère envoyer des octets +* Un message de 4 lettres ASCII sera souvent envoyé comme 4 octets (même si seulement 7 bits sont nécessaires) Utiliser ASCII en Python ------------------------ Avec ``chr`` et ``ord``:: - x = chr(98) + x = chr(0x42) print(x) - # affiche: b + # affiche: B - x = ord('a') + x = ord('B') print(x) - # affiche: 97 + # affiche: 66 Affichage des bytearrays en Python ---------------------------------- diff --git a/cours/source/index.rst b/cours/source/index.rst index a27a7b8..42451be 100644 --- a/cours/source/index.rst +++ b/cours/source/index.rst @@ -20,7 +20,7 @@ remarques. 01-introduction/index 02-premiers-pas/index 03-variables-et-types/index - 04-code-source/index + 04-booléens/index 05-flot-de-controle/index 06-fonctions/index 07-listes/index