Langages universels

Bash

Commande	Description
`pwd`	Affiche le chemin courant.
`ls`	Liste les fichiers et dossiers.
`ls -la`	Liste détaillée avec fichiers cachés.
`ls -lh`	Liste avec tailles lisibles.
`cd my_project`	Change le répertoire courant.
`cd ..`	Remonte d’un niveau.
`cd ~`	Va au home directory.
`cd -`	Retourne au répertoire précédent.
`mkdir my_project`	Crée un nouveau dossier.
`mkdir -p path/to/folder`	Crée avec parents si nécessaire.
`rmdir my_folder`	Supprime un dossier vide.
`rm -rf my_folder`	Supprime un dossier et son contenu.
`touch file.txt`	Crée un fichier vide.
`cp source dest`	Copie un fichier.
`cp -r source dest`	Copie un dossier récursivement.
`mv source dest`	Déplace/renomme.
`rm file.txt`	Supprime un fichier.

Affichage et manipulation de contenu

Commande	Description
`echo "Hello" > file.txt`	Écrit “Hello” dans un fichier.
`echo "Hello" >> file.txt`	Ajoute à la fin du fichier.
`cat file.txt`	Affiche le contenu.
`head file.txt`	Affiche les 10 premières lignes.
`head -n 20 file.txt`	Affiche les 20 premières lignes.
`tail file.txt`	Affiche les 10 dernières lignes.
`tail -f file.txt`	Suit le fichier en temps réel.
`less file.txt`	Visualise page par page.
`grep "pattern" file.txt`	Recherche un motif.
`grep -r "pattern" .`	Recherche récursive.
`grep -i "pattern" file.txt`	Recherche insensible à la casse.
`wc -l file.txt`	Compte les lignes.
`wc -w file.txt`	Compte les mots.

Processus et système

Commande	Description
`ps aux`	Liste tous les processus.
`top`	Moniteur de processus temps réel.
`htop`	Version améliorée de top.
`kill PID`	Termine un processus.
`kill -9 PID`	Force la terminaison.
`jobs`	Liste les jobs du shell.
`bg`	Met en arrière-plan.
`fg`	Met en avant-plan.
`nohup command &`	Lance en arrière-plan persistent.
`which python`	Localise un exécutable.
`df -h`	Espace disque.
`du -sh folder/`	Taille d’un dossier.
`free -h`	Mémoire disponible.

Réseau et téléchargement

Commande	Description
`curl URL`	Télécharge et affiche.
`curl -O URL`	Télécharge dans un fichier.
`wget URL`	Télécharge un fichier.
`ssh user@host`	Connexion SSH.
`scp file user@host:/path`	Copie via SSH.
`ping google.com`	Test de connexion.
`netstat -an`	Connexions réseau.

Scripts et environnement

Commande	Description
`python3 script.py`	Exécute un script Python.
`bash script.sh`	Exécute un script bash.
`chmod +x script.sh`	Rend exécutable.
`source venv/bin/activate`	Active un environnement virtuel.
`deactivate`	Désactive un environnement virtuel.
`export VAR=value`	Définit une variable d’environnement.
`echo $VAR`	Affiche une variable.
`env`	Liste toutes les variables d’environnement.
`alias ll='ls -la'`	Crée un alias.
`history`	Historique des commandes.
`!!`	Répète la dernière commande.
`!$`	Dernier argument de la commande précédente.

Pipes et redirection

Commande	Description
`command1 \\| command2`	Pipe la sortie.
`command > output.txt`	Redirige la sortie.
`command >> output.txt`	Ajoute à la fin.
`command 2> error.txt`	Redirige les erreurs.
`command &> all.txt`	Redirige tout.
`command < input.txt`	Utilise comme entrée.
`command1 && command2`	Exécute si succès.
`command1 \\|\\| command2`	Exécute si échec.

Pip

Gestion des packages

Commande	Description
`pip install XXX`	Installe la bibliothèque XXX.
`pip install XXX==1.2.3`	Installe une version spécifique.
`pip install --upgrade XXX`	Met à jour un package.
`pip uninstall XXX`	Désinstalle un package.
`pip list`	Liste tous les packages installés.
`pip freeze`	Liste avec versions exactes.
`pip freeze > requirements.txt`	Exporte les dépendances.
`pip install -r requirements.txt`	Installe depuis requirements.
`pip show XXX`	Infos sur un package.
`pip search XXX`	Recherche un package (deprecated).
`pip check`	Vérifie les dépendances.
`pip cache purge`	Vide le cache pip.

Environnements virtuels

Commande	Description
`python -m venv env_name`	Crée un environnement virtuel.
`source env_name/bin/activate`	Active (Linux/Mac).
`env_name\Scripts\activate`	Active (Windows).
`deactivate`	Désactive l’environnement.
`pip install --user XXX`	Installe pour l’utilisateur uniquement.
`pip install --editable .`	Installe en mode développement.

Git

Configuration et initialisation

Commande	Description
`git init`	Initialise un nouveau dépôt Git.
`git config --global user.name "Name"`	Configure le nom d’utilisateur global.
`git config --global user.email "email"`	Configure l’email global.
`git config --list`	Liste toutes les configurations.

Staging et commits

Commande	Description
`git add .`	Ajoute tous les fichiers au suivi.
`git add <file>`	Ajoute un fichier spécifique.
`git commit -m "Message"`	Crée un commit avec un message.
`git commit --amend`	Modifie le dernier commit.
`git reset HEAD~1`	Annule le dernier commit (garde les changements).
`git reset --hard HEAD~1`	Annule le dernier commit (supprime les changements).

Branches et fusion

Commande	Description
`git branch`	Liste les branches locales.
`git branch <name>`	Crée une nouvelle branche.
`git checkout <branch>`	Change de branche.
`git checkout -b <branch>`	Crée et change vers une nouvelle branche.
`git merge <branch>`	Fusionne une branche dans la branche courante.
`git branch -d <branch>`	Supprime une branche locale.
`git rebase <branch>`	Rebase la branche courante.

Remote et synchronisation

Commande	Description
`git remote add origin https://github.com/ton-utilisateur/nom-du-repo.git`	Lie le dossier au repo distant.
`git push origin main`	Pousse les changements sur GitHub.
`git pull origin main`	Récupère les dernières modifications.
`git fetch`	Récupère les changements sans merger.
`git clone <url>`	Clone un repository distant.
`git remote -v`	Liste les remotes configurés.

Inspection et historique

Commande	Description
`git status`	Affiche l’état du dépôt.
`git log`	Affiche l’historique des commits.
`git log --oneline`	Historique condensé.
`git diff`	Affiche les différences non stagées.
`git diff --staged`	Affiche les différences stagées.
`git show <commit>`	Affiche un commit spécifique.
`git blame <file>`	Montre qui a modifié chaque ligne.

Stash et tags

Commande	Description
`git stash`	Met de côté les changements temporairement.
`git stash pop`	Applique et supprime le dernier stash.
`git stash list`	Liste tous les stashes.
`git tag <name>`	Crée un tag léger.
`git tag -a <name> -m "message"`	Crée un tag annoté.

[[Python]]

Commande	Description
`print("Hello, World!")`	Affiche un message à l’écran.
`type(variable)`	Retourne le type d’une variable.
`len(object)`	Retourne la longueur d’un objet.
`help(function)`	Affiche l’aide d’une fonction.
`dir(object)`	Liste les attributs et méthodes d’un objet.
`isinstance(obj, class)`	Vérifie si un objet est d’une classe donnée.
`id(object)`	Retourne l’identifiant unique d’un objet.
`input("prompt")`	Demande une entrée utilisateur.
`int(x)`	Convertit en entier.
`float(x)`	Convertit en décimal.
`str(x)`	Convertit en chaîne.
`bool(x)`	Convertit en booléen.
`abs(x)`	Valeur absolue.
`round(x, n)`	Arrondit à n décimales.
`min(iterable)`	Valeur minimale.
`max(iterable)`	Valeur maximale.
`sum(iterable)`	Somme des éléments.
`all(iterable)`	True si tous les éléments sont True.
`any(iterable)`	True si au moins un élément est True.

Chaînes de caractères

Commande	Description
`str.upper()`	Convertit en majuscules.
`str.lower()`	Convertit en minuscules.
`str.capitalize()`	Première lettre en majuscule.
`str.title()`	Première lettre de chaque mot en majuscule.
`str.strip()`	Supprime les espaces aux extrémités.
`str.lstrip()`	Supprime les espaces à gauche.
`str.rstrip()`	Supprime les espaces à droite.
`str.strip(chars)`	Supprime les caractères spécifiés.
`str.split()`	Divise sur les espaces.
`str.split(delimiter)`	Divise sur un délimiteur.
`str.split(delimiter, maxsplit)`	Limite le nombre de divisions.
`str.splitlines()`	Divise sur les sauts de ligne.
`str.join(iterable)`	Joint les éléments avec la chaîne.
`str.replace(old, new)`	Remplace les occurrences.
`str.replace(old, new, count)`	Limite le nombre de remplacements.
`str.find(substring)`	Index de la première occurrence (-1 si absent).
`str.rfind(substring)`	Index de la dernière occurrence.
`str.index(substring)`	Comme find mais lève une erreur si absent.
`str.startswith(prefix)`	Vérifie le début.
`str.endswith(suffix)`	Vérifie la fin.
`str.count(substring)`	Compte les occurrences.
`str.isdigit()`	Vérifie si tous les caractères sont des chiffres.
`str.isalpha()`	Vérifie si tous sont alphabétiques.
`str.isalnum()`	Vérifie si tous sont alphanumériques.
`str.isspace()`	Vérifie si tous sont des espaces.
`str.zfill(width)`	Remplit avec des zéros à gauche.
`str.center(width, fillchar)`	Centre la chaîne.
`str.ljust(width)`	Justifie à gauche.
`str.rjust(width)`	Justifie à droite.
`f"{variable}"`	F-string (formatage 3.6+).
`"{:.2f}".format(3.14159)`	Formatage avec précision.
`"{}{}".format(a, b)`	Format avec positions.
`"{1}{0}".format(a, b)`	Format avec indices.

Listes

Commande	Description
`list()` ou `[]`	Crée une liste vide.
`list(range(10))`	Crée une liste de 0 à 9.
`[1, 2, 3] * 2`	Répète la liste ([1, 2, 3, 1, 2, 3]).
`list1 + list2`	Concatène deux listes.
`list.append(x)`	Ajoute un élément à la fin.
`list.extend(iterable)`	Ajoute tous les éléments d’un itérable.
`list.insert(i, x)`	Insère x à la position i.
`list.remove(x)`	Supprime la première occurrence de x.
`list.pop()`	Retire et retourne le dernier élément.
`list.pop(index)`	Retire et retourne l’élément à l’index.
`list.clear()`	Vide la liste.
`list.index(x)`	Retourne l’index de la première occurrence.
`list.index(x, start, end)`	Cherche x dans une plage spécifique.
`list.count(x)`	Compte les occurrences de x.
`list.sort()`	Trie la liste en place.
`list.sort(reverse=True)`	Trie en ordre décroissant.
`list.sort(key=len)`	Trie avec une fonction de clé.
`list.reverse()`	Inverse la liste en place.
`list.copy()`	Crée une copie superficielle.
`sorted(list)`	Retourne une nouvelle liste triée.
`reversed(list)`	Retourne un itérateur inversé.
`list[start:end:step]`	Slicing avec pas.
`list[::-1]`	Inverse la liste (nouvelle copie).
`list[::2]`	Un élément sur deux.
`del list[index]`	Supprime l’élément à l’index.
`del list[start:end]`	Supprime une plage d’éléments.
`x in list`	Vérifie si x est dans la liste.
`x not in list`	Vérifie si x n’est pas dans la liste.

Dictionnaires

Commande	Description
`dict()` ou `{}`	Crée un dictionnaire vide.
`dict(zip(keys, values))`	Crée depuis deux listes.
`dict.fromkeys(keys, value)`	Crée avec des clés et une valeur par défaut.
`dict[key]`	Accède à la valeur (erreur si clé absente).
`dict.get(key)`	Accède à la valeur (None si absente).
`dict.get(key, default)`	Avec valeur par défaut.
`dict[key] = value`	Ajoute ou modifie une paire.
`dict.setdefault(key, default)`	Obtient la valeur ou la définit si absente.
`dict.update(other_dict)`	Met à jour avec un autre dictionnaire.
`dict.update(key=value)`	Met à jour avec des arguments nommés.
`dict.pop(key)`	Supprime et retourne la valeur.
`dict.pop(key, default)`	Avec valeur par défaut si clé absente.
`dict.popitem()`	Supprime et retourne la dernière paire (3.7+).
`del dict[key]`	Supprime une clé.
`dict.clear()`	Vide le dictionnaire.
`dict.keys()`	Vue des clés.
`dict.values()`	Vue des valeurs.
`dict.items()`	Vue des paires (clé, valeur).
`key in dict`	Vérifie si la clé existe.
`key not in dict`	Vérifie si la clé n’existe pas.
`dict.copy()`	Copie superficielle.
`len(dict)`	Nombre de paires.
`{dict1, dict2}`	Fusion de dictionnaires (3.5+).
`dict1 \\| dict2`	Fusion de dictionnaires (3.9+).

Sets

Commande	Description
`set()` ou `{1, 2, 3}`	Crée un ensemble.
`set(list)`	Convertit une liste en ensemble.
`set.add(elem)`	Ajoute un élément.
`set.update(iterable)`	Ajoute plusieurs éléments.
`set.remove(elem)`	Supprime (erreur si absent).
`set.discard(elem)`	Supprime (pas d’erreur si absent).
`set.pop()`	Supprime et retourne un élément arbitraire.
`set.clear()`	Vide l’ensemble.
`set1.union(set2)` ou `set1 \\| set2`	Union.
`set1.intersection(set2)` ou `set1 & set2`	Intersection.
`set1.difference(set2)` ou `set1 - set2`	Différence.
`set1.symmetric_difference(set2)` ou `set1 ^ set2`	Différence symétrique.
`set1.issubset(set2)` ou `set1 <= set2`	Sous-ensemble.
`set1.issuperset(set2)` ou `set1 >= set2`	Sur-ensemble.
`set1.isdisjoint(set2)`	Ensembles disjoints.
`frozenset(iterable)`	Ensemble immuable.

Tuples et unpacking

Commande	Description
`tuple()` ou `()`	Tuple vide.
`(1,)`	Tuple à un élément (virgule obligatoire).
`(1, 2, 3)`	Tuple à plusieurs éléments.
`tuple(list)`	Convertit une liste en tuple.
`a, b = (1, 2)`	Unpacking simple.
`a, b = b, a`	Échange de variables.
`a, *rest = [1, 2, 3, 4]`	Unpacking avec reste.
`*first, last = [1, 2, 3, 4]`	Unpacking fin.
`a, *middle, z = [1, 2, 3, 4]`	Unpacking milieu.
`for i, (x, y) in enumerate(points):`	Unpacking dans boucle.

Conditions

Commande	Description
`if condition:`	Condition simple.
`if x == y:`	Égalité.
`if x != y:`	Différence.
`if x < y:`	Inférieur.
`if x <= y:`	Inférieur ou égal.
`if x > y:`	Supérieur.
`if x >= y:`	Supérieur ou égal.
`if x is y:`	Identité (même objet).
`if x is not y:`	Objets différents.
`if x in collection:`	Appartenance.
`if x not in collection:`	Non-appartenance.
`if condition1 and condition2:`	ET logique.
`if condition1 or condition2:`	OU logique.
`if not condition:`	Négation.
`elif condition:`	Else if.
`else:`	Sinon.
`x if condition else y`	Expression conditionnelle (ternaire).
`(a, b)[condition]`	Alternative au ternaire.

