Au fur et à mesure de votre progression avec **SciPy**, il est important de développer la capacité à identifier quels sous-modules sont les mieux adaptés à différentes tâches de programmation scientifique. **SciPy** est organisé en sous-modules spécialisés, chacun ciblant un domaine particulier tel que l'optimisation, l'intégration, l'algèbre linéaire, et bien d'autres. En vous exerçant à importer correctement ces sous-modules, vous posez les bases d'un calcul scientifique efficace et précis.


import unittest
import user_code
import ast
import re   
import importlib
import sys
import types
import unittest

class TestTask(unittest.TestCase):
    def test_import_optimize(self):
        import user_code
        importlib.reload(user_code)
        has_optimize = hasattr(user_code, 'optimize') or 'scipy.optimize' in sys.modules
        try:
            from scipy import optimize
            expected = True
        except ImportError:
            expected = False
        _dynamic_test(
            self,
            expected and ('scipy.optimize' in sys.modules or hasattr(user_code, 'optimize')),
            "Correctly imports scipy.optimize for root finding",
            "Did not import scipy.optimize for root finding",
        )

    def test_import_integrate(self):
        import user_code
        importlib.reload(user_code)
        has_integrate = hasattr(user_code, 'integrate') or 'scipy.integrate' in sys.modules
        try:
            from scipy import integrate
            expected = True
        except ImportError:
            expected = False
        _dynamic_test(
            self,
            expected and ('scipy.integrate' in sys.modules or hasattr(user_code, 'integrate')),
            "Correctly imports scipy.integrate for numerical integration",
            "Did not import scipy.integrate for numerical integration",
        )

    def test_import_linalg(self):
        import user_code
        importlib.reload(user_code)
        has_linalg = hasattr(user_code, 'linalg') or 'scipy.linalg' in sys.modules
        try:
            from scipy import linalg
            expected = True
        except ImportError:
            expected = False
        _dynamic_test(
            self,
            expected and ('scipy.linalg' in sys.modules or hasattr(user_code, 'linalg')),
            "Correctly imports scipy.linalg for linear algebra",
            "Did not import scipy.linalg for linear algebra",
        )

    def test_import_interpolate(self):
        import user_code
        importlib.reload(user_code)
        has_interpolate = hasattr(user_code, 'interpolate') or 'scipy.interpolate' in sys.modules
        try:
            from scipy import interpolate
            expected = True
        except ImportError:
            expected = False
        _dynamic_test(
            self,
            expected and ('scipy.interpolate' in sys.modules or hasattr(user_code, 'interpolate')),
            "Correctly imports scipy.interpolate for interpolation",
            "Did not import scipy.interpolate for interpolation",
        )

    def test_import_signal(self):
        import user_code
        importlib.reload(user_code)
        has_signal = hasattr(user_code, 'signal') or 'scipy.signal' in sys.modules
        try:
            from scipy import signal
            expected = True
        except ImportError:
            expected = False
        _dynamic_test(
            self,
            expected and ('scipy.signal' in sys.modules or hasattr(user_code, 'signal')),
            "Correctly imports scipy.signal for signal processing",
            "Did not import scipy.signal for signal processing",
        )

def _dynamic_test(test_case, condition, success_message, failure_message):
    if condition:
        test_case._testMethodName = success_message
        test_case.assertTrue(True, success_message)
    else:
        test_case._testMethodName = failure_message
        test_case.fail(failure_message)

def normalize_text(text):
    text = text.lower()
    text = re.sub(r"\s{2,}", " ", text)
    text = re.sub(r"\s*([,:?])\s*", r"\1 ", text)
    return text.strip()

def change_var(code: str, var_name: str, value: str) -> str:
    tree = ast.parse(code)
    lines = code.splitlines()
    for i, node in enumerate(tree.body):
        if isinstance(node, ast.Assign):
            for target in node.targets:
                if isinstance(target, ast.Name) and target.id == var_name:
                    start_line = node.lineno - 1
                    line = lines[start_line]
                    indent = ' ' * (len(line) - len(line.lstrip()))
                    lines[start_line] = f"{indent}{var_name} = {value}"
                    next_line = len(lines)
                    for next_node in tree.body[i+1:]:
                        if hasattr(next_node, 'lineno'):
                            next_line = next_node.lineno - 1
                            break
                    if next_line > start_line + 1:
                        lines[start_line+1:next_line] = []
                    
                    return '\\n'.join(lines)
    return code

if __name__ == "__main__":
    unittest.main()


test_main.py

Un cours complet conçu pour les étudiants ayant de solides bases en mathématiques et des compétences intermédiaires à avancées en Python, axé sur l'utilisation de SciPy pour le calcul scientifique, l'optimisation, l'intégration et les opérations mathématiques avancées.

Découvrez la structure, les modules principaux et les fonctionnalités essentielles de SciPy pour le calcul scientifique.

Plongez dans les puissantes capacités d'algèbre linéaire de SciPy pour résoudre des problèmes mathématiques concrets.

Maîtriser les techniques d'optimisation et les algorithmes de recherche de racines avec SciPy pour des problèmes scientifiques et d'ingénierie.

Explorez des opérations mathématiques avancées, y compris l'intégration, l'interpolation et le traitement du signal de base avec SciPy.

Défi : Exploration des Sous-modules de SciPy

Solution