Ce cour présente le langage Python. Son univers, à savoir: les modules et packages, l'auto-loading, le gestionnaire de dépendances pip, et enfin ce qu'est l'environnement virtuel.
Python est un langage de programmation polyvalent créé par Guido van Rossum et lancé en 1991. Il est apprécié pour sa simplicité et sa lisibilité, ce qui le rend accessible aux débutants tout en étant puissant pour les développeurs expérimentés.
Caractéristiques Principales :
Utilisations Courantes :
Python est un choix populaire pour les développeurs grâce à sa flexibilité et à la richesse de ses bibliothèques, permettant de répondre à une multitude de besoins de programmation.
Site officiel pour l'installation: python.org
Les modules et packages sont des éléments fondamentaux de l'organisation du code en Python. Ils permettent de structurer les programmes de manière modulaire et réutilisable.
.py contenant le code souhaité.import nom_module pour importer un module et accéder à ses fonctionnalités.import math
print(math.sqrt(16)) # Affiche 4.0from math import pi
print(pi)# exemples avec plusieurs modules
import random, os, sys, re__init__.py, qui indique à Python que le répertoire doit être traité comme un package.import nom_package.nom_module pour importer un module d'un package.Structure d'un package:
mon_package/
__init__.py
module1.py
module2.py__init__.pyCe fichier est présent dans le dossier du package afin d'indiquer à Python que ce répertoire doit être traité comme un package.
Code d'initialisation: il peut contenir du code qui s'exécute lors de l'importation du package. Vous pouvez ainsi définir des variables, initialiser des ressources ou même importer automatiquement certains sous-modules du package.
Exemple simple d'un fichier __init__.py :
# __init__.py
# Importation directe de sous-modules pour les rendre accessibles
from . import module1
from . import module2
# Variable __all__ pour contrôler l'exportation des noms
__all__ = ["module1", "module2"]__all__La variable spéciale __all__ est une liste de chaînes de caractères qui définit explicitement les noms publics à exporter lorsqu'on utilise la syntaxe: from mon_package import *
Cela permet de limiter quels modules, classes ou fonctions sont exposés à l'utilisateur du package. Seuls les éléments listés dans __all__ seront importés.
En restreignant l'importation globale, vous évitez d'accéder accidentellement à des fonctions ou à des variables internes non destinées à l'usage externe.
Exemple:
# Définition des éléments exportés publiquement par le package
__all__ = ["module1", "module2"]Ainsi, lorsque l'on exécute : from mon_package import *
Seuls module1 et module2 seront importés et accessibles, ce qui permet d'encapsuler le code non destiné à être exposé.
Les modules et packages sont essentiels pour écrire du code propre et maintenable, en permettant de séparer les fonctionnalités et de réutiliser le code efficacement.
Voici une méthode proposée par python.19633.com.
Exécuter la commande: pip list --outdated > outdated.txt
Penser à sauvegarder votre travail via git par exemple avant de mettre à jour. Puis executer le script suivant:
'''
1. run this commande:
pip list --outdated > outdated.txt
2. run this script:
py upd.py
Source: https://python.19633.com/fr/Python/1001015136.html
Update by Le chat Mistral IA - #09/04/25
'''
import subprocess
# Lire les paquets obsolètes
with open("outdated.txt", 'r') as packages_file:
# Ignorer les deux premières lignes d'en-tête
packages_file.readline()
packages_file.readline()
for line in packages_file:
if line.strip():
package_name = line.split()[0]
print(f"Mise à jour de {package_name}...")
try:
subprocess.check_call(["pip", "install", "--upgrade", package_name])
except subprocess.CalledProcessError as e:
print(f"Erreur lors de la mise à jour de {package_name}: {e}")Étant débutant en Python, je ne peux évaluer la qualité de cette méthode. Elle semble fonctionner.
Lorsque vous faites un import en Python, l'interpréteur doit localiser le module demandé. Le module search path (chemin de recherche des modules) est la liste des répertoires que Python parcourt pour trouver le module correspondant à votre import. Cette recherche se fait selon un ordre prédéfini, influencé par plusieurs facteurs, comme le répertoire courant, la variable d'environnement PYTHONPATH et les répertoires standards de l'installation de Python.
sys.pathsys.path est une liste Python, accessible via le module sys, qui contient tous les chemins dans lesquels Python cherche les modules.
Ordre de recherche :
PYTHONPATH (si définie): Ces chemins supplémentaires permettent de personnaliser la recherche de modules.site-packages).Consultation et modification: Vous pouvez consulter le contenu de sys.path avec:
import sys
print(sys.path)Et si besoin, ajouter un répertoire temporairement: sys.path.append('/chemin/vers/mon/module')
ou, pour l'ajouter en priorité: sys.path.insert(0, '/chemin/vers/mon/module')
PYTHONPATHPYTHONPATH est une variable d'environnement qui peut être définie dans votre système d'exploitation (Unix, Linux, Windows). Elle permet d'ajouter des chemins supplémentaires à sys.path avant que Python ne parcoure les répertoires standards.
Par exemple, sur une machine Unix, vous pouvez l'ajouter dans votre terminal ou dans votre fichier de configuration shell (.bashrc ou .zshrc): export PYTHONPATH=/chemin/vers/mes/modules
Ainsi, tout module placé dans /chemin/vers/mes/modules pourra être importé directement dans vos scripts Python.
import mon_module, Python cherche d'abord un fichier mon_module.py, puis un package nommé mon_module (dossier contenant un fichier __init__.py) dans chacun des répertoires listés dans sys.path.PYTHONPATH (si définie).sys.path, le premier trouvé dans l'ordre de cette liste sera importé.Vous pouvez modifier sys.path à la volée dans votre script pour ajouter ou réordonner les chemins de recherche. Cette technique doit être utilisée avec précaution pour éviter des conflits ou des difficultés à maintenir le code.
venv ou conda) pour isoler les dépendances et avoir un contrôle plus fin sur le module search path.sys.path dans votre code afin de garder une structure claire et prévisible.__name__En Python, __name__ est une variable spéciale qui permet de déterminer si un module (un fichier Python) est exécuté directement ou s'il est importé dans un autre module.
Exécution directe: Quand vous lancez un fichier Python directement (par exemple, en exécutant python mon_script.py), la variable __name__ dans ce fichier est automatiquement définie à la valeur "__main__".
Cela signifie que le code contenu dans ce module est exécuté en tant que programme principal.
Importation d'un module: Si le même fichier est importé dans un autre module, alors __name__ prend la valeur du nom du module (généralement le nom du fichier sans l'extension .py).
Ainsi, le bloc de code qui dépend de if __name__ == "__main__": ne sera pas exécuté lors de l'importation.
L'utilisation principale de __name__ est de séparer le code qui devrait s'exécuter lors de l'exécution directe du module de celui qui doit être accessible lors d'une importation.
Concrètement, cela permet de :
main()) lorsque le script est lancé directement.Imaginons un module appelé calcul.py:
# calcul.py
def addition(a, b):
return a + b
def multiplication(a, b):
return a * b
if __name__ == "__main__":
# Ce bloc s'exécute uniquement si le module est exécuté en tant que programme principal
print("Exécution directe de calcul.py")
x, y = 3, 4
print("Addition :", addition(x, y))
print("Multiplication :", multiplication(x, y))Quand vous exécutez calcul.py directement: la condition if __name__ == "__main__": est vraie, et donc le code à l'intérieur de ce bloc est exécuté, affichant les résultats.
Quand vous importez calcul.py dans un autre fichier (par exemple, programme.py):
# programme.py
import calcul
print("Utilisation de la fonction addition :", calcul.addition(5, 6))Dans ce cas, __name__ dans calcul.py vaudra "calcul", et le bloc conditionnel ne sera pas exécuté. Vous pourrez ainsi utiliser les fonctions sans déclencher le code de démonstration ou de test.
En résumé, __name__ est un mécanisme fondamental en Python qui améliore la réutilisabilité et la modularité de votre code. Il vous permet de créer des modules qui fonctionnent à la fois comme des bibliothèques importables et comme des programmes autonomes, en exécutant un bloc de code spécifique uniquement lorsque cela est nécessaire.
L'auto-loading en Python fait référence à la capacité du langage à charger automatiquement des modules et des packages lorsqu'ils sont nécessaires. Cela permet une gestion dynamique des dépendances et améliore l'efficacité du code.
Concept d'Auto-loading :
Utilisation des Modules et Packages :
importlib pour importer des modules dynamiquement en fonction des besoins du programme.import et from ... import ... :
import module: Charge tout le module et nécessite d'utiliser le préfixe du module (ex. : module.fonction()).from module import fonction: importe uniquement la fonction spécifiée, permettant de l'utiliser directement (ex. : fonction()).Exemple Pratique :
import importlib
# Importation dynamique d'un module
module_name = 'math'
module = importlib.import_module(module_name)
# Utilisation d'une fonction du module importé
result = module.sqrt(16)
print(result) # Affiche 4.0L'auto-loading est particulièrement utile dans les grands projets où il est crucial de gérer efficacement les ressources et d'optimiser les performances.
pip est l'outil de gestion des paquets pour Python, permettant d'installer et de gérer les bibliothèques supplémentaires nécessaires à vos projets.
pip est un gestionnaire de paquets qui facilite l'installation et la gestion des bibliothèques Python.pip est généralement inclus avec les installations récentes de Python. Vous pouvez vérifier sa présence en exécutant pip --version dans votre terminal.Commandes de Base:
pip install nom_packagepip uninstall nom_packagepip listpip install --upgrade nom_packageUtilisation de requirements.txt:
requirements.txt liste toutes les dépendances d'un projet, facilitant leur installation en une seule commande.pip freeze: Génère automatiquement un fichier requirements.txt basé sur les packages actuellement installés dans l'environnement. Utilisez pip freeze > requirements.txt.pip install -r requirements.txtAlternatives :
pip et virtualenv pour une gestion simplifiée des environnements virtuels et des dépendances.pip est essentiel pour gérer les dépendances de vos projets Python, assurant que toutes les bibliothèques nécessaires sont installées et à jour. Nous y reviendrons dans la section suivante.
Python dispose d'une bibliothèque standard riche que vous pouvez utiliser immédiatement dans vos projets. Cependant, si vous avez besoin d'un package qui n'est pas disponible dans la bibliothèque standard, vous pouvez le trouver sur l'Index des Packages Python (PyPI).
Le Python Package Index (PyPI) est le plus grand dépôt de packages Python. Il contient de nombreux packages Python développés et maintenus par la communauté Python. Pour trouver un package, vous pouvez utiliser la barre de recherche sur le site PyPI. Par exemple, pour rechercher des packages qui traitent des requêtes HTTP, vous pouvez simplement utiliser le mot-clé requests.
Les packages Python utilisent la version sémantique, qui se compose de trois numéros : version majeure, version mineure et correctif (patch) :
Par exemple, le package requests a la version 2.24.0 (au moment de l'écriture). Cela signifie que la version majeure est 2, la version mineure est 24, et le correctif est zéro. Si vous utilisez la version 2.24.0 dans votre projet, vous pouvez la mettre à niveau vers n'importe quelle version ayant la version majeure 2, par exemple 2.25.1. Cependant, si vous installez une version avec une version majeure plus élevée, par exemple 3.0.0, votre application risque de ne pas fonctionner correctement.
pip est l'installateur de package pour Python. Il permet d'installer des packages depuis PyPI et d'autres dépôts. Python est livré avec pip par défaut. Pour vérifier si pip est disponible sur votre ordinateur, vous pouvez ouvrir l'invite de commande (ou PowerShell) sur Windows et taper la commande suivante:pip --version
Sur macOS ou Linux, vous pouvez lancer le terminal et utiliser pip3 à la place de pip:pip3 --version
Pour installer un package depuis PyPI, utilisez la commande suivante sur Windows:
pip install <package_name>
Et remplacez pip par pip3 sur macOS et Linux:
pip3 install <package_name>
Par exemple, la commande suivante installe le package requests:pip install requests
Vous pouvez maintenant utiliser le package requests dans n'importe quel projet. Par exemple, le code suivant utilise le package requests pour faire une requête HTTP à https://pypi.org/ et affiche le code de statut HTTP :
import requests
response = requests.get('https://pypi.org/')
print(response.status_code) Pour installer une version spécifique d'un package, utilisez la commande suivante:pip install <package_name>==<version>
Par exemple, pour installer la version 2.20.1 du package requests:pip install requests==2.20.1
Pour lister tous les packages installés, utilisez la commande suivante:pip list
Cela retournera une liste des packages installés sur votre ordinateur. Pour vérifier quels packages sont obsolètes, utilisez la commande suivante:pip list --outdated
Pour désinstaller un package, utilisez la commande suivante:pip uninstall <package_name>
Cela vous demandera une confirmation avant de désinstaller le package.
Lorsque vous installez un package et que ce package utilise d'autres packages, pip installera le package ainsi que ses dépendances. Pour afficher les dépendances d'un package, utilisez la commande suivante:
pip show <package_name>
Par exemple, pour afficher les dépendances du package requests:pip show requests
La ligne Requires liste les packages utilisés par le package requests.
Les environnements virtuels sont essentiels pour isoler les dépendances de vos projets Python, évitant ainsi les conflits entre les versions des bibliothèques.
Pourquoi Utiliser des Environnements Virtuels ?
Création et Activation d'un Environnement Virtuel:
python -m venv nom_environnement pour créer un environnement virtuel.nom_environnement\Scripts\activatesource nom_environnement/bin/activatedeactivate pour quitter l'environnement virtuel.Comparaison avec d'autres Outils:
venv mais avec une gestion plus large des dépendances non-Python.Les environnements virtuels sont indispensables pour maintenir des projets Python organisés et exempts de conflits de dépendances, garantissant ainsi une meilleure gestion et portabilité des projets.
Source: Conceptualisé par mes soins et rédiger via le concours du Chat (mistral.AI).