Boucles

Commande	Description
`for i in range(10):`	Boucle de 0 à 9.
`for i in range(1, 11):`	Boucle de 1 à 10.
`for i in range(0, 10, 2):`	Boucle avec pas de 2.
`for i in range(10, 0, -1):`	Boucle décroissante.
`for item in list:`	Parcourt une liste.
`for i, item in enumerate(list):`	Avec index et valeur.
`for i, item in enumerate(list, start=1):`	Index commence à 1.
`for key in dict:`	Parcourt les clés.
`for value in dict.values():`	Parcourt les valeurs.
`for key, value in dict.items():`	Parcourt les paires.
`for a, b in zip(list1, list2):`	Parcourt deux listes en parallèle.
`for a, b, c in zip(list1, list2, list3):`	Trois listes en parallèle.
`for line in file:`	Parcourt les lignes d’un fichier.
`for char in string:`	Parcourt les caractères.
`for i in reversed(range(10)):`	Range inversé.
`for item in sorted(list):`	Parcourt en ordre trié.
`for item in set(list):`	Parcourt les éléments uniques.
`break`	Sort de la boucle.
`continue`	Passe à l’itération suivante.
`else:` après for	Exécuté si pas de break.

Compréhensions

Commande	Description
`[x for x in iterable]`	List comprehension basique.
`[x for x in iterable if condition]`	Avec filtre.
`[x if condition else y for x in iterable]`	Avec condition ternaire.
`[x for x in iterable for y in x]`	Boucles imbriquées.
`{k:v for k,v in iterable}`	Dict comprehension.
`{x for x in iterable}`	Set comprehension.
`(x for x in iterable)`	Générateur expression.
`yield value`	Mot-clé pour créer un générateur.
`next(generator)`	Obtient la prochaine valeur.

Gestion des erreurs et debugging

Commande	Description
`try:...except:`	Gestion basique des exceptions.
`try:...except Exception as e:`	Capture l’exception dans une variable.
`try:...except ValueError:`	Capture un type spécifique.
`try:...except (ValueError, TypeError):`	Plusieurs types.
`try:...except:...else:`	Else exécuté si pas d’erreur.
`try:...except:...finally:`	Finally toujours exécuté.
`raise Exception("message")`	Lève une exception.
`raise`	Re-lève l’exception courante.
`assert condition, "message"`	Assertion avec message.
`traceback.print_exc()`	Affiche la traceback.
`pdb.set_trace()`	Point d’arrêt debugger.
`breakpoint()`	Point d’arrêt (Python 3.7+).
`logging.debug(msg)`	Log niveau debug.
`logging.info(msg)`	Log niveau info.
`logging.warning(msg)`	Log niveau warning.
`logging.error(msg)`	Log niveau erreur.
`logging.critical(msg)`	Log niveau critique.

Programmation fonctionnelle

Commande	Description
`lambda x: x*2`	Fonction lambda simple.
`lambda x, y: x + y`	Lambda à plusieurs arguments.
`map(function, iterable)`	Applique une fonction.
`list(map(int, strings))`	Convertit une liste de strings en ints.
`filter(function, iterable)`	Filtre les éléments.
`list(filter(lambda x: x>0, nums))`	Garde les positifs.
`reduce(function, iterable)`	Réduit à une valeur (functools).
`functools.partial(func, arg)`	Fonction partielle.
`@property`	Décorateur propriété.
`@staticmethod`	Méthode statique.
`@classmethod`	Méthode de classe.
`@functools.cache`	Cache les résultats (3.9+).
`@functools.lru_cache`	Cache LRU.

Classes et objets

Commande	Description
`class MyClass:`	Définit une classe.
`def __init__(self):`	Constructeur.
`def __str__(self):`	Représentation string.
`def __repr__(self):`	Représentation développeur.
`def __len__(self):`	Pour len().
`def __getitem__(self, key):`	Pour obj[key].
`def __setitem__(self, key, value):`	Pour obj[key] = value.
`def __contains__(self, item):`	Pour in.
`def __eq__(self, other):`	Pour ==.
`def __lt__(self, other):`	Pour <.
`super().__init__()`	Appelle le constructeur parent.
`isinstance(obj, Class)`	Vérifie le type.
`hasattr(obj, 'attr')`	Vérifie si l’attribut existe.
`getattr(obj, 'attr', default)`	Obtient un attribut.
`setattr(obj, 'attr', value)`	Définit un attribut.
`delattr(obj, 'attr')`	Supprime un attribut.
`vars(obj)`	Dictionnaire des attributs.

Astuces et idiomes Python

Commande	Description
`if __name__ == "__main__":`	Point d’entrée du script.
`*args`	Arguments positionnels variables.
`**kwargs`	Arguments nommés variables.
`_, x, _ = (1, 2, 3)`	Ignore certaines valeurs.
`for _ in range(10):`	Ignore la variable de boucle.
`x = x or default`	Valeur par défaut.
`x = value if value else default`	Alternative explicite.
`collections.defaultdict(list)`	Dict avec valeur par défaut.
`collections.Counter(iterable)`	Compte les occurrences.
`itertools.chain(*iterables)`	Chaîne plusieurs itérables.
`itertools.combinations(iterable, r)`	Combinaisons.
`itertools.permutations(iterable, r)`	Permutations.
`itertools.product(*iterables)`	Produit cartésien.
`enumerate(iterable, start=0)`	Ajoute un compteur.
`zip(*iterables, strict=True)`	Zip avec vérification longueur (3.10+).
`any([])` retourne `False`	Piège courant.
`all([])` retourne `True`	Piège courant.
`[] * 3` crée `[[], [], []]` partagées!	Piège : références partagées.
`[[] for _ in range(3)]`	Solution : compréhension.

Data Manipulation

[[NumPy]]

Numpy_Python_Cheat_Sheet.pdf

Création de tableaux

Commande / Fonction	Description
`np.array([1,2,3])`	Crée un tableau à partir d’une liste Python.
`np.zeros((3,4))`	Crée un tableau de zéros.
`np.ones((2,3,4), dtype=np.int16)`	Crée un tableau de uns.
`np.arange(10,25,5)`	Crée un tableau de valeurs espacées régulièrement.
`np.linspace(0,2,9)`	Crée un tableau de valeurs espacées selon le nombre d’échantillons.
`np.full((2,2),7)`	Crée un tableau constant.
`np.eye(2)`	Crée une matrice identité.
`np.random.random((2,2))`	Crée un tableau de valeurs aléatoires.
`np.empty((3,2))`	Crée un tableau vide.
`np.fromfunction(lambda i,j: i+j, (3,3))`	Crée un tableau depuis une fonction.
`np.fromiter(iter, dtype)`	Crée un tableau depuis un itérateur.
`np.frombuffer(buffer, dtype)`	Crée un tableau depuis un buffer.

Formes et dimensions

Commande / Fonction	Description
`arr.shape`	Dimensions du tableau (tuple).
`arr.ndim`	Nombre de dimensions.
`arr.size`	Nombre total d’éléments.
`arr.dtype`	Type de données des éléments.
`arr.astype(dtype)`	Convertit le type des éléments.
`arr.reshape(3,2)`	Redimensionne le tableau.
`arr.resize((2,6))`	Change la taille en place.
`arr.T`	Transposition du tableau.
`arr.swapaxes(0,1)`	Échange deux axes.
`arr.flatten()`	Aplatit en 1D (copie).
`arr.ravel()`	Aplatit en 1D (vue si possible).
`np.squeeze(arr)`	Supprime les dimensions de taille 1.
`np.expand_dims(arr, axis)`	Ajoute une dimension.
`np.tolist()`	Convertit en liste.

Indexation et slicing

Commande	Description
`arr[0]`	Premier élément.
`arr[-1]`	Dernier élément.
`arr[0,1]`	Élément à la position (0,1).
`arr[0:2]`	Slice de l’index 0 à 2 (exclu).
`arr[:, 1]`	Toute la colonne 1.
`arr[1, :]`	Toute la ligne 1.
`arr[arr > 3]`	Éléments supérieurs à 3 (boolean indexing).
`arr[[0,2]]`	Lignes 0 et 2 (fancy indexing).
`arr[np.ix_([0,2],[1,3])]`	Sous-matrice aux intersections.
`np.where(condition)`	Indices où la condition est vraie.
`np.argmax(arr)`	Indice du maximum.
`np.argmin(arr)`	Indice du minimum.
`np.argsort(arr)`	Indices pour trier le tableau.

Opérations mathématiques

Commande / Fonction	Description
`arr + 2`	Addition scalaire.
`arr1 + arr2`	Addition élément par élément.
`arr * 3`	Multiplication scalaire.
`arr1 @ arr2` ou `np.dot(arr1, arr2)`	Produit matriciel.
`arr1 * arr2`	Multiplication élément par élément.
`np.sqrt(arr)`	Racine carrée.
`np.exp(arr)`	Exponentielle.
`np.log(arr)`	Logarithme naturel.
`np.log10(arr)`	Logarithme base 10.
`np.sin(arr)`	Sinus.
`np.cos(arr)`	Cosinus.
`np.power(arr, 2)`	Élève à la puissance.
`np.abs(arr)`	Valeur absolue.
`np.sign(arr)`	Signe des éléments.
`np.ceil(arr)`	Arrondi supérieur.
`np.floor(arr)`	Arrondi inférieur.
`np.round(arr, decimals)`	Arrondi à n décimales.
`np.clip(arr, min, max)`	Limite les valeurs entre min et max.

Statistiques et agrégations

Commande / Fonction	Description
`arr.sum()`	Somme de tous les éléments.
`arr.mean()`	Moyenne.
`arr.std()`	Écart-type.
`arr.var()`	Variance.
`arr.min()`	Minimum.
`arr.max()`	Maximum.
`arr.cumsum()`	Somme cumulative.
`arr.cumprod()`	Produit cumulatif.
`np.median(arr)`	Médiane.
`np.percentile(arr, 50)`	Percentile.
`np.histogram(arr, bins)`	Histogramme.
`np.correlate(a, b)`	Corrélation croisée.
`np.corrcoef(arr)`	Coefficient de corrélation.
`np.cov(arr)`	Covariance.
`np.unique(arr, return_counts=True)`	Valeurs uniques et leurs fréquences.

Algèbre linéaire

Commande / Fonction	Description
`np.linalg.inv(arr)`	Inverse d’une matrice.
`np.linalg.det(arr)`	Déterminant.
`np.linalg.eig(arr)`	Valeurs et vecteurs propres.
`np.linalg.norm(arr)`	Norme.
`np.linalg.solve(A, b)`	Résout Ax = b.
`np.linalg.lstsq(A, b)`	Moindres carrés.
`np.linalg.svd(arr)`	Décomposition en valeurs singulières.
`np.linalg.qr(arr)`	Décomposition QR.
`np.linalg.cholesky(arr)`	Décomposition de Cholesky.
`np.trace(arr)`	Trace de la matrice.

Combinaison et séparation

Commande / Fonction	Description
`np.concatenate((a,b), axis=0)`	Concatène selon un axe.
`np.vstack((a,b))`	Empile verticalement.
`np.hstack((a,b))`	Empile horizontalement.
`np.column_stack((a,b))`	Empile comme colonnes.
`np.split(arr, 3)`	Divise en n parties égales.
`np.hsplit(arr, 3)`	Divise horizontalement.
`np.vsplit(arr, 3)`	Divise verticalement.
`np.array_split(arr, 3)`	Divise en parties (pas forcément égales).

Broadcasting et vectorisation

Commande	Description
`np.vectorize(func)`	Vectorise une fonction Python.
`np.broadcast_to(arr, shape)`	Broadcast vers une forme.
`np.broadcast_arrays(*arrays)`	Broadcast plusieurs tableaux.
`np.meshgrid(x, y)`	Crée des grilles de coordonnées.

Génération de nombres aléatoires

Commande	Description
`np.random.seed(42)`	Fixe la graine aléatoire.
`np.random.rand(3,2)`	Uniforme [0,1).
`np.random.randn(3,2)`	Normale standard.
`np.random.randint(low, high, size)`	Entiers aléatoires.
`np.random.choice(arr, size)`	Échantillonnage avec remise.
`np.random.shuffle(arr)`	Mélange en place.
`np.random.permutation(arr)`	Permutation aléatoire.
`np.random.normal(mean, std, size)`	Distribution normale.
`np.random.uniform(low, high, size)`	Distribution uniforme.
`np.random.binomial(n, p, size)`	Distribution binomiale.
`np.random.poisson(lam, size)`	Distribution de Poisson.

Masques et conditions

Commande	Description
`np.logical_and(cond1, cond2)`	ET logique.
`np.logical_or(cond1, cond2)`	OU logique.
`np.logical_not(cond)`	NON logique.
`np.all(arr)`	Vrai si tous les éléments sont vrais.
`np.any(arr)`	Vrai si au moins un élément est vrai.
`np.isnan(arr)`	Masque des NaN.
`np.isinf(arr)`	Masque des infinis.
`np.isfinite(arr)`	Masque des valeurs finies.

Input/Output

Commande	Description
`np.save('file.npy', arr)`	Sauvegarde en binaire.
`np.load('file.npy')`	Charge depuis binaire.
`np.savez('file.npz', a=arr1, b=arr2)`	Sauvegarde multiple compressée.
`np.savetxt('file.txt', arr)`	Sauvegarde en texte.
`np.loadtxt('file.txt')`	Charge depuis texte.
`np.genfromtxt('file.csv', delimiter=',')`	Charge CSV avec gestion des valeurs manquantes.

Pandas

Pandas Cheat Sheet

Création de DataFrames

Commande / Fonction	Description
`pd.DataFrame(dict)`	DataFrame depuis un dictionnaire.
`pd.DataFrame(list)`	DataFrame depuis une liste.
`pd.DataFrame(np_array)`	DataFrame depuis NumPy array.
`pd.Series(list)`	Crée une Series.
`pd.date_range('2024-01-01', periods=5)`	Crée une plage de dates.
`pd.DataFrame(index=idx, columns=cols)`	DataFrame vide avec index et colonnes.

Import/Export de données

Commande	Description
`pd.read_csv('file.csv')`	Lit un fichier CSV.
`pd.read_excel('file.xlsx')`	Lit un fichier Excel.
`pd.read_json('file.json')`	Lit un fichier JSON.
`pd.read_sql(query, connection)`	Lit depuis une base SQL.
`pd.read_parquet('file.parquet')`	Lit un fichier Parquet.
`pd.read_feather('file.feather')`	Lit un fichier Feather.
`pd.read_pickle('file.pkl')`	Lit un fichier pickle.
`pd.read_html(url)`	Lit des tables HTML.
`pd.read_clipboard()`	Lit depuis le presse-papier.
`df.to_csv('file.csv', index=False)`	Écrit en CSV.
`df.to_excel('file.xlsx')`	Écrit en Excel.
`df.to_json('file.json')`	Écrit en JSON.
`df.to_sql('table', connection)`	Écrit en SQL.
`df.to_parquet('file.parquet')`	Écrit en Parquet.
`df.to_pickle('file.pkl')`	Écrit en pickle.
`df.to_html('file.html')`	Écrit en HTML.
`df.to_latex()`	Écrit en LaTeX.
`df.to_markdown()`	Écrit en Markdown.

Exploration des données

