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