Vous appréciez mon travail ?
Je serais ravi de prendre un café !

Vous prenez du plaisir à lire mes articles ? Vous apprenez de nouvelles choses ? Je serais ravis que vous supportiez mon travail avec une petite participation

1 café Merci, vous financez ma dose quotidienne de théïne (oui, en vrai je ne bois pas de café).
5 cafés Génial, ça couvre mes frais de serveur mensuels.
10 cafés Fantastique, avec ça je peux investir dans du matériel et approfondir mes connaissances.
BazinGa's - Tips & tuto IT

Python 101 – Démarrez avec Python

Voici un tutoriel qui vous permettra de démarrer facilement avec Python.

Le principe de cet article est de balayer de nombreux éléments mais très rapidement afin d’avoir quelques clés pour démarrer ou simplement pour se remémorrer rapidement certains concepts. N’hésitez pas à approfondir les différents items avec les très nombreuses ressources que l’on peut trouver en ligne.

Introduction

Qu’est-ce que Python ?

Python est un langage de programmation inventé en 1989 (première version en 1991) par Guido Van Rossum et nommé en l’honneur des Monty Python.

Ses caractéristiques en font un langage :

  • Multiplateforme (Windows, Mac OS, Linux)
  • Interprété
  • Orienté objet

Il s’agit d’un langage sous licence libre qui est largement utilisé (1er langage selon l’index TIOBE (2023)).

Fonctionnement

Il s’agit d’un langage interprété, cela signifie que le code écrit est compilé puis traité par la machine lors de l’exécution de celui-ci à la différence d’un langage comme le C qui doit être compilé manuellement avant de pouvoir être exécuté.

La compilation est une étape qui transforme le code Python en instructions spécifiques, le bytecode, qui peuvent être traitées par la machine.

Ainsi, le code Python est interprété par le programme Python.

Pour faciliter les développeurs de nombreux modules permettent d’ajouter des fonctions supplémentaires.

Certains sont intégrés nativement :

  • Os
  • Random
  • Gzip
  • Csv
  • Time

D’autres doivent être installés, plusieurs méthodes existent :

  • Via PIP, gestionnaire de module livré avec Python.
  • Manuellement
  • Via un gestionnaire tiers comme Conda.

Installation

Architecture

Plusieurs méthodes d’installation sont possibles :

Il est tout à fait possible d’avoir plusieurs installations en parallèle, dans ce cas il convient de faire attention :

  • Au choix de l’interpréteur utilisé.
  • A l’emplacement des modules installés.

Notez qu’il existe des site pour tester son code comme :

Quelques pro-tips

Décrire l’architecture locale dans un fichier, les multi installations sont courantes avec différents projets et il devient vite difficile de se rappeler de ce qui est présent sur votre machine.

Ajouter l’interpréteur favoris dans les variables d’environnement, cela permet d’éviter de préfixer python.exe en ligne de commande.

Conda permet de gérer des paquets non disponibles dans PIP (notamment GDAL), c’est intéressant pour des traitements locaux mais peu adapté pour un script à déployer sur une autre machine (car il faudrait alors y installer Conda également).

Si vous souhaitez vous lancer dans la data-science, le deep-learning et/ou l’IA, utilisez Conda. La plupart des modules en lien avec ces thématiques y sont disponibles.

Attention à l’emplacement des modules lors de leur installation :

  • Installation en mode administrateur : installation pour toute la machine.
  • Installation avec l’utilisateur local : installation pour l’utilisateur actif.

Module

L’installation des modules est dépendante de l’architecture, il convient donc de faire attention à :

  • L’emplacement du Python à utiliser
  • L’emplacement de stockage des modules (commande en administrateur ou en utilisateur)

L’installation d’un module Python se fait de l’une des deux façons suivantes :

python –m pip install mon_module
pip install mon_module

Si vous utilisez Conda, vous pouvez suivre la procédure suivante :

conda install mon_module