Commande	Description
`df.head(n)`	Affiche les n premières lignes.
`df.tail(n)`	Affiche les n dernières lignes.
`df.sample(n)`	Échantillon aléatoire de n lignes.
`df.shape`	Dimensions (lignes, colonnes).
`df.info()`	Informations sur le DataFrame.
`df.describe()`	Statistiques descriptives.
`df.dtypes`	Types de chaque colonne.
`df.columns`	Liste des colonnes.
`df.index`	Index du DataFrame.
`df.values`	Valeurs en NumPy array.
`df.memory_usage()`	Usage mémoire par colonne.
`df.nunique()`	Nombre de valeurs uniques par colonne.

Sélection et indexation

Commande	Description
`df['col']`	Sélectionne une colonne.
`df[['col1', 'col2']]`	Sélectionne plusieurs colonnes.
`df.loc[row_indexer, col_indexer]`	Sélection par labels.
`df.iloc[row_indexer, col_indexer]`	Sélection par position.
`df.at[row, col]`	Accès rapide à une cellule (label).
`df.iat[row, col]`	Accès rapide à une cellule (position).
`df[df['col'] > value]`	Filtrage par condition.
`df[df['col'].isin(values)]`	Filtrage par liste de valeurs.
`df.query('col > value')`	Requête style SQL.
`df.filter(items=['col1', 'col2'])`	Filtre les colonnes par nom.
`df.filter(like='pattern')`	Filtre les colonnes contenant pattern.
`df.filter(regex='^col')`	Filtre par expression régulière.
`df.where(cond)`	Remplace les valeurs ne satisfaisant pas la condition par NaN.
`df.mask(cond)`	Remplace les valeurs satisfaisant la condition par NaN.
`mask = (df['a'] > 0) & (df['b'] == 'x')`	Construire un masque booléen réutilisable (toujours parenthéser les conditions).
`df[mask]`	Appliquer un masque booléen pré-calculé (lecture / filtrage).
`df.loc[mask, 'col'] = value`	Affecter des valeurs seulement aux lignes satisfaisant le masque (boolean indexing + assignation sûre).
`df[df['col'].str.contains('pat', na=False)]`	Boolean indexing avec conditions sur chaînes.
`df[df['col'].between(low, high)]`	Filtrer avec between (plus lisible que >= et <=).
`df[np.where(cond, 'A', 'B')]`	Utiliser np.where pour créer une colonne basée sur un masque.
`df[(df[‘x’]>1)`	(df[‘y’]<0)]
`df[~mask]`	Négation du masque (toutes les lignes ne satisfaisant pas la condition).
`df[mask].copy()`	Faire .copy() avant modif du sous-DataFrame (évite warnings et effets de bord).
`df.index.isin([...])`	Boolean indexing sur l’index (utile pour sélectionner par index listé).
`df.loc[df.groupby('g')['v'].transform('max') == df['v']]`	Exemple avancé : boolean indexing avec transform pour sélectionner les max par groupe.
`df.any(axis=1) / df.all(axis=1)`	Réductions logiques utiles pour construire masques (ex. garder lignes où au moins une condition est vraie).

Modification des données

Commande	Description
`df['new_col'] = values`	Ajoute une nouvelle colonne.
`df.drop('col', axis=1)`	Supprime une colonne.
`df.drop(index)`	Supprime des lignes.
`df.rename(columns={'old': 'new'})`	Renomme les colonnes.
`df.replace(old, new)`	Remplace des valeurs.
`df.fillna(value)`	Remplit les NaN.
`df.dropna()`	Supprime les lignes avec NaN.
`df.drop_duplicates()`	Supprime les doublons.
`df.astype(dtype)`	Change le type de données.
`df.assign(new_col=lambda x: x['col']*2)`	Ajoute des colonnes avec assign.
`df.insert(loc, column, value)`	Insère une colonne à une position.
`df.update(other)`	Met à jour avec les valeurs d’un autre DataFrame.
`df.clip(lower, upper)`	Limite les valeurs entre bornes.

Tri et réorganisation

Commande	Description
`df.sort_values('col')`	Trie par valeurs d’une colonne.
`df.sort_values(['col1', 'col2'], ascending=[True, False])`	Tri multi-colonnes.
`df.sort_index()`	Trie par index.
`df.nlargest(n, 'col')`	Les n plus grandes valeurs.
`df.nsmallest(n, 'col')`	Les n plus petites valeurs.
`df.rank()`	Calcule le rang des valeurs.
`df.reindex(new_index)`	Réorganise selon un nouvel index.
`df.reset_index()`	Réinitialise l’index.
`df.set_index('col')`	Définit une colonne comme index.

Agrégations et groupby

Commande	Description
`df.groupby('col')`	Groupe par colonne.
`df.groupby(['col1', 'col2'])`	Groupe par plusieurs colonnes.
`df.groupby('col').mean()`	Moyenne par groupe.
`df.groupby('col').sum()`	Somme par groupe.
`df.groupby('col').size()`	Taille de chaque groupe.
`df.groupby('col').agg(['mean', 'std'])`	Plusieurs agrégations.
`df.groupby('col').agg({'col2': 'mean', 'col3': 'sum'})`	Agrégations personnalisées (tuples possibles en fonctions).
`df.pivot_table(values, index, columns, aggfunc)`	Table pivot.
`df.crosstab(index, columns)`	Tableau croisé.
`df.groupby('col').transform(lambda x: x - x.mean())`	Transforme au sein des groupes.
`df.groupby('col').apply(func)`	Applique une fonction aux groupes.
`df.groupby('col').filter(lambda x: len(x) > 2)`	Filtre les groupes.
`df.resample('D').mean()`	Rééchantillonnage temporel.
`df.rolling(window=3).mean()`	Moyenne mobile.
`df.expanding().sum()`	Somme cumulative expansive.

Fusion et jointure

Commande	Description
`pd.concat([df1, df2])`	Concatène verticalement.
`pd.concat([df1, df2], axis=1)`	Concatène horizontalement.
`pd.merge(df1, df2, on='key')`	Fusion sur une clé.
`pd.merge(df1, df2, left_on='key1', right_on='key2')`	Fusion sur clés différentes.
`df1.join(df2, on='key')`	Jointure sur index.
`pd.merge(df1, df2, how='left')`	Left join.
`pd.merge(df1, df2, how='right')`	Right join.
`pd.merge(df1, df2, how='outer')`	Outer join.
`pd.merge(df1, df2, how='inner')`	Inner join.
`df.append(other)`	Ajoute des lignes (deprecated, use concat).
`pd.merge_asof(df1, df2, on='time')`	Merge asof (temporel).
`pd.merge_ordered(df1, df2)`	Merge ordonné.

Reshape et pivot

Commande	Description
`df.pivot(index, columns, values)`	Pivot simple.
`df.pivot_table(values, index, columns, aggfunc)`	Table pivot avec agrégation.
`df.melt(id_vars, value_vars)`	Unpivot/Melt.
`df.stack()`	Empile les colonnes en index.
`df.unstack()`	Dépile l’index en colonnes.
`df.T` ou `df.transpose()`	Transpose.
`df.explode('col')`	Explose les listes en lignes.

Traitement des dates

Commande	Description
`pd.to_datetime(df['col'])`	Convertit en datetime.
`df['date'].dt.year`	Extrait l’année.
`df['date'].dt.month`	Extrait le mois.
`df['date'].dt.day`	Extrait le jour.
`df['date'].dt.dayofweek`	Jour de la semaine.
`df['date'].dt.hour`	Extrait l’heure.
`df['date'].dt.date`	Partie date seulement.
`df['date'].dt.time`	Partie heure seulement.
`df['date'].dt.quarter`	Trimestre.
`df['date'].dt.weekofyear`	Semaine de l’année.
`df['date'].dt.days_in_month`	Jours dans le mois.
`df['date'].dt.is_leap_year`	Année bissextile.
`df['date'].dt.strftime('%Y-%m')`	Formate la date.
`pd.date_range('2024-01-01', periods=5, freq='D')`	Génère une plage de dates.
`df.between_time('09:00', '17:00')`	Filtre par heures.
`df.at_time('15:00')`	À une heure spécifique.

Traitement des chaînes (str accessor)

Commande	Description
`df['col'].str.len()`	Longueur des chaînes.
`df['col'].str.strip()`	Strip spaces.
`df['col'].str.lower()` / `.str.upper()`	Case conversion.
`df['col'].str.contains('pattern', na=False, regex=True)`	Contient motif regex.
`df.filter(regex='^Sepal')`	Colonnes commençant par motif.
`df['col'].str.replace(r'\s+', '_', regex=True)`	Remplacer par regex.
`df['col'].str.extract(r'(\d{4})')`	Extraction par capture regex.
`df['col'].str.split('delimiter')`	Divise les chaînes.
`df['col'].str.join(' ')`	Joint les éléments.
`df['col'].str.startswith('prefix')`	Commence par.
`df['col'].str.endswith('suffix')`	Finit par.
`df['col'].str.pad(width, side='left')`	Padding.
`df['col'].str.center(width, fillchar)`	Centre les chaînes.
`df['col'].str.zfill(width)`	Padding avec zéros.
`df['col'].str.slice(start, stop)`	Substring.
`df['col'].str.title()`	Title case.
`df['col'].str.capitalize()`	Capitalize.
`df['col'].str.swapcase()`	Inverse la casse.
`df['col'].str.normalize('NFC')`	Normalisation Unicode.

MultiIndex & exemples

Commande	Description
`pd.MultiIndex.from_tuples([('a',1),('a',2),('b',1)], names=['x','y'])`	Crée un MultiIndex.
`df.set_index(['a','b'])`	Index multi-niveaux.
`df.stack()` / `df.unstack()`	Pivot entre niveaux d’index.
`df.xs('value', level='level_name')`	Cross-section par niveau.
`df.droplevel(level)`	Supprime un niveau d’index.
`df.swaplevel()`	Échange les niveaux d’index.
`df.sort_index(level=0)`	Trie par niveau d’index.
`df.index.get_level_values(0)`	Valeurs d’un niveau d’index.

Gestion de la mémoire et optimisation

Commande	Description
`df.memory_usage(deep=True)`	Usage mémoire détaillé.
`pd.get_dummies(df['col'])`	One-hot encoding.
`df.select_dtypes(include=['float'])`	Sélectionne par type.
`df.convert_dtypes()`	Convertit vers les meilleurs types.
`df['col'].astype('category')`	Convertit en catégorie (économie mémoire).
`df.to_numpy()`	Convertit en NumPy array.
`df.copy()`	Copie profonde du DataFrame.

Statistiques

Commande	Description
`df.corr()`	Matrice de corrélation.
`df.cov()`	Matrice de covariance.
`df.corrwith(other)`	Corrélation avec un autre DataFrame.
`df.quantile([0.25, 0.5, 0.75])`	Quantiles.
`df.mad()`	Mean absolute deviation.
`df.sem()`	Standard error of mean.
`df.skew()`	Asymétrie.
`df.kurt()`	Kurtosis.
`df.pct_change()`	Changement en pourcentage.
`df.diff()`	Différence avec la ligne précédente.
`df.cummax()` / `df.cummin()`	Maximum/Minimum cumulatif.

SQL

Création et gestion de bases

Commande / Syntaxe	Description
`CREATE DATABASE Zoo;`	Crée une nouvelle base de données.
`SELECT * FROM sys.databases;`	Liste toutes les bases de données disponibles.
`USE Zoo;`	Sélectionne la base de données active.
`DROP DATABASE Zoo;`	Supprime définitivement une base de données.
`SELECT * FROM sys.tables;`	Liste toutes les tables de la base active.
`EXEC sp_help 'Animal';`	Affiche la structure détaillée d’une table.

Création et modification de tables

Commande / Syntaxe	Description
`CREATE TABLE Habitat (Id INT, Name VARCHAR(64));`	Crée une table avec des colonnes définies.
`CREATE TABLE Habitat (Id INT PRIMARY KEY IDENTITY, Name VARCHAR(64));`	Crée une table avec clé primaire auto-incrémentée.
`CREATE TABLE Animal (Id INT PRIMARY KEY IDENTITY, Name VARCHAR(64), HabitatId INT, FOREIGN KEY (HabitatId) REFERENCES Habitat(Id));`	Crée une table avec clé étrangère référençant une autre table.
`EXEC sp_rename 'AnimalSchema.Animal', 'Pet';`	Renomme une table existante.
`ALTER TABLE Animal ADD COLUMN Name VARCHAR(64);`	Ajoute une nouvelle colonne à une table.
`EXEC sp_rename 'AnimalSchema.Animal.Id', 'Identifier', 'COLUMN';`	Renomme une colonne existante.
`ALTER TABLE Animal ALTER COLUMN Name VARCHAR(128);`	Modifie le type de données d’une colonne.
`ALTER TABLE Animal DROP COLUMN Name;`	Supprime une colonne d’une table.
`DROP TABLE Animal;`	Supprime définitivement une table.

Requêtes SELECT et jointures

Commande / Syntaxe	Description
`SELECT Species, AVG(Age) AS AverageAge FROM Animal WHERE Id != 3 GROUP BY Species HAVING AVG(Age) > 3 ORDER BY AVG(Age) DESC;`	Requête complète avec filtre, regroupement et tri.
`SELECT City.Name, Country.Name FROM City JOIN Country ON City.CountryId = Country.Id;`	Requête multi-tables avec jointure.
`INNER JOIN`	Retourne uniquement les lignes avec correspondance dans les deux tables (intersection).
`LEFT JOIN`	Retourne toutes les lignes de la table de gauche, avec NULL si pas de correspondance à droite.
`RIGHT JOIN`	Retourne toutes les lignes de la table de droite, avec NULL si pas de correspondance à gauche.
`FULL OUTER JOIN`	Retourne toutes les lignes des deux tables, avec NULL là où il n’y a pas de correspondance.
`CROSS JOIN`	Produit cartésien : chaque ligne de la première table avec chaque ligne de la seconde.

Agrégations et regroupements

Commande / Syntaxe	Description
`AVG(expr)`	Calcule la moyenne des valeurs d’une colonne.
`COUNT(expr)`	Compte le nombre de valeurs non-NULL.
`COUNT(*)`	Compte toutes les lignes, y compris les NULL.
`COUNT(DISTINCT Name)`	Compte uniquement les valeurs uniques.
`MAX(expr)`	Retourne la valeur maximale.
`MIN(expr)`	Retourne la valeur minimale.
`SUM(expr)`	Calcule la somme des valeurs.
`SELECT Species, COUNT(Id) FROM Animal GROUP BY Species;`	Regroupe les résultats par espèce et compte les individus.
`SELECT HabitatId, AVG(Age), MIN(Age), MAX(Age) FROM Animal GROUP BY HabitatId;`	Agrégations multiples sur des groupes.

Manipulation de données (DML)

Commande / Syntaxe	Description
`INSERT INTO Habitat VALUES (1, 'River'), (2, 'Forest');`	Insère plusieurs lignes en spécifiant toutes les colonnes.
`INSERT INTO Habitat (Name) VALUES ('Savanna');`	Insère en spécifiant uniquement certaines colonnes.
`UPDATE Animal SET Species = 'Duck', Name = 'Quack' WHERE Id = 2;`	Met à jour des valeurs existantes selon une condition.
`DELETE FROM Animal WHERE Id = 1;`	Supprime des lignes selon une condition.
`TRUNCATE TABLE Animal;`	Vide complètement une table (plus rapide que DELETE, non journalisé).

Fonctions texte

