🏝️ Surface de l'île & introduction à Python

Apprendre à calculer une surface à partir d'une carte, avec Python

Aucune connaissance préalable programmation ou concernant le langage Python n'est requise ☺

📺 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.

Morceau de code pour passer des latitudes/longitudes en coordonnées cartésiennes / distances Morceau de code qui va coloriser les carrés, sur le svg et morceau de code pour aire totale

# _________________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