Cheatsheets — vue longue

Jupyter fonctionne en deux modes : Édition (dans une cellule) et Commande (entre cellules). Échap bascule en mode commande, Entrée revient en édition.

Raccourcis essentiels

Le réflexe à prendre : Échap, B, puis Shift + Entrée — nouvelle cellule, exécution, passage à la suivante.

Action	Raccourci
Exécuter et aller à la cellule suivante	Shift + Entrée
Exécuter sans bouger	Cmd + Entrée
Exécuter et créer une cellule dessous	Option + Entrée
Créer une cellule au-dessus	Échap, puis A
Créer une cellule en dessous	Échap, puis B
Supprimer la cellule	Échap, puis D, D
Copier / couper / coller une cellule	Échap, puis C / X / V
Annuler la suppression	Échap, puis Z
Transformer en cellule Markdown	Échap, puis M
Transformer en cellule Code	Échap, puis Y
Naviguer entre cellules	Échap, puis ↑ / ↓

Magics utiles

%time ma_fonction()          # Temps d'une instruction
%timeit ma_fonction()        # Moyenne sur plusieurs exécutions
%%time                       # Temps de toute la cellule
%load_ext autoreload
%autoreload 2                # Recharger les modules modifiés
%matplotlib inline           # Afficher les plots inline
%pdb                         # Debugger automatique sur erreur
!pip install package         # Commande shell

Afficher plusieurs résultats

Par défaut, seule la dernière expression s'affiche.

from IPython.display import display

display(df.head())
display(df.describe())

Éviter le scroll infini

import pandas as pd
pd.set_option('display.max_rows', 50)

Redémarrer le kernel

Échap, puis 0, 0 redémarre le kernel. Utile quand l'état est cassé.

Convertir en script

jupyter nbconvert --to script notebook.ipynb

Extensions JupyterLab

pip install jupyterlab-code-formatter black isort

Permet de formater le code avec Cmd + Shift + F.

Variables d'environnement et secrets

from dotenv import load_dotenv, dotenv_values, find_dotenv
import os

# Charger automatiquement le .env trouvé
load_dotenv()

# Charger un fichier précis
load_dotenv(".env")
load_dotenv("/chemin/vers/.env")

# Recharger en remplaçant les valeurs déjà présentes dans le kernel
load_dotenv(".env", override=True)

.env = fichier sur disque ; os.environ = variables actuellement en mémoire dans le kernel. load_dotenv(..., override=True) copie le premier vers le second en remplaçant les valeurs existantes.

# Trouver le .env réellement utilisé
env_path = find_dotenv(usecwd=True)
print(env_path)

# Lire le fichier sans modifier l'environnement du notebook
env_vars = dotenv_values(".env")
print(env_vars.keys())

# Vérifier les noms et la présence des valeurs sans afficher les secrets
for name, value in dotenv_values(".env").items():
    print(f"{name}: {'définie' if value else 'vide'}")

# Lire une variable chargée
api_key = os.environ.get("GOOGLE_API_KEY")

# Vérifier une variable sans révéler sa valeur
print(bool(os.environ.get("GOOGLE_API_KEY")))

# Définir ou modifier temporairement une variable dans le notebook
os.environ["GOOGLE_API_KEY"] = "nouvelle_valeur"

# Supprimer une variable du kernel actuel
os.environ.pop("GOOGLE_API_KEY", None)

Variables d'environnement

%env

Liste toutes les variables d'environnement. À éviter si tu as des clés secrètes.

%env GOOGLE_API_KEY

Affiche la valeur d'une variable précise — à éviter aussi pour une clé.

%env MODE=development

Crée ou remplace une variable dans le kernel.

%env MODE development

Même résultat, avec un espace au lieu de =.

my_value = "development"
%env MODE=$my_value

Copie la valeur d'une variable Python dans une variable d'environnement.

%env?

Affiche l'aide exacte de ta version.

Introspection avec ? et ??

objet?

Affiche l'aide : documentation, signature et type.

len?
get_current_weather?
PolygonToolkit?

Pour une fonction, tu verras ses arguments et sa docstring.

objet??

Fait la même chose, mais essaie aussi d'afficher le code source Python.

get_current_weather??

Très pratique pour tes propres fonctions, ou pour comprendre une fonction d'une librairie.

Le code source peut ne pas apparaître si l'objet est écrit en C, compilé, ou si le package ne fournit pas les sources (list?? par exemple).

Recherche

# Recherche les objets dont le nom contient "embed"
*embed*?

# Avec un import récent
from langchain_community.agent_toolkits.polygon.toolkit import PolygonToolkit

PolygonToolkit?
PolygonToolkit.from_polygon_api_wrapper?

À retenir : ? = comprendre comment utiliser ; ?? = essayer de voir comment c'est construit.

See also

