Codez avec GitHub Copilot

Vous savez maintenant dialoguer avec Copilot et lui faire écrire du code depuis votre navigateur.

Mais Copilot peut aller plus loin : il peut travailler directement dans votre environnement de développement, à l’intérieur de vos projets de code.
Et pour ça, vous aurez besoin d’activer GitHub Copilot.

GitHub permet de : 

• créer des dépôts (ou repositories en anglais),

• versionner votre travail,

• travailler à plusieurs sans jamais perdre une ligne. 

Copilot peut s’intégrer à GitHub pour proposer du code, des explications et même des tests directement dans votre éditeur.

Activez GitHub Copilot

Bonne nouvelle : activer GitHub Copilot ne prend que quelques minutes et une fois que c’est fait, vous allez pouvoir coder avec votre assistant directement depuis votre éditeur.

Une fois connecté :

1. Cliquez sur votre photo de profil en haut à droite.

2. Sélectionnez “Settings” (paramètres).

3. Dans le menu latéral, descendez jusqu’à la section “Copilot”.

4. Cliquez sur “Copilot” → “Features”=>”Start Copilot for free”

Vous arrivez sur la page dédiée à Copilot. C’est ici que vous pourrez activer ou gérer votre abonnement.

Préparez votre espace de travail

Ok, c’est activé. Et maintenant, je le vois où ?

C’est ici que tout devient concret :

1. Retournez sur la page d’accueil de GitHub,

2. Cliquez sur l'icône d’option 

3. Puis cliquez sur Codespaces

Ok, c’est activé. Et maintenant, je le vois où ?

C’est ici que tout devient concret :

1. Retournez sur la page d’accueil de GitHub,

2. Cliquez sur l'icône d’option 

3. Puis cliquez sur Codespaces

On va maintenant remettre les mains dans notre projet de e-commerce. Vous vous souvenez ? On avait demandé à Copilot d’écrire une fonction JavaScript ou Python pour calculer le prix final d’un panier après remise. Eh bien, on va maintenant voir comment Copilot peut vous aider directement à l’intérieur de votre projet GitHub.

Cliquez sur “Use this template” de la carte “Blank”. Vous vous retrouvez maintenant dans un environnement de travail similaire à celui de VSCode mais en ligne et surtout connecté a GitHub. Vous pouvez maintenant faire un copier-coller de votre code ou alors lui demander de re-générer votre projet. 

Comme avec la version Copilot Web, une fonction assez similaire vient de vous être proposée (sur la droite de la capture d’écran).

Alors, effectivement pour le moment cela se ressemble mais vous allez voir qu’on peut aller beaucoup plus loin. Une des choses essentielles c’est que Copilot Chat simule votre code, avec l’environnement de développement vous allez pouvoir le tester pour de vrai. Vous pourrez également créer un projet, gérer le versionning, travailler à plusieurs, etc. 

Exploitez Copilot GitHub

Vous pouvez maintenant lui dire :

“Explique le fonctionnement de ma fonction calculateFinalPrice"

Copilot va lire votre code et détailler la logique ligne par ligne et parfois même vous suggérer des améliorations.

Si vous ne souhaitez pas une explication globale de la fonction vous pouvez également sélectionner une partie seulement de la fonction ou quelques lignes puis faire un clic droit et cliquer sur “explain”. GitHub Copilot va alors vous expliquer spécifiquement ce morceau de la fonction en vous donnant des exemples. 

Maintenant que vous avez compris votre nouvelle fonction, nous allons l’importer dans l’éditeur pour l’exécuter. Pour faire cela, Il vous suffit de passer la souris sur le code généré par Copilot et trois petit icônes vont apparaître en haut à droite du code généré : 

• Appliquer dans l’éditeur ajoute le code directement dans l’éditeur de code,

• Insérer au curseur ajoute le code à l'endroit où est votre curseur dans l’éditeur de code,

• Copier copie le code dans le presse papier.

Cliquez sur Appliquer dans l’éditeur ; votre code arrive directement dans la fenêtre du milieu. 

Pour lancer la fonction :

1. Allez dans le menu de gauche sur Exécuter et déboguer

