NO PRODUCT SETTINGS FOUND FOR:

pyly

Gentle remainder that the product name comes from the `origin` first subfolder (after `/pms` ).

👣 Premiers pas avec Python

Ces premiers pas ne deviendront pas une chorégraphie virale, mais ils t'apprendront quelque chose. Bref, tout l'opposé de Tiktok.

📺 Affichages avec la fonction `print`

Lorsque l'on code, tout se passe à l'intérieur de la machine. On a donc besoin d'indiquer au programme si l'on souhaite qu'il affiche des valeurs à l'écran. En Python, c'est la fonction print qui permet de réaliser un affichage.

# _________________foreground_script_________________


# _________________corrector_________________
from io import StringIO
from pprint import pprint
import sys
import typing
import unittest
class PythonCorrector:
    def __init__(self, background_script):
        self.background_script = background_script
        self.last_error: str | None = None
        self.testcase = unittest.TestCase()
        self.check_counter = 0
        self.correction = {}
        # TODO: move this in the teacher class
        # Create a StringIO object to capture output
        self.original_stdout = sys.stdout
        # self.stdout = StringIO()
        # sys.stdout = self.stdout
        self.stdout = sys.stdout

        # if pyodide
        # todo : write surcouche pour data get

        print(sys.platform)

        #     print(codex_id)
        #     # load the data-background-script with js
        #     self.background_script = ''
        #     # js.globals.data_background_script

        #     self.background_script = document.activeElement.id

    def __del__(self):
        sys.stdout = sys.__stdout__

    @staticmethod
    def gracefully_check(check_method):
        def wrapper(self, *args, **kwargs):
            try:
                check_method(self, *args, **kwargs)
                success, msg = 1, ''
            except AssertionError as e:
                success, msg = 0, str(e)

            self.check_counter += 1
            self.correction[self.check_counter] = (success, msg)
            return success, msg

        return wrapper

    def check_coincide(self, x: typing.Any) -> None:
        namespace = {}
        exec(self.background_script, namespace)
        # TODO : SAME SETUP FOR ALL BECAUSE OF AUTOFORMAT
        x_name = f'{x=}'.split('=')[0]
        self.check_equal(x, namespace[x_name])

    @gracefully_check
    def check_equal(self, x: typing.Any, y: typing.Any) -> None:
        # First check if types match
        self.testcase.assertIsInstance(x, type(y))
        # Booleans
        if isinstance(x, bool):
            self.testcase.assertEqual(x, y)
        # Strings
        if isinstance(x, str):
            self.testcase.assertEqual(x, y)
        # Numbers
        elif isinstance(x, int):
            self.testcase.assertEqual(x, y)
        elif isinstance(x, float):
            self.testcase.assertAlmostEqual(x, y)
        # Sequences
        elif isinstance(x, list):
            self.testcase.assertListEqual(x, y)
        elif isinstance(x, tuple):
            self.testcase.assertTupleEqual(x, y)
        elif isinstance(x, set):
            self.testcase.assertSetEqual(x, y)
        # Dictionaries
        elif isinstance(x, dict):
            self.testcase.assertDictEqual(x, y)
        # Handle None
        elif x is None:
            self.testcase.assertIsNone(y)
        # Default case
        else:
            # raise NotImplementedError(f'PythonCorrector cannot compare {type(x)=}')
            self.testcase.assertEqual(x, y)

    @gracefully_check
    def check_equals_on_grid(self, f, args, values):
        for x, y in zip(args, values, strict=False):
            self.testcase.assertEqual(f(x), y)

    @gracefully_check
    def check_module_is_imported(self, module_name, teacher):
        # TODO mad: handle from_imports
        self.testcase.assertIn(module_name, teacher.story['user_input']['imports']['imports'])

    def check_stdout_equals(self, x):
        # NOTE mad: no need for the `gracefully_check` decorator as the `check_equal` method is used
        stdout = self.stdout.getvalue()
        stdout = stdout.strip().replace('\n', '')
        x = x.strip().replace('\n', '')
        self.check_equal(stdout, x)

    def check_nb_lines(self): ...

    # TODO: mad
    # check if nb lines consistent with sections
    # check if nb lines ==

    def correct(self) -> bool:
        ...
        # TODO: ideally the checks would be performed there
        # answer_nature = answer['nature'].split('_')
        # return self.correction

