Git et GitHub pour débuter en Python sans stress

Quand on débute en Python, enregistrer régulièrement son fichier .py paraît suffisant. Cela l’est… jusqu’au jour où une modification casse un programme qui fonctionnait, qu’un fichier est supprimé par erreur ou qu’il faut montrer son projet à quelqu’un. Git répond précisément à ce besoin : il garde une trace organisée des changements dans votre code.

GitHub complète Git en permettant d’héberger un projet en ligne, de le partager et de le retrouver depuis un autre ordinateur. Ces deux outils sont très utilisés dans les formations et les équipes de développement, mais ils sont aussi utiles pour un simple exercice Python personnel.

Ce guide suit un mini-projet concret : un script Python qui enregistre une liste de tâches dans un fichier. L’objectif n’est pas de retenir toutes les commandes de Git, mais d’acquérir les bons réflexes pour sauvegarder proprement un projet, puis le publier sur GitHub sans y déposer votre environnement virtuel ou des informations confidentielles.

Git et GitHub : la différence à comprendre dès le départ

Git est un logiciel installé sur votre ordinateur. Il suit l’historique des fichiers d’un dossier appelé dépôt, ou repository. À chaque étape importante, vous créez un point de sauvegarde nommé commit.

GitHub est un service en ligne qui peut héberger des dépôts Git. Votre projet reste donc suivi localement avec Git, tout en pouvant être envoyé sur GitHub pour être sauvegardé en ligne ou partagé.

On peut résumer ainsi :

• Git : l’outil qui suit les versions sur votre machine ;
• un dépôt Git local : le dossier de votre projet avec son historique ;
• GitHub : une plateforme où vous pouvez publier une copie de ce dépôt ;
• un commit : une sauvegarde décrite par un message court et clair ;
• push : l’action d’envoyer vos commits locaux vers GitHub.

Git n’est donc pas réservé aux grandes applications. Il est pertinent dès votre premier mini-projet Python. Si vous réalisez une calculatrice, un jeu de devinettes ou un programme de gestion de tâches, Git vous permet de revenir à une version qui marchait après un essai raté.

Un commit n’est pas une sauvegarde automatique de tout votre ordinateur. C’est une version volontaire des fichiers que vous avez choisi d’ajouter à votre projet.

Pourquoi utiliser Git dès son premier projet Python

Le premier bénéfice est de pouvoir expérimenter sans peur. Imaginons que votre fichier taches.py fonctionne. Vous ajoutez ensuite une fonction pour supprimer une tâche, puis le programme affiche une erreur. Avec un historique Git, vous pouvez comparer vos changements ou revenir à une version antérieure.

Git vous aide aussi à comprendre l’évolution de votre programme. Au lieu de conserver des fichiers comme projet_final.py, projet_final_v2.py et projet_final_vraiment_final.py, vous gardez un seul fichier principal et des commits explicites :

• Créer la liste de tâches
• Ajouter la sauvegarde dans un fichier
• Gérer les tâches terminées

Ce journal est utile pour vous-même, mais également si vous demandez de l’aide. Vous pouvez partager l’adresse d’un dépôt GitHub avec un formateur ou un autre développeur. La personne verra les fichiers du projet, les commits et, si le dépôt est public, pourra les consulter sans vous demander une archive par e-mail.

Enfin, Git installe une habitude professionnelle très saine : faire de petites modifications, les tester, puis les enregistrer avec un message compréhensible. Cette méthode s’accorde bien avec l’apprentissage progressif de Python, par exemple après avoir appris les fonctions Python ou la lecture et l’écriture de fichiers.

Installer Git et préparer votre identité

Avant de créer un dépôt, installez Git depuis le site officiel : git-scm.com/downloads. Le site propose des installateurs pour Windows, macOS et Linux. Sous Linux, Git est souvent disponible via le gestionnaire de paquets de la distribution.

Après l’installation, ouvrez un terminal et vérifiez que Git répond :

git --version