2. Cliquez sur Exécuter et déboguer 

Vous pouvez regarder dans le terminal : s’il n’y a pas d’erreur c’est que votre est exécuté avec succès (vous verrez dans le terminal le résultat de votre fonction avec le message : “Total à payer : €131.24”). 

Félicitations, vous venez d’écrire du code,de le lancer et… tout va bien ! 

Validez le code par des tests automatisés

L’objectif maintenant, c’est de vérifier que la fonction fait bien ce qu’on attend d’elle encore une fois sans rien installer et en passant par GitHub. 

Oui c’est vrai que la fonction… fonctionne. Mais, en réalité, vous avez juste testé que le code s’exécute ! À ce stade, rien ne nous indique qu’avec de vrais nombres tout se passe bien. 

Rappelez vous, nous devons calculer des remises sur des chiffres ; cela peut être intéressant de tester avec de vrais chiffres cette fois. Et là, il y a deux techniques : 

1. Créer vous-même votre processus de test : Vous allez devoir essayer plusieurs cas (avec des chiffres positifs, négatifs, différentes variantes des remises, etc.).

2. Faire appeler à Pytest : Pytest va générer aléatoirement des tests pour tester votre fonction. 

L’être humain a tendance à privilégier ce qui est le plus facile : si une fonction fait le travail pour nous, autant l’utiliser ! 

L’idée cela va être de vérifier si notre code fonctionne avec 10 exemples créés aléatoirement. Pour cela, on va lui demander de nous créer 10 tests avec Pytest”. 

Voici la syntaxe de mon prompt :

"Est ce que tu peux ajouter 10 tests différents que tu vas faire avec Pytest pour tester la fonction ?“

Une fois que tout est terminé vous avez un message dans le terminal qui vous dit :

=== 10 passed in 0.02s === 

Cela signifie que tous les tests ont fonctionné. 

En réalité, ce que vous utilisez dans GitHub Copilot n’est pas seulement une IA qui répond à des prompts. Derrière Copilot se trouve un véritable agent d’intelligence artificielle.

La nuance peut sembler subtile, mais elle change beaucoup de choses.

Dans l’exemple, lorsque vous avez demandé la création de 10 tests, l’agent IA a effectué plusieurs actions sans intervention humaine :

• Il a généré le code des tests,

• créé un dossier tests dans votre Codespace,

• ajouté un fichier  test_discount_calculator.py

• y a collé le code généré,

• …et a exécuté les tests automatiquement :

À vous de jouer !

Consigne

Vous aviez créé votre fonction analyze_numbers(numbers)dans Copilot Chat. C’est le moment de recréer cette fonction dans votre environnement de développement.

Reprenez votre fonctionanalyze_numbers(numbers)puis demandez des explications et générez des tests avec la fonction associée.

Résultat : 

Prompt 1 - Création du programme

• Contexte : Je veux créer une fonction Python pour m’entraîner à manipuler des listes de nombres.

• Langage : Python 3, sans utiliser de librairies externes.

• Objectif du code : Écrire une fonction  analyze_numbers(numbers)  qui prend une liste de nombres en entrée et retourne un dictionnaire contenant :

  • la moyenne

  • la médiane

  • la valeur minimale

  • la valeur maximale

• Contraintes :

  • Le code doit gérer les erreurs (liste vide, valeurs non numériques).

  • Ajouter des commentaires pour expliquer les étapes.

• Sortie attendue :Le dictionnaire final affiché dans la console.

"""Analyse de listes numériques sans dépendances externes."""

from __future__ import annotations

from typing import Iterable, Union, Dict

Number = Union[int, float]