_pc = PythonCorrector('')

# _________________public_checks_________________


# _________________private_checks_________________

# _________________foreground_script_________________


# _________________corrector_________________
from io import StringIO
from pprint import pprint
import sys
import typing
import unittest
class PythonCorrector:
    def __init__(self, background_script):
        self.background_script = background_script
        self.last_error: str | None = None
        self.testcase = unittest.TestCase()
        self.check_counter = 0
        self.correction = {}
        # TODO: move this in the teacher class
        # Create a StringIO object to capture output
        self.original_stdout = sys.stdout
        # self.stdout = StringIO()
        # sys.stdout = self.stdout
        self.stdout = sys.stdout

        # if pyodide
        # todo : write surcouche pour data get

        print(sys.platform)

        #     print(codex_id)
        #     # load the data-background-script with js
        #     self.background_script = ''
        #     # js.globals.data_background_script

        #     self.background_script = document.activeElement.id

    def __del__(self):
        sys.stdout = sys.__stdout__

    @staticmethod
    def gracefully_check(check_method):
        def wrapper(self, *args, **kwargs):
            try:
                check_method(self, *args, **kwargs)
                success, msg = 1, ''
            except AssertionError as e:
                success, msg = 0, str(e)

            self.check_counter += 1
            self.correction[self.check_counter] = (success, msg)
            return success, msg

        return wrapper

    def check_coincide(self, x: typing.Any) -> None:
        namespace = {}
        exec(self.background_script, namespace)
        # TODO : SAME SETUP FOR ALL BECAUSE OF AUTOFORMAT
        x_name = f'{x=}'.split('=')[0]
        self.check_equal(x, namespace[x_name])

    @gracefully_check
    def check_equal(self, x: typing.Any, y: typing.Any) -> None:
        # First check if types match
        self.testcase.assertIsInstance(x, type(y))
        # Booleans
        if isinstance(x, bool):
            self.testcase.assertEqual(x, y)
        # Strings
        if isinstance(x, str):
            self.testcase.assertEqual(x, y)
        # Numbers
        elif isinstance(x, int):
            self.testcase.assertEqual(x, y)
        elif isinstance(x, float):
            self.testcase.assertAlmostEqual(x, y)
        # Sequences
        elif isinstance(x, list):
            self.testcase.assertListEqual(x, y)
        elif isinstance(x, tuple):
            self.testcase.assertTupleEqual(x, y)
        elif isinstance(x, set):
            self.testcase.assertSetEqual(x, y)
        # Dictionaries
        elif isinstance(x, dict):
            self.testcase.assertDictEqual(x, y)
        # Handle None
        elif x is None:
            self.testcase.assertIsNone(y)
        # Default case
        else:
            # raise NotImplementedError(f'PythonCorrector cannot compare {type(x)=}')
            self.testcase.assertEqual(x, y)

    @gracefully_check
    def check_equals_on_grid(self, f, args, values):
        for x, y in zip(args, values, strict=False):
            self.testcase.assertEqual(f(x), y)

    @gracefully_check
    def check_module_is_imported(self, module_name, teacher):
        # TODO mad: handle from_imports
        self.testcase.assertIn(module_name, teacher.story['user_input']['imports']['imports'])

    def check_stdout_equals(self, x):
        # NOTE mad: no need for the `gracefully_check` decorator as the `check_equal` method is used
        stdout = self.stdout.getvalue()
        stdout = stdout.strip().replace('\n', '')
        x = x.strip().replace('\n', '')
        self.check_equal(stdout, x)

    def check_nb_lines(self): ...

    # TODO: mad
    # check if nb lines consistent with sections
    # check if nb lines ==

    def correct(self) -> bool:
        ...
        # TODO: ideally the checks would be performed there
        # answer_nature = answer['nature'].split('_')
        # return self.correction