La commande doit afficher une version de Git. Si le terminal indique que la commande est introuvable, fermez puis rouvrez le terminal. Sous Windows, vous pouvez utiliser Git Bash installé avec Git, le terminal intégré de Visual Studio Code ou PowerShell si Git est accessible dans votre système.

Git associe chaque commit à un nom et à une adresse e-mail. Configurez-les une fois sur votre ordinateur :

git config --global user.name "Votre Nom"
git config --global user.email "[email protected]"

Utilisez une adresse e-mail que vous acceptez d’associer à vos commits. GitHub propose aussi une adresse de type noreply dans les réglages de votre compte si vous préférez ne pas afficher votre adresse personnelle dans les commits publics. Consultez la documentation GitHub sur l’adresse e-mail de commit avant de choisir cette option.

Vous n’avez pas besoin de maîtriser le terminal pour programmer en Python. Cependant, apprendre quelques commandes Git est plus simple que dépendre uniquement de boutons graphiques : elles fonctionnent dans VS Code, Git Bash, le Terminal macOS et la plupart des environnements de développement.

Créer un premier dépôt Git dans un projet Python

Créez un dossier, par exemple mes-taches-python, puis ouvrez ce dossier dans VS Code. Vous pouvez aussi le créer depuis le terminal :

mkdir mes-taches-python
cd mes-taches-python

Ajoutez un fichier nommé taches.py avec ce programme volontairement simple :

taches = []

nouvelle_tache = input("Quelle tâche voulez-vous ajouter ? ")
taches.append(nouvelle_tache)

print("Vos tâches :")
for tache in taches:
    print("-", tache)

Testez-le avant de penser à Git. Dans le terminal ouvert dans le bon dossier :

python taches.py

Selon votre installation, la commande peut être python3 taches.py. Le principe important est le suivant : vérifiez votre code avant de créer une sauvegarde Git.

Initialisez ensuite le dépôt :

git init

Git crée alors un dossier caché nommé .git. C’est lui qui contient l’historique du dépôt. Ne le supprimez pas et ne le modifiez pas à la main. Votre dossier de projet devient maintenant un dépôt local.

La branche principale peut s’appeler main ou master, selon votre configuration Git. Pour suivre la convention courante sur GitHub, vous pouvez définir main comme nom par défaut pour les futurs dépôts :

git config --global init.defaultBranch main

Si vous exécutez cette commande après avoir déjà lancé git init, elle ne renomme pas automatiquement la branche existante. Vous pouvez la renommer dans ce dépôt avec :

git branch -M main

Comprendre status, add, commit et log avec un exemple

Les quatre commandes à connaître en priorité sont git status, git add, git commit et git log. Elles suffisent pour installer un rythme de sauvegarde efficace.

Vérifier la situation avec git status

Commencez par :

git status

Git vous indique les fichiers non suivis, modifiés ou prêts à être enregistrés. Après l’initialisation de votre dépôt, taches.py apparaît généralement comme un fichier non suivi. Exécutez git status souvent : c’est une commande sans risque, qui ne modifie aucun fichier.

Choisir les fichiers avec git add

Pour préparer votre script pour le prochain commit :

git add taches.py

Cette commande place une version du fichier dans une zone intermédiaire appelée staging area, ou zone d’index. Retenez simplement que git add signifie : « je veux inclure l’état actuel de ce fichier dans ma prochaine sauvegarde ».

Pour ajouter tous les fichiers pertinents du dossier courant, on rencontre souvent :

git add .

Cette commande est pratique, mais utilisez-la avec attention. Vérifiez d’abord git status, surtout si votre dossier contient un fichier .env, un environnement virtuel ou des données que vous ne souhaitez pas publier.

Créer une sauvegarde avec git commit

Créez votre premier commit :

git commit -m "Créer le script de liste de tâches"

Le texte entre guillemets est le message de commit. Il doit décrire ce changement précis. Préférez « Ajouter la validation de la saisie » à un message vague comme « modifications » ou « test ».

Vous pouvez maintenant améliorer le script : vérifier qu’une tâche n’est pas vide, écrire les tâches dans un fichier texte, ou ajouter un menu. Après une étape fonctionnelle, répétez la séquence :