Il est également possible d’installer un module via PIP avec Conda mais uniquement pour des modules non présents dans Conda :

conda activate 
pip install mon_module

Environnement

Chaque projet a des besoins spécifiques, pour cela il est possible de créer un environnement dédié, avec les modules spécifique à cet environnement.

Un environnement est un contexte d’exécution isolé, il possède :

  • Un interpréteur Python spécifique.
    Il s’agit d’un lien symbolique vers une installation de Python sur la machine.
  • Une liste de module spécifique.
    Les modules sont installés dans l’environnement uniquement.
  • Il est matérialisé par un répertoire contenant tout le nécessaire.
    Souvent créé dans le même répertoire que les scripts du projet.
    Même s’il est possible de nommé un environnement, ils sont souvent nommé « env ».

Un environnement peut être associé à une liste de module requis stocké dans un fichier : requirements.txt

Cela permet de réinstaller rapidement tous le modules si besoin.

Plusieurs outils permettent de créer des environnements :

  • venv : module intégré à Python.
  • Virtualenv : module très populaire avec beaucoup de fonctionnalités.
  • Conda

Voici quelques éléments pour créer des environnements :

Venv

Créer un environnement :

python –m venv C:\chemin\nom_environnement\venv

Activer l’environnement :

C:\chemin\nom_environnement\Scripts\activate.bat

Installer un module dans l’environnement (l’environnement doit être activé) :

pip install mon_module

Installer les modules requis :

pip install -r requirements.txt

Générer la liste des modules requis :

pip freeze > requirements.txt

Désactiver l’environnement :

deactivate

Un environnement se matérialise par un répertoire contenant tout le nécessaire, pour le supprimer il suffit de supprimer ce répertoire.

Virtualenv

Créer un environnement :

pip install virtualenv
virtualenv C:\chemin\nom_environnement\venv

Activer l’environnement :

C:\chemin\nom_environnement\Scripts\activate.bat

Installer un module dans l’environnement (l’environnement doit être activé) :

pip install mon_module

Installer les modules requis :

pip install -r requirements.txt

Générer la liste des modules requis :

pip freeze > requirements.txt

Désactiver l’environnement :

deactivate

Un environnement se matérialise par un répertoire contenant tout le nécessaire, pour le supprimer il suffit de supprimer ce répertoire.

Conda

Créer un environnement :

  • Dans les environnement Conda :
conda create --name mon_environnement
  • Dans un répertoire spécifique :
conda create --prefix C:\chemin\mon_environnement

Spécifier la version de Python à utiliser :

conda create --prefix C:\chemin\mon_environnement python=3.10

Créer un environnement depuis un fichier YAML (le fichier YAML permet de décrire le contenu de l’environnement) :

conda create --prefix C:\chemin\mon_environnement --file environment.yml

Voici un exemple de contenu décrivant la version de Python à utiliser ainsi que différents modules à installer dont un via PIP :

name: mon_environnement

dependencies:
 - python=3.9
 - matplotlib
 - pip
 - pip:
   - psycopg==3.*

Activer l’environnement :

  • Dans les environnement Conda :
conda activate mon_environnement
  • Dans un répertoire spécifique :
conda activate C:\chemin\mon_environnement

Installer un module (l’environnement doit être activé)

  • Module Conda :
conda install mon_module
  • Module PIP (seulement si le paquet n’existe pas sur Conda) :
pip install mon_module

Désactiver l’environnement :

conda deactivate

Supprimer un environnement :

  • Dans les environnement Conda :
conda remove --name myenv --all
  • Dans un répertoire spécifique :
conda remove --prefix C:\chemin\mon_environnement --all

Prise en main

Premières lignes de code

Démarrage

Lancer l’interpréteur :

>python
Python 3.11.2 (tags/v3.11.2:878ead1, Feb  7 2023, 16:38:35) [MSC v.1934 64 bit (AMD64)] on win32
Type "help", "copyright", "credits" or "license" for more information.
>>>

