Project Oxygen & Ideo-LabIDEO LAB Dashboard 2026

🐍 PyCharm – IDE Python, Debugging & Data Science

Guide complet IDEO-Lab pour maĂźtriser PyCharm, de la gestion de vEnv au debugging de Django.

1.1

Vue d'ensemble

Qu'est-ce que PyCharm ? L'IDE Python de JetBrains.

IDE Python JetBrains
1.2

Community vs Pro

Comparaison des éditions (Gratuit vs Payant).

Community (Free) Professional Data Science
1.3

Installation (Toolbox)

Toolbox App (reco), Snap/Flatpak, Standalone.

Toolbox snap Windows macOS
2.1

Structure Projet & UI

Projets, .idea, venv, Contenu (src).

.idea venv UI
2.2

Gestion des Interpréteurs

Le concept clé : vEnv, Conda, Interpréteur SystÚme.

vEnv Conda Isolation
2.3

Gestion des Paquets

UI, requirements.txt, pyproject.toml.

pip requirements.txt Poetry
3.1

Éditeur & Intentions

Smart completion, Alt+Entrée, Type Hints.

Alt+Entrée Completion Inspections
3.2

Refactoring

Rename (Shift+F6), Extract (Ctrl+Alt+M/V).

Refactor Shift+F6 Ctrl+Alt+M
3.3

Navigation (Usages)

Find Usages (Alt+F7), Go to Declaration (Ctrl+B).

Alt+F7 Ctrl+B Navigation
4.1

Run/Debug Configs

Gérer les configurations (Script Python, Django...).

Run Debug Configuration
4.2

Le Débogueur

Breakpoints, Stepping (F7/F8), Evaluate.

Debugger Breakpoints F8
4.3

Intégration Git

Commit, Push, Pull, Branches, Merge (UI).

Git VCS Ctrl+K
5.1

Tests (Pytest)

Lancer les tests (Pytest, Unittest) via l'UI.

Pytest Unittest Test Runner
5.2

Web Dev (Pro)

Support Django, Flask, Jinja2, JS/CSS.

Django Flask Professional
5.3

Outils BDD (Pro)

Client BDD (type DataGrip), Query Console.

Database SQL Professional
6.1

Data Science (Pro)

Jupyter Notebooks, Scientific View, Plots.

Jupyter Pandas Professional
6.2

Plugins & Terminal

Marketplace, Terminal (Alt+F12), Scratch files.

Plugins Terminal Marketplace
6.3

Cheat-sheet

Top 10 des raccourcis indispensables.

Shortcuts Raccourcis
1.1 Vue d'ensemble PyCharm
L'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ĂšrePyCharmVS Code (avec extensions)
TypeIDE IntĂ©grĂ© (Tout-en-un).Éditeur de code (Modulaire).
Prise en mainPlus complexe, trÚs structuré (notion de "Projet").TrÚs rapide, plus léger, centré sur le fichier/dossier.
RefactoringExcellent. "Safe" (Renommer, Extraire...) grĂące Ă  l'indexation.Bon, mais souvent moins "fiable" sur des projets complexes.
DébogueurExcellent. Robuste et intégré.TrÚs bon (launch.json), mais la configuration est moins "clic-bouton".
Data ScienceExcellent (Édition Pro) avec le SciView, Jupyter.Excellent, l'intĂ©gration Jupyter est souvent prĂ©fĂ©rĂ©e.
RessourcesPlus 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.

1.2 PyCharm Community vs Professional

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 PythonOui (Éditeur, Debugger, Tests, Git)Oui
Développement Web
(Django, Flask, FastAPI)
NonOui (Clé)
Web (JS, TypeScript, HTML)NonOui (IntĂšgre WebStorm)
Data Science
(Jupyter, SciView, Pandas)
NonOui (Clé)
Outils Base de DonnéesNonOui (IntÚgre DataGrip)
Profiler (CPU, Mémoire)NonOui

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.

1.3 Installation (JetBrains Toolbox)
La JetBrains Toolbox App

C'est la méthode d'installation recommandée par JetBrains pour tous les OS (Windows, macOS, Linux).

  1. Téléchargez "Toolbox App" depuis le site de JetBrains.
  2. Installez-la.
  3. 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
2.1 Structure Projet & UI
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.
2.2 Gestion des Interpréteurs (vEnv)

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é :

  1. Lors de la création d'un "New Project".
  2. PyCharm propose "New environment using" > "vEnv".
  3. Laissez-le créer un venv dans 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...).

2.3 Gestion des Paquets (pip)

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.

3.1 Éditeur, Intentions & Type Hints
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Ă©e proposera "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.

3.2 Refactoring

Le refactoring est "safe" car PyCharm indexe tout le code. C'est la mĂȘme base que IntelliJ.

RaccourciActionDescription
Shift + F6RenameRenomme l'élément (variable, méthode, classe, fichier) et toutes ses références (y compris dans les commentaires ou Docstrings).
Ctrl + Alt + MExtract MethodSélectionnez un bloc de code et transformez-le en une nouvelle méthode/fonction.
Ctrl + Alt + VExtract VariableExtrait une expression dans une variable locale.
Ctrl + Alt + PExtract ParameterTransforme une variable locale en paramĂštre de fonction.
Ctrl + Alt + FExtract FieldTransforme une variable locale en champ de classe (self.xxx).
F6MoveDéplace une fonction ou une classe dans un autre fichier.
4.1 Run/Debug Configurations

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).
  • 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").

4.2 Le Débogueur

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.

4.3 Intégration Git

L'intĂ©gration VCS (Git) est identique Ă  celle d'IntelliJ IDEA. Elle est extrĂȘmement complĂšte et visuelle.

RaccourciActionDescription
Ctrl + KCommitOuvre la fenĂȘtre "Commit". Montre les fichiers modifiĂ©s (diff), permet d'Ă©crire le message, de cocher les fichiers.
Ctrl + Shift + KPushPousse les commits locaux.
Ctrl + TUpdate Project (Pull)Tire les changements (Pull). Vous pouvez choisir Merge ou Rebase.
Alt + 9Git Tool WindowOuvre la vue "Git", qui montre l'historique (Log) du projet et des branches.
(Clic droit > Git)Show HistoryAffiche 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.

5.1 Tests (Pytest & Unittest)

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.

5.2 DĂ©veloppement Web (Édition Pro)

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.py et crĂ©e une "Run Config" pour le serveur de dev.
  • TĂąches manage.py : Outil pour lancer shell, dbshell, runserver...
  • Templates (Jinja2/Django) : Auto-complĂ©tion, coloration, et navigation (Ctrl+B sur 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.

5.3 Outils Base de DonnĂ©es (Édition Pro)

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.
6.1 Data Science (Édition Pro)

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 .ipynb directement 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 matplotlib ou seaborn.
6.2 Plugins & Terminal
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.

6.3 Cheat-sheet (Top Raccourcis)

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)