Il faut parler de l'intépréteur interactif bien après - au début, il n'apporte que de la confusionmaster
| @@ -0,0 +1,72 @@ | |||
| Installation | |||
| ============ | |||
| Pour suivre ce cours, il vous faudra installer deux composants | |||
| essentiels: | |||
| * L'interpréteur Python | |||
| * Un éditeur de texte | |||
| Installation de Python | |||
| ---------------------- | |||
| Linux | |||
| +++++ | |||
| Il y a toutes les chances que Python soit déjà installé sur votre | |||
| distribution. Pour vous en assurer, tapez: | |||
| .. code-block:: console | |||
| python3 --version | |||
| Sinon, installez le paquet correspondant à Python3 (quelque chose comme | |||
| ``sudo apt install python3``` | |||
| macOS | |||
| ++++++ | |||
| Python3 est disponible dans `homebrew <https://brew.sh/>`_ | |||
| .. code-block:: console | |||
| brew install python | |||
| Windows | |||
| +++++++ | |||
| Python3 est disponible dans Microsoft store. | |||
| Sinon, vous pouvez aussi télécharger l'installeur depuis https://python.org | |||
| Veillez à cocher la case "Ajouter Python au PATH" | |||
| Installation d'un éditeur de texte | |||
| ---------------------------------- | |||
| Je vous conseille pour commencer d'utiliser un éditeur | |||
| de texte basique. Vous n'avez pas besoin d'un IDE, | |||
| surtout si vous débutez | |||
| * Linux; ``gedit``, ``kate``, ... | |||
| * macOS: ``CotEditor`` | |||
| * Windows: ``Notepad++`` | |||
| J'insiste sur **simple**. Inutile d'installer un IDE pour le moment. | |||
| Configuration de l'éditeur de texte | |||
| ------------------------------------ | |||
| Prenez le tempe de configurer votre éditeur | |||
| de texte de la façon suivante: | |||
| * Police de caractères à chasse fixe | |||
| * Indentation de *4 espaces* | |||
| * Remplacer les tabulations par des espaces | |||
| * Activer la coloration syntaxique | |||
| Cela vous évitera des soucis plus tard. | |||
| @@ -1,5 +1,5 @@ | |||
| L'interpréteur interactif | |||
| ========================= | |||
| Code source | |||
| =========== | |||
| Installation | |||
| ------------ | |||
| @@ -0,0 +1,85 @@ | |||
| Code source | |||
| =========== | |||
| Définition | |||
| ----------------------- | |||
| Aussi appelé: "code source", ou "source". | |||
| L'essence du logiciel libre :) | |||
| Notre premier fichier source | |||
| ----------------------------- | |||
| Insérez le code suivant dans votre éditeur de texte | |||
| .. code-block:: python | |||
| print("Bonjour, monde") | |||
| # affiche: Bnojour, monde | |||
| Oui, juste ces deux lignes. | |||
| Sauvegardez dans un fichier `bonjour.py` dans `Documents/e2l/python` par exemple | |||
| Lancer du code en ligne de commande | |||
| ----------------------------------- | |||
| Lancez une invite de commandes et tapez quelque chose comme: | |||
| .. code-block:: console | |||
| cd Documents/e2l/python/ | |||
| python3 bonjour.py | |||
| Si tout se passe bien, vous devrez voir s'afficher ceci: | |||
| .. code-block:: text | |||
| Bonjour, monde | |||
| print() | |||
| ------- | |||
| Revenons sur ce qu'il s'est passé : nous avions le mot `print` avec des parenthèses | |||
| et quelque chose à l'intérieur des parenthèses, et ceci a provoqué l'affichage | |||
| du contenu des parenthèses dans le terminal. | |||
| C'est *la* principale façon d'intéragir avec du code Python : on peut demander | |||
| à l'interpréteur d'afficher n'importe quel valeur. | |||
| Commentaires | |||
| ------------ | |||
| La deuxième ligne, quant à elle, a été complètement ignorée par l'interpréteur parce | |||
| qu'elle commençait par un ``#``. Il s'agit d'un *commentaire*, et il sert principalement | |||
| aux humains qui lisent le code. | |||
| Note à propos des examples | |||
| --------------------------- | |||
| La plupart des examples de ce cours contiendront un ou plusieurs appels à | |||
| `print` afin d'afficher les opérations que l'interpréteur a effectué. | |||
| Pour lire ce cours de manière efficace, il est conseillé de lancer les | |||
| examples de code sur votre machine, et de vérifier si ce qui est | |||
| affiché sur votre machine correspond à ce qui est écrit dans le cours. | |||
| Il est aussi recommandé de _ne pas_ copier/coller le code. | |||
| À la place, prenez le temps de retaper le code dans votre éditeur. | |||
| Plusieurs raisons à cela: | |||
| * Recopier le code vous aidera à vous souvenir de la syntaxe | |||
| * Si vous faites des erreurs, Python vous préviendra et vous | |||
| découvrirer les erreurs courantes | |||
| * Il est possible que des erreurs subsistent dans ce cours, | |||
| et procéder ainsi nous permettra de les corriger. | |||
| @@ -1,62 +0,0 @@ | |||
| Maths simples | |||
| ============= | |||
| Opérations avec des entiers | |||
| --------------------------- | |||
| .. code-block:: python | |||
| >>> 1 | |||
| 1 | |||
| >>> 2 | |||
| 2 | |||
| >>> 1 + 2 | |||
| 3 | |||
| >>> 2 * 3 | |||
| 6 | |||
| Opérations avec des flottants | |||
| ----------------------------- | |||
| C'est le ``.`` qui fait le flottant | |||
| .. code-block:: python | |||
| >>> 0.5 | |||
| 0.5 | |||
| >>> 0.5 + 0.2 | |||
| 0.7 | |||
| >>> 10 / 3 | |||
| 3.3333333333333335 | |||
| *Note: les flottants sont imprécis* | |||
| Division entières et modulo | |||
| --------------------------- | |||
| .. code-block:: python | |||
| >>> 14 // 3 | |||
| 4 | |||
| >>> 14 % 3 | |||
| 2 | |||
| *Le `%` n'a rien à voir avec un pourcentage!* | |||
| Priorité des opérations | |||
| ------------------------ | |||
| .. code-block:: python | |||
| >>> 1 + 2 * 3 | |||
| 7 | |||
| >>> (1 + 2) * 3 | |||
| 9 | |||
| *Les parenthèses permettent de grouper les expressions* | |||
| @@ -0,0 +1,76 @@ | |||
| Maths simples | |||
| ============= | |||
| Opérations avec des entiers | |||
| --------------------------- | |||
| On peut utiliser ``+, *, -`` avec des entiers: | |||
| .. code-block:: python | |||
| print(1 + 2) | |||
| # affiche: 3 | |||
| print(6 - 3) | |||
| # affiche: 4 | |||
| print(2 * 4) # une étoile pour la multiplication | |||
| # affiche: 8 | |||
| Opérations avec des flottants | |||
| ----------------------------- | |||
| C'est le ``.`` qui fait le flottant | |||
| .. code-block:: python | |||
| print(0.5 + 0.2) | |||
| # affiche: 0.7 | |||
| print(10 / 3) | |||
| 3.3333333333333335 | |||
| .. note:: | |||
| Les flottants sont imprécis, | |||
| ce qui explique le `5` à la fin de l'affichage | |||
| de la division de 10 par 3 | |||
| Division entières et modulo | |||
| --------------------------- | |||
| 14 divisé par 3 font 4 avec un reste de 2. | |||
| On peut récupérer le quotient avec `//` et | |||
| le reste avec ``%``. | |||
| .. code-block:: python | |||
| print(14 // 3) | |||
| # affiche: 4 | |||
| print(14 % 3) | |||
| # affiche: 2 | |||
| .. warning:: | |||
| Le ``%`` n'a rien à voir avec un pourcentage! | |||
| Priorité des opérations | |||
| ------------------------ | |||
| Comme en maths, la multiplication est prioritaire | |||
| sur les autres opérations:: | |||
| print(1 + 2 * 3) | |||
| # affiche: 7 | |||
| et on peut utiliser des parenthèses pour grouper les opérations:: | |||
| print((1 + 2) * 3) | |||
| # affiche: 9 | |||
| @@ -5,5 +5,6 @@ Chapitre 2 - Premiers pas | |||
| :maxdepth: 1 | |||
| 01-bases-ligne-de-commandes | |||
| 02-interpréteur.rst | |||
| 03-maths-simples.rst | |||
| 02-installation | |||
| 03-code-source | |||
| 04-maths-simples.rst | |||
| @@ -1,45 +1,46 @@ | |||
| Variables | |||
| ========= | |||
| .. code-block:: python | |||
| 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*. | |||
| >>> a = 2 | |||
| >>> a | |||
| 2 | |||
| >>> b = 3 | |||
| >>> a + b | |||
| 5 | |||
| Ensuite, on peut utiliser la variable à la place de sa valeur: | |||
| à chaque fois que l'interpréteur essaye d'exécuter du code, | |||
| il commence par remplacer les variables par leurs valeurs:: | |||
| * On peut nommer des valeurs | |||
| * On peut afficher la valeur d'une variable entrant son nom dans le REPL | |||
| a = 2 | |||
| print(a) | |||
| # affiche: 2 | |||
| b = 3 | |||
| print(a + b) | |||
| # affiche: 5 | |||
| .. code-block:: python | |||
| >>> a = 2 | |||
| >>> a | |||
| 2 | |||
| >>> a = 3 | |||
| >>> a | |||
| 3 | |||
| On peut aussi *changer* la valeur d'une variable en l'assignant | |||
| à une nouvelle valeur:: | |||
| * On peut changer la valeur d'une variable (d'où son nom) | |||
| a = 2 | |||
| print(a) | |||
| # affiche: 2 | |||
| * Quand Python essaie d'exécuter du code, il commence par remplacer les | |||
| variables par leurs valeurs | |||
| a = 3 | |||
| print(a) | |||
| # affiche: 3 | |||
| Nom des variables | |||
| ----------------- | |||
| Préférez des noms longs et descriptifs | |||
| Ci-dessus j'ai utilisé des noms de variables à une lettre, comme en maths, | |||
| mais il est préférable d'avoir des noms longs et descriptifs | |||
| Toujours en minuscules | |||
| Aussi, la convention est de: | |||
| Séparez les "mots" par des tirets bas (underscore) | |||
| .. code-block:: python | |||
| * Les écrire en minuscules | |||
| * De séparer les mots par des tirest bas (*underscore*):: | |||
| score = 42 | |||
| age_moyen = 22 | |||
| @@ -1,57 +1,55 @@ | |||
| Chaînes de caractères | |||
| ====================== | |||
| Aussi appelées "string". | |||
| Les chaînes de caractères, aussi appelées "string", permettent | |||
| de représenter du texte. On a utilisé une string pour afficher | |||
| "bonjour monde" dans le chapitre précédent. | |||
| On écrit toujours les strings entre guillemets. | |||
| Avec des simple quotes (``'``) | |||
| soit avec des doubles guillemets:: | |||
| .. code-block:: python | |||
| >>> 'Bonjour monde!' | |||
| 'Bonjour monde!' | |||
| print("Bonjour monde!") | |||
| # affiche: Bonjour monde! | |||
| Marche aussi avec des double quotes (`"`) | |||
| .. code-block:: python | |||
| soit avec des guillemets simples:: | |||
| >>> "Bonjour, monde!" | |||
| 'Bonjour monde' | |||
| print("Bonjour monde!") | |||
| # affiche: Bonjour monde! | |||
| Double et simple quotes | |||
| ----------------------- | |||
| On peut mettre des simples quotes dans des double quotes et vice-versa. | |||
| On peut mettre des simples quotes dans des double quotes et vice-versa:: | |||
| .. code-block:: python | |||
| >>> "Il a dit: 'bonjour' ce matin." | |||
| "Il a dit: 'bonjour' ce matin." | |||
| print("Il a dit: 'bonjour' ce matin.") | |||
| # affiche: Il a dit: 'bonjour' ce matin. | |||
| >>> 'Il a dit: "bonjour" ce matin' | |||
| 'Il a dit: "bonjour" ce matin!' | |||
| print('Il a dit: "bonjour" ce matin') | |||
| # affiche: Il a dit: "bonjour" ce matin | |||
| Échappement | |||
| ----------- | |||
| Avec la barre oblique inversée "backslash" | |||
| On peut aussi *échapper* des caractères avec la | |||
| barre oblique inversée ``\\`` - backslash. | |||
| .. code-block:: python | |||
| >>> 'Il a dit: "bonjour". C\'est sympa!' | |||
| 'Il a dit: "bonjour". C\'est sympa!' | |||
| print('Il a dit: "bonjour". C\'est sympa!') | |||
| # affiche: Il a dit: "bonjour". C'est sympa! | |||
| Concaténation | |||
| ------------- | |||
| On peut construire de longues chaînes de caractères en | |||
| en concaténatant de plus petites:: | |||
| .. code-block:: python | |||
| >>> name = "John" | |||
| >>> message = "Bonjour " + name + " !" | |||
| >>> message | |||
| "Bonjour John !" | |||
| name = "John" | |||
| message = "Bonjour " + name + " !" | |||
| print(message) | |||
| # affiche: Bonjour John ! | |||
| @@ -1,36 +1,65 @@ | |||
| Types | |||
| ===== | |||
| .. code-block:: python | |||
| On a vu qu'on pouvait utiliser ``+`` **à la fois** pour additionner des nombres | |||
| ou concaténer des strings. Mais on ne peut pas utiliser ``+`` avec une string | |||
| d'un côté et un entier de l'autre:: | |||
| >>> a = 42 | |||
| >>> message = "La réponse est: " + a | |||
| TypeError: can only concatenate str (not "int") to str | |||
| a = 42 | |||
| b = 4 | |||
| a + b # ok | |||
| *Notre premier message d'erreur !* | |||
| salutation = "bonjour, " | |||
| prénom = "Bob" | |||
| salutation + prénom # ok | |||
| message = "La réponse est " + a | |||
| # affiche: | |||
| # TypeError: can only concatenate str (not "int") to str | |||
| Ceci est notre premier message d'erreur: si l'interpréteur est incapable | |||
| d'éxécuter une instruction, il affiche un message d'erreur est s'interrompt | |||
| immédiatement. | |||
| On ne mélange pas les torchons et les serviettes! | |||
| Conversions | |||
| ----------- | |||
| Pour résoudre le problème ci-dessus, il faut effectuer une *conversion de types:* | |||
| Entier vers string | |||
| ++++++++++++++++++ | |||
| .. code-block:: python | |||
| On peut convertir un entier en string en utilisant le mot ``str`` et des parenthèses | |||
| autour de la variable ou de la valeur:: | |||
| >>> a = 42 | |||
| >>> message = "La réponse est: " + str(a) | |||
| >>> message | |||
| 'La réponse est 42' | |||
| message = "La réponse est: " + str(42) | |||
| print(message) | |||
| # affiche: La réponse est 42 | |||
| String vers entier | |||
| ++++++++++++++++++ | |||
| réponse = 42 | |||
| message = "La réponse est: " + str(42) | |||
| print(message) | |||
| # affiche: La réponse est 42 | |||
| String vers nombres | |||
| +++++++++++++++++++ | |||
| Inversement, on peut convertir un string en entrier en utilisant | |||
| le mot ``int`` et des parenthèses:: | |||
| quarante_deux_en_chiffres = "42" | |||
| réponse = int(quarante_deux_en_chiffres) | |||
| print(réponse) | |||
| # affiche: 42 | |||
| Pour convertir une string en flottant, on peut utiliser ``float()``:: | |||
| .. code-block:: python | |||
| taille_sur_le_passeport = "1.62" | |||
| taille_en_mètres = float(taille_sur_le_passeport) | |||
| >>> answer = int("42") | |||
| >>> answer | |||
| 42 | |||
| Notez les parenthèses autour des valeurs. | |||