Qu'est-ce que Git et pourquoi est-ce important en NSI ?

Git est un système de contrôle de version qui permet de suivre les modifications de fichiers, de revenir en arrière et de travailler en équipe. En NSI, il est essentiel pour gérer tes projets Python, éviter de perdre du travail et collaborer proprement.

Comment initialiser un dépôt Git ?

Ouvre un terminal dans le dossier de ton projet et tape `git init`. Cela crée un dossier caché `.git` qui contient tout l'historique. Ensuite, configure ton identité avec `git config --global user.name` et `git config --global user.email`.

Quelle est la différence entre git add et git commit ?

`git add` ajoute des fichiers à l'index (zone de staging), c'est-à-dire qu'il prépare les fichiers pour la sauvegarde. `git commit` enregistre une photo de ces fichiers dans l'historique avec un message descriptif.

Comment annuler un commit ou revenir à une version précédente ?

Pour revenir à une version précédente d'un fichier, utilise `git checkout -- fichier.py`. Pour annuler un commit tout en gardant l'historique, utilise `git revert `. Évite `git reset --hard` car il efface les modifications non commitées.

Quel est le rôle du fichier .gitignore ?

Le fichier `.gitignore` indique à Git quels fichiers ou dossiers il doit ignorer, comme les caches Python (`__pycache__`), les fichiers d'environnement ou les fichiers temporaires. Cela permet de garder le dépôt propre et de ne versionner que le code source.

Comment travailler à plusieurs sur un projet Git ?

Chaque membre clone le dépôt avec `git clone`, crée sa propre branche (`git checkout -b ma-branche`), effectue ses modifications, commit et pousse (`git push`). Ensuite, on fusionne via une pull request sur GitHub.

Git NSI : la checklist pour réussir la gestion de version

Tu en as marre de sauvegarder tes fichiers en les nommant projet_final_v2_corrige.py ? Tu n'es pas seul·e ! En NSI, la gestion de version est une compétence clé, et Git est l'outil standard que tu dois maîtriser. Dans cet article, je te propose une checklist complète pour utiliser Git comme un pro, éviter les pièges et briller au bac. Prêt·e ? C'est parti !

Pourquoi Git est indispensable en NSI ?

En spécialité NSI, tu vas écrire des programmes de plus en plus complexes. Sans gestion de version, tu risques de perdre du travail, d'écraser un fichier important ou de ne plus savoir quelle version est la bonne. Git te permet de suivre l'historique de tes modifications, de revenir en arrière et de travailler en équipe sans conflit majeur.

Git est un système de contrôle de version décentralisé. Concrètement, chaque copie d'un projet contient tout l'historique. Tu peux donc travailler hors ligne, puis synchroniser avec un serveur (comme GitHub) quand tu veux.

La checklist Git pour tes projets NSI

Voici les étapes essentielles, à cocher au fur et à mesure. Tu peux les appliquer dès aujourd'hui sur n'importe quel projet Python.

1. Initialiser un dépôt Git

Avant de commencer à coder, ou dès que tu décides d'utiliser Git, ouvre ton terminal (ou l'invite de commande) dans le dossier de ton projet et tape :

git init

Cette commande crée un dossier caché .git qui contient tout l'historique. Une seule fois par projet suffit. Vérifie que tout fonctionne avec git status.

2. Configurer ton identité

Pour que tes commits soient signés, configure ton nom et ton e-mail (ceux que tu utiliseras sur GitHub) :

git config --global user.name "Ton Pseudo"
git config --global user.email "ton@email.fr"

Tu peux aussi les configurer par projet si tu utilises plusieurs identités.

3. Créer un fichier .gitignore

Dans un projet Python, tu ne veux pas versionner les fichiers temporaires, les caches (__pycache__) ou les fichiers de configuration locaux. Crée un fichier .gitignore à la racine et ajoute :

__pycache__/
*.pyc
.env
.venv/

Ce fichier dit à Git : ignore ces fichiers. C'est une bonne pratique pour garder un dépôt propre.

4. Ajouter les fichiers à l'index

Pour suivre un fichier, tu dois l'ajouter à l'index (la zone de staging). Utilise :

git add nom_du_fichier.py

ou pour tout ajouter :

git add .

Fais attention : git add . ajoute tout, sauf ce qui est dans .gitignore. Vérifie avec git status que les bons fichiers sont en vert.

5. Faire un commit

Un commit est une photo de l'état de ton projet à un instant T. Il doit être accompagné d'un message clair décrivant les changements :

git commit -m "Ajout de la fonction calcul_moyenne"