git status
git add taches.py
git commit -m "Ajouter une tâche seulement si elle n'est pas vide"

Lire l’historique avec git log

Pour consulter la liste des commits :

git log

Vous y verrez notamment l’identifiant du commit, son auteur, sa date et son message. Une version compacte est souvent plus agréable :

git log --oneline

Vous obtenez alors une ligne par commit. Cet historique rend votre progression visible et évite de perdre le fil lorsque vous reprenez un projet après quelques jours.

Créer un fichier .gitignore adapté à Python

Un projet Python contient souvent des fichiers qui ne doivent pas être versionnés. Le plus connu est l’environnement virtuel. Si vous avez suivi un guide pour créer un environnement virtuel avec venv, vous avez peut-être un dossier .venv ou venv dans votre projet.

Ce dossier contient une copie locale de Python et des paquets installés. Il peut être recréé sur une autre machine : il n’a donc pas besoin d’être envoyé sur GitHub. Il peut aussi contenir de très nombreux fichiers, ce qui alourdit inutilement le dépôt.

À la racine du projet, créez un fichier nommé exactement .gitignore. Ajoutez par exemple :

# Environnements virtuels
.venv/
venv/
env/

# Fichiers Python temporaires
__pycache__/
*.py[cod]

# Outils et éditeurs
.vscode/
.idea/

# Variables locales et secrets
.env

# Système d'exploitation
.DS_Store

Ces règles indiquent à Git quels fichiers non encore suivis il doit ignorer. Le fichier .gitignore, lui, doit être ajouté au dépôt, car il fait partie des règles utiles à toute personne qui récupère le projet :

git add .gitignore
git commit -m "Ajouter les fichiers Python à ignorer"

Vous pouvez consulter le modèle Python maintenu par GitHub dans le dépôt github/gitignore. Il contient davantage de règles pour les tests, outils de couverture et distributions de paquets. Pour un petit exercice, commencez avec un fichier court que vous comprenez.

Attention : si vous avez déjà ajouté un fichier à Git avant de l’inscrire dans .gitignore, Git continue de le suivre. Il faut alors le retirer de l’index sans le supprimer de votre disque :

git rm --cached .env

Adaptez naturellement cette commande au fichier concerné. Vérifiez ensuite avec git status, puis créez un commit.

Publier le dépôt sur GitHub pas à pas

Créez un compte sur GitHub si vous n’en avez pas. Depuis votre page d’accueil, utilisez le bouton de création d’un nouveau dépôt. Donnez-lui par exemple le nom mes-taches-python.

Pour un dépôt local qui contient déjà des commits, évitez d’initialiser le dépôt GitHub avec un fichier README, une licence ou un .gitignore depuis l’interface. Vous éviterez ainsi de créer un historique distant distinct dès le départ. Vous pourrez ajouter un README depuis votre projet local juste après.

Choisissez ensuite la visibilité :

• Public : tout le monde peut consulter le code ;
• Privé : seuls vous et les personnes auxquelles vous donnez accès peuvent le voir.

Un dépôt privé est préférable pour un exercice personnel au début. Un dépôt public peut constituer un portfolio, à condition de relire soigneusement son contenu avant la publication.

Après la création, GitHub affiche une adresse de dépôt. Pour la relier à votre dépôt local, utilisez la commande proposée par GitHub, qui ressemble à ceci :

git remote add origin https://github.com/VOTRE-PSEUDO/mes-taches-python.git
git push -u origin main

Remplacez VOTRE-PSEUDO par votre identifiant GitHub. Le mot origin est simplement un alias courant pour désigner le dépôt distant sur GitHub.

Lors du premier envoi en HTTPS, GitHub peut ouvrir votre navigateur pour vous connecter et autoriser Git. GitHub n’accepte plus l’authentification par mot de passe pour les opérations Git en HTTPS : selon votre configuration, vous utiliserez une connexion dans le navigateur, GitHub CLI ou un jeton d’accès personnel. Suivez les instructions affichées par Git ou consultez la documentation GitHub sur les dépôts distants.