python-requests pandas numpy pytorch keras-tensorflow

Charge des variables d'environnement depuis un fichier .env sans polluer le shell parent, utile en notebook et pour les secrets locaux.

Charger

from dotenv import load_dotenv
import os

# Cherche .env dans le répertoire courant et les parents
load_dotenv()

# Charger un fichier précis
load_dotenv(".env.local")
load_dotenv("/chemin/absolu/.env")

# Recharger en écrasant les valeurs déjà présentes dans le kernel
load_dotenv(override=True)

Lire sans modifier l'environnement

from dotenv import dotenv_values

# Retourne un dict, sans toucher à os.environ
env_vars = dotenv_values(".env")
print(env_vars.keys())

# Vérifier les noms et la présence des valeurs sans afficher les secrets
for name, value in dotenv_values(".env").items():
    print(f"{name}: {'définie' if value else 'vide'}")

Diagnostic

from dotenv import find_dotenv

# Trouver le .env réellement utilisé
env_path = find_dotenv(usecwd=True)
print(env_path)  # '' si aucun fichier trouvé

# Vérifier qu'une variable est chargée sans révéler sa valeur
print(bool(os.environ.get("GOOGLE_API_KEY")))

Manipuler l'environnement du kernel

# Lire une variable chargée
api_key = os.environ.get("GOOGLE_API_KEY")

# Définir ou modifier temporairement
os.environ["GOOGLE_API_KEY"] = "nouvelle_valeur"

# Supprimer du kernel actuel
os.environ.pop("GOOGLE_API_KEY", None)

Distinction à retenir

Objet	Portée
.env	fichier sur disque
os.environ	variables en mémoire dans le kernel Python actuel
load_dotenv()	copie le fichier vers os.environ
override=True	remplace les valeurs déjà présentes

Le fichier .env n'est jamais modifié par load_dotenv(). Les modifications de os.environ ne persistent pas après redémarrage du kernel.

---

title: python-dotenv category: cheatsheets created: 2025-01-21 updated: 2025-01-21 tags: [python, dotenv, env, secrets, configuration, jupyter] confidence: high publish: true

Charger des variables d'environnement depuis un fichier .env sans les commiter, surtout utile en notebook où l'environnement shell n'est pas lu au démarrage.

Import et chargement

from dotenv import load_dotenv, dotenv_values, find_dotenv
import os

# Charger automatiquement le .env trouvé
load_dotenv()

# Charger un fichier précis
load_dotenv(".env")
load_dotenv("/chemin/vers/.env")

# Recharger en remplaçant les valeurs déjà présentes dans le kernel
load_dotenv(".env", override=True)

Lire sans charger

# Lire le fichier sans modifier l'environnement du notebook
env_vars = dotenv_values(".env")
print(env_vars.keys())

# Vérifier les noms et la présence des valeurs sans afficher les secrets
for name, value in dotenv_values(".env").items():
    print(f"{name}: {'définie' if value else 'vide'}")

Utiliser les variables

# Lire une variable chargée
api_key = os.environ.get("GOOGLE_API_KEY")

# Vérifier une variable sans révéler sa valeur
print(bool(os.environ.get("GOOGLE_API_KEY")))

Modifier temporairement

# Définir ou modifier temporairement une variable dans le notebook
os.environ["GOOGLE_API_KEY"] = "nouvelle_valeur"

# Supprimer une variable du kernel actuel
os.environ.pop("GOOGLE_API_KEY", None)

Diagnostic

# Trouver le .env réellement utilisé
env_path = find_dotenv(usecwd=True)
print(env_path)

À retenir

.env = fichier sur disque ; os.environ = variables actuellement en mémoire dans le kernel. load_dotenv(..., override=True) copie le premier vers le second en remplaçant les valeurs existantes.

Saisir un secret sans l'afficher avec getpass

from getpass import getpass

api_key = getpass("Entre ta clé API : ")

La saisie est masquée. Utile dans un notebook pour tester sans écrire la clé dans le fichier.

Charger directement dans l'environnement :

import os
from getpass import getpass

os.environ["GOOGLE_API_KEY"] = getpass("Clé Gemini : ")

Puis lire normalement :

api_key = os.environ.get("GOOGLE_API_KEY")

Vérifier qu'elle existe, sans l'afficher :

print(bool(api_key))

Récupérer ton nom d'utilisateur système :

from getpass import getuser
print(getuser())

À retenir : la valeur vit en mémoire dans le kernel, disparaît au redémarrage. Ne pas faire print(api_key). Pratique pour tester sans .env ni écriture dans le notebook.

See also

• jupyter
• python-requests
• pydantic

See also

• python-requests — charger une clé API depuis .env
• jupyter — redémarrer le kernel pour effacer os.environ
• pydantic — Settings avec model_config = SettingsConfigDict(env_file=".env")