_pc = PythonCorrector('')

# _________________public_checks_________________


# _________________private_checks_________________

🧮 Calculatrice

Addition et soustraction avec `+` et `-`

Multiplication et division `*` et `/`

# _________________foreground_script_________________


# _________________corrector_________________
from io import StringIO
from pprint import pprint
import sys
import typing
import unittest
class PythonCorrector:
    def __init__(self, background_script):
        self.background_script = background_script
        self.last_error: str | None = None
        self.testcase = unittest.TestCase()
        self.check_counter = 0
        self.correction = {}
        # TODO: move this in the teacher class
        # Create a StringIO object to capture output
        self.original_stdout = sys.stdout
        # self.stdout = StringIO()
        # sys.stdout = self.stdout
        self.stdout = sys.stdout

        # if pyodide
        # todo : write surcouche pour data get

        print(sys.platform)

        #     print(codex_id)
        #     # load the data-background-script with js
        #     self.background_script = ''
        #     # js.globals.data_background_script

        #     self.background_script = document.activeElement.id

    def __del__(self):
        sys.stdout = sys.__stdout__

    @staticmethod
    def gracefully_check(check_method):
        def wrapper(self, *args, **kwargs):
            try:
                check_method(self, *args, **kwargs)
                success, msg = 1, ''
            except AssertionError as e:
                success, msg = 0, str(e)

            self.check_counter += 1
            self.correction[self.check_counter] = (success, msg)
            return success, msg

        return wrapper

    def check_coincide(self, x: typing.Any) -> None:
        namespace = {}
        exec(self.background_script, namespace)
        # TODO : SAME SETUP FOR ALL BECAUSE OF AUTOFORMAT
        x_name = f'{x=}'.split('=')[0]
        self.check_equal(x, namespace[x_name])

    @gracefully_check
    def check_equal(self, x: typing.Any, y: typing.Any) -> None:
        # First check if types match
        self.testcase.assertIsInstance(x, type(y))
        # Booleans
        if isinstance(x, bool):
            self.testcase.assertEqual(x, y)
        # Strings
        if isinstance(x, str):
            self.testcase.assertEqual(x, y)
        # Numbers
        elif isinstance(x, int):
            self.testcase.assertEqual(x, y)
        elif isinstance(x, float):
            self.testcase.assertAlmostEqual(x, y)
        # Sequences
        elif isinstance(x, list):
            self.testcase.assertListEqual(x, y)
        elif isinstance(x, tuple):
            self.testcase.assertTupleEqual(x, y)
        elif isinstance(x, set):
            self.testcase.assertSetEqual(x, y)
        # Dictionaries
        elif isinstance(x, dict):
            self.testcase.assertDictEqual(x, y)
        # Handle None
        elif x is None:
            self.testcase.assertIsNone(y)
        # Default case
        else:
            # raise NotImplementedError(f'PythonCorrector cannot compare {type(x)=}')
            self.testcase.assertEqual(x, y)

    @gracefully_check
    def check_equals_on_grid(self, f, args, values):
        for x, y in zip(args, values, strict=False):
            self.testcase.assertEqual(f(x), y)

    @gracefully_check
    def check_module_is_imported(self, module_name, teacher):
        # TODO mad: handle from_imports
        self.testcase.assertIn(module_name, teacher.story['user_input']['imports']['imports'])

    def check_stdout_equals(self, x):
        # NOTE mad: no need for the `gracefully_check` decorator as the `check_equal` method is used
        stdout = self.stdout.getvalue()
        stdout = stdout.strip().replace('\n', '')
        x = x.strip().replace('\n', '')
        self.check_equal(stdout, x)

    def check_nb_lines(self): ...

    # TODO: mad
    # check if nb lines consistent with sections
    # check if nb lines ==

    def correct(self) -> bool:
        ...
        # TODO: ideally the checks would be performed there
        # answer_nature = answer['nature'].split('_')
        # return self.correction