def analyze_numbers(numbers: Iterable[Number]) -> Dict[str, float]:
    """Analyse une collection de nombres et retourne ses statistiques basiques.

    Parameters
    ----------
    numbers : Iterable[Number]
        Suite de valeurs numériques (int ou float).

    Returns
    -------
    dict
        Dictionnaire contenant la moyenne, la médiane, le minimum et le maximum.

    Raises
    ------
    TypeError
        Si l'entrée n'est pas itérable ou contient des valeurs non numériques.
    ValueError
        Si l'itérable est vide.
    """

    if numbers is None:
        raise TypeError("numbers must be an iterable of numeric values")

    sanitized: list[float] = []

    # Nettoie et valide chaque valeur reçue.
    for value in numbers:
        if not isinstance(value, (int, float)):
            raise TypeError("all elements must be numeric")
        sanitized.append(float(value))

    if not sanitized:
        raise ValueError("numbers cannot be empty")

    count = len(sanitized)
    total = sum(sanitized)
    mean = total / count

    sorted_values = sorted(sanitized)
    mid = count // 2
    # Calcule une médiane adaptée aux tailles paires et impaires.
    if count % 2 == 1:
        median = sorted_values[mid]
    else:
        median = (sorted_values[mid - 1] + sorted_values[mid]) / 2

    # Regroupe toutes les statistiques demandées dans un dictionnaire.
    result = {
        "mean": mean,
        "median": median,
        "min": sorted_values[0],
        "max": sorted_values[-1],
    }

    return result


def _pretty_print(result: Dict[str, float]) -> None:
    """Affiche les statistiques calculées sous un format lisible."""

    for key, value in result.items():
        print(f"{key.capitalize():<6}: {value:.2f}")


if __name__ == "__main__":
    sample_numbers = [12, 5.5, 18, 7, 5.5, 21]
    stats = analyze_numbers(sample_numbers)
    print("--- Résultat de analyze_numbers ---")
    print(stats)
    _pretty_print(stats)

Prompt 2 - Création des 7 tests simples avec Pytest :

"Écris des tests unitaires en Python (pytest) pour vérifier les cas normaux, les valeurs limites et les entrées invalides.”

from pathlib import Path
import sys

import pytest

PROJECT_ROOT = Path(__file__).resolve().parents[1]
if str(PROJECT_ROOT) not in sys.path:
    sys.path.insert(0, str(PROJECT_ROOT))

from analyze_numbers import analyze_numbers


def test_basic_stats_with_integers():
    numbers = [1, 2, 3, 4, 5]
    result = analyze_numbers(numbers)
    assert result == {"mean": 3.0, "median": 3.0, "min": 1.0, "max": 5.0}


def test_even_number_of_values_median_average():
    numbers = [10, 2, 8, 4]
    result = analyze_numbers(numbers)
    assert result["median"] == 6.0
    assert result["mean"] == pytest.approx(6.0)


def test_handles_floats_and_ints_mix():
    numbers = [1, 2.5, 3, 4.5]
    result = analyze_numbers(numbers)
    assert result["min"] == 1.0
    assert result["max"] == 4.5


def test_preserves_original_sequence_order():
    numbers = [3, 1, 2]
    analyze_numbers(numbers)
    assert numbers == [3, 1, 2]


def test_raises_type_error_on_non_numeric_value():
    with pytest.raises(TypeError):
        analyze_numbers([1, "two", 3])


def test_raises_value_error_on_empty_iterable():
    with pytest.raises(ValueError):
        analyze_numbers([])


def test_none_input_raises_type_error():
    with pytest.raises(TypeError):
        analyze_numbers(None)

Vous devriez alors avoir : 

===================== 7 passed in 0.02s =====================

En résumé

• GitHub Copilot s’intègre à votre environnement de développement pour écrire, expliquer et tester du code sans quitter l’éditeur. Une fois activé depuis votre compte GitHub, il devient un assistant intelligent capable d’interagir avec vos fichiers et de proposer des améliorations adaptées.

• L’activation est rapide : connectez-vous à GitHub, ouvrez la section Copilot dans les paramètres, puis lancez l’essai gratuit. Les étudiants et enseignants peuvent en bénéficier via le GitHub Student Developer Pack.

• Avec Codespaces, tout se fait en ligne : vous pouvez coder et collaborer sans installation. GitHub Copilot explique votre code, génère des tests avec Pytest et vérifie automatiquement les résultats.

Vous avez vu les bases, manipulé le code, validé vos tests… Il est temps de tester vos acquis sur Microsoft Copilot avec un quiz, bonne chance !