Aide-mémoire Python 3 et pip
| pip - Gestionnaire de Paquets |
|---|
| Objectif | Commande |
| Version et aide |
pip --version
pip3 --version # Python 3 explicitement
python -m pip --version # via le module Python (plus fiable) |
| Installer un paquet |
pip install requests
pip install requests==2.31.0 # version exacte
pip install "requests>=2.28,<3" # contrainte de version
pip install requests --upgrade # mettre à jour
pip install requests --user # sans droits root
pip install -r requirements.txt # depuis un fichier |
| Désinstaller / Lister |
pip uninstall requests
pip uninstall -y requests # sans confirmation
pip list # tous les paquets installés
pip list --outdated # paquets à mettre à jour
pip show requests # infos sur un paquet |
| requirements.txt |
# Générer la liste des dépendances
pip freeze > requirements.txt
# Installer depuis le fichier
pip install -r requirements.txt
# Contenu typique requirements.txt :
# requests==2.31.0
# flask>=3.0,<4
# sqlalchemy~=2.0 # ~= : compatible (2.0.x) |
| Mettre à jour pip lui-même |
python -m pip install --upgrade pip |
| Installer depuis GitHub |
pip install git+https://github.com/user/repo.git
pip install git+https://github.com/user/repo.git@branche |
| Installer en mode développement |
pip install -e . # depuis setup.py ou pyproject.toml
pip install -e .[dev] # avec extras "dev" |
| Paquets indispensables |
pip install requests # HTTP client
pip install flask # web framework léger
pip install fastapi uvicorn # API REST moderne
pip install sqlalchemy # ORM base de données
pip install pandas numpy # data science
pip install matplotlib seaborn # graphiques
pip install pillow # traitement d'images
pip install pydantic # validation de données
pip install python-dotenv # fichiers .env
pip install pytest # tests
pip install black isort flake8 # formatage + linting
pip install paramiko # SSH programmatique
pip install pymysql psycopg2 # MySQL / PostgreSQL |
| Environnements Virtuels (venv) |
|---|
| Créer et activer |
# Créer un environnement virtuel
python -m venv venv
python3 -m venv venv
python3.12 -m venv venv # version spécifique
# Activer
source venv/bin/activate # Linux / macOS
venv\Scripts\activate # Windows CMD
venv\Scripts\Activate.ps1 # Windows PowerShell
# Désactiver
deactivate
# Supprimer
rm -rf venv # Linux
Remove-Item -Recurse venv # Windows PowerShell |
| Workflow complet |
# 1. Créer le venv
python -m venv venv
# 2. Activer
source venv/bin/activate
# 3. Installer les dépendances
pip install -r requirements.txt
# 4. Travailler...
# 5. Sauvegarder les dépendances
pip freeze > requirements.txt
# 6. Désactiver
deactivate |
| .gitignore recommandé |
venv/
.venv/
__pycache__/
*.pyc
*.pyo
.env
.env.local
*.egg-info/
dist/
build/
.pytest_cache/ |
| pyenv (gérer plusieurs versions Python) |
# Installer pyenv (Linux/macOS)
curl https://pyenv.run | bash
pyenv install 3.12.0 # installer une version
pyenv versions # lister les versions
pyenv global 3.12.0 # version globale
pyenv local 3.11.0 # version locale (crée .python-version)
python --version |
| Bases du Langage |
|---|
| Variables et types |
# Python est dynamiquement typé
nom = "Alice" # str
age = 30 # int
taille = 1.75 # float
actif = True # bool
liste = [1, 2, 3] # list
tuple_ = (1, 2, 3) # tuple (immutable)
dico = {"a": 1} # dict
ens = {1, 2, 3} # set (valeurs uniques)
rien = None # équivalent de null
# Annotations de type (Python 3.5+, recommandé)
def saluer(nom: str, age: int = 0) -> str:
return f"Bonjour {nom}" |
| Conversion de types |
int("42") # 42
float("3.14") # 3.14
str(42) # "42"
bool(0) # False
list((1,2,3)) # [1,2,3]
tuple([1,2,3]) # (1,2,3)
set([1,1,2,3]) # {1,2,3}
type(x) # type de x
isinstance(x, str) # bool |
| Structures de contrôle |
# If / elif / else
if age >= 18:
print("majeur")
elif age >= 13:
print("adolescent")
else:
print("enfant")
# Ternaire
statut = "majeur" if age >= 18 else "mineur"
# Match (Python 3.10+)
match commande:
case "start": print("démarrage")
case "stop": print("arrêt")
case _: print("commande inconnue") |
| Boucles |
for i in range(5): # 0 1 2 3 4
print(i)
for i in range(1, 10, 2): # 1 3 5 7 9
print(i)
for item in ["a", "b", "c"]:
print(item)
for i, item in enumerate(["a","b","c"]): # avec index
print(i, item)
for k, v in {"a":1, "b":2}.items(): # dict
print(k, v)
for a, b in zip([1,2,3], ["x","y","z"]): # zip
print(a, b)
while condition:
if sortir: break
if passer: continue |
| Exceptions |
try:
resultat = 10 / 0
except ZeroDivisionError as e:
print(f"Division par zéro : {e}")
except (ValueError, TypeError) as e:
print(f"Erreur de valeur/type : {e}")
except Exception as e:
print(f"Erreur inattendue : {e}")
else:
print("Succès (exécuté si pas d'exception)")
finally:
print("Toujours exécuté")
# Lever une exception
raise ValueError("Valeur invalide")
raise ValueError(f"Age invalide : {age}") from None |
| Chaînes de Caractères |
|---|
| Formatage (f-strings) |
f"Bonjour {nom}"
f"Prix : {prix:.2f} €" # 2 décimales
f"{valeur:>10}" # aligné à droite sur 10
f"{valeur:0>5}" # rembourrer avec 0 : "00042"
f"{n:,}" # séparateur milliers : 1,234,567
f"{pct:.1%}" # pourcentage : 42.0%
f"{obj!r}" # repr() de l'objet
f"Résultat : {2 + 2}" # expression |
| Méthodes string |
s = " Bonjour le Monde "
s.lower() # minuscules
s.upper() # majuscules
s.strip() # suppr. espaces
s.split() # découper (séparateur: espace)
s.split(",") # découper par ","
", ".join(["a","b","c"]) # "a, b, c"
s.replace("Bonjour", "Salut")
s.startswith("Bon") # bool
s.endswith("nde ") # bool
"monde" in s.lower() # bool
s.find("le") # position (-1 si absent)
s.count("o") # occurrences
s.zfill(10) # rembourrer avec 0
s.center(20, "-") # centrer |
| Slicing (découpage) |
s = "Hello World"
s[0] # "H"
s[-1] # "d"
s[0:5] # "Hello"
s[6:] # "World"
s[::-1] # "dlroW olleH" (inversé)
s[::2] # "HloWrd" (un sur deux) |
| Listes |
|---|
| Opérations de base |
a = [1, 2, 3]
a.append(4) # [1,2,3,4]
a.insert(1, 10) # [1,10,2,3,4]
a.extend([5, 6]) # [1,10,2,3,4,5,6]
a.remove(10) # supprime la valeur 10
a.pop() # supprime et retourne le dernier
a.pop(0) # supprime l'index 0
a.sort() # tri en place
sorted(a) # nouveau tableau trié
a.sort(key=lambda x: x['age'], reverse=True)
a.reverse() # inverser en place
len(a) # longueur
min(a) / max(a) / sum(a) # agrégats
a.index(3) # position de la valeur 3
3 in a # bool
a.count(3) # occurrences
a.copy() # copie superficielle
a.clear() # vider
a + [7, 8] # concaténer
[0] * 5 # [0,0,0,0,0] |
| List comprehensions |
carres = [x**2 for x in range(10)]
pairs = [x for x in range(20) if x % 2 == 0]
flat = [x for row in matrix for x in row]
strings = [str(x) for x in [1, 2, 3]]
dicos = {k: v for k, v in zip("abc", [1,2,3])}
unique = {x for x in [1,1,2,3]} # set comprehension
gen = (x**2 for x in range(10)) # générateur (lazy) |
| Fonctions sur listes |
list(map(str, [1,2,3])) # ["1","2","3"]
list(filter(lambda x: x>2, [1,2,3,4])) # [3,4]
from functools import reduce
reduce(lambda a,b: a+b, [1,2,3,4]) # 10
any([False, True, False]) # True
all([True, True, True]) # True |
| Dictionnaires |
|---|
| Opérations courantes |
d = {"nom": "Alice", "age": 30}
d["nom"] # "Alice" (KeyError si absent)
d.get("nom") # "Alice" (None si absent)
d.get("taille", 0) # valeur par défaut
d["email"] = "a@b.com" # ajouter/modifier
d.update({"age": 31, "ville": "Paris"})
d.pop("age") # supprimer et retourner
d.setdefault("role", "user") # ajouter si absent
# Itérer
d.keys() # vue des clés
d.values() # vue des valeurs
d.items() # vue des (clé, valeur)
for k, v in d.items():
print(f"{k}: {v}")
# Fusion (Python 3.9+)
d3 = d1 | d2 # nouveau dict fusionné
d1 |= d2 # fusionner en place
# Depuis deux listes
dict(zip(["a","b"], [1,2])) # {"a":1,"b":2} |
| defaultdict / Counter |
from collections import defaultdict, Counter, OrderedDict
# defaultdict : valeur par défaut automatique
d = defaultdict(list)
d["fruits"].append("pomme") # pas de KeyError
# Counter : compter les occurrences
mots = ["chat","chien","chat","oiseau","chat"]
c = Counter(mots) # Counter({'chat':3, ...})
c.most_common(2) # [('chat',3),('chien',1)] |
| Fonctions |
|---|
| Arguments |
def fonc(pos, *args, cle=default, **kwargs):
print(pos) # positionnel
print(args) # tuple des positionnels extra
print(cle) # keyword avec défaut
print(kwargs) # dict des kwargs inconnus
# Unpacking à l'appel
args = [1, 2, 3]
fonc(*args) # décompacte la liste
fonc(**{"cle": "val"}) # décompacte le dict |
| Lambda / fonctions anonymes |
double = lambda x: x * 2
carre = lambda x: x ** 2
somme = lambda a, b: a + b
# Utile avec sorted, map, filter
personnes.sort(key=lambda p: p["age"])
adultes = list(filter(lambda p: p["age"] >= 18, personnes)) |
| Décorateurs |
import functools, time
def timer(func):
@functools.wraps(func)
def wrapper(*args, **kwargs):
debut = time.time()
resultat = func(*args, **kwargs)
fin = time.time()
print(f"{func.__name__} : {fin-debut:.3f}s")
return resultat
return wrapper
@timer
def ma_fonction():
time.sleep(1)
# Décorateurs courants
@staticmethod # méthode statique
@classmethod # méthode de classe
@property # getter via propriété
@functools.lru_cache() # cache mémoïsation |
| Générateurs |
def compte(n):
for i in range(n):
yield i # lazy : calcul à la demande
gen = compte(5)
next(gen) # 0
list(compte(5)) # [0,1,2,3,4]
# Générateur infini (avec itertools)
from itertools import count, cycle, islice
list(islice(count(0, 2), 5)) # [0,2,4,6,8] |
| Classes et POO |
|---|
| Classe de base |
class Animal:
nb_animaux = 0 # attribut de classe
def __init__(self, nom: str, age: int):
self.nom = nom # attribut d'instance
self.age = age
Animal.nb_animaux += 1
def __str__(self) -> str:
return f"Animal: {self.nom}"
def __repr__(self) -> str:
return f"Animal(nom={self.nom!r}, age={self.age})"
def __eq__(self, other) -> bool:
return self.nom == other.nom
@property
def info(self) -> str:
return f"{self.nom}, {self.age} ans"
@staticmethod
def creer_chiot() -> "Animal":
return Animal("Chiot", 0)
@classmethod
def nb_total(cls) -> int:
return cls.nb_animaux |
| Héritage |
class Chien(Animal):
def __init__(self, nom: str, age: int, race: str):
super().__init__(nom, age) # appel du parent
self.race = race
def aboyer(self) -> str:
return "Woof !"
def __str__(self) -> str:
return f"Chien: {self.nom} ({self.race})"
rex = Chien("Rex", 3, "Berger")
isinstance(rex, Chien) # True
isinstance(rex, Animal) # True |
| dataclass (Python 3.7+) |
from dataclasses import dataclass, field
@dataclass
class Produit:
nom: str
prix: float
stock: int = 0
tags: list[str] = field(default_factory=list)
def est_disponible(self) -> bool:
return self.stock > 0
p = Produit("Livre", 15.99, 10)
print(p) # Produit(nom='Livre', prix=15.99...) |
| Modules Standard Utiles |
|---|
| os et sys |
import os, sys
os.getcwd() # dossier courant
os.chdir('/tmp') # changer de dossier
os.listdir('.') # lister
os.path.exists('/tmp/fichier') # bool
os.path.join('/var', 'www', 'html') # "/var/www/html"
os.path.basename('/var/www/f.php') # "f.php"
os.path.dirname('/var/www/f.php') # "/var/www"
os.makedirs('/tmp/a/b', exist_ok=True)
os.remove('fichier.txt')
os.rename('a.txt', 'b.txt')
os.environ.get('HOME', '/home/user') # variable env
sys.argv # arguments CLI
sys.exit(0) # quitter
sys.version # version Python |
| pathlib (moderne) |
from pathlib import Path
p = Path('/var/www/html')
p / 'index.php' # /var/www/html/index.php
p.exists() # bool
p.is_dir() / p.is_file()
p.name # "html"
p.suffix # ".php"
p.stem # "index"
p.parent # /var/www
p.read_text() # contenu du fichier
p.write_text("contenu")
list(p.glob("*.php")) # fichiers .php
list(p.rglob("*.php")) # récursif
p.mkdir(parents=True, exist_ok=True) |
| json |
import json
data = {"nom": "Alice", "age": 30, "actif": True}
# Sérialiser
json_str = json.dumps(data)
json_str = json.dumps(data, indent=2, ensure_ascii=False)
# Désérialiser
data = json.loads(json_str)
# Fichier
with open('fichier.json', 'w', encoding='utf-8') as f:
json.dump(data, f, indent=2, ensure_ascii=False)
with open('fichier.json', 'r', encoding='utf-8') as f:
data = json.load(f) |
| datetime |
from datetime import datetime, date, timedelta
maintenant = datetime.now()
auj = date.today()
# Formater
maintenant.strftime("%d/%m/%Y %H:%M") # "22/02/2026 14:30"
# Parser
d = datetime.strptime("22/02/2026", "%d/%m/%Y")
# Calculs
demain = auj + timedelta(days=1)
il_y_a_1an = maintenant - timedelta(days=365)
diff = datetime(2027,1,1) - maintenant
diff.days # jours restants |
| re (expressions régulières) |
import re
# Tester / Chercher
re.match(r'^\d+$', '42') # début de chaîne
re.search(r'\d+', 'abc123def') # Match object
re.findall(r'\d+', 'a1b2c3') # ['1','2','3']
re.sub(r'\s+', ' ', 'trop d espaces') # remplacer
re.split(r'[,;]+', 'a,b;;c') # ['a','b','c']
# Groupes de capture
m = re.search(r'(\d{4})-(\d{2})-(\d{2})', '2026-02-22')
if m:
print(m.group(1), m.group(2), m.group(3)) # 2026 02 22
# Compiler (réutilisation performante)
pattern = re.compile(r'\b\w{5}\b', re.IGNORECASE)
pattern.findall("Hello World test") |
| subprocess (commandes système) |
import subprocess
# Exécuter et capturer
res = subprocess.run(['ls', '-la'], capture_output=True, text=True)
print(res.stdout)
print(res.returncode) # 0 = succès
# Shell
res = subprocess.run('ls *.py', shell=True, capture_output=True, text=True)
# Vérifier les erreurs
subprocess.run(['git', 'status'], check=True) # lève CalledProcessError si != 0 |
| logging |
import logging
logging.basicConfig(
level=logging.DEBUG,
format='%(asctime)s - %(levelname)s - %(message)s',
handlers=[
logging.FileHandler('appli.log'),
logging.StreamHandler()
]
)
logging.debug("Message de debug")
logging.info("Information")
logging.warning("Avertissement")
logging.error("Erreur")
logging.critical("Erreur critique") |
| argparse (arguments CLI) |
import argparse
parser = argparse.ArgumentParser(description="Mon outil")
parser.add_argument("fichier", help="Fichier à traiter")
parser.add_argument("-v", "--verbose", action="store_true")
parser.add_argument("-n", "--nombre", type=int, default=10)
parser.add_argument("-o", "--output", default="resultat.txt")
args = parser.parse_args()
print(args.fichier, args.verbose, args.nombre) |
| requests (HTTP) |
import requests
# GET
r = requests.get("https://api.exemple.com/users", params={"page": 1})
r.status_code # 200
r.json() # dictionnaire
r.text # texte brut
r.raise_for_status() # lève HTTPError si >= 400
# POST JSON
r = requests.post("https://api.exemple.com/users",
json={"nom": "Alice", "email": "a@b.com"},
headers={"Authorization": "Bearer TOKEN"}
)
# Session (réutiliser cookies/headers)
with requests.Session() as s:
s.headers.update({"Authorization": "Bearer TOKEN"})
r = s.get("https://api.exemple.com/me")
# Timeout
r = requests.get(url, timeout=5) # 5 secondes |