Commande / Syntaxe	Description
`'Michael'` / `N'Michél'`	Chaîne de caractères simple (Unicode si préfixée par `N`).
`CONCAT('Hi ', 'there!')`	Concatène plusieurs chaînes sans séparateur.
`CONCAT_WS(' ', 'Olivier', 'Norris')`	Concatène avec un séparateur (`' '` ici).
`SELECT column_a \\| " " \\| column_b`	Concatène deux colonnes directement comme une seule.
`SELECT Name FROM City WHERE Name != 'Berlin';`	Filtre sur des chaînes avec condition d’inégalité.
`SELECT Name FROM City WHERE Name LIKE 'P%' OR Name LIKE '%s';`	Recherche de motif (`LIKE` avec `%` pour n’importe quelle suite de caractères).
`SELECT Name FROM City WHERE Name LIKE '_ublin';`	Recherche avec motif de longueur fixe (`_` = un caractère).
`LEN('LearnSQL.com')`	Renvoie la longueur de la chaîne (nombre de caractères).
`LENGTH('LearnSQL.com')`	Variante selon le dialecte SQL (souvent équivalent à `LEN`).
`UPPER('LearnSQL.com')`	Convertit en majuscules.
`LOWER('LEARNSQL.COM')`	Convertit en minuscules.
`SUBSTRING('LearnSQL.com', 1, 5)` ou `SUBSTR('LearnSQL.com', 1, 5)`	Extrait une sous-chaîne à partir de la position donnée.
`INSTR('LearnSQL.com', 'SQL')`	Donne la position de la sous-chaîne dans le texte.
`REPLACE('LearnSQL.com', 'SQL', 'Python')`	Remplace une sous-chaîne par une autre.
`TRIM(' LearnSQL.com ')`	Supprime les espaces à gauche et à droite.
`LTRIM(' LearnSQL.com ')`	Supprime uniquement les espaces à gauche.
`RTRIM(' LearnSQL.com ')`	Supprime uniquement les espaces à droite.
`SELECT DISTINCT(Name)`	Supprime les doublons dans une colonne texte.
`SELECT CHARINDEX('SQL', 'LearnSQL.com')`	Trouve la position d’un motif (SQL Server).
`SELECT REVERSE('LearnSQL.com')`	Inverse la chaîne de caractères.

Fonctions numériques

Commande / Syntaxe	Description
`SELECT 60 * 60 * 24 * 7;` → `604800`	Calcul simple (ici : secondes dans une semaine).
`SELECT 25 / 4;` → `6`	Division entière (selon le dialecte SQL).
`SELECT CAST(25 AS DECIMAL) / 4;` ou `SELECT 25.0 / 4;` → `6.25`	Division décimale.
`SELECT MOD(13, 2);` → `1`	Reste de la division entière (modulo).
`SELECT ROUND(1234.56789, 3);` → `1234.568`	Arrondit à 3 décimales.
`SELECT CEILING(13.1), FLOOR(13.8);` → `14`, `13`	Arrondi supérieur et inférieur.
`SELECT ABS(-42);` → `42`	Valeur absolue.
`SELECT POWER(2, 3);` → `8`	Élève un nombre à une puissance.
`SELECT SQRT(16);` → `4`	Racine carrée.
`SELECT EXP(1);` → `2.71828`	Exponentielle.
`SELECT LOG(10);`	Logarithme naturel (base e).
`SELECT LOG10(1000);`	Logarithme base 10.
`SELECT RAND();`	Génère un nombre pseudo-aléatoire entre 0 et 1.
`SELECT SIGN(-12);` → `-1`	Indique le signe du nombre.

Gestion des NULL et dates

Commande / Syntaxe	Description
`SELECT Name FROM City WHERE Rating IS NOT NULL;`	Filtre les lignes où la valeur n’est pas NULL.
`SELECT Domain, COALESCE(Domain, 'domain missing') FROM Contacts;`	Retourne la première valeur non-NULL de la liste.
`GETDATE()`	Retourne la date et l’heure actuelles.
`DATEADD(datepart, number, date)`	Ajoute un intervalle à une date (ex: DATEADD(day, 7, GETDATE())).
`DATEDIFF(datepart, start, end)`	Calcule la différence entre deux dates.
`DATENAME(datepart, date)`	Retourne le nom d’une partie de la date (ex: nom du mois).
`DATEPART(datepart, date)`	Extrait une partie numérique d’une date.
`DAY(date)`, `MONTH(date)`, `YEAR(date)`	Extraient respectivement le jour, le mois ou l’année.
`strftime(format, date)`	Formate une date selon un format spécifique (SQLite principalement). Exemples: `'%Y-%m-%d'` pour année-mois-jour, `'%H:%M:%S'` pour heure:minute:seconde, `'%d/%m/%Y %H:%M'` pour format français avec heure.

Contraintes et index

Commande / Syntaxe	Description
`PRIMARY KEY`	Définit une clé primaire (unique et non-NULL).
`FOREIGN KEY`	Établit une relation de clé étrangère vers une autre table.
`UNIQUE`	Garantit l’unicité des valeurs dans une colonne.
`NOT NULL`	Interdit les valeurs NULL dans une colonne.
`CHECK`	Définit une condition que les valeurs doivent respecter.
`DEFAULT`	Assigne une valeur par défaut à une colonne.
`CREATE INDEX idx_name ON table(column);`	Crée un index pour accélérer les recherches.
`CREATE UNIQUE INDEX idx_name ON table(column);`	Crée un index garantissant l’unicité.
`DROP INDEX idx_name ON table;`	Supprime un index existant.

Vues et procédures stockées

Commande / Syntaxe	Description
`CREATE VIEW view_name AS SELECT ...;`	Crée une vue (requête sauvegardée réutilisable).
`ALTER VIEW view_name AS SELECT ...;`	Modifie une vue existante.
`DROP VIEW view_name;`	Supprime une vue.
`CREATE PROCEDURE proc_name AS BEGIN ... END;`	Crée une procédure stockée réutilisable.
`EXEC proc_name;`	Exécute une procédure stockée.
`DROP PROCEDURE proc_name;`	Supprime une procédure stockée.

Transactions

Commande / Syntaxe	Description
`BEGIN TRANSACTION;`	Démarre une transaction (bloc d’opérations atomique).
`COMMIT;`	Valide définitivement les modifications de la transaction.
`ROLLBACK;`	Annule toutes les modifications depuis le BEGIN TRANSACTION.
`SAVEPOINT savepoint_name;`	Crée un point de sauvegarde dans la transaction.
`ROLLBACK TO savepoint_name;`	Revient à un point de sauvegarde spécifique.

