|
|
|
@ -0,0 +1,203 @@
|
|
|
|
|
# Configurer l'espace de travail
|
|
|
|
|
|
|
|
|
|
## Installer python
|
|
|
|
|
|
|
|
|
|
Python est peut-être déjà installé sur votre système, mais il faut vérifier la version:
|
|
|
|
|
|
|
|
|
|
```
|
|
|
|
|
user@host:~$ python --version
|
|
|
|
|
Python 3.7.3
|
|
|
|
|
```
|
|
|
|
|
|
|
|
|
|
et la liste des versions disponibles:
|
|
|
|
|
|
|
|
|
|
```
|
|
|
|
|
user@host:~$ update-alternatives --list python
|
|
|
|
|
/usr/bin/python2
|
|
|
|
|
/usr/bin/python3
|
|
|
|
|
```
|
|
|
|
|
|
|
|
|
|
Pour installer la version qui vous manque:
|
|
|
|
|
```
|
|
|
|
|
sudo apt install python2
|
|
|
|
|
# OU
|
|
|
|
|
sudo apt install python3
|
|
|
|
|
```
|
|
|
|
|
|
|
|
|
|
Nous avons besoin du numéro de version pour python2 et python3:
|
|
|
|
|
```
|
|
|
|
|
user@host:~$ ls -l /usr/bin/python{2,3}
|
|
|
|
|
lrwxrwxrwx 1 root root 9 mars 4 2019 /usr/bin/python2 -> python2.7
|
|
|
|
|
lrwxrwxrwx 1 root root 9 mars 26 2019 /usr/bin/python3 -> python3.7
|
|
|
|
|
```
|
|
|
|
|
|
|
|
|
|
Nous allons donner la priorité 1 à python2 et la priorité 2 à python3:
|
|
|
|
|
|
|
|
|
|
```
|
|
|
|
|
sudo update-alternatives --install /usr/bin/python python /usr/bin/python3.7 2
|
|
|
|
|
sudo update-alternatives --install /usr/bin/python python /usr/bin/python2.7 1
|
|
|
|
|
```
|
|
|
|
|
|
|
|
|
|
---
|
|
|
|
|
|
|
|
|
|
## Installer pip
|
|
|
|
|
|
|
|
|
|
pip (Package installer for python or "Pip Installs Packages") est un outil très utile pour gérer les dépendances dans un projet python.
|
|
|
|
|
|
|
|
|
|
Là aussi, il y a pip pou python2 et pip pour python3, mais Debian utilisera la version correpondante à la version de python définie avec `update-alternatives`.
|
|
|
|
|
|
|
|
|
|
```
|
|
|
|
|
user@host:~$ sudo apt install python3-pip python-pip
|
|
|
|
|
user@host:~$ pip --version
|
|
|
|
|
pip 18.1 from /usr/lib/python3/dist-packages/pip (python 3.7)
|
|
|
|
|
```
|
|
|
|
|
|
|
|
|
|
---
|
|
|
|
|
|
|
|
|
|
## Utiliser la console python
|
|
|
|
|
|
|
|
|
|
Pour découvrir python, rien de plus simple, on saisit la commande `python` dans le terminal:
|
|
|
|
|
|
|
|
|
|
```
|
|
|
|
|
user@host:~$ python
|
|
|
|
|
Python 3.7.3 (default, Dec 20 2019, 18:57:59)
|
|
|
|
|
[GCC 8.3.0] on linux
|
|
|
|
|
Type "help", "copyright", "credits" or "license" for more information.
|
|
|
|
|
>>>
|
|
|
|
|
```
|
|
|
|
|
Les trois chevrons `>>>` vous indiquent que vous êtes dans la console python.
|
|
|
|
|
Faites ++ctrl+d++ pour en sortir.
|
|
|
|
|
|
|
|
|
|
Vous pouvez déclarer une variable, la transformer et l'afficher:
|
|
|
|
|
|
|
|
|
|
```
|
|
|
|
|
>>> MA_VARIABLE = " ceci est le contenu de ma variable "
|
|
|
|
|
>>>
|
|
|
|
|
>>> print(MA_VARIABLE)
|
|
|
|
|
ceci est le contenu de ma variable
|
|
|
|
|
>>>
|
|
|
|
|
>>> VAR_2 = MA_VARIABLE + " et celle-ci est plus longue"
|
|
|
|
|
>>>
|
|
|
|
|
>>> print(VAR_2)
|
|
|
|
|
ceci est le contenu de ma variable et celle-ci est plus longue
|
|
|
|
|
```
|
|
|
|
|
|
|
|
|
|
---
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
## Commencer un projet
|
|
|
|
|
|
|
|
|
|
On démarre un projet simplement en créant un dossier, dans lequel (par convention), on crée le fichier `main.py`
|
|
|
|
|
```
|
|
|
|
|
user@host:~$ mkdir mon_projet && cd mon_projet && touch main.py
|
|
|
|
|
```
|
|
|
|
|
|
|
|
|
|
Ce fichier main.py contiendra les instructions principales du programme, et pourra appeler d'autres fichiers python.
|
|
|
|
|
|
|
|
|
|
On met un **shebang** en 1ère ligne pour indiquer la version de python:
|
|
|
|
|
```
|
|
|
|
|
#!/usr/bin/env python3
|
|
|
|
|
|
|
|
|
|
VAR_1 = " ce serpent "
|
|
|
|
|
print(VAR_2)
|
|
|
|
|
VAR_2 = VAR_1 + " est dangereux"
|
|
|
|
|
print(VAR_2)
|
|
|
|
|
```
|
|
|
|
|
|
|
|
|
|
On peut simplement exécuter ce script avec `python poi.py` ou l'exécuter en mode **interactif** (-i) pour continuer à manipuler les variables et les fonctions du programme:
|
|
|
|
|
|
|
|
|
|
```
|
|
|
|
|
user@host:~$ python -i poi.py
|
|
|
|
|
ce serpent
|
|
|
|
|
ce serpent est dangereux
|
|
|
|
|
>>>
|
|
|
|
|
>>> type(VAR_2)
|
|
|
|
|
<class 'str'>
|
|
|
|
|
```
|
|
|
|
|
|
|
|
|
|
---
|
|
|
|
|
|
|
|
|
|
## Les types de variables dans python
|
|
|
|
|
|
|
|
|
|
### Les chaînes de caractères
|
|
|
|
|
|
|
|
|
|
Les variables que nous avons utilisées sont du type `str` ou `string`, c'est à-dire une **chaîne de caractères**.
|
|
|
|
|
On les déclare entre guillemets:
|
|
|
|
|
|
|
|
|
|
```
|
|
|
|
|
>>> VAR_A = " some random string, with 6 words"
|
|
|
|
|
>>> type(VAR_A)
|
|
|
|
|
<class 'str'>
|
|
|
|
|
```
|
|
|
|
|
|
|
|
|
|
### Autres variables simples
|
|
|
|
|
|
|
|
|
|
Il y a d'autre variables simples:
|
|
|
|
|
|
|
|
|
|
```
|
|
|
|
|
>>> VAR_B=True
|
|
|
|
|
>>> type(VAR_B)
|
|
|
|
|
<class 'bool'> # VAR_B est un `boolean`, une valeur booléenne, \
|
|
|
|
|
# qui ne peut être que `True` ou `False`
|
|
|
|
|
|
|
|
|
|
>>> VAR_C = 10
|
|
|
|
|
>>> type(VAR_C)
|
|
|
|
|
<class 'int'> # VAR_C est un `integer`, un nombre entier
|
|
|
|
|
>>>
|
|
|
|
|
>>>
|
|
|
|
|
>>> VAR_D=3.141592
|
|
|
|
|
>>> type(VAR_E)
|
|
|
|
|
<class 'float'> # VAR_E est un `float`, un nombre décimal
|
|
|
|
|
```
|
|
|
|
|
|
|
|
|
|
### Les listes et les tuples
|
|
|
|
|
|
|
|
|
|
Il y a des variables qui permettent de stocker plusieurs valeurs: les **listes** ( `list`), les **tuples**, et les **dictionnaires** (`dictionary`).
|
|
|
|
|
|
|
|
|
|
Les listes sont déclarées entre crochets ( `brackets [ ] `) et contiennent plusieurs éléments (int, str, list...) séparés par une virgule.
|
|
|
|
|
|
|
|
|
|
```
|
|
|
|
|
>>> VAR_F = ["object",150,"proc","package",2000]
|
|
|
|
|
>>> type(VAR_F)
|
|
|
|
|
<class 'list'>
|
|
|
|
|
```
|
|
|
|
|
|
|
|
|
|
On peut modifier les éléments de la liste en les indexant entre crochets:
|
|
|
|
|
|
|
|
|
|
```
|
|
|
|
|
>>> print(VAR_F[0:2])
|
|
|
|
|
['object', 150]
|
|
|
|
|
>>>
|
|
|
|
|
>>> VAR_F[1] = 250
|
|
|
|
|
>>> print(VAR_F[0:2])
|
|
|
|
|
['object', 250]
|
|
|
|
|
```
|
|
|
|
|
|
|
|
|
|
Les **tuples** sont des listes qu'on ne peut pas modifier. On les appelle entre parenthèses:
|
|
|
|
|
```
|
|
|
|
|
>>> VAR_F = ( "elem1", "elem2", "elem3")
|
|
|
|
|
>>>
|
|
|
|
|
>>> print(type(VAR_F))
|
|
|
|
|
<class 'tuple'>
|
|
|
|
|
```
|
|
|
|
|
|
|
|
|
|
### Les dictionnaires
|
|
|
|
|
|
|
|
|
|
Les dictionnaires sont des séries de paires clé-valeur, déclarées entre accolades ( `curly brackets { } `)
|
|
|
|
|
|
|
|
|
|
```
|
|
|
|
|
>>> VAR_G = { "name": "python", "version_number": 3.8, "use": "coding"}
|
|
|
|
|
>>> type(VAR_G)
|
|
|
|
|
<class 'dict'>
|
|
|
|
|
```
|
|
|
|
|
|
|
|
|
|
Comme pour les listes, on peut accéder aux valeurs et les modifier en indexant avec les crochets:
|
|
|
|
|
```
|
|
|
|
|
>>> VAR_G["use"] = VAR_G["use"] + " and playing"
|
|
|
|
|
>>>
|
|
|
|
|
>>> print(VAR_G)
|
|
|
|
|
{'name': 'python', 'version': '3.8', 'version_number': 3.8, 'use': 'coding and playing'}
|
|
|
|
|
```
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|