L’interpréteur est démarré, on le voit au 3 chevron en début de ligne. Il attend les instructions à exécuter.

Voici un premier code à exécuter :

>>> print("hello world")

Appuyez sur « entrée », vous devriez avoir le retour suivant :

hello world

Pour quitter l’interpréteur utilisez exit().

Variables

Créer une variable et lui attribuer une valeur :

>>> x = 14

Le nommage :

  • N’importe quels caractère de a à z, de A à Z, de 0 à 9 et souligné (« _ »)
  • Ne débute pas par un chiffre
  • Sensible à la casse
  • Certain mots sont réservés par python

Afficher la variable :

>>> x
14
>>> print(x)
14

Le typage

  • Définition manuelle ou automatiquement lors de l’assignation
  • Les fonctions str(), int(), float()… permettent de changer le type
  • La fonction type() permet de connaitre le type d’une variable
>>> type(x)
<class 'int'> 

Attention aux erreurs de type :

>>> print("Ma valeur : " + x)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: can only concatenate str (not "int") to str

>>> print("Ma valeur : " + str(x))
Ma valeur : 14

Quelques opérations

Voici quelques opérations possibles :

La notation scientifique avec e : 2e3 = 2×103 = 2000,0

>>> 2+2
4

L’utilisation d’opérateurs :

  • Les classiques : +, -, *, /
  • Les plus sérieux : **, //, %
>>> 8//4
2

>>> 8%4
0

Les opérateurs combinés sont disponibles pour assigner directement le résultat à une variable : +=, -=, *=, /=

>>> x += 4
>>> x
18

Concaténation de deux chaines de texte avec se fait avec + et la multiplication d’une chaine de texte avec *

>>> 'AB_'*3
'AB_AB_AB_'

Programmation

Qu’est-ce qu’un programme

Un programme est simplement un fichier dans lequel des instructions sont détaillées.

Le fichier est en .py et est interprété par python.exe.

Créez un fichier exo.py, et ajoutez le code suivant :

x = 14
Print(x)

Exécutez le fichier dans votre console en lançant l’interpréteur python.exe et en lui indiquant le chemin vers votre fichier. En retour vous devriez obtenir la valeur 14.

python "C:\chemin_vers\exo.py"
14

A partir de maintenant les commandes fournies devront être ajoutées au fichier exo.py.

Il faudra lancer le fichier pour tester les commandes fournies.

Quelques règles

Il ne pas hésiter à commenter son code ; Pour soi-même mais également pour les autres…

Ce n’est pas parce que c’était difficile à programmer que ça doit être dur à comprendre

Arthur Bazin

Code is read much more often than it is written

G. Van Rossum

Les commentaires sur 1 ligne débutent avec #.

