As you continue your journey with **SciPy**, it is important to develop the ability to identify which submodules are best suited for different scientific programming tasks. **SciPy** is organized into specialized submodules, each targeting a particular area such as optimization, integration, linear algebra, and more. By practicing how to import these submodules correctly, you build the foundation for efficient and accurate scientific computing.


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

A comprehensive course designed for students with strong math backgrounds and intermediate to advanced Python skills, focusing on leveraging SciPy for scientific computing, optimization, integration, and advanced mathematical operations.

Explore the structure, core modules, and essential features of SciPy for scientific computing.

Dive into SciPy's powerful linear algebra capabilities for solving real-world mathematical problems.

Master optimization techniques and root-finding algorithms using SciPy for scientific and engineering problems.

Explore advanced mathematical operations including integration, interpolation, and basic signal processing with SciPy.

Challenge: Exploring SciPy Submodules

Oplossing

Awesome!

Challenge: Exploring SciPy Submodules

Oplossing