Une fois l’envoi terminé, rechargez la page GitHub de votre dépôt. Vous devriez voir taches.py, .gitignore et vos commits. Pour les prochains changements, votre routine sera très courte :

git status
git add .
git commit -m "Décrire la modification"
git push

Ajoutez aussi un fichier README.md. Même si GitHub le rend joliment lisible, il s’agit d’un simple fichier texte au format Markdown. Indiquez au minimum le rôle du projet et la manière de l’exécuter :

# Mes tâches Python

Petit programme en console pour ajouter et afficher des tâches.

## Lancer le programme

python taches.py

Ajoutez ensuite ce fichier à Git et envoyez-le sur GitHub. Un README rend votre dépôt beaucoup plus compréhensible, y compris pour vous dans quelques mois.

Ne jamais publier de secrets : les réflexes indispensables

Un dépôt GitHub public est visible par tous. Un dépôt privé mérite également de bonnes pratiques, car il peut être partagé, cloné ou rendu public par erreur. Ne placez jamais dans Git des mots de passe, clés API, jetons d’accès, identifiants de base de données ou fichiers contenant des données personnelles.

Un fichier .env est fréquemment utilisé pour stocker des variables locales, par exemple :

API_KEY=valeur_secrete
DATABASE_URL=valeur_secrete

Ajoutez .env au .gitignore avant votre premier git add .. Si votre programme a besoin d’indiquer quelles variables sont attendues, publiez plutôt un fichier .env.example sans aucune valeur réelle :

API_KEY=
DATABASE_URL=

Le fichier .env.example peut être ajouté au dépôt, contrairement au véritable .env.

Si vous publiez accidentellement une clé, supprimer le fichier dans un commit ultérieur ne suffit pas : la clé peut rester présente dans l’historique Git et avoir été copiée. Il faut immédiatement révoquer ou régénérer la clé auprès du service concerné. Ensuite, retirez-la du projet et examinez l’historique. GitHub propose des mécanismes de détection de secrets, mais ils ne remplacent pas votre vigilance.

Avant chaque publication, prenez trente secondes pour relire la sortie de :

git status

Posez-vous trois questions simples :

• Est-ce que je reconnais tous les fichiers listés ?
• Est-ce qu’un fichier contient un mot de passe, une clé ou des données réelles ?
• Est-ce que mon environnement virtuel et les fichiers temporaires sont bien ignorés ?

Les erreurs normales quand on commence avec Git

La première erreur classique consiste à lancer une commande Git dans le mauvais dossier. Si Git indique not a git repository, revenez dans le dossier du projet avec cd, puis vérifiez sa présence avec la commande adaptée à votre terminal. Vous devez vous trouver dans le dossier où vous avez exécuté git init.

Autre situation fréquente : vous avez modifié un fichier, mais git commit ne crée rien. Exécutez git status. Vous avez probablement oublié git add. Git distingue volontairement les fichiers modifiés et les fichiers choisis pour le prochain commit.

Enfin, ne vous inquiétez pas si Git vous demande de configurer votre nom et votre e-mail lors du premier commit. Il suffit d’utiliser les commandes git config --global présentées plus haut, puis de relancer le commit.

Dans VS Code, l’icône de contrôle de code source permet de voir les modifications, de préparer des fichiers et de créer des commits avec une interface graphique. C’est pratique, mais les notions restent identiques : consultez l’état, choisissez les fichiers, écrivez un message, créez un commit et envoyez-le sur GitHub.

Conclusion : adopter une routine Git simple et utile

Pour débuter avec Git et GitHub en Python, vous n’avez pas besoin de branches complexes ni de dizaines de commandes. Retenez une routine : testez votre programme, consultez git status, ajoutez les fichiers utiles, créez un commit clair, puis utilisez git push lorsque vous souhaitez synchroniser votre travail avec GitHub.

Le fichier .gitignore est tout aussi important : il évite d’envoyer votre environnement virtuel, les fichiers temporaires et surtout les secrets locaux. Commencez dès maintenant sur un petit script Python, faites un premier commit après chaque amélioration et transformez progressivement Git en filet de sécurité pour tous vos projets.