[[SQL#Window Functions — Fonctions de Fenêtre SQL|Window Functions]]

Commande / Syntaxe	Description
`ROW_NUMBER() OVER (ORDER BY col)`	Assigne un numéro unique à chaque ligne selon un ordre donné. Utile pour créer des identifiants ou filtrer des doublons.
`RANK() OVER (ORDER BY col)`	Classe les lignes avec des rangs pouvant avoir des ex aequo (les rangs suivants sont sautés).
`DENSE_RANK() OVER (ORDER BY col)`	Classe les lignes sans sauter de rangs même en cas d’ex aequo.
`NTILE(n) OVER (ORDER BY col)`	Divise les résultats en n groupes aussi égaux que possible (utile pour les quartiles, déciles…).
`LAG(col [, offset]) OVER (ORDER BY col)`	Renvoie la valeur d’une ligne précédente (par défaut, la ligne juste avant).
`LEAD(col [, offset]) OVER (ORDER BY col)`	Renvoie la valeur d’une ligne suivante (par défaut, la ligne juste après).
`SUM(col) OVER (PARTITION BY group_col ORDER BY col)`	Calcule une somme cumulative ou par groupe sans réduire le nombre de lignes.
`AVG(col) OVER (PARTITION BY group_col)`	Calcule une moyenne par groupe en conservant toutes les lignes.
`MIN(col) OVER (PARTITION BY group_col)` / `MAX(col) OVER (...)`	Donne la valeur minimale ou maximale dans chaque groupe ou partition.
`COUNT(col) OVER (PARTITION BY group_col)`	Compte les lignes dans chaque partition (utile pour ajouter des statistiques locales).
`FIRST_VALUE(col) OVER (ORDER BY col)` / `LAST_VALUE(col) OVER (ORDER BY col)`	Renvoie la première ou dernière valeur d’une fenêtre ordonnée.

CTE (Common Table Expressions)

Commande / Syntaxe	Description
`WITH cte_name AS (SELECT ...) SELECT * FROM cte_name;`	Crée une table temporaire nommée valable pour une seule requête.
`WITH Sales_CTE AS (SELECT EmployeeId, SUM(Amount) AS Total FROM Sales GROUP BY EmployeeId) SELECT * FROM Sales_CTE WHERE Total > 10000;`	Exemple de CTE pour simplifier une requête avec agrégation.
`WITH RECURSIVE cte_name AS (SELECT ... UNION ALL SELECT ...) SELECT * FROM cte_name;`	CTE récursive pour parcourir des hiérarchies (ex: organigrammes, arborescences).
`WITH cte1 AS (...), cte2 AS (...) SELECT * FROM cte1 JOIN cte2 ON ...;`	Multiple CTEs dans une même requête pour décomposer la logique.
`WITH OrderedData AS (SELECT , ROW_NUMBER() OVER (ORDER BY Date) AS rn FROM Sales) SELECT FROM OrderedData WHERE rn <= 10;`	Combiner CTE avec window functions pour des requêtes analytiques élégantes.

Bonnes pratiques et conventions

Commande / Syntaxe	Description
`SELECT [First Name], [Age] FROM [Customers];`	Utilise des crochets pour les noms contenant espaces ou caractères spéciaux (SQL Server).
`Schema.Table` (ex : `AnimalSchema.Habitat`)	Préfixe les tables avec leur schéma pour éviter les ambiguïtés.
`GO`	Séparateur de batch dans SQL Server Management Studio (exécute les commandes par blocs).

Data Visualization

Configuration et styles

Commande	Description
`import matplotlib.pyplot as plt`	Importe le module de tracé Matplotlib.
`import seaborn as sns`	Importe la bibliothèque Seaborn.
`plt.style.use('ggplot')`	Applique un style prédéfini.
`plt.rcParams['figure.dpi'] = 100`	Configure la résolution.
`plt.rcParams['font.size'] = 12`	Configure la taille de police.
`sns.set_style("whitegrid")`	Définit le style des graphiques Seaborn.
`sns.set_palette("color_palette")`	Définit la palette de couleurs Seaborn.
`sns.set_context("notebook")`	Définit le contexte d’affichage.

Création de figures

Commande	Description
`plt.figure(figsize=(width, height))`	Définit la taille de la figure.
`fig, ax = plt.subplots()`	Crée figure et axes.
`fig, axes = plt.subplots(nrows=2, ncols=2)`	Crée plusieurs sous-graphiques.
`plt.subplot(2, 2, 1)`	Active un sous-graphique.
`fig.suptitle("Title")`	Titre global de la figure.
`plt.tight_layout()`	Ajuste automatiquement l’espacement.
`plt.subplots_adjust(hspace=0.4)`	Ajuste l’espacement manuel.

Types de graphiques de base

Commande	Description
`plt.plot(x, y)`	Trace une courbe.
`plt.plot(x, y, 'ro-')`	Courbe avec style (rouge, points, ligne).
`plt.scatter(x, y)`	Trace un nuage de points.
`plt.bar(x, height)`	Crée un diagramme en barres verticales.
`plt.barh(y, width)`	Crée un diagramme en barres horizontales.
`plt.hist(data, bins=n)`	Crée un histogramme.
`plt.pie(sizes, labels=labels)`	Crée un graphique en secteurs.
`plt.boxplot(data)`	Crée une boîte à moustaches.
`plt.violinplot(data)`	Crée un violin plot.
`plt.imshow(image)`	Affiche une image/matrice.
`plt.contour(X, Y, Z)`	Trace des contours.
`plt.contourf(X, Y, Z)`	Contours remplis.
`plt.hexbin(x, y)`	Hexagonal binning.
`plt.stem(x, y)`	Stem plot.
`plt.step(x, y)`	Step plot.
`plt.stackplot(x, y1, y2)`	Graphique empilé.
`plt.fill_between(x, y1, y2)`	Remplit entre deux courbes.

Personnalisation des axes et labels

Commande	Description
`plt.title("Title")`	Définit le titre du graphique.
`plt.xlabel("Label X")`	Définit le label de l’axe X.
`plt.ylabel("Label Y")`	Définit le label de l’axe Y.
`plt.xlim(min, max)`	Définit les limites de l’axe X.
`plt.ylim(min, max)`	Définit les limites de l’axe Y.
`plt.xticks(positions, labels)`	Personnalise les ticks X.
`plt.yticks(positions, labels)`	Personnalise les ticks Y.
`plt.grid(True)`	Affiche la grille.
`plt.grid(True, alpha=0.3)`	Grille avec transparence.
`ax.set_xscale('log')`	Échelle logarithmique X.
`ax.set_yscale('log')`	Échelle logarithmique Y.
`ax.invert_xaxis()`	Inverse l’axe X.
`ax.secondary_yaxis('right')`	Axe Y secondaire.

Légendes et annotations

Commande	Description
`plt.legend()`	Affiche la légende.
`plt.legend(loc='upper right')`	Position de la légende.
`plt.text(x, y, 'Text')`	Ajoute du texte.
`plt.annotate('Note', xy=(x,y), xytext=(x2,y2))`	Annotation avec flèche.
`plt.axhline(y=0, color='k', linestyle='-')`	Ligne horizontale.
`plt.axvline(x=0, color='k', linestyle='-')`	Ligne verticale.
`plt.axhspan(ymin, ymax, alpha=0.3)`	Zone horizontale.
`plt.axvspan(xmin, xmax, alpha=0.3)`	Zone verticale.

Graphiques Seaborn

Commande	Description
`sns.lineplot(x, y, data=df)`	Trace une courbe avec Seaborn.
`sns.scatterplot(x, y, data=df)`	Trace un nuage de points avec Seaborn.
`sns.barplot(x, y, data=df)`	Trace un diagramme en barres avec Seaborn.
`sns.histplot(data, bins=n)`	Trace un histogramme avec Seaborn.
`sns.boxplot(x, y, data=df)`	Trace un diagramme en boîte avec Seaborn.
`sns.violinplot(x, y, data=df)`	Violin plot avec Seaborn.
`sns.swarmplot(x, y, data=df)`	Swarm plot.
`sns.stripplot(x, y, data=df)`	Strip plot.
`sns.heatmap(data, annot=True)`	Crée une carte thermique avec annotations.
`sns.clustermap(data)`	Heatmap avec clustering.
`sns.pairplot(df)`	Crée une matrice de graphiques en paires.
`sns.jointplot(x, y, data=df)`	Graphique joint avec distributions.
`sns.regplot(x, y, data=df)`	Scatter avec régression linéaire.
`sns.lmplot(x, y, data=df, hue='category')`	Régression par catégorie.
`sns.catplot(x, y, data=df, kind='box')`	Graphiques catégoriels.
`sns.countplot(x, data=df)`	Compte les occurrences.
`sns.distplot(data)`	Distribution (deprecated, use histplot).
`sns.kdeplot(data)`	Estimation de densité.

Couleurs et styles

Commande	Description
`plt.plot(x, y, color='red')`	Définit la couleur.
`plt.plot(x, y, c='#FF5733')`	Couleur hexadécimale.
`plt.plot(x, y, linewidth=2)`	Épaisseur de ligne.
`plt.plot(x, y, linestyle='--')`	Style de ligne (tirets).
`plt.plot(x, y, marker='o')`	Style de marqueur.
`plt.plot(x, y, markersize=10)`	Taille du marqueur.
`plt.plot(x, y, alpha=0.7)`	Transparence.
`plt.colorbar()`	Ajoute une barre de couleur.
`plt.cm.get_cmap('viridis')`	Obtient une colormap.

Sauvegarde et affichage

Commande	Description
`plt.show()`	Affiche le graphique.
`plt.savefig("filename.png")`	Enregistre le graphique comme image.
`plt.savefig("file.pdf", dpi=300)`	Sauvegarde haute résolution.
`plt.savefig("file.svg", bbox_inches='tight')`	Sauvegarde ajustée.
`plt.close()`	Ferme la figure courante.
`plt.close('all')`	Ferme toutes les figures.

Graphiques 3D

Commande	Description
`from mpl_toolkits.mplot3d import Axes3D`	Import pour 3D.
`ax = plt.axes(projection='3d')`	Crée des axes 3D.
`ax.plot3D(x, y, z)`	Ligne 3D.
`ax.scatter3D(x, y, z)`	Nuage de points 3D.
`ax.plot_surface(X, Y, Z)`	Surface 3D.
`ax.plot_wireframe(X, Y, Z)`	Wireframe 3D.

Machine Learning

Statistiques

Notations

N = Population n = échantillon $\mu$ = moyenne sur population $\bar{x}$ = moyenne sur échantillon

Notions de base

Concept	Formule	Description	Python
[[Statistiques et probabilités#Moyenne Arithmétique\|Moyenne]]	$\bar{x} = \frac{1}{n} \sum_{i=1}^{n} x_i$	Somme des valeurs divisée par le nombre de valeurs	`np.mean(x)` `statistics.mean(x)` `df['col'].mean()` `df.mean()`
[[Statistiques et probabilités#Médiane\|Médiane]]	`mediane(x)`	Valeur centrale d’un jeu de données trié. ==Insensible aux outliers.==	`np.median(x)` `statistics.median(x)` `df['col'].median()` `df.median()`
[[Statistiques et probabilités#Mode\|Mode]]	`mode(x)`	Valeur la plus fréquente	`statistics.mode(x)` `scipy.stats.mode(x)` `df['col'].mode()` `df.mode()`
[[Statistiques et probabilités#Variance et Écart-Type\|Variance (population)]]	$\sigma^2 = \frac{\sum_{i=1}^{N} (x_i - \mu)^2}{N}$	Dispersion des données par rapport à la moyenne populationnelle	`np.var(x, ddof=0)` `statistics.pvariance(x)` `df['col'].var(ddof=0)` `df.var(ddof=0)`
[[Statistiques et probabilités#Variance et Écart-Type\|Variance (échantillon)]]	$s^2 = \frac{\sum_{i=1}^{n} (x_i - \bar{x})^2}{n-1}$	Estimation de la variance populationnelle	`np.var(x, ddof=1)` `statistics.variance(x)` `df['col'].var()` `df.var()`
[[Statistiques et probabilités#Variance et Écart-Type\|Écart-type]]	$\sigma = \sqrt{\sigma^2}, \quad s = \sqrt{s^2}$	Dispersion dans la même unité que les données	`np.std(x, ddof=0)` (pop) `np.std(x, ddof=1)` (éch) `df['col'].std()` `df.std()`
[[Statistiques et probabilités#Coefficient de Variation\|Coefficient de variation]]	$CV = \frac{\sigma}{\bar{x}} \times 100\%$	Dispersion relative	`(np.std(x)/np.mean(x))100` `scipy.stats.variation(x)100` `(df['col'].std()/df['col'].mean())*100`
[[Statistiques et probabilités#Étendue\|Étendue (Range)]]	$R = \max(x) - \min(x)$	Différence entre max et min	`np.ptp(x)` `max(x) - min(x)` `df['col'].max() - df['col'].min()`

Statistiques descriptives

Concept	Formule	Description	Python
[[Statistiques et probabilités#Quartiles et Boîtes à Moustaches\|Quartiles]]	`Q1`, `Q2`, `Q3`	Découpe des données en 4 parties égales	`np.percentile(x, [25, 50, 75])` `np.quantile(x, [0.25, 0.5, 0.75])` `df.describe()` `df['col'].quantile([0.25, 0.5, 0.75])`
[[Statistiques et probabilités#Quartiles et Boîtes à Moustaches\|Intervalle interquartiles]]	$IQR = Q3 - Q1$	Étendue du milieu 50% des données	`scipy.stats.iqr(x)` `np.percentile(x,75)-np.percentile(x,25)` `df['col'].quantile(0.75) - df['col'].quantile(0.25)`
[[Statistiques et probabilités#Percentiles\|Percentiles]]	Position dans la distribution (0-100)	Valeur en-dessous de laquelle se trouve n% des données	`np.percentile(x, p)` `df['col'].quantile(p/100)`
[[Statistiques et probabilités#Covariance\|Covariance]]	$\text{Cov}(X,Y) = \frac{\sum_{i=1}^{n} (x_i - \bar{x})(y_i - \bar{y})}{n-1}$	Mesure linéaire de dépendance entre deux variables	`np.cov(x, y, ddof=1)[0,1]` `pd.DataFrame({'x':x,'y':y}).cov()` `df[['col1', 'col2']].cov()` `df.cov()`
[[Statistiques et probabilités#Corrélation\|Corrélation]]	$\rho_{XY} = \frac{\text{Cov}(X,Y)}{\sigma_X \sigma_Y}$	Force et direction de la relation linéaire, varie entre -1 et 1	`np.corrcoef(x, y)[0,1]` `scipy.stats.pearsonr(x, y)` `df[['col1', 'col2']].corr()` `df.corr()` `df['col1'].corr(df['col2'])`
[[Statistiques et probabilités#Corrélation de Spearman\|Corrélation de Spearman]]	Corrélation de rangs	Mesure la relation monotone (non nécessairement linéaire)	`scipy.stats.spearmanr(x, y)` `df[['col1', 'col2']].corr(method='spearman')` `df.corr(method='spearman')`
[[Statistiques et probabilités#Asymétrie\|Asymétrie (Skewness)]]	Mesure d’asymétrie de la distribution	Positive: queue à droite, Négative: queue à gauche	`scipy.stats.skew(x)` `pd.Series(x).skew()` `df['col'].skew()` `df.skew()`
[[Statistiques et probabilités#Aplatissement\|Aplatissement (Kurtosis)]]	Mesure de concentration autour de la moyenne	Positive: plus pointue, Négative: plus plate	`scipy.stats.kurtosis(x)` `pd.Series(x).kurtosis()` `df['col'].kurtosis()` `df.kurtosis()`

Probabilités de base

Concept	Formule	Description	Python
[[Statistiques et probabilités#Types de Probabilité\|Probabilité]]	$P(A) = \frac{\text{cas favorables}}{\text{cas possibles}}$	Chance qu’un événement se produise	`favorable/total` ou simulations `(df['col'] == valeur).mean()` (fréquence empirique)
[[Statistiques et probabilités#Événements Dépendants et Indépendants\|Indépendance]]	$P(A \cap B) = P(A) \times P(B)$	A et B n’influencent pas	Test via contingence: `pd.crosstab(df['A'], df['B'])`
[[Statistiques et probabilités#Espérance Mathématique\|Espérance]]	$E[X] = \sum x_i P(x_i)$	Valeur moyenne attendue	`np.sum(x * p)` ou `df['col'].mean()` (empirique)
[[Statistiques et probabilités#Variance d’une Variable Aléatoire\|Variance théorique]]	$Var(X) = E[(X - E[X])^2]$	Dispersion d’une variable aléatoire	`np.sum((x - np.mean(x))*2 p)` ou `df['col'].var()`
[[Statistiques et probabilités#Combinaisons et Permutations\|Combinaisons]]	$C(n,k) = \frac{n!}{k!(n-k)!}$	Choix de k éléments parmi n	`scipy.special.comb(n, k)` Pandas: génération via `itertools.combinations()`
[[Statistiques et probabilités#Combinaisons et Permutations\|Permutations]]	$P(n,k) = \frac{n!}{(n-k)!}$	Arrangements de k parmi n	`scipy.special.perm(n, k)` Pandas: génération via `itertools.permutations()`

Distributions de probabilité

Distribution	Paramètres	Caractéristiques	Python
[[Statistiques et probabilités#Distribution Normale\|Normale (Gaussienne)]]	μ (moyenne), σ (écart-type)	Symétrique, en forme de cloche	`scipy.stats.norm(loc=μ, scale=σ)` `df['col'].plot(kind='density')` (visualisation) `df['col'].hist(density=True)` ou `plt.plot(x, stats.norm.PDF OU CDF(x, mu, sigma)`)
[[Statistiques et probabilités#Distribution Binomiale\|Binomiale]]	n (essais), p (probabilité succès)	Nombre de succès sur n essais	`scipy.stats.binom(n, p)` Simulation: `(df.sample(n, replace=True)['col'] == val).sum()`
[[Statistiques et probabilités#Distribution de Poisson\|Poisson]]	λ (taux moyen)	Nombre d’événements dans intervalle fixe	`scipy.stats.poisson(μ=λ)` Comptage d’événements: `df.groupby('intervalle')['events'].count()`
[[Statistiques et probabilités#Distribution Uniforme\|Uniforme]]	a (min), b (max)	Probabilité égale sur intervalle	`scipy.stats.uniform(loc=a, scale=b-a)` Génération: `pd.Series(np.random.uniform(a, b, n))`
[[Statistiques et probabilités#Distribution Exponentielle\|Exponentielle]]	λ (taux)	Temps entre événements (processus Poisson)	`scipy.stats.expon(scale=1/λ)` Génération: `pd.Series(np.random.exponential(1/λ, n))`
[[Statistiques et probabilités#Distribution t de Student\|t de Student]]	ν (degrés de liberté)	Semblable à normale mais queues plus lourdes	`scipy.stats.t(df=ν)` Pandas: pas d’implémentation directe (utiliser scipy)
[[Statistiques et probabilités#Distribution du Chi-carré\|Chi-carré (χ²)]]	k (degrés de liberté)	Somme de carrés de variables normales	`scipy.stats.chi2(df=k)` Test: `pd.crosstab(df['A'], df['B'])` + scipy.stats.chi2_contingency
[[Statistiques et probabilités#Distribution F\|F de Fisher]]	d₁, d₂ (degrés de liberté)	Ratio de variances	`scipy.stats.f(dfn=d₁, dfd=d₂)` Pandas: pas d’implémentation directe
[[Statistiques et probabilités#Distribution Bêta\|Bêta]]	α, β (paramètres de forme)	Variable bornée entre 0 et 1	`scipy.stats.beta(a=α, b=β)` Pandas: pas d’implémentation directe
[[Statistiques et probabilités#Distribution Gamma\|Gamma]]	k (forme), θ (échelle)	Généralisation de exp et chi-carré	`scipy.stats.gamma(a=k, scale=θ)` Pandas: pas d’implémentation directe

Intervalles de confiance

Type d’intervalle	Formule/Contexte	Description	Python
[[Statistiques et probabilités#Intervalle de Confiance pour la Moyenne\|IC Moyenne (σ connu)]]	$\bar{x} \pm z_{\alpha/2} \frac{\sigma}{\sqrt{n}}$	Quand variance population connue	`scipy.stats.norm.interval(confidence, loc=mean, scale=σ/np.sqrt(n))` `df['col'].mean() ± z * df['col'].std()/np.sqrt(len(df))`
[[Statistiques et probabilités#Intervalle de Confiance pour la Moyenne\|IC Moyenne (σ inconnu)]]	$\bar{x} \pm t_{\alpha/2, n-1} \frac{s}{\sqrt{n}}$	Utilise distribution t	`scipy.stats.t.interval(confidence, df=n-1, loc=mean, scale=s/np.sqrt(n))` Avec pandas: calcul manuel des composants
[[Statistiques et probabilités#Intervalle de Confiance pour une Proportion\|IC Proportion]]	$\hat{p} \pm z_{\alpha/2} \sqrt{\frac{\hat{p}(1-\hat{p})}{n}}$	Intervalle pour proportions	`statsmodels.stats.proportion.proportion_confint(count, n)` `p_hat = (df['col']==val).mean()` puis calcul manuel
[[Statistiques et probabilités#IC pour Variance\|IC Variance]]	Basé sur distribution Chi-carré	Intervalle pour variance population	`chi2.ppf([α/2, 1-α/2], df=n-1)` puis formule Composants via `df['col'].var()`
[[Statistiques et probabilités#IC pour Différence de Moyennes\|IC Différence de moyennes]]	$(\bar{x}_1 - \bar{x}_2) \pm t \times SE$	Comparaison de deux groupes	`scipy.stats.ttest_ind()` retourne IC Groupes: `df.groupby('group')['value'].agg(['mean', 'std', 'count'])`

Tests d’hypothèses

Test	Hypothèses	Contexte	Conditions	Python
[[Statistiques et probabilités#Test Z\|Test Z (1 échantillon)]]	H₀: μ = μ₀	Test moyenne avec σ connu	Distribution normale, σ connu	`statsmodels.stats.weightstats.ztest()` `df['col'].mean()` puis calcul manuel
[[Statistiques et probabilités#Test t (1 échantillon)\|Test t (1 échantillon)]]	H₀: μ = μ₀	Test moyenne avec σ inconnu	Distribution normale ou n>30	`scipy.stats.ttest_1samp(df['col'], μ₀)` `scipy.stats.ttest_1samp(x, μ₀)`
[[Statistiques et probabilités#Test t (2 échantillons indépendants)\|Test t (2 échantillons)]]	H₀: μ₁ = μ₂	Comparaison de 2 groupes indépendants	Normalité, variances égales (ou Welch si non)	`scipy.stats.ttest_ind(df[df['group']=='A']['val'], df[df['group']=='B']['val'])` `scipy.stats.ttest_ind(group1, group2)`
[[Statistiques et probabilités#Test t apparié\|Test t apparié]]	H₀: μ_diff = 0	Comparaison mesures répétées	Différences suivent distribution normale	`scipy.stats.ttest_rel(df['before'], df['after'])` `scipy.stats.ttest_rel(x, y)`
[[Statistiques et probabilités#Test du Chi-carré\|Test du Chi-carré]]	H₀: indépendance	Test indépendance variables catégorielles	Fréquences attendues ≥ 5	`scipy.stats.chi2_contingency(pd.crosstab(df['A'], df['B']))` `chi2_contingency(crosstab)`
[[Statistiques et probabilités#ANOVA (One-Way)\|ANOVA à un facteur]]	H₀: μ₁ = μ₂ = … = μₖ	Comparaison de plusieurs groupes	Normalité, homoscédasticité	`scipy.stats.f_oneway(df[df['group']=='A']['val'], df[df['group']=='B']['val'], ...)` `f_oneway(*groups)`
[[Statistiques et probabilités#Test de Shapiro-Wilk\|Test de Shapiro-Wilk]]	H₀: distribution normale	Test de normalité	n < 5000	`scipy.stats.shapiro(df['col'])` `scipy.stats.shapiro(x)`
[[Statistiques et probabilités#Test de Kolmogorov-Smirnov\|Test de Kolmogorov-Smirnov]]	H₀: même distribution	Test d’ajustement à distribution théorique	Variables continues	`scipy.stats.kstest(df['col'], 'norm')` `scipy.stats.ks_2samp(x, y)`
[[Statistiques et probabilités#Test de Levene\|Test de Levene]]	H₀: variances égales	Test d’homoscédasticité	Alternative robuste au test F	`scipy.stats.levene(df[df['group']=='A']['val'], df[df['group']=='B']['val'])` `levene(*groups)`
[[Statistiques et probabilités#Test de Mann-Whitney U\|Test de Mann-Whitney U]]	H₀: mêmes distributions	Alternative non-paramétrique au t-test	Données ordinales ou non-normales	`scipy.stats.mannwhitneyu(df[df['group']=='A']['val'], df[df['group']=='B']['val'])` `mannwhitneyu(x, y)`
[[Statistiques et probabilités#Test de Wilcoxon\|Test de Wilcoxon]]	H₀: médiane diff = 0	Alternative non-paramétrique au t-test apparié	Données appariées, non-normales	`scipy.stats.wilcoxon(df['before'], df['after'])` `scipy.stats.wilcoxon(x, y)`
[[Statistiques et probabilités#Test de Kruskal-Wallis\|Test de Kruskal-Wallis]]	H₀: mêmes médianes	Test non paramétrique	Alternative à ANOVA	`scipy.stats.kruskal(df[df['group']=='A']['val'], df[df['group']=='B']['val'], ...)` `kruskal(*groups)`

Bayes et Likelihood

Concept	Formule	Description	Python
[[Statistiques et probabilités#Théorème de Bayes\|Théorème de Bayes]]	$P({H}\|{E}) = \frac{P({E}\|{H}) P(H)}{P({E}\|{H}) P(H) + P({E}\|{–H}) P(\neg H)}$	Mise à jour de croyance après evidence	Calcul manuel ou `pymc` pour inférence bayésienne Pandas: calcul des probabilités avec `.value_counts(normalize=True)`
[[Statistiques et probabilités#Fonction de Vraisemblance\|Likelihood]]	$L(\theta\| Y) = P(Y\|\theta)$	Support des données pour un paramètre	Dépend de la loi: `.pmf()` ou `.pdf()` Pandas: préparation données avec `.groupby()`
[[Statistiques et probabilités#Log-vraisemblance\|Log-vraisemblance]]	$\ell(\theta) = \log L(\theta\| Y) = \sum_i \log P(y_i\|\theta)$	Transformation logarithmique pour faciliter calculs	`np.sum(np.log(prob))` ou méthodes `.logpdf()` Pandas: `np.log(df['prob']).sum()`
[[Statistiques et probabilités#Estimateur du Maximum de Vraisemblance (MLE)\|Maximum Likelihood Estimate (MLE)]]	$\hat{\theta}_{MLE} = \arg\max_\theta L(\theta\| Y)$	Paramètre qui maximise la likelihood	`scipy.optimize.minimize()` ou `scipy.stats.distribution.fit(data)` Avec pandas: `scipy.stats.distribution.fit(df['col'])`
[[Statistiques et probabilités#Statistique Suffisante\|Statistique suffisante]]	Condense toute l’information pertinente pour estimer un paramètre	Ex: moyenne pour μ	Dépend de la distribution Pandas: extraction via `.mean()`, `.sum()` selon distribution
[[Statistiques et probabilités#Profile Likelihood et Paramètres de Nuisance\|Nuisance parameter & Profile Likelihood]]	Paramètre secondaire remplacé par estimateur pour se concentrer sur paramètre principal	$L_p(\mu) = L(\mu, \hat{\sigma}^2)$	`scipy.optimize.minimize()` avec contrainte Pandas: préparation des données
[[Statistiques et probabilités#Rapport de vraisemblance\|Rapport de vraisemblance]]	$\Lambda = \frac{L(\theta_0\| Y)}{L(\hat{\theta}\| Y)}$	Test d’hypothèse basé sur vraisemblance	`-2*log(Lambda)` suit loi Chi-carré Pandas: calcul des composants
[[Statistiques et probabilités#AIC\|AIC (Critère d’Akaike)]]	$AIC = 2k - 2\ln(L)$	Sélection de modèle (pénalise complexité)	Calcul manuel ou via packages de modélisation Pandas: organisation résultats avec `pd.DataFrame({'model': [...], 'AIC': [...]})`
[[Statistiques et probabilités#BIC\|BIC (Critère Bayésien)]]	$BIC = k\ln(n) - 2\ln(L)$	Sélection de modèle (pénalité plus forte)	Calcul manuel ou via packages de modélisation Pandas: organisation résultats avec `pd.DataFrame({'model': [...], 'BIC': [...]})`

Régression et modélisation

Concept	Formule	Description	Python
[[Statistiques et probabilités#Régression Linéaire Simple\|Régression linéaire simple]]	$y = \beta_0 + \beta_1 x + \epsilon$	Modèle linéaire à 1 variable	`scipy.stats.linregress(x, y)` `sklearn.linear_model.LinearRegression()` Pandas: préparation avec `df[['x', 'y']]` ou visualisation `df.plot.scatter(x='x', y='y')`
[[Statistiques et probabilités#Régression Linéaire Multiple\|Régression linéaire multiple]]	$y = \beta_0 + \sum_{i=1}^p \beta_i x_i + \epsilon$	Modèle linéaire à p variables	`statsmodels.formula.api.ols()` `sklearn.linear_model.LinearRegression()` Pandas: sélection features `df[['x1', 'x2', 'x3']]` et target `df['y']`
[[Statistiques et probabilités#R²\|R² (coefficient de détermination)]]	$R^2 = 1 - \frac{SS_{res}}{SS_{tot}}$	Proportion de variance expliquée	`sklearn.metrics.r2_score(y_true, y_pred)`, Retourné par `linregress()` Pandas: `df[['y_true', 'y_pred']].corr().iloc[0,1]**2` (approximation)
[[Statistiques et probabilités#R² ajusté\|R² ajusté]]	$R^2_{adj} = 1 - \frac{(1-R^2)(n-1)}{n-p-1}$	R² pénalisé par nombre de variables	Via `statsmodels` dans résumé de modèle Pandas: calcul manuel avec `len(df)` pour n
[[Statistiques et probabilités#MSE\|Erreur quadratique moyenne (MSE)]]	$MSE = \frac{1}{n}\sum_{i=1}^n (y_i - \hat{y}_i)^2$	Mesure d’erreur de prédiction	`sklearn.metrics.mean_squared_error(y_true, y_pred)` Pandas: `((df['y_true'] - df['y_pred'])**2).mean()`
[[Statistiques et probabilités#MAE\|Erreur absolue moyenne (MAE)]]	$MAE = \frac{1}{n}\sum_{i=1}^n\|y_i - \hat{y}_i\|$	Mesure d’erreur robuste aux outliers	`sklearn.metrics.mean_absolute_error(y_true, y_pred)` Pandas: `(df['y_true'] - df['y_pred']).abs().mean()`
[[Statistiques et probabilités#RMSE\|RMSE]]	$RMSE = \sqrt{MSE}$	Erreur dans unité originale	`np.sqrt(mean_squared_error(y_true, y_pred))` Pandas: `np.sqrt(((df['y_true'] - df['y_pred'])**2).mean())`

Résumé OLS

![[Pasted_image_20251031104418.png]]

Résumé Logit

![[Pasted_image_20251031104349.png]]

Concepts avancés

Concept	Description	Python
[[Statistiques et probabilités#Bootstrap\|Bootstrap]]	Rééchantillonnage avec remise pour estimer distribution	`scipy.stats.bootstrap()` Ou boucle avec `np.random.choice(x, size=n, replace=True)` Pandas: `df.sample(n=len(df), replace=True)`
[[Statistiques et probabilités#Validation Croisée\|Validation croisée]]	Division données en train/test pour évaluer modèle	`sklearn.model_selection.cross_val_score()` `sklearn.model_selection.KFold()` Pandas: indices avec `df.iloc[]` pour split manuel
[[Statistiques et probabilités#p-value\|p-value]]	Probabilité d’observer résultat si H₀ vraie	Retournée par tous les tests dans `scipy.stats` Pandas: organisation résultats `pd.DataFrame({'test': [...], 'p_value': [...]})`
[[Statistiques et probabilités#Puissance du test\|Puissance du test]]	Probabilité de rejeter H₀ quand fausse (1-β)	`statsmodels.stats.power` modules Pandas: simulation avec échantillonnage répété via `.sample()`
[[Statistiques et probabilités#Taille d’effet\|Taille d’effet]]	Magnitude de la différence (Cohen’s d, etc.)	`cohen_d = (mean1-mean2)/pooled_std` `pingouin.compute_effsize()` Pandas: `(df.groupby('group')['val'].mean().diff().iloc[-1]) / df['val'].std()` (Cohen’s d)
[[Statistiques et probabilités#Correction de Bonferroni\|Correction de Bonferroni]]	Ajustement α pour tests multiples	`alpha_corrected = alpha / n_tests` `statsmodels.stats.multitest.multipletests()` Pandas: organisation p-values `df['p_adjusted'] = df['p_value'] * n_tests`
[[Statistiques et probabilités#Transformation de Box-Cox\|Transformation de Box-Cox]]	Normalisation de distributions asymétriques	`scipy.stats.boxcox(x)` Pandas: `df['col_transformed'], lambda_param = scipy.stats.boxcox(df['col'])`
[[Statistiques et probabilités#Test de Grubbs\|Test de Grubbs]]	Détection d’outliers	`outliers` package ou calcul manuel avec distribution t Pandas: `df[(df['col'] - df['col'].mean()).abs() > 3*df['col'].std()]` (méthode 3-sigma alternative)

Mathématiques

Notations de base

Notation	Signification	Exemple	Python
$\sum_{i=1}^{N} x_i$	Somme de plusieurs termes	$\sum_{i=1}^N x_i = x_1 + \cdots + x_N$	`sum(x)` ou `np.sum(x)`
$\prod_{i=1}^{N} x_i$	Produit de plusieurs termes	$\prod_{i=1}^N x_i = x_1 \cdots x_N$	`np.prod(x)`
$\log\prod_{i=1}^N x_i$	Produit → somme logarithmique	$\log\prod_{i=1}^N x_i = \sum_{i=1}^N \log x_i$	`np.sum(np.log(x))`
$\bar{x}$	Moyenne d’un vecteur	$\bar{x} = \frac{1}{N}\sum_{i=1}^N x_i$	`np.mean(x)` ou `df['col'].mean()`
$\hat{y}$	Valeur prédite	Prédiction du modèle	`model.predict(X)`
$x_i$	i-ème élément d’un vecteur	Pour $x = (3, 6, 29, 4, 7)$, $x_3 = 29$	`x[2]` (indexation à partir de 0)

Logique mathématique

Connecteur	Nom	Symbole	Interprétation	Python
$\land$	Conjonction	ET	Vrai si les deux sont vrais	`a and b` ou `np.logical_and(a, b)`
$\lor$	Disjonction	OU	Vrai si au moins un est vrai	`a or b` ou `np.logical_or(a, b)`
$\neg$	Négation	NON	Inverse la valeur de vérité	`not a` ou `np.logical_not(a)`
$\Rightarrow$	Implication	Si…alors	Fausse uniquement si p vrai et q faux	`(not p) or q`
$\Leftrightarrow$	Biconditionnelle	Si et seulement si	Vrai si p et q ont même valeur	`p == q`

Lois de De Morgan :

$\neg(p \land q) \equiv (\neg p \lor \neg q)$
$\neg(p \lor q) \equiv (\neg p \land \neg q)$

Dérivées

Fonction $f(x)$	Dérivée $f’(x)$	Remarques	Python (SymPy)
$c$ (constante)	$0$	Toute constante dérivée est nulle	`sp.diff(c, x)`
$x^n$	$nx^{n-1}$	$n \in \mathbb{R}$, règle de puissance	`sp.diff(x**n, x)`
$e^x$	$e^x$	Exponentielle, sa dérivée est elle-même	`sp.diff(sp.exp(x), x)`
$a^x$	$a^x \ln a$	$a > 0$, $a \neq 1$	`sp.diff(a**x, x)`
$\ln x$	$\frac{1}{x}$	Défini pour $x > 0$	`sp.diff(sp.log(x), x)`
$\sin x$	$\cos x$	Fonction trigonométrique	`sp.diff(sp.sin(x), x)`
$\cos x$	$-\sin x$	Fonction trigonométrique	`sp.diff(sp.cos(x), x)`
$\tan x$	$\frac{1}{\cos^2 x} = 1 + \tan^2 x$	Définie sauf pour $x = \frac{\pi}{2} + k\pi$	`sp.diff(sp.tan(x), x)`

Primitives

Fonction $f(x)$	Primitive $F(x)$	Remarques	Python (SymPy)
$0$	$C$ (constante)	Primitive d’une fonction nulle	`sp.integrate(0, x)`
$x^n$ (avec $n \neq -1$)	$\frac{x^{n+1}}{n+1} + C$	Intégration par puissance	`sp.integrate(x**n, x)`
$\frac{1}{x}$	$\ln\|x\| + C$	Défini pour $x \neq 0$	`sp.integrate(1/x, x)`
$e^x$	$e^x + C$	Exponentielle	`sp.integrate(sp.exp(x), x)`
$a^x$	$\frac{a^x}{\ln a} + C$	$a > 0$, $a \neq 1$	`sp.integrate(a**x, x)`
$\sin x$	$-\cos x + C$	Fonction trigonométrique	`sp.integrate(sp.sin(x), x)`
$\cos x$	$\sin x + C$	Fonction trigonométrique	`sp.integrate(sp.cos(x), x)`
$\frac{1}{\cos^2 x}$	$\tan x + C$	Dérivée de la tangente	`sp.integrate(1/sp.cos(x)**2, x)`

Fonctions

Type de fonction	Équation	Paramètres	Propriétés	Python
Identité	$f(x) = x$	-	Ne transforme pas l’input	`lambda x: x`
Linéaire	$f(x) = mx + b$	$m$ (pente), $b$ (ordonnée à l’origine)	Droite	`lambda x: m*x + b`
Quadratique	$f(x) = ax^2 + bx + c$	$a$, $b$, $c$	Parabole	`lambda x: ax2 + bx + c`
Exponentielle	$f(x) = a \cdot e^{bx}$	$a$ (amplitude), $b$ (taux)	Croissance/décroissance rapide	`lambda x: a * np.exp(b*x)`
Logarithmique	$f(x) = a \ln(x) + b$	$a$, $b$	Croissance lente	`lambda x: a * np.log(x) + b`
Puissance	$f(x) = ax^n$	$a$, $n$	Dépend du signe de $n$	`lambda x: a * x**n`
Sigmoïde	$f(x) = \frac{1}{1 + e^{-x}}$	-	Courbe en S, sortie entre 0 et 1	`lambda x: 1/(1 + np.exp(-x))`
ReLU	$f(x) = \max(0, x)$	-	Fonction d’activation neurones	`lambda x: np.maximum(0, x)`
Tangente hyperbolique	$f(x) = \tanh(x)$	-	Sortie entre -1 et 1	`lambda x: np.tanh(x)`

Fonction inverse : Si $f(x) = y$, alors $f^{-1}(y) = x$ Composition : $(f \circ g)(x) = f(g(x))$

Vecteurs

Concept	Notation/Formule	Description	Python (NumPy)
Vecteur	$\mathbf{v} = \begin{bmatrix} v_1 \ v_2 \ \vdots \ v_n \end{bmatrix}$	Liste ordonnée de nombres	`v = np.array([v1, v2, ..., vn])`
Norme L1 (Manhattan)	$\|\mathbf{v}\|1 = \sum{i=1}^n \|v_i\|$	Somme des valeurs absolues	`np.linalg.norm(v, ord=1)` ou `np.sum(np.abs(v))`
Norme L2 (Euclidienne)	$\|\mathbf{v}\|2 = \sqrt{\sum{i=1}^n v_i^2}$	Distance euclidienne depuis l’origine	`np.linalg.norm(v)` ou `np.sqrt(np.sum(v**2))`
Norme infinie	$\|\mathbf{v}\|_\infty = \max_i \|v_i\|$	Valeur absolue maximale	`np.linalg.norm(v, ord=np.inf)` ou `np.max(np.abs(v))`
Produit scalaire	$\mathbf{a} \cdot \mathbf{b} = \sum_{i=1}^n a_i b_i$	Mesure de similarité	`np.dot(a, b)` ou `a @ b`
Angle entre vecteurs	$\cos \theta = \frac{\mathbf{a} \cdot \mathbf{b}}{\|\mathbf{a}\| \|\mathbf{b}\|}$	Angle via produit scalaire	`np.arccos(np.dot(a,b)/(np.linalg.norm(a)*np.linalg.norm(b)))`
Distance euclidienne	$d(\mathbf{a}, \mathbf{b}) = \|\mathbf{a} - \mathbf{b}\|_2$	Distance entre deux vecteurs	`np.linalg.norm(a - b)`
Similarité cosinus	$\cos \theta = \frac{\mathbf{a} \cdot \mathbf{b}}{\|\mathbf{a}\| \|\mathbf{b}\|}$	Mesure de similarité [-1, 1]	`np.dot(a, b) / (np.linalg.norm(a) * np.linalg.norm(b))`

Matrices

Concept	Notation/Formule	Description	Python (NumPy)
Matrice	$\mathbf{A} = \begin{bmatrix} a_{11} & a_{12} \ a_{21} & a_{22} \end{bmatrix}$	Tableau 2D de nombres	`A = np.array([[a11, a12], [a21, a22]])`
Forme/Dimensions	$(m, n)$	$m$ lignes, $n$ colonnes	`A.shape`
Transposition	$\mathbf{A}^T$	Échange lignes ↔ colonnes	`A.T` ou `np.transpose(A)`
Matrice identité	$\mathbf{I}_n$	Diagonale de 1, reste 0	`np.eye(n)` ou `np.identity(n)`
Multiplication matricielle	$\mathbf{C} = \mathbf{A} \cdot \mathbf{B}$	$c_{ij} = \sum_k a_{ik} b_{kj}$	`A @ B` ou `np.dot(A, B)` ou `np.matmul(A, B)`
Matrice inverse	$\mathbf{A}^{-1}$	$\mathbf{A}^{-1} \cdot \mathbf{A} = \mathbf{I}$	`np.linalg.inv(A)`
Déterminant	$\det(\mathbf{A})$	Scalaire caractérisant la matrice	`np.linalg.det(A)`
Trace	$\text{tr}(\mathbf{A}) = \sum_i a_{ii}$	Somme des éléments diagonaux	`np.trace(A)`
Résolution système linéaire	$\mathbf{A}\mathbf{x} = \mathbf{b}$	Trouve $\mathbf{x}$ tel que $\mathbf{Ax} = \mathbf{b}$	`np.linalg.solve(A, b)` ou `np.linalg.inv(A) @ b`

Propriétés clés :

$\mathbf{A}^{-1}$ existe si et seulement si $\det(\mathbf{A}) \neq 0$
$(AB)^T = B^T A^T$
$(AB)^{-1} = B^{-1} A^{-1}$

Complexité computationnelle

Notation	Nom	Exemple	Description
$O(1)$	Constant	Accès `list[0]`	Temps fixe, indépendant de $n$
$O(\log n)$	Logarithmique	Recherche dichotomique	Divise le problème par 2 à chaque étape
$O(n)$	Linéaire	Parcourir une liste	Temps proportionnel à $n$
$O(n \log n)$	Linéarithmique	Tri efficace (quicksort, mergesort)	Bon compromis vitesse/complexité
$O(n^2)$	Quadratique	Boucle imbriquée (double `for`)	Chaque élément comparé à tous les autres
$O(n^3)$	Cubique	Multiplication matricielle naïve, inversion de matrice	Opérations matricielles lourdes
$O(2^n)$	Exponentielle	Force brute, récursion naïve	Explosion combinatoire
$O(n!)$	Factorielle	Permutations exhaustives	Impraticable au-delà de $n \approx 10$

Applications en ML :

Multiplication matricielle : $O(n^3)$ (optimisable à $\approx O(n^{2.37})$)
Inversion de matrice : $O(n^3)$ via élimination de Gauss
PCA : $O(n^3)$ pour le calcul des valeurs propres
K-means : $O(nkdi)$ où $n$ = points, $k$ = clusters, $d$ = dimensions, $i$ = itérations
[[Scikit-learn]]

Import et préparation des données

Commande	Description
`from sklearn.model_selection import train_test_split`	Sépare les données en ensembles d’entraînement et de test.
`X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)`	Split 80/20.
`from sklearn.preprocessing import StandardScaler`	Import du standardiseur.
`scaler = StandardScaler()`	Crée un standardiseur.
`X_scaled = scaler.fit_transform(X)`	Standardise les features.
`from sklearn.preprocessing import MinMaxScaler`	Normalisation min-max.
`from sklearn.preprocessing import LabelEncoder`	Encodage des labels.
`from sklearn.preprocessing import OneHotEncoder`	One-hot encoding.
`from sklearn.impute import SimpleImputer`	Imputation des valeurs manquantes.
`from sklearn.feature_extraction.text import TfidfVectorizer`	Vectorisation TF-IDF.
`from sklearn.feature_extraction.text import CountVectorizer`	Vectorisation par comptage.

Modèles

Régression

Commande	Description
`from sklearn.linear_model import LinearRegression`	Importe le modèle de régression linéaire.
`model = LinearRegression()`	Crée une instance du modèle.
`from sklearn.linear_model import Ridge`	Régression Ridge (L2).
`from sklearn.linear_model import Lasso`	Régression Lasso (L1).
`from sklearn.linear_model import ElasticNet`	ElasticNet (L1 + L2).
`from sklearn.linear_model import LogisticRegression`	Régression logistique.
`from sklearn.tree import DecisionTreeRegressor`	Arbre de décision pour régression.
`from sklearn.ensemble import RandomForestRegressor`	Random Forest régression.
`from sklearn.ensemble import GradientBoostingRegressor`	Gradient Boosting régression.
`from sklearn.svm import SVR`	Support Vector Regression.
`from sklearn.neighbors import KNeighborsRegressor`	K-NN régression.

Classification

Commande	Description
`from sklearn.tree import DecisionTreeClassifier`	Arbre de décision.
`from sklearn.ensemble import RandomForestClassifier`	Random Forest.
`from sklearn.ensemble import GradientBoostingClassifier`	Gradient Boosting.
`from sklearn.svm import SVC`	Support Vector Classifier.
`from sklearn.neighbors import KNeighborsClassifier`	K-NN classification.
`from sklearn.naive_bayes import GaussianNB`	Naive Bayes gaussien.
`from sklearn.naive_bayes import MultinomialNB`	Naive Bayes multinomial.
`from sklearn.discriminant_analysis import LinearDiscriminantAnalysis`	LDA.
`from sklearn.ensemble import AdaBoostClassifier`	AdaBoost.
`from sklearn.ensemble import VotingClassifier`	Ensemble voting.

Attributs

Commande / Attribut	Description
`model.fit(X_train, y_train)`	Entraîne le modèle.
`model.predict(X_test)`	Prédit les valeurs pour de nouvelles données.
`model.score(X_test, y_test)`	Retourne le score (R² ou accuracy selon le type de modèle).
`model.get_params()`	Affiche tous les hyperparamètres du modèle.
`model.set_params(**params)`	Met à jour les hyperparamètres du modèle.
`model.fit_predict(X)`	Entraîne puis prédit (souvent pour le clustering).
`model.fit_transform(X)`	Entraîne puis transforme (souvent pour PCA, scalers, etc.).
`model.transform(X)`	Transforme les données (PCA, StandardScaler…).
`model.inverse_transform(X_transformed)`	Reconstitue les données originales après transformation.
`model.classes_`	Liste des classes dans un modèle de classification.
`model.feature_importances_`	Importance des features (arbres, RF, GB, etc.).
`model.coef_`	Coefficients des features (modèles linéaires).
`model.intercept_`	Biais (modèles linéaires).
`model.n_features_in_`	Nombre de variables d’entrée utilisées.
`model.best_params_`	(GridSearchCV) — Meilleurs hyperparamètres trouvés.
`model.best_score_`	(GridSearchCV) — Score associé aux meilleurs paramètres.
`model.cv_results_`	(GridSearchCV) — Résultats complets de la recherche.
`model.predict_proba(X)`	Probabilités de chaque classe (classifieurs probabilistes).
`model.decision_function(X)`	Distance au plan de séparation (SVM, LDA…).

Métriques et évaluation

Commande	Description
`from sklearn.metrics import accuracy_score`	Importe la fonction pour calculer la précision.
`accuracy_score(y_test, predictions)`	Calcule la précision du modèle.
`from sklearn.metrics import mean_squared_error`	MSE pour régression.
`from sklearn.metrics import mean_absolute_error`	MAE pour régression.
`from sklearn.metrics import r2_score`	Score R².
`from sklearn.metrics import confusion_matrix`	Matrice de confusion.
`from sklearn.metrics import classification_report`	Rapport de classification.
`from sklearn.metrics import precision_recall_curve`	Courbe précision-rappel.
`from sklearn.metrics import roc_curve, auc`	Courbe ROC et AUC.
`from sklearn.metrics import f1_score`	Score F1.
`from sklearn.metrics import precision_score`	Précision.
`from sklearn.metrics import recall_score`	Rappel.

Fonction	Description	Retour
`accuracy_score(y_true, y_pred)`	Taux de prédictions correctes.	float
`f1_score(y_true, y_pred)`	Moyenne harmonique précision/rappel.	float
`precision_score(y_true, y_pred)`	Taux de vrais positifs parmi les positifs prédits.	float
`recall_score(y_true, y_pred)`	Taux de vrais positifs parmi les réels positifs.	float
`r2_score(y_true, y_pred)`	Score R² (régression).	float
`mean_squared_error(y_true, y_pred, squared=False)`	Erreur quadratique moyenne (ou RMSE).	float
`mean_absolute_error(y_true, y_pred)`	Erreur absolue moyenne.	float
`confusion_matrix(y_true, y_pred)`	Matrice de confusion.	ndarray
`classification_report(y_true, y_pred)`	Rapport détaillé (precision, recall, f1).	str
`roc_curve(y_true, y_score)`	Points de la courbe ROC.	(fpr, tpr, seuils)
`auc(fpr, tpr)`	Aire sous la courbe ROC.	float
`precision_recall_curve(y_true, y_score)`	Points précision/rappel.	(precision, recall, seuils)
`balanced_accuracy_score(y_true, y_pred)`	Moyenne équilibrée des recalls.	float

Visualisations

Commande	Description
`from sklearn.metrics import ConfusionMatrixDisplay`	Affiche la matrice de confusion.
`ConfusionMatrixDisplay.from_estimator(model, X_test, y_test)`	Génère la matrice automatiquement.
`from sklearn.metrics import RocCurveDisplay`	Affiche la courbe ROC.
`RocCurveDisplay.from_estimator(model, X_test, y_test)`	ROC à partir du modèle.
`from sklearn.metrics import PrecisionRecallDisplay`	Courbe précision-rappel.
`PrecisionRecallDisplay.from_estimator(model, X_test, y_test)`	PR curve automatique.

Validation croisée et tuning

Cross-validation

Commande	Description
`from sklearn.model_selection import cross_val_score`	Validation croisée.
`scores = cross_val_score(model, X, y, cv=5)`	5-fold cross-validation.
`from sklearn.model_selection import GridSearchCV`	Recherche en grille.
`grid_search = GridSearchCV(model, param_grid, cv=5)`	Configuration grid search.
`from sklearn.model_selection import RandomizedSearchCV`	Recherche aléatoire.
`from sklearn.model_selection import KFold`	K-Fold manuel.
`from sklearn.model_selection import StratifiedKFold`	K-Fold stratifié.
`from sklearn.model_selection import LeaveOneOut`	Leave-one-out CV.
`model.best_params_`	Meilleurs paramètres trouvés.
`model.best_score_`	Meilleur score obtenu.

Plusieurs métriques

Commande	Description
`from sklearn.model_selection import cross_validate`	Validation croisée complète avec plusieurs métriques.
`results = cross_validate(model, X, y, cv=5, scoring=['r2', 'neg_mean_squared_error'])`	Retourne un dict de scores.
`results['test_r2']`	Liste des scores R² par fold.
`results['fit_time']`	Temps d’entraînement pour chaque fold.

Prédiction

Commande	Description
`from sklearn.model_selection import cross_val_predict`	Prédit en cross-validation.
`y_pred = cross_val_predict(model, X, y, cv=5)`	Prédictions CV pour tout le dataset.

Learning curve

Commande	Description
`from sklearn.model_selection import learning_curve`	Calcule les courbes d’apprentissage.
`train_sizes, train_scores, test_scores = learning_curve(model, X, y, cv=5)`	Renvoie tailles d’échantillon et scores.

Validation curve

Commande	Description
`from sklearn.model_selection import validation_curve`	Étudie un hyperparamètre en particulier.
`param_range = np.logspace(-3, 3, 7)`	Définit les valeurs à tester.
`train_scores, test_scores = validation_curve(model, X, y, param_name='C', param_range=param_range, cv=5)`	Retourne scores d’entraînement/test selon un paramètre.

Réduction de dimensionnalité et clustering

Commande	Description
`from sklearn.decomposition import PCA`	Analyse en composantes principales.
`pca = PCA(n_components=2)`	PCA à 2 composantes.
`from sklearn.decomposition import TruncatedSVD`	SVD tronquée.
`from sklearn.manifold import TSNE`	t-SNE.
`from sklearn.feature_selection import SelectKBest`	Sélection des K meilleures features.
`from sklearn.feature_selection import RFE`	Recursive Feature Elimination.
`from sklearn.cluster import KMeans`	K-Means clustering.
`from sklearn.cluster import DBSCAN`	DBSCAN clustering.
`from sklearn.cluster import AgglomerativeClustering`	Clustering hiérarchique.
`from sklearn.mixture import GaussianMixture`	Gaussian Mixture Model.

Pipelines et persistance

Commande	Description
`from sklearn.pipeline import Pipeline`	Import Pipeline.
`pipeline = Pipeline([('scaler', StandardScaler()), ('model', SVC())])`	Crée un pipeline.
`from sklearn.compose import ColumnTransformer`	Transformation par colonne.
`import joblib`	Pour sauvegarder les modèles.
`joblib.dump(model, 'model.pkl')`	Sauvegarde le modèle.
`model = joblib.load('model.pkl')`	Charge le modèle.
`from sklearn.preprocessing import FunctionTransformer`	Transformateur personnalisé.

Web Scraping

BeautifulSoup basics

Commande	Description
`from bs4 import BeautifulSoup`	Import BeautifulSoup.
`soup = BeautifulSoup(html, "html.parser")`	Parse le contenu HTML.
`soup = BeautifulSoup(html, "lxml")`	Parse avec lxml (plus rapide).
`soup.prettify()`	Affiche le HTML formaté.

Commande	Description
`soup.find("h1")`	Récupère la première balise h1.
`soup.find_all("p")`	Récupère toutes les balises p.
`soup.find("div", class_="className")`	Trouve par classe.
`soup.find("div", {"id": "myId"})`	Trouve par ID.
`soup.find("a", href=True)`	Trouve les liens avec href.
`soup.find_all("tag", limit=5)`	Limite le nombre de résultats.
`soup.find_parent("div")`	Trouve le parent.
`soup.find_next_sibling()`	Prochain élément frère.
`soup.find_previous_sibling()`	Élément frère précédent.
`soup.children`	Enfants directs.
`soup.descendants`	Tous les descendants.

Extraction de données

Commande	Description
`element.get_text()`	Récupère le texte d’un élément.
`element.get_text(strip=True)`	Texte sans espaces superflus.
`element.string`	Contenu texte direct.
`element.attrs`	Récupère les attributs d’un élément.
`element.get("href")`	Récupère un attribut spécifique.
`element["href"]`	Autre façon de récupérer un attribut.
`soup.find("a")["href"]`	Récupère l’URL d’un lien.
`element.name`	Nom de la balise.

Sélecteurs CSS

Commande	Description
`soup.select("div.classname")`	Sélectionne les éléments avec une classe spécifique.
`soup.select("#idname")`	Sélectionne par ID.
`soup.select("div > p")`	Enfants directs.
`soup.select("div p")`	Tous les descendants.
`soup.select("div + p")`	Élément adjacent.
`soup.select("div ~ p")`	Éléments frères.
`soup.select("a[href]")`	Éléments avec attribut.
`soup.select("a[href='value']")`	Attribut avec valeur spécifique.
`soup.select("p:nth-of-type(3)")`	Nième élément.

Requests et sessions

Commande	Description
`import requests`	Import requests.
`response = requests.get(url)`	GET request.
`response = requests.post(url, data=data)`	POST request.
`response.text`	Contenu HTML.
`response.content`	Contenu binaire.
`response.status_code`	Code de statut.
`response.headers`	Headers de réponse.
`response.cookies`	Cookies.
`session = requests.Session()`	Crée une session.
`session.get(url)`	Request avec session.
`requests.get(url, headers={'User-Agent': 'Mozilla/5.0'})`	Headers personnalisés.
`requests.get(url, timeout=5)`	Timeout.
`requests.get(url, proxies={'http': 'proxy_url'})`	Utilise un proxy.

Selenium pour JavaScript

Commande	Description
`from selenium import webdriver`	Import Selenium.
`driver = webdriver.Chrome()`	Lance Chrome.
`driver.get(url)`	Ouvre une page.
`driver.find_element_by_id("id")`	Trouve par ID.
`driver.find_element_by_class_name("class")`	Trouve par classe.
`driver.find_element_by_xpath("//path")`	Trouve par XPath.
`element.click()`	Clique sur un élément.
`element.send_keys("text")`	Envoie du texte.
`driver.implicitly_wait(10)`	Attente implicite.
`driver.quit()`	Ferme le navigateur.

Concept	Formule	Description	Python
[[Statistiques et probabilités#Moyenne Arithmétique\|Moyenne]]	\(\bar{x} = \frac{1}{n} \sum_{i=1}^{n} x_i\)	Somme des valeurs divisée par le nombre de valeurs	`np.mean(x)` `statistics.mean(x)` `df['col'].mean()` `df.mean()`
[[Statistiques et probabilités#Médiane\|Médiane]]	`mediane(x)`	Valeur centrale d’un jeu de données trié. ==Insensible aux outliers.==	`np.median(x)` `statistics.median(x)` `df['col'].median()` `df.median()`
[[Statistiques et probabilités#Mode\|Mode]]	`mode(x)`	Valeur la plus fréquente	`statistics.mode(x)` `scipy.stats.mode(x)` `df['col'].mode()` `df.mode()`
[[Statistiques et probabilités#Variance et Écart-Type\|Variance (population)]]	\(\sigma^2 = \frac{\sum_{i=1}^{N} (x_i - \mu)^2}{N}\)	Dispersion des données par rapport à la moyenne populationnelle	`np.var(x, ddof=0)` `statistics.pvariance(x)` `df['col'].var(ddof=0)` `df.var(ddof=0)`
[[Statistiques et probabilités#Variance et Écart-Type\|Variance (échantillon)]]	\(s^2 = \frac{\sum_{i=1}^{n} (x_i - \bar{x})^2}{n-1}\)	Estimation de la variance populationnelle	`np.var(x, ddof=1)` `statistics.variance(x)` `df['col'].var()` `df.var()`
[[Statistiques et probabilités#Variance et Écart-Type\|Écart-type]]	\(\sigma = \sqrt{\sigma^2}, \quad s = \sqrt{s^2}\)	Dispersion dans la même unité que les données	`np.std(x, ddof=0)` (pop) `np.std(x, ddof=1)` (éch) `df['col'].std()` `df.std()`
[[Statistiques et probabilités#Coefficient de Variation\|Coefficient de variation]]	\(CV = \frac{\sigma}{\bar{x}} \times 100\%\)	Dispersion relative	`(np.std(x)/np.mean(x))100` `scipy.stats.variation(x)100` `(df['col'].std()/df['col'].mean())*100`
[[Statistiques et probabilités#Étendue\|Étendue (Range)]]	\(R = \max(x) - \min(x)\)	Différence entre max et min	`np.ptp(x)` `max(x) - min(x)` `df['col'].max() - df['col'].min()`

Concept	Formule	Description	Python
[[Statistiques et probabilités#Types de Probabilité\|Probabilité]]	\(P(A) = \frac{\text{cas favorables}}{\text{cas possibles}}\)	Chance qu’un événement se produise	`favorable/total` ou simulations `(df['col'] == valeur).mean()` (fréquence empirique)
[[Statistiques et probabilités#Événements Dépendants et Indépendants\|Indépendance]]	\(P(A \cap B) = P(A) \times P(B)\)	A et B n’influencent pas	Test via contingence: `pd.crosstab(df['A'], df['B'])`
[[Statistiques et probabilités#Espérance Mathématique\|Espérance]]	\(E[X] = \sum x_i P(x_i)\)	Valeur moyenne attendue	`np.sum(x * p)` ou `df['col'].mean()` (empirique)
[[Statistiques et probabilités#Variance d’une Variable Aléatoire\|Variance théorique]]	\(Var(X) = E[(X - E[X])^2]\)	Dispersion d’une variable aléatoire	`np.sum((x - np.mean(x))*2 p)` ou `df['col'].var()`
[[Statistiques et probabilités#Combinaisons et Permutations\|Combinaisons]]	\(C(n,k) = \frac{n!}{k!(n-k)!}\)	Choix de k éléments parmi n	`scipy.special.comb(n, k)` Pandas: génération via `itertools.combinations()`
[[Statistiques et probabilités#Combinaisons et Permutations\|Permutations]]	\(P(n,k) = \frac{n!}{(n-k)!}\)	Arrangements de k parmi n	`scipy.special.perm(n, k)` Pandas: génération via `itertools.permutations()`

Type d’intervalle	Formule/Contexte	Description	Python
[[Statistiques et probabilités#Intervalle de Confiance pour la Moyenne\|IC Moyenne (σ connu)]]	\(\bar{x} \pm z_{\alpha/2} \frac{\sigma}{\sqrt{n}}\)	Quand variance population connue	`scipy.stats.norm.interval(confidence, loc=mean, scale=σ/np.sqrt(n))` `df['col'].mean() ± z * df['col'].std()/np.sqrt(len(df))`
[[Statistiques et probabilités#Intervalle de Confiance pour la Moyenne\|IC Moyenne (σ inconnu)]]	\(\bar{x} \pm t_{\alpha/2, n-1} \frac{s}{\sqrt{n}}\)	Utilise distribution t	`scipy.stats.t.interval(confidence, df=n-1, loc=mean, scale=s/np.sqrt(n))` Avec pandas: calcul manuel des composants
[[Statistiques et probabilités#Intervalle de Confiance pour une Proportion\|IC Proportion]]	\(\hat{p} \pm z_{\alpha/2} \sqrt{\frac{\hat{p}(1-\hat{p})}{n}}\)	Intervalle pour proportions	`statsmodels.stats.proportion.proportion_confint(count, n)` `p_hat = (df['col']==val).mean()` puis calcul manuel
[[Statistiques et probabilités#IC pour Variance\|IC Variance]]	Basé sur distribution Chi-carré	Intervalle pour variance population	`chi2.ppf([α/2, 1-α/2], df=n-1)` puis formule Composants via `df['col'].var()`
[[Statistiques et probabilités#IC pour Différence de Moyennes\|IC Différence de moyennes]]	\((\bar{x}_1 - \bar{x}_2) \pm t \times SE\)	Comparaison de deux groupes	`scipy.stats.ttest_ind()` retourne IC Groupes: `df.groupby('group')['value'].agg(['mean', 'std', 'count'])`

Concept	Formule	Description	Python
[[Statistiques et probabilités#Théorème de Bayes\|Théorème de Bayes]]	\(P({H}\|{E}) = \frac{P({E}\|{H}) P(H)}{P({E}\|{H}) P(H) + P({E}\|{–H}) P(\neg H)}\)	Mise à jour de croyance après evidence	Calcul manuel ou `pymc` pour inférence bayésienne Pandas: calcul des probabilités avec `.value_counts(normalize=True)`
[[Statistiques et probabilités#Fonction de Vraisemblance\|Likelihood]]	\(L(\theta\| Y) = P(Y\|\theta)\)	Support des données pour un paramètre	Dépend de la loi: `.pmf()` ou `.pdf()` Pandas: préparation données avec `.groupby()`
[[Statistiques et probabilités#Log-vraisemblance\|Log-vraisemblance]]	\(\ell(\theta) = \log L(\theta\| Y) = \sum_i \log P(y_i\|\theta)\)	Transformation logarithmique pour faciliter calculs	`np.sum(np.log(prob))` ou méthodes `.logpdf()` Pandas: `np.log(df['prob']).sum()`
[[Statistiques et probabilités#Estimateur du Maximum de Vraisemblance (MLE)\|Maximum Likelihood Estimate (MLE)]]	\(\hat{\theta}_{MLE} = \arg\max_\theta L(\theta\| Y)\)	Paramètre qui maximise la likelihood	`scipy.optimize.minimize()` ou `scipy.stats.distribution.fit(data)` Avec pandas: `scipy.stats.distribution.fit(df['col'])`
[[Statistiques et probabilités#Statistique Suffisante\|Statistique suffisante]]	Condense toute l’information pertinente pour estimer un paramètre	Ex: moyenne pour μ	Dépend de la distribution Pandas: extraction via `.mean()`, `.sum()` selon distribution
[[Statistiques et probabilités#Profile Likelihood et Paramètres de Nuisance\|Nuisance parameter & Profile Likelihood]]	Paramètre secondaire remplacé par estimateur pour se concentrer sur paramètre principal	\(L_p(\mu) = L(\mu, \hat{\sigma}^2)\)	`scipy.optimize.minimize()` avec contrainte Pandas: préparation des données
[[Statistiques et probabilités#Rapport de vraisemblance\|Rapport de vraisemblance]]	\(\Lambda = \frac{L(\theta_0\| Y)}{L(\hat{\theta}\| Y)}\)	Test d’hypothèse basé sur vraisemblance	`-2*log(Lambda)` suit loi Chi-carré Pandas: calcul des composants
[[Statistiques et probabilités#AIC\|AIC (Critère d’Akaike)]]	\(AIC = 2k - 2\ln(L)\)	Sélection de modèle (pénalise complexité)	Calcul manuel ou via packages de modélisation Pandas: organisation résultats avec `pd.DataFrame({'model': [...], 'AIC': [...]})`
[[Statistiques et probabilités#BIC\|BIC (Critère Bayésien)]]	\(BIC = k\ln(n) - 2\ln(L)\)	Sélection de modèle (pénalité plus forte)	Calcul manuel ou via packages de modélisation Pandas: organisation résultats avec `pd.DataFrame({'model': [...], 'BIC': [...]})`

Concept	Formule	Description	Python
[[Statistiques et probabilités#Régression Linéaire Simple\|Régression linéaire simple]]	\(y = \beta_0 + \beta_1 x + \epsilon\)	Modèle linéaire à 1 variable	`scipy.stats.linregress(x, y)` `sklearn.linear_model.LinearRegression()` Pandas: préparation avec `df[['x', 'y']]` ou visualisation `df.plot.scatter(x='x', y='y')`
[[Statistiques et probabilités#Régression Linéaire Multiple\|Régression linéaire multiple]]	\(y = \beta_0 + \sum_{i=1}^p \beta_i x_i + \epsilon\)	Modèle linéaire à p variables	`statsmodels.formula.api.ols()` `sklearn.linear_model.LinearRegression()` Pandas: sélection features `df[['x1', 'x2', 'x3']]` et target `df['y']`
[[Statistiques et probabilités#R²\|R² (coefficient de détermination)]]	\(R^2 = 1 - \frac{SS_{res}}{SS_{tot}}\)	Proportion de variance expliquée	`sklearn.metrics.r2_score(y_true, y_pred)`, Retourné par `linregress()` Pandas: `df[['y_true', 'y_pred']].corr().iloc[0,1]**2` (approximation)
[[Statistiques et probabilités#R² ajusté\|R² ajusté]]	\(R^2_{adj} = 1 - \frac{(1-R^2)(n-1)}{n-p-1}\)	R² pénalisé par nombre de variables	Via `statsmodels` dans résumé de modèle Pandas: calcul manuel avec `len(df)` pour n
[[Statistiques et probabilités#MSE\|Erreur quadratique moyenne (MSE)]]	\(MSE = \frac{1}{n}\sum_{i=1}^n (y_i - \hat{y}_i)^2\)	Mesure d’erreur de prédiction	`sklearn.metrics.mean_squared_error(y_true, y_pred)` Pandas: `((df['y_true'] - df['y_pred'])**2).mean()`
[[Statistiques et probabilités#MAE\|Erreur absolue moyenne (MAE)]]	\(MAE = \frac{1}{n}\sum_{i=1}^n\|y_i - \hat{y}_i\|\)	Mesure d’erreur robuste aux outliers	`sklearn.metrics.mean_absolute_error(y_true, y_pred)` Pandas: `(df['y_true'] - df['y_pred']).abs().mean()`
[[Statistiques et probabilités#RMSE\|RMSE]]	\(RMSE = \sqrt{MSE}\)	Erreur dans unité originale	`np.sqrt(mean_squared_error(y_true, y_pred))` Pandas: `np.sqrt(((df['y_true'] - df['y_pred'])**2).mean())`

Contenu protégé

Langages universels

Bash

Navigation et fichiers

Affichage et manipulation de contenu

Processus et système

Réseau et téléchargement

Scripts et environnement

Pipes et redirection

Pip

Gestion des packages

Environnements virtuels

Git

Configuration et initialisation

Staging et commits

Branches et fusion

Remote et synchronisation

Inspection et historique

Stash et tags

[[Python]]

Chaînes de caractères

Listes

Dictionnaires

Sets

Tuples et unpacking

Conditions

Boucles

Compréhensions

Gestion des erreurs et debugging

Programmation fonctionnelle

Classes et objets

Astuces et idiomes Python

Data Manipulation

[[NumPy]]

Création de tableaux

Formes et dimensions

Indexation et slicing

Opérations mathématiques

Statistiques et agrégations

Algèbre linéaire

Combinaison et séparation

Broadcasting et vectorisation

Génération de nombres aléatoires

Masques et conditions

Input/Output

Pandas

Création de DataFrames

Import/Export de données

Exploration des données

Sélection et indexation

Modification des données

Tri et réorganisation

Agrégations et groupby

Fusion et jointure

Reshape et pivot

Traitement des dates

Traitement des chaînes (str accessor)

MultiIndex & exemples

Gestion de la mémoire et optimisation

Statistiques

SQL

Création et gestion de bases

Création et modification de tables

Requêtes SELECT et jointures

Agrégations et regroupements

Manipulation de données (DML)

Fonctions texte

Fonctions numériques

Gestion des NULL et dates

Contraintes et index

Vues et procédures stockées

Transactions

[[SQL#Window Functions — Fonctions de Fenêtre SQL|Window Functions]]

CTE (Common Table Expressions)

Bonnes pratiques et conventions

Data Visualization

Configuration et styles

Création de figures

Types de graphiques de base

Personnalisation des axes et labels