đ PyCharm â IDE Python, Debugging & Data Science
Guide complet IDEO-Lab pour maĂźtriser PyCharm, de la gestion de vEnv au debugging de Django.
Vue d'ensemble
Qu'est-ce que PyCharm ? L'IDE Python de JetBrains.
IDE Python JetBrainsCommunity vs Pro
Comparaison des éditions (Gratuit vs Payant).
Community (Free) Professional Data ScienceInstallation (Toolbox)
Toolbox App (reco), Snap/Flatpak, Standalone.
Toolbox snap Windows macOSStructure Projet & UI
Projets, .idea, venv, Contenu (src).
Gestion des Interpréteurs
Le concept clé : vEnv, Conda, Interpréteur SystÚme.
vEnv Conda IsolationGestion des Paquets
UI, requirements.txt, pyproject.toml.
Ăditeur & Intentions
Smart completion, Alt+Entrée, Type Hints.
Refactoring
Rename (Shift+F6), Extract (Ctrl+Alt+M/V).
Navigation (Usages)
Find Usages (Alt+F7), Go to Declaration (Ctrl+B).
Run/Debug Configs
Gérer les configurations (Script Python, Django...).
Run Debug ConfigurationLe Débogueur
Breakpoints, Stepping (F7/F8), Evaluate.
Debugger Breakpoints F8Intégration Git
Commit, Push, Pull, Branches, Merge (UI).
Git VCS Ctrl+KTests (Pytest)
Lancer les tests (Pytest, Unittest) via l'UI.
Pytest Unittest Test RunnerWeb Dev (Pro)
Support Django, Flask, Jinja2, JS/CSS.
Django Flask ProfessionalOutils BDD (Pro)
Client BDD (type DataGrip), Query Console.
Database SQL ProfessionalData Science (Pro)
Jupyter Notebooks, Scientific View, Plots.
Jupyter Pandas ProfessionalPlugins & Terminal
Marketplace, Terminal (Alt+F12), Scratch files.
Cheat-sheet
Top 10 des raccourcis indispensables.
Shortcuts RaccourcisL'IDE Python de Référence
PyCharm est l'Environnement de Développement Intégré (IDE) de JetBrains, spécifiquement conçu pour le langage Python.
Il est construit sur la plateforme IntelliJ, ce qui signifie qu'il partage la mĂȘme base, les mĂȘmes raccourcis et la mĂȘme philosophie que IntelliJ IDEA, WebStorm, etc.
PyCharm est réputé pour sa compréhension profonde du code Python ("intelligence"), son débogueur de premier plan et ses intégrations robustes pour le web et la data science.
Cas d'usage
- DĂ©veloppement Web : Django, Flask, FastAPI (Ădition Pro).
- Data Science : Jupyter Notebooks, Pandas, SciPy (Ădition Pro).
- Scripts & Automatisation : Scripts systĂšme, TĂąches (Ădition Community).
- Qualité de code : Refactoring, tests, linting.
Flux de travail typique (Python)
1. Création Projet
â
âŒ
2. Configuration Interpréteur
â (CrĂ©ation d'un vEnv/Conda)
âŒ
3. Installation des Paquets
â (via `requirements.txt` ou UI)
âŒ
4. Codage
â (Ăditeur, Auto-complĂ©tion, Alt+EntrĂ©e)
âŒ
5. Tests
â (Lancement de Pytest/Unittest)
âŒ
6. Debug
â (Lancer l'app, poser des breakpoints)
âŒ
7. Commit (VCS)
â (IntĂ©gration Git)Positionnement : PyCharm vs VS Code
VS Code (avec les extensions Python) est le principal concurrent de PyCharm.
| CritĂšre | PyCharm | VS Code (avec extensions) |
|---|---|---|
| Type | IDE IntĂ©grĂ© (Tout-en-un). | Ăditeur de code (Modulaire). |
| Prise en main | Plus complexe, trÚs structuré (notion de "Projet"). | TrÚs rapide, plus léger, centré sur le fichier/dossier. |
| Refactoring | Excellent. "Safe" (Renommer, Extraire...) grĂące Ă l'indexation. | Bon, mais souvent moins "fiable" sur des projets complexes. |
| Débogueur | Excellent. Robuste et intégré. | TrÚs bon (launch.json), mais la configuration est moins "clic-bouton". |
| Data Science | Excellent (Ădition Pro) avec le SciView, Jupyter. | Excellent, l'intĂ©gration Jupyter est souvent prĂ©fĂ©rĂ©e. |
| Ressources | Plus lourd (RAM, CPU), à cause de l'indexation. | Plus léger au démarrage. |
En rĂ©sumĂ© : PyCharm est un "tank", puissant, qui brille par son refactoring et ses intĂ©grations (tests, web) sur de gros projets. VS Code est plus lĂ©ger, plus rapide et extrĂȘmement populaire, notamment pour la Data Science et les scripts.
Le choix de l'édition est crucial. La version "Community" est gratuite et open-source. "Professional" (payante) débloque les fonctionnalités avancées (Web, Data, BDD).
| Fonctionnalité | Community Edition (Gratuit) | Professional Edition (Payant) |
|---|---|---|
| DĂ©veloppement Python | Oui (Ăditeur, Debugger, Tests, Git) | Oui |
| Développement Web (Django, Flask, FastAPI) | Non | Oui (Clé) |
| Web (JS, TypeScript, HTML) | Non | Oui (IntĂšgre WebStorm) |
| Data Science (Jupyter, SciView, Pandas) | Non | Oui (Clé) |
| Outils Base de Données | Non | Oui (IntÚgre DataGrip) |
| Profiler (CPU, Mémoire) | Non | Oui |
En résumé : Si vous faites du Django/Flask, de la Data Science (Jupyter, Pandas) ou si vous avez besoin de l'outil BDD, PyCharm Professional est nécessaire.
La JetBrains Toolbox App
C'est la méthode d'installation recommandée par JetBrains pour tous les OS (Windows, macOS, Linux).
- Téléchargez "Toolbox App" depuis le site de JetBrains.
- Installez-la.
- Depuis la Toolbox, cliquez sur "Install" à cÎté de "PyCharm Professional" (ou Community).
Avantages de la Toolbox
- Mises Ă jour faciles : Met Ă jour l'IDE en un clic.
- Rollbacks : Si une mise à jour pose problÚme, vous pouvez revenir à la version précédente.
- Gestion centralisée : GÚre tous vos IDE JetBrains (PyCharm, IntelliJ, WebStorm...).
- Nettoyage : GĂšre proprement les anciennes versions.
Installation Standalone
Vous pouvez télécharger les installeurs .exe (Windows) ou .dmg (macOS) directement.
Linux (Snap / Flatpak)
Si vous n'utilisez pas la Toolbox, les paquets Snap sont la méthode préférée.
# Installer Community sudo snap install pycharm-community --classic # Installer Professional sudo snap install pycharm-professional --classic
Structure de Fichiers
Quand vous créez un projet, PyCharm crée une structure de dossiers :
mon-projet/ âââ .idea/ â âââ (Fichiers de config de PyCharm. â Ă mettre dans .gitignore) â âââ venv/ â âââ (Dossier de l'environnement virtuel. â Toujours mettre dans .gitignore) â âââ src/ (ou app/) â âââ (Vos fichiers .py, "Sources Root") â âââ requirements.txt
"Content Roots" (Racines)
PyCharm doit savoir oĂč se trouve votre code source (pour les imports). Vous pouvez marquer un dossier (ex: src) comme "Sources Root" (clic droit > Mark Directory as...).
Cela permet à PyCharm de résoudre les imports import my_module au lieu de import src.my_module.
Vues Principales (Tool Windows)
- 1. Project (Alt+1) : L'arbre de vos fichiers.
- 7. Structure (Alt+7) : Les méthodes/classes du fichier actuel.
- 9. Git (Alt+9) : L'interface de version control.
- 4. Debug (Alt+5) : Le débogueur.
- 6. Python Packages : Gérer vos paquets
pip.
C'est le concept le plus important de PyCharm. Python utilise des environnements virtuels (vEnv) pour isoler les dépendances (librairies) de chaque projet.
Isolation des projets
Ne jamais utiliser l'interpréteur "SystÚme" (/usr/bin/python3) pour vos projets.
- Projet A peut avoir besoin de
Django==3.0. - Projet B peut avoir besoin de
Django==4.0.
Un environnement virtuel (vEnv) est un dossier (ex: venv/) qui contient une copie de Python et ses propres librairies (installées via pip). PyCharm gÚre cela pour vous.
Configuration dans PyCharm
PyCharm gÚre les interpréteurs dans File > Settings > Project: [nom] > Python Interpreter.
Workflow Recommandé :
- Lors de la création d'un "New Project".
- PyCharm propose "New environment using" > "vEnv".
- Laissez-le créer un
venvdans le dossier du projet.
Changer d'interpréteur
En bas Ă droite de la fenĂȘtre, PyCharm affiche l'interprĂ©teur actuel (ex: "Python 3.11 (mon-projet)"). Vous pouvez cliquer dessus pour changer ou en ajouter (vEnv, Conda, Docker...).
PyCharm s'intĂšgre Ă pip (le gestionnaire de paquets Python) et Ă requirements.txt.
FenĂȘtre "Python Packages"
En bas (ou Alt+6), l'onglet "Python Packages" vous offre une interface graphique pour :
- Voir les paquets installés dans votre vEnv.
- Installer de nouveaux paquets (ex:
requests,pandas) via une barre de recherche. - Mettre à jour ou désinstaller des paquets.
requirements.txt
C'est le standard pour lister les dépendances.
# requirements.txt django==4.2 requests==2.31
Quand PyCharm détecte ce fichier, il vous propose :
- Notification : "Install requirements" (installe tout ce qui est listé).
- Avertissement : Si vous installez un paquet (ex:
numpy) via l'UI, PyCharm vous demandera si vous voulez l'ajouter Ărequirements.txt.
PyCharm supporte aussi Poetry (pyproject.toml) comme alternative moderne.
Intentions (Alt + Entrée)
C'est le raccourci le plus important. C'est la "baguette magique" contextuelle.
Quand vous voyez une ampoule (jaune ou rouge) ou que votre curseur est sur du code souligné, appuyez sur Alt+Entrée.
Exemples Python :
- Import : Si vous tapez
requests.get()sans import,Alt+Entréeproposera "Import 'requests'". - Création : "Create function 'ma_fonction'".
- Type Hints : "Add type hint for variable".
- Refactor : "Invert if condition".
Support des Type Hints
PyCharm excelle dans l'utilisation des "Type Hints" (standard de Python 3) pour l'auto-complétion.
def get_user_name(user: User) -> str:
# ...
return user.name
# PyCharm sait que 'user' est de type 'User'.
# Quand vous tapez `user.`, il propose
# les méthodes et attributs de la classe 'User'.Inspections (Analyse Statique)
PyCharm analyse votre code en permanence (Inspections PEP 8, code mort, bugs potentiels) et s'intĂšgre aussi avec des linters externes comme Pylint ou Flake8.
Le refactoring est "safe" car PyCharm indexe tout le code. C'est la mĂȘme base que IntelliJ.
| Raccourci | Action | Description |
|---|---|---|
Shift + F6 | Rename | Renomme l'élément (variable, méthode, classe, fichier) et toutes ses références (y compris dans les commentaires ou Docstrings). |
Ctrl + Alt + M | Extract Method | Sélectionnez un bloc de code et transformez-le en une nouvelle méthode/fonction. |
Ctrl + Alt + V | Extract Variable | Extrait une expression dans une variable locale. |
Ctrl + Alt + P | Extract Parameter | Transforme une variable locale en paramĂštre de fonction. |
Ctrl + Alt + F | Extract Field | Transforme une variable locale en champ de classe (self.xxx). |
F6 | Move | Déplace une fonction ou une classe dans un autre fichier. |
Une "Run Configuration" est un profil pour lancer une tùche. (ex: exécuter un script, lancer un serveur Django, lancer des tests).
Création
Méthode rapide : Clic droit sur un fichier .py > "Run 'nom_du_fichier'". PyCharm crée et sauvegarde une configuration "Python script".
Exemples de Configurations
- Python script : (Défaut) Exécute un fichier
.py.- *Options :* ParamĂštres du script, variables d'environnement.
- Django server (Pro) : Lance
manage.py runserver.- *Options :* Port, variables d'environnement (ex:
DJANGO_SETTINGS_MODULE).
- *Options :* Port, variables d'environnement (ex:
- Pytest (Pro/Comm) : Exécute des tests.
- *Options :* Cible (un fichier, un dossier, un mot-clé).
Vous gérez ces configurations dans le menu déroulant en haut à droite (à cÎté du bouton "Play").
Le dĂ©bogueur de PyCharm est l'une de ses fonctionnalitĂ©s phares. Il fonctionne de la mĂȘme maniĂšre que celui d'IntelliJ.
Breakpoints (Points d'arrĂȘt)
Cliquez dans la marge pour poser un breakpoint (point rouge). Lancez en mode Debug (l'icĂŽne "insecte" đ). L'exĂ©cution s'arrĂȘtera Ă cet endroit.
Breakpoints Conditionnels : Clic droit sur le point > Mettre une condition (ex: user.id == 123). L'arrĂȘt ne se produit que si la condition est vraie.
Stepping (Navigation pas-Ă -pas)
Une fois arrĂȘtĂ©, la fenĂȘtre "Debug" (Alt+5) s'ouvre :
F8(Step Over) : Exécute la ligne et passe à la suivante (sans entrer dans les fonctions).F7(Step Into) : Si la ligne est un appel de fonction, entre dans cette fonction.Shift + F8(Step Out) : Sort de la fonction actuelle.Alt + F9(Run to Cursor) : Continue l'exécution jusqu'au curseur.
Variables & Console
La vue "Variables" vous montre l'état de toutes les variables (locales, self...).
L'onglet "Console" du débogueur est un shell Python (iPython) interactif, dans l'état exact de votre breakpoint. Vous pouvez y taper du code (ex: print(variable.attribut)) pour inspecter.
Evaluate Expression (Alt + F8)
Ouvre une popup pour tester n'importe quelle expression Python (ex: my_list[0].get_name()) dans le contexte actuel.
L'intĂ©gration VCS (Git) est identique Ă celle d'IntelliJ IDEA. Elle est extrĂȘmement complĂšte et visuelle.
| Raccourci | Action | Description |
|---|---|---|
Ctrl + K | Commit | Ouvre la fenĂȘtre "Commit". Montre les fichiers modifiĂ©s (diff), permet d'Ă©crire le message, de cocher les fichiers. |
Ctrl + Shift + K | Push | Pousse les commits locaux. |
Ctrl + T | Update Project (Pull) | Tire les changements (Pull). Vous pouvez choisir Merge ou Rebase. |
Alt + 9 | Git Tool Window | Ouvre la vue "Git", qui montre l'historique (Log) du projet et des branches. |
| (Clic droit > Git) | Show History | Affiche l'historique Git d'un fichier ou d'un dossier spécifique. |
Gestion des Branches
En bas à droite, le sélecteur de branche permet de voir la branche actuelle, de créer/changer de branche (Checkout), et de gérer les fusions (Merge) et les conflits visuellement.
PyCharm dispose d'un "Test Runner" graphique intégré qui supporte Unittest (standard lib), Pytest (le plus populaire), Behave, etc.
Lancement des Tests
PyCharm détecte les fichiers de test (ex: test_*.py ou *_test.py) et les fonctions (ex: def test_...).
Vous pouvez lancer les tests en cliquant sur l'icÎne "Play" (flÚche verte) dans la marge, à cÎté :
- D'une fonction de test (lance ce test).
- D'une classe de test (lance cette classe).
- D'un fichier (lance tout le fichier).
La FenĂȘtre de RĂ©sultats
PyCharm ouvre une fenĂȘtre dĂ©diĂ©e aux tests :
- Liste arborescente des tests (SuccĂšs / Ăchec / IgnorĂ©).
- (Vert) si tout passe, (Rouge) si échec.
- Permet de voir le "stdout" (print) et les "diff" d'assertions.
- Permet de relancer uniquement les tests échoués.
Vous pouvez également "Run with Coverage" (lancer avec couverture) pour voir quelles lignes de votre code ont été (ou non) exécutées par les tests.
Note : Fonctionnalité réservée à PyCharm Professional.
L'Ă©dition Pro intĂšgre les fonctionnalitĂ©s de WebStorm, ce qui la rend extrĂȘmement puissante pour les frameworks web Python.
Support Django
- Configuration : Détecte
manage.pyet crée une "Run Config" pour le serveur de dev. - Tùches
manage.py: Outil pour lancershell,dbshell,runserver... - Templates (Jinja2/Django) : Auto-complétion, coloration, et navigation (
Ctrl+Bsur un nom de template ou une vue pour y sauter). - ORM : Compréhension de l'ORM Django (complétion sur les
.objects.filter()).
Support Flask / FastAPI
- Débogage performant.
- Complétion des routes et des paramÚtres.
- Reconnaissance des templates Jinja2.
Frontend
IntĂšgre tout WebStorm : support JavaScript, TypeScript, React, Vue, SASS, LESS, etc.
Note : Fonctionnalité réservée à PyCharm Professional.
PyCharm Pro intÚgre l'IDE de base de données DataGrip. C'est un client SQL complet (remplace DBeaver, pgAdmin, etc.).
FenĂȘtre "Database"
Une fenĂȘtre d'outil (droite) "Database" vous permet de :
- Configurer des "Data Sources" (PostgreSQL, MySQL, SQLite, Oracle...).
- Naviguer dans les schémas, tables, vues.
- Modifier les données (clic droit > Edit Data).
- Générer des diagrammes E/R.
La "Query Console"
Vous pouvez ouvrir une "Query Console" pour exécuter du SQL.
- Auto-complétion SQL contextuelle (connaßt vos tables/colonnes).
- Refactoring SQL.
- ExĂ©cution de requĂȘtes (
Ctrl+Entrée). - Historique local.
Note : Fonctionnalité réservée à PyCharm Professional.
L'édition Pro est un environnement de Data Science trÚs puissant, concurrentiel à VS Code ou RStudio.
Support Jupyter Notebook
- Ouvrir, éditer et exécuter des fichiers
.ipynbdirectement dans PyCharm. - Lancement d'un serveur Jupyter managé.
- Débogage de cellule : Permet de poser des breakpoints *à l'intérieur* d'une cellule Jupyter.
- Prévisualisation des dataframes Pandas.
Scientific View
Quand vous exécutez un script .py en mode "Scientific", PyCharm ouvre une vue spéciale :
- Variable Explorer : Affiche les variables (DataFrames Pandas, arrays NumPy) en temps réel, comme dans RStudio.
- Plot Viewer : Une fenĂȘtre dĂ©diĂ©e pour afficher et naviguer dans les graphiques
matplotlibouseaborn.
Plugins (Marketplace)
Vous pouvez étendre PyCharm via File > Settings > Plugins.
Plugins Python populaires :
- Pylint : Intégration du linter Pylint.
- Black : Intégration du formateur de code Black.
- .env files support : Coloration pour les fichiers
.env.
Plugins Généraux :
- Material Theme UI : ThĂšmes visuels.
- Key Promoter X : Vous apprend les raccourcis.
Terminal (Alt + F12)
PyCharm intĂšgre un terminal (bash, zsh, PowerShell...).
Avantage : Il est "conscient" de votre vEnv. Quand vous l'ouvrez, il active automatiquement l'environnement virtuel du projet. Vous pouvez taper pip install ou python en étant certain d'utiliser le bon environnement.
Scratch Files (Brouillons)
Ctrl + Alt + Shift + Insert
Crée un fichier temporaire (ex: scratch.py) pour tester un petit bout de code sans l'ajouter au projet.
La plupart des raccourcis sont partagés avec IntelliJ IDEA.
Top 10 (Indispensables)
1. Shift + Shift
(Search Everywhere)
2. Alt + Entrée
(Show Intentions / "Baguette Magique")
3. Ctrl + N
(Go to Class)
4. Ctrl + Shift + N
(Go to File)
5. Alt + F7
(Find Usages)
6. Shift + F6
(Rename / Refactor)
7. Ctrl + B
(Go to Declaration)
8. F8
(Step Over - Debug)
9. Ctrl + K
(Commit - Git)
10. Ctrl + Espace
(Basic Completion)Ădition & Refactor
Ctrl + W / Ctrl + Shift + W (Extend / Shrink Selection) Ctrl + D (Duplicate Line) Ctrl + Y (Delete Line) Ctrl + / (Comment / Uncomment Line) Ctrl + Alt + M (Extract Method) Ctrl + Alt + V (Extract Variable) Ctrl + Alt + L (Reformat Code)
Navigation & Vues
Alt + 1 (Project View) Alt + 5 (Debug View) Alt + 9 (Git View) Alt + F12 (Terminal) Ctrl + E (Recent Files)