Un bon message commence par un verbe à l'infinitif et explique le pourquoi si nécessaire. Par exemple : "Correction du bug d'index dans la boucle".

6. Vérifier l'historique

Pour voir tous tes commits, utilise :

git log --oneline

Tu verras une liste de commits avec leur identifiant unique (un hash). Si tu veux voir les détails d'un commit précis : git show <hash>.

7. Revenir à une version antérieure

Si tu as cassé ton code, pas de panique ! Tu peux revenir à un commit précédent avec :

git checkout <hash> -- nom_du_fichier.py

ou restaurer tout le projet à un état précédent (attention, cela écrase les modifications non commitées) :

git reset --hard <hash>

Mais utilise reset --hard avec précaution, car tu perds les changements non sauvegardés. Préfère git revert pour annuler proprement un commit.

8. Travailler avec des branches

Les branches te permettent de développer des fonctionnalités séparément sans casser la version stable. Crée une branche avec :

git branch ma-fonctionnalite

Puis bascule dessus :

git checkout ma-fonctionnalite

ou combine les deux : git checkout -b ma-fonctionnalite. Une fois la fonctionnalité terminée, tu peux fusionner (merge) avec la branche principale main :

git checkout main
git merge ma-fonctionnalite

Les branches sont très utiles pour les projets d'équipe, mais même seul·e, elles t'aident à expérimenter.

Exemple concret : un mini-projet Python versionné

Imaginons que tu crées un script pour calculer la moyenne d'une liste de notes. Voici comment tu pourrais travailler avec Git.

Étape 1 : Créer le fichier initial

# moyenne.py
def calcul_moyenne(notes):
    return sum(notes) / len(notes)

if __name__ == "__main__":
    notes = [12, 15, 18]
    print(calcul_moyenne(notes))

Initialise le dépôt et fais un premier commit :

git init
git add moyenne.py
git commit -m "Création du script moyenne"

Étape 2 : Ajouter une fonctionnalité

Tu veux afficher la moyenne sur 20. Tu modifies le script :

def afficher_moyenne(notes):
    moyenne = calcul_moyenne(notes)
    print(f"Moyenne : {moyenne:.2f}/20")

Tu ajoutes cette fonction et tu commit à nouveau :

git add moyenne.py
git commit -m "Ajout de l'affichage formaté"

Étape 3 : Corriger un bug

Si tu t'aperçois que la fonction ne gère pas la liste vide, tu corriges :

def calcul_moyenne(notes):
    if not notes:
        return 0
    return sum(notes) / len(notes)

Et tu commit : git commit -m "Gestion du cas liste vide".

Grâce à Git, tu as un historique complet de chaque étape. Tu peux comparer les versions avec git diff ou revenir à une ancienne version si besoin.

Cas d'usage : le projet de groupe en NSI

En NSI, tu auras probablement un projet à faire en équipe. Git devient alors ton meilleur ami. Voici un workflow simple :

Un membre crée le dépôt sur GitHub et invite les autres.
Chacun clone le dépôt : git clone https://github.com/ton-pseudo/projet.git.
Chacun travaille sur sa branche : git checkout -b fonctionnalite-1.
On commit régulièrement avec des messages clairs.
On pousse sa branche : git push origin fonctionnalite-1.
On crée une pull request sur GitHub pour fusionner les changements.

Ce processus évite les conflits et permet de garder une trace de tout. Si tu veux approfondir, consulte notre fiche sur Git.

Conseils pour réviser Git avant le bac

Le bac NSI évalue des compétences de programmation, mais aussi de gestion de projet. Savoir utiliser Git est un plus, et tu pourrais même être interrogé·e à l'oral sur ton projet. Voici comment te préparer :

Refais les commandes de base sur un petit projet fictif.
Entraîne-toi à résoudre des conflits de fusion (en créant deux branches qui modifient la même ligne).
Apprends à utiliser git log, git diff, git status sans hésiter.
Prépare un exemple de projet versionné à montrer lors de l'épreuve pratique.

Pour t'entraîner, tu peux utiliser nos exercices en ligne ou nos fiches de révision.

Conclusion : lance-toi !

Git peut sembler intimidant au début, mais avec cette checklist, tu as toutes les clés en main. Commence dès maintenant à versionner tes projets NSI, même les petits exercices. Tu gagneras en sérénité et en professionnalisme. N'oublie pas : chaque commit est une sécurité. Alors, prêt·e à faire ton premier git commit ?

Si tu veux aller plus loin, découvre aussi nos ressources sur AlloBac et AlloLycée pour réviser efficacement.