Multiprocessing i Python möjliggör att köra flera processer parallellt, där varje process har sin egen Python-tolk och minnesutrymme. Detta tillvägagångssätt är särskilt användbart för CPU-intensiva uppgifter, där du vill utnyttja flera CPU-kärnor för att utföra beräkningar snabbare. Genom att använda multiprocessing kan du avsevärt förbättra prestandan för operationer som kräver tung beräkning, såsom databehandling, vetenskapliga beräkningar eller simuleringar.

Klassen `multiprocessing.Manager` tillhandahåller ett sätt att skapa delade objekt – såsom listor och ordböcker – som kan nås och ändras säkert av flera processer. När du behöver samla in resultat eller samordna data mellan separata `Process`-instanser, använd alltid en `Manager` för att skapa dessa delade objekt. Vanliga Python-listor och ordböcker delas inte mellan processer, så ändringar som görs i en process blir inte synliga för andra. Med en `Manager`-lista kan varje process lägga till eller ändra data, och alla ändringar blir synliga för varje process som använder det delade objektet.

Notering

from multiprocessing import Process, Manager

def add_value(value, shared_list):
    shared_list.append(value)

if __name__ == "__main__":
    manager = Manager()
    shared_list = manager.list()
    processes = []
    values = [10, 20, 30, 40, 50]

    for v in values:
        p = Process(target=add_value, args=(v, shared_list))
        processes.append(p)
        p.start()

    for p in processes:
        p.join()

    print("Collected results:", list(shared_list))

Den här koden visar hur man använder `multiprocessing.Manager` för att skapa en delad lista som flera processer kan komma åt och ändra. Varje process beräknar kvadraten av ett tal och lägger till sitt resultat i den delade listan. Genom att använda en `Manager`-lista säkerställs att alla processer kan dela och samla in data på ett säkert sätt, vilket gör det möjligt att samla resultat från separata processer som körs parallellt.

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

class TestTask(unittest.TestCase):
    def test_compute_square_function(self):
        import user_code
        importlib.reload(user_code)
        func = getattr(user_code, 'compute_square', None)
        _dynamic_test(self, callable(func),
            'compute_square function is defined',
            'compute_square function is missing or not callable.'
        )
        if callable(func):
            results = []
            func(3, results)
            _dynamic_test(self, results == [9],
                'compute_square(3, results) appends 9',
                f'compute_square(3, results) should append 9, got {results}'
            )
            results = []
            func(0, results)
            _dynamic_test(self, results == [0],
                'compute_square(0, results) appends 0',
                f'compute_square(0, results) should append 0, got {results}'
            )
            results = []
            func(-2, results)
            _dynamic_test(self, results == [4],
                'compute_square(-2, results) appends 4',
                f'compute_square(-2, results) should append 4, got {results}'
            )

    def test_results_variable(self):
        import user_code
        importlib.reload(user_code)
        results = getattr(user_code, 'results', None)
        _dynamic_test(self,
            isinstance(results, list),
            'results is a list',
            f'results is not a list: {results}'
        )
        expected = set([1, 4, 9, 16, 25])
        if isinstance(results, list):
            _dynamic_test(self,
                set(results) == expected and len(results) == 5,
                f'results contains all squares: {expected}',
                f'Expected results: {expected}, got: {set(results)}'
            )

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()
    changed = False
    assign_nodes = [
        (i, node)
        for i, node in enumerate(tree.body)
        if isinstance(node, ast.Assign)
        and any(isinstance(target, ast.Name) and target.id == var_name for target in node.targets)
    ]
    if not assign_nodes:
        return code
    for i, node in reversed(assign_nodes):
        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] = []
        changed = True
    return '\\n'.join(lines) if changed else code

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


test_main.py

Du kommer att förvärva praktiska färdigheter i Pythons moduler och importer för effektiv kodhantering. Behärska avancerade tekniker för felhantering för mer tillförlitliga applikationer, automatisera filoperationer med filhantering och lär dig robusta teststrategier med Pytest och Unittest för att säkerställa kodens integritet.

Master Python's exception system for robust error handling and debugging.

Explore advanced techniques for file operations and resource management using context managers.

Compare and apply Python's multithreading and multiprocessing modules for concurrent programming.

Master asynchronous programming in Python using the asyncio library for scalable I/O-bound applications.

Explore how to write, organize, and run tests using Python's unittest and pytest frameworks.

Challenge: Den Parallella Kvadratsamlaren

Lösning