Les commentaires multi-ligne débutent avec """.

# Voici un commentaire sur une ligne
x = 14 # Voici un commentaire en bout de ligne

""" 
Voici un commentaire
Multi-ligne
"""

Les blocs d’instruction sont indentés.

En général on utilise 1 tabulation ou 4 espaces mais c’est le programmeur qui choisit. En revanche, il faut toujours le faire de la même façon au sein du programme.

Interaction avec l’utilisateur

L’utilisateur peut avoir un retour sur ce qui se passe dans le code. Il est même possible d’interagir avec lui.

Pour récupérer une valeur de l’utilisateur :

info_user = input("Donnez moi une information")

Pour afficher des valeurs

Dans la console : print()

print(x)
print("Ma valeur :", info_user)
print(f"Ma valeur : {info_user}")
print("Ma valeur :", info_user, end="_____", sep="_")
print("Voici un texte")

Dans un fichier de log :

logfile = open('mon_log.log', 'w', encoding="utf-8")
logfile.write('Ma valeur : ' + info_user)
logfile.close()

Pour gérer les fichiers de log, il existe un module spécialisé : logging.

Les types de données container

Il existe plusieurs formats de données dits « container », c’est à dire qu’ils ne contiennent pas qu’une seule valeur comme un entier, un texte ou autre.

Les listes

Une liste est une suite de valeurs dont les propriétés sont les suivantes :

  • Les valeurs sont ordonnées : l’appel d’une valeur se fait via un indice (qui débute à 0) : ma_liste[0] appel le premier élément.
  • Chaque élément de la liste est modifiable.
  • On utilise les crochets [] pour définir la liste.
ma_liste = ["valeur 1", "valeur 2", "valeur 3"]
# Modification de la 3ème valeur : "valeur 3" devient "valeur 4"
ma_liste[2] = "valeur 4"

Les tuples

Une liste est une suite de valeurs dont les propriétés sont les suivantes :

  • Les valeurs sont ordonnées : l’appel d’une valeur se fait via un indice (qui débute à 0) : mon_tuple[0] appel le premier élément.
  • Aucun élément d’un tuple n’est modifiable.
  • On utilise les parenthèses () pour définir le tuple.

Un tuple est un peu comme une liste non modifiable.

mon_tuple = ("valeur 1", "valeur 2", "valeur 3")

Les sets

Un set est une suite de valeurs dont les propriétés sont les suivantes :

  • Les valeurs ne sont pas ordonnées : il est impossible d’appeler une valeur à une position donnée.
  • Aucune valeur ne peut être présente en doublon. Si une valeur est répétée, elle est automatiquement supprimée.
  • Aucun élément d’un set n’est modifiable.
  • On utilise les accolades {} pour définir le set.

Un set est un peu comme un tuple non ordonné et sans doublon.

# La valeur "valeur 3" ne sera présente qu'une seule fois malgré sa répétition
mon_set = {"valeur 1", "valeur 2", "valeur 3", "valeur 3"}

Les dictionnaires

Un dictionnaire est une suite de valeurs dont les propriétés sont les suivantes :

  • Les valeurs sont associée à une clé : l’appel d’une valeur se fait en désignant l’indice : mon_dict['ma clé'].
  • Chaque élément du dictionnaire est modifiable.
  • On utilise les accolades {} pour définir le dictionnaire.

Un dictionnaire est un peu comme une liste avec assignation de clés.

mon_dict = {"clé 1" : "valeur 1", "clé 2" : "valeur 2", "clé 3" : "valeur 3"}

Les boucles

Les boucle permettent de répéter une suite d’opérations.

Les boucles se terminent d’elles mêmes en fonction des paramètres définissant la boucle mais il est possible de contrôler leurs déroulement :

  • Avec continue qui permet de passer à l’itération suivante.
  • Avec break qui permet de sortir de la boucle.

Attention, car il est possible de définir une boucle dite « infinie » : qui ne s’arrête jamais.

Boucle for

for permet de boucler sur une suite finie d’éléments.

# Boucler de 0 à 4
for i in range(4):
	print(i)

# Boucler sur toutes les valeurs d'une liste
for e in ma_liste:
	print(e)

# Boucler sur les clés d'un dictionnaire
for key in mon_dict:
	print(f"Clé : {key} - Valeur : {mon_dict[key]}")

# Boucler sur les éléments d'un dictionnaire : un élément est un tuple
for item in mon_dict.items():
	print(f"Clé : {item[0]} - Valeur : {item[1]}")

# Boucler sur les éléments d'un dictionnaire en assignant les composants du tuple
for key, val in mon_dict.items():
	print(f"Clé : {key} - Valeur : {val}")

Boucle while

while permet de boucler jusqu’a ce qu’une condition soit remplie.

# Initialisation d'une variable d'itération
i = 0

# Boucler tant que i est inférieur à la longueur de la liste ma_liste
while i < len(ma_liste):
	print(f"Itération n°{i}, valeur : {ma_liste[i]}" )
	i += 1

Les conditions

Les conditions sont gérées avec if, elif et else.

Les opérateurs suivants peuvent être utilisés :

  • ==  : égal à
  • !=  : différent de
  • <   : inférieur à
  • <=  : inférieur ou égal à
  • >   : supérieur à
  • >=  : supérieur ou égal à
  • and : et
  • or  : ou
y = "souris"
if y == "souris":
	print("J'ai pas peur... hein... ;-)")
elif y == "chat":
	print("Je n'ai pas peur du tout")
else:
	print("Je suis un programme simple et ne sais pas gérer ce type d'animal...")

Une structure raccourci existe : a if condition else b

x = 14
z = 3
print("X gagne") if x > z else print("Z gagne")
print("X gagne") if x > z else print("ex aequo") if x == z else print("Z gagne")

Les fonctions

De nombreuses fonctions existent

print(len(ma_liste))

Il est possible de créer ses propres fonctions

def ma_fct():
	print("Hello Mars")

Des arguments peuvent être passés à la fonction

def ma_fct2(x, y):
	return x*y

Les arguments peuvent avoir des valeurs par défaut

def ma_fct3(x=0, y=1):
	return x*y

L’appel des argument se fait :

  • De façon positionnel (selon la position) : ma_fct3(2, 2)
  • Par mot clé : ma_fct3(y=22)

Il est possible d’utiliser une fonction comme argument d’une autre fonction

print(len(ma_liste))

Une fonction peut s’appeler elle-même : cela permet de faire de la récursivité

def ma_fct4(text, space=0):
	if space > 0:
		text = ma_fct4(' '+text, space-1)
	return text

Les variables créées dans une fonction ne sont pas visible en dehors de celle-ci

Les variables extérieurs à une fonction ne sont pas visible depuis la fonction Sauf avec le mot clé global

def ma_fct5():
	global x 
	print(x)

Les modules

Les modules permettent d’étendre les fonctionnalités disponibles

L’appel peut se faire de différente façon :

  • Importer le module complet : import mon_module
    L’appel d’une fonction se fait alors avec mon_module.la_fonction()
  • Importer le module complet et lui donner un alias : import mon_module as xxx
    L’appel se fait alors avec xxx.la_fonction()
  • Importer une fonction du module : from mon_module import zzz
    L’appel se fait alors avec la_fonction(), sans préfixe car celle-ci est importée dans votre programme
    Il est possible mais non recommandé d’importer toutes les fonctions du module : from mon_module import *

Modules disponibles

Voici quelques modules intéressants :

  • Fournis avec Python
    • sys : interaction avec l’interpréteur Python, passage d’arguments.
    • os : dialogue avec le système d’exploitation.
    • datetime et time : fonctions de date et de temps.
    • subprocess : gestion de sous-processus
    • logging : création et gestion de fichiers de log
    • requests : requêtes http
  • A installer via pip et/ou conda
    • Psycopg : transaction avec PostgreSQL
    • Panda et geopanda : manipulation de données
    • Numpy : gestion de données et de calcul
    • SciPy : bibliothèque d’algoritmes scientifiques
    • Matplotlib et SeaBorn : création de graphiques
    • BeautifulSoup : web scraping
    • Jupyter : programmation interactive

Modules personnels

Afin de faciliter la structuration d’un programme, il est possible de créer son propre module, il s’agit d’un fichier python (.py) contenant un ensemble de fonctions.

Le fichier est importé de la même façon qu’un module :

Si le fichier est dans le répertoire courant (le même que celui du fichier hôte) : import mon_fichier

Si le fichier est dans un sous répertoire : import mon_repertoire/mon_fichier

Si le fichier est ailleurs, il faut alors ajouter son emplacement dans le path de Python :

sys.path.append(emplacement/du/fichier)

import mon_fichier

Quelques ressources

Voici quelques ressources utiles pour aller plus loin.


Cet article vous a plu ?

N'hésitez pas à le partager, il interessera surement certains de vos contacts.

Les thèmes suivants contiennent des articles en lien avec celui-ci, allez faire un tour :

ProgrammationPython condaenvironnementtuto

50%