_pc = PythonCorrector('')

# _________________public_checks_________________


# _________________private_checks_________________

Division euclidienne avec `//` et `%`

Priorité des opérations

En utilisant la fonction print, calcule combien d'heures tu as passé à dormir si tu dors 8h par nuit depuis que t'es né (prends ton âge en années).

Si t'as 16 ans, tu devrais trouver 16 × 365 × 8 heures de sommeil. Ça fait un paquet d'heures sur TikTok manquées, non ? 😉

# _________________foreground_script_________________


# _________________corrector_________________
from io import StringIO
from pprint import pprint
import sys
import typing
import unittest
class PythonCorrector:
    def __init__(self, background_script):
        self.background_script = background_script
        self.last_error: str | None = None
        self.testcase = unittest.TestCase()
        self.check_counter = 0
        self.correction = {}
        # TODO: move this in the teacher class
        # Create a StringIO object to capture output
        self.original_stdout = sys.stdout
        # self.stdout = StringIO()
        # sys.stdout = self.stdout
        self.stdout = sys.stdout

        # if pyodide
        # todo : write surcouche pour data get

        print(sys.platform)

        #     print(codex_id)
        #     # load the data-background-script with js
        #     self.background_script = ''
        #     # js.globals.data_background_script

        #     self.background_script = document.activeElement.id

    def __del__(self):
        sys.stdout = sys.__stdout__

    @staticmethod
    def gracefully_check(check_method):
        def wrapper(self, *args, **kwargs):
            try:
                check_method(self, *args, **kwargs)
                success, msg = 1, ''
            except AssertionError as e:
                success, msg = 0, str(e)

            self.check_counter += 1
            self.correction[self.check_counter] = (success, msg)
            return success, msg

        return wrapper

    def check_coincide(self, x: typing.Any) -> None:
        namespace = {}
        exec(self.background_script, namespace)
        # TODO : SAME SETUP FOR ALL BECAUSE OF AUTOFORMAT
        x_name = f'{x=}'.split('=')[0]
        self.check_equal(x, namespace[x_name])

    @gracefully_check
    def check_equal(self, x: typing.Any, y: typing.Any) -> None:
        # First check if types match
        self.testcase.assertIsInstance(x, type(y))
        # Booleans
        if isinstance(x, bool):
            self.testcase.assertEqual(x, y)
        # Strings
        if isinstance(x, str):
            self.testcase.assertEqual(x, y)
        # Numbers
        elif isinstance(x, int):
            self.testcase.assertEqual(x, y)
        elif isinstance(x, float):
            self.testcase.assertAlmostEqual(x, y)
        # Sequences
        elif isinstance(x, list):
            self.testcase.assertListEqual(x, y)
        elif isinstance(x, tuple):
            self.testcase.assertTupleEqual(x, y)
        elif isinstance(x, set):
            self.testcase.assertSetEqual(x, y)
        # Dictionaries
        elif isinstance(x, dict):
            self.testcase.assertDictEqual(x, y)
        # Handle None
        elif x is None:
            self.testcase.assertIsNone(y)
        # Default case
        else:
            # raise NotImplementedError(f'PythonCorrector cannot compare {type(x)=}')
            self.testcase.assertEqual(x, y)

    @gracefully_check
    def check_equals_on_grid(self, f, args, values):
        for x, y in zip(args, values, strict=False):
            self.testcase.assertEqual(f(x), y)

    @gracefully_check
    def check_module_is_imported(self, module_name, teacher):
        # TODO mad: handle from_imports
        self.testcase.assertIn(module_name, teacher.story['user_input']['imports']['imports'])

    def check_stdout_equals(self, x):
        # NOTE mad: no need for the `gracefully_check` decorator as the `check_equal` method is used
        stdout = self.stdout.getvalue()
        stdout = stdout.strip().replace('\n', '')
        x = x.strip().replace('\n', '')
        self.check_equal(stdout, x)

    def check_nb_lines(self): ...

    # TODO: mad
    # check if nb lines consistent with sections
    # check if nb lines ==

    def correct(self) -> bool:
        ...
        # TODO: ideally the checks would be performed there
        # answer_nature = answer['nature'].split('_')
        # return self.correction

_pc = PythonCorrector('')

# _________________public_checks_________________


# _________________private_checks_________________

📦 Variables

Comme en maths, tes boîtes préférées

Plutôt que de tout calculer d'un coup, on peut stocker des valeurs dans des variables. C'est comme créer des raccourcis !

Par exemple :

age = 16                  # Mon âge
jours_par_an = 365        # Nombre de jours dans une année
heures_dodo = 8           # Heures de sommeil par nuit
total = age * jours_par_an * heures_dodo
print("J'ai dormi environ", total, "heures dans ma vie !")

T'inquiète pas si tu comprends pas tout, on va y aller step by step.

# _________________foreground_script_________________


# _________________corrector_________________
from io import StringIO
from pprint import pprint
import sys
import typing
import unittest
class PythonCorrector:
    def __init__(self, background_script):
        self.background_script = background_script
        self.last_error: str | None = None
        self.testcase = unittest.TestCase()
        self.check_counter = 0
        self.correction = {}
        # TODO: move this in the teacher class
        # Create a StringIO object to capture output
        self.original_stdout = sys.stdout
        # self.stdout = StringIO()
        # sys.stdout = self.stdout
        self.stdout = sys.stdout

        # if pyodide
        # todo : write surcouche pour data get

        print(sys.platform)

        #     print(codex_id)
        #     # load the data-background-script with js
        #     self.background_script = ''
        #     # js.globals.data_background_script

        #     self.background_script = document.activeElement.id

    def __del__(self):
        sys.stdout = sys.__stdout__

    @staticmethod
    def gracefully_check(check_method):
        def wrapper(self, *args, **kwargs):
            try:
                check_method(self, *args, **kwargs)
                success, msg = 1, ''
            except AssertionError as e:
                success, msg = 0, str(e)

            self.check_counter += 1
            self.correction[self.check_counter] = (success, msg)
            return success, msg

        return wrapper

    def check_coincide(self, x: typing.Any) -> None:
        namespace = {}
        exec(self.background_script, namespace)
        # TODO : SAME SETUP FOR ALL BECAUSE OF AUTOFORMAT
        x_name = f'{x=}'.split('=')[0]
        self.check_equal(x, namespace[x_name])

    @gracefully_check
    def check_equal(self, x: typing.Any, y: typing.Any) -> None:
        # First check if types match
        self.testcase.assertIsInstance(x, type(y))
        # Booleans
        if isinstance(x, bool):
            self.testcase.assertEqual(x, y)
        # Strings
        if isinstance(x, str):
            self.testcase.assertEqual(x, y)
        # Numbers
        elif isinstance(x, int):
            self.testcase.assertEqual(x, y)
        elif isinstance(x, float):
            self.testcase.assertAlmostEqual(x, y)
        # Sequences
        elif isinstance(x, list):
            self.testcase.assertListEqual(x, y)
        elif isinstance(x, tuple):
            self.testcase.assertTupleEqual(x, y)
        elif isinstance(x, set):
            self.testcase.assertSetEqual(x, y)
        # Dictionaries
        elif isinstance(x, dict):
            self.testcase.assertDictEqual(x, y)
        # Handle None
        elif x is None:
            self.testcase.assertIsNone(y)
        # Default case
        else:
            # raise NotImplementedError(f'PythonCorrector cannot compare {type(x)=}')
            self.testcase.assertEqual(x, y)

    @gracefully_check
    def check_equals_on_grid(self, f, args, values):
        for x, y in zip(args, values, strict=False):
            self.testcase.assertEqual(f(x), y)

    @gracefully_check
    def check_module_is_imported(self, module_name, teacher):
        # TODO mad: handle from_imports
        self.testcase.assertIn(module_name, teacher.story['user_input']['imports']['imports'])

    def check_stdout_equals(self, x):
        # NOTE mad: no need for the `gracefully_check` decorator as the `check_equal` method is used
        stdout = self.stdout.getvalue()
        stdout = stdout.strip().replace('\n', '')
        x = x.strip().replace('\n', '')
        self.check_equal(stdout, x)

    def check_nb_lines(self): ...

    # TODO: mad
    # check if nb lines consistent with sections
    # check if nb lines ==

    def correct(self) -> bool:
        ...
        # TODO: ideally the checks would be performed there
        # answer_nature = answer['nature'].split('_')
        # return self.correction

_pc = PythonCorrector('')

# _________________public_checks_________________


# _________________private_checks_________________

Crée des variables pour calculer combien de minutes tu passes sur ton téléphone en une année si tu y passes 3 heures par jour. Utilise des noms de variables qui ont du sens !

C'est souvent plus facile de décomposer un problème en plusieurs étapes avec des variables intermédiaires qu'essayer de tout faire en une seule ligne.

# _________________foreground_script_________________


# _________________corrector_________________
from io import StringIO
from pprint import pprint
import sys
import typing
import unittest
class PythonCorrector:
    def __init__(self, background_script):
        self.background_script = background_script
        self.last_error: str | None = None
        self.testcase = unittest.TestCase()
        self.check_counter = 0
        self.correction = {}
        # TODO: move this in the teacher class
        # Create a StringIO object to capture output
        self.original_stdout = sys.stdout
        # self.stdout = StringIO()
        # sys.stdout = self.stdout
        self.stdout = sys.stdout

        # if pyodide
        # todo : write surcouche pour data get

        print(sys.platform)

        #     print(codex_id)
        #     # load the data-background-script with js
        #     self.background_script = ''
        #     # js.globals.data_background_script

        #     self.background_script = document.activeElement.id

    def __del__(self):
        sys.stdout = sys.__stdout__

    @staticmethod
    def gracefully_check(check_method):
        def wrapper(self, *args, **kwargs):
            try:
                check_method(self, *args, **kwargs)
                success, msg = 1, ''
            except AssertionError as e:
                success, msg = 0, str(e)

            self.check_counter += 1
            self.correction[self.check_counter] = (success, msg)
            return success, msg

        return wrapper

    def check_coincide(self, x: typing.Any) -> None:
        namespace = {}
        exec(self.background_script, namespace)
        # TODO : SAME SETUP FOR ALL BECAUSE OF AUTOFORMAT
        x_name = f'{x=}'.split('=')[0]
        self.check_equal(x, namespace[x_name])

    @gracefully_check
    def check_equal(self, x: typing.Any, y: typing.Any) -> None:
        # First check if types match
        self.testcase.assertIsInstance(x, type(y))
        # Booleans
        if isinstance(x, bool):
            self.testcase.assertEqual(x, y)
        # Strings
        if isinstance(x, str):
            self.testcase.assertEqual(x, y)
        # Numbers
        elif isinstance(x, int):
            self.testcase.assertEqual(x, y)
        elif isinstance(x, float):
            self.testcase.assertAlmostEqual(x, y)
        # Sequences
        elif isinstance(x, list):
            self.testcase.assertListEqual(x, y)
        elif isinstance(x, tuple):
            self.testcase.assertTupleEqual(x, y)
        elif isinstance(x, set):
            self.testcase.assertSetEqual(x, y)
        # Dictionaries
        elif isinstance(x, dict):
            self.testcase.assertDictEqual(x, y)
        # Handle None
        elif x is None:
            self.testcase.assertIsNone(y)
        # Default case
        else:
            # raise NotImplementedError(f'PythonCorrector cannot compare {type(x)=}')
            self.testcase.assertEqual(x, y)

    @gracefully_check
    def check_equals_on_grid(self, f, args, values):
        for x, y in zip(args, values, strict=False):
            self.testcase.assertEqual(f(x), y)

    @gracefully_check
    def check_module_is_imported(self, module_name, teacher):
        # TODO mad: handle from_imports
        self.testcase.assertIn(module_name, teacher.story['user_input']['imports']['imports'])

    def check_stdout_equals(self, x):
        # NOTE mad: no need for the `gracefully_check` decorator as the `check_equal` method is used
        stdout = self.stdout.getvalue()
        stdout = stdout.strip().replace('\n', '')
        x = x.strip().replace('\n', '')
        self.check_equal(stdout, x)

    def check_nb_lines(self): ...

    # TODO: mad
    # check if nb lines consistent with sections
    # check if nb lines ==

    def correct(self) -> bool:
        ...
        # TODO: ideally the checks would be performed there
        # answer_nature = answer['nature'].split('_')
        # return self.correction

_pc = PythonCorrector('')

# _________________public_checks_________________


# _________________private_checks_________________

💬 Commentaires

Soit $a$ un réel non nul. Calculer l'unique antécédent de $0$ par la fonction $f$ définie sur $\mathbb{R}$ par $f(x)=ax+b$.

🔁 Récap

<!-- # Variables et affichages

Pour découvrir ce langage de programmation, utilisons Python comme une calculatrice !

Quelques calculs

Blablablablabl
Blablabla

codexPCAVersion: 1
script_path: "intro/calculatrice_4_ope.py"

En utilisant la fonction print, et l'opérateur +, écris du code qui calcule le nombre de jours au cours de la décennie 2010-2019.

(ca envoie le code)

Lalal

codexPCAVersion: 1
script_path: "intro/calculatrice_4_ope_question_0.py"

Example maths for later

Soit $a$ un réel non nul. Calculer l'unique antécédent de $0$ par la fonction $f$ définie sur $\mathbb{R}$ par $f(x)=ax+b$.

mathPCAVersion: 1
mask: x_0=
nature: give_formula
expression: -b/a
perfect_test: -\frac{b}{a}
``` --&gt;

## 🧪 Démo des fragments (couverture complète)

---

### Listes simples

- Premier élément
- Deuxième élément

1. Étape 1
2. Étape 2

### Liste labellisée

&lt;ul&gt;
  &lt;li class="lbl"&gt;Définition&lt;/li&gt;
  &lt;li class="lbl"&gt;Théorème&lt;/li&gt;
  &lt;li class="lbl"&gt;Exemple&lt;/li&gt;
  &lt;li class="lbl"&gt;Remarque&lt;/li&gt;
  &lt;li class="lbl"&gt;Conclusion&lt;/li&gt;
&lt;/ul&gt;

### Question à choix (radio)

&lt;ul&gt;
  &lt;li class="i-radio"&gt;Paris{: 0}&lt;/li&gt;
  &lt;li class="i-radio"&gt;Ajaccio{: 1}&lt;/li&gt;
  &lt;li class="i-radio"&gt;Lyon{: 0}&lt;/li&gt;
&lt;/ul&gt;

### Tableau

| Nom | Valeur |
|---|---|
| a | 1 |
| b | 2 |

### Séparateur

---

### Vector graph (HTML)

```html
&lt;vector-graph width="300" height="200"&gt;&lt;/vector-graph&gt;

Graph (YAML)

Table de variations (YAML avec classe)

yaml {.table-variations} headers: [x, f(x)] rows: - [-2, 5] - [0, 1] - [2, -3]