Testen von Code

• Zu Aufgabe 1 - Matrizenmultiplikation in Python
• Zu Aufgabe 2 - Generierung einer großen Liste: Vermeidung von Speicherüberlauf durch effiziente Implementierung
• Zu Aufgabe 3 - Fakultätsberechnungen
• Zu Aufgabe 4 - Summe der Primzahlen
• Fazit

1. Aufgabe: Matrizenmultiplikation in Python

Diese Funktion multipliziert zwei Matrizen a und b und gibt das Ergebnis zurück. Sie verwendet verschachtelte Schleifen, um alle Elemente der beiden Matrizen zu durchlaufen. Wenn jedoch die Matrizen zu groß sind, kann dies zu einem Speicherüberlauf oder einer Ausführungszeitüberschreitung führen.

def multiply_matrices(a, b):

   result = []

   for i in range(len(a)):

       row = []

       for j in range(len(b[0])):

           element = 0

           for k in range(len(b)):

               element += a[i][k] * b[k][j]

           row.append(element)

       result.append(row)

   return result

Prompt:

Test diesen code auf mögliche Grenzen in seiner Ausführbarkeit:

   result = []

   for i in range(len(a)):

       row = []

       for j in range(len(b[0])):

           element = 0

           for k in range(len(b)):

               element += a[i][k] * b[k][j]

           row.append(element)

       result.append(row)

   return result

Ergebnis:

Der gegebene Code multipliziert zwei Matrizen. Im Allgemeinen ist die Ausführbarkeit des Codes von der Größe der Matrizen abhängig, die multipliziert werden sollen. Hier sind einige mögliche Grenzen, die berücksichtigt werden sollten:

1. Speicherbegrenzung: Der Code erstellt eine neue Matrix, um das Ergebnis zu speichern. Wenn die beiden Eingabematrizen sehr groß sind, kann dies dazu führen, dass der Computer nicht genügend Speicher hat, um das Ergebnis zu speichern. Dies kann zu einer Speicherüberlastung führen und den Code zum Absturz bringen.
2. Zeitbegrenzung: Der Code verwendet drei ineinander verschachtelte Schleifen, um das Ergebnis zu berechnen. Wenn die Matrizen sehr groß sind, kann dies dazu führen, dass der Code sehr langsam wird und möglicherweise gar nicht ausgeführt werden kann, bevor ein Timeout erreicht wird.
3. Eingabebegrenzung: Der Code geht davon aus, dass die beiden Eingabematrizen eine gültige Größe haben, um multipliziert werden zu können. Wenn eine der Matrizen leer ist oder eine ungültige Größe hat, kann dies zu Fehlern führen.
4. Datentypbegrenzung: Der Code geht davon aus, dass die Elemente der Matrizen numerisch sind und dass die Matrizen denselben Datentyp haben. Wenn die Matrizen andere Datentypen haben oder nicht numerisch sind, kann dies zu Fehlern führen.
5. Rundungsfehlerbegrenzung: Bei der Matrixmultiplikation können Rundungsfehler auftreten, insbesondere wenn die Matrizen sehr große oder sehr kleine Werte enthalten. Wenn die Genauigkeit der Ergebnisse wichtig ist, müssen möglicherweise spezielle Techniken zur Fehlerreduzierung verwendet werden.
6. Parallelisierungsbegrenzung: Der Code ist sequentiell geschrieben und nutzt nicht die Vorteile der parallelen Verarbeitung. Wenn die Matrizen sehr groß sind, kann es vorteilhaft sein, den Code parallel auszuführen, um die Verarbeitungszeit zu reduzieren.

import numpy as np

def multiply_matrices(a, b):
    if len(a[0]) != len(b):
        raise ValueError("Matrix dimensions don't match")

    a_np = np.array(a)
    b_np = np.array(b)

    result_np = np.dot(a_np, b_np)

    result = result_np.tolist()
    return result

Die Änderungen, die vorgenommen wurden, umfassen:

1. Verwendung von numpy: Numpy ist eine leistungsfähige Bibliothek für numerische Berechnungen in Python. Der Code verwendet die numpy-Bibliothek, um die Matrixmultiplikation durchzuführen, was zu einer besseren Leistung führen kann.
2. Fehlerprüfung: Der Code prüft, ob die Dimensionen der Eingabematrizen übereinstimmen. Wenn die Dimensionen nicht übereinstimmen, wird eine ValueError-Ausnahme ausgelöst.
3. Rückgabe des Ergebnisses als Liste: Der Code konvertiert das Ergebnis von numpy-Array in eine Liste, um die Ausgabe mit dem ursprünglichen Code kompatibel zu machen.

Dieser Code ist nicht nur schneller und effizienter, sondern berücksichtigt auch einige der möglichen Grenzen, die im ursprünglichen Code genannt wurden.

2. Aufgabe: Generierung einer großen Liste: Vermeidung von Speicherüberlauf durch effiziente Implementierung

Diese Funktion erstellt eine Liste der Größe size und füllt sie mit aufeinanderfolgenden Zahlen. Wenn size jedoch zu groß ist, kann dies zu einem Speicherüberlauf führen, da der Computer möglicherweise nicht genügend Speicherplatz hat, um die gesamte Liste zu erstellen.

def create_large_list(size):

   my_list = []

   for i in range(size):

       my_list.append(i)

   return my_list

Prompt:

Test diesen code auf mögliche Grenzen in seiner Ausführbarkeit:

def create_large_list(size):

   my_list = []

   for i in range(size):

       my_list.append(i)

   return my_list

Ergebnis:

Der Code sieht gut aus und sollte problemlos ausgeführt werden können, solange der verfügbare Arbeitsspeicher des Systems ausreicht, um eine Liste der angegebenen Größe zu erstellen.

Es gibt jedoch einige mögliche Grenzen, die die Ausführbarkeit des Codes beeinträchtigen können:

1. Speicherbegrenzung: Wenn der verfügbare Arbeitsspeicher des Systems nicht ausreicht, um eine Liste der angegebenen Größe zu erstellen, wird ein Speicherfehler auftreten.
2. Maximale Listenlänge: In Python gibt es eine maximale Listenlänge, die durch die Größe des zugewiesenen Speichers begrenzt wird. Die maximale Größe der Liste hängt also von der verfügbaren Systemressource ab. Wenn die maximale Listenlänge überschritten wird, wird ein Overflow-Fehler auftreten.
3. Rechenzeit: Wenn die Größe der Liste sehr groß ist, kann es länger dauern, um die Schleife auszuführen und die Liste zu erstellen. In diesem Fall kann die Ausführung des Codes eine längere Zeit in Anspruch nehmen oder zu einer Timeout-Exception führen.

Es ist jedoch unwahrscheinlich, dass diese Grenzen für eine typische Anwendung ein Problem darstellen werden, da die meisten Systeme über ausreichend Speicher und Rechenleistung verfügen, um eine Liste der angegebenen Größe zu erstellen.

3. Aufgabe: Fakultätsberechnungen

Prompt:
Führe für folgenden Code unit tests durch:

def factorial(n): 
 	if n == 0: 
 		return 1 
 	else: 
 		return n * factorial(n - 1)

Ergebnis ChatGPT:

Hier sind Unit-Tests für die gegebene Funktion factorial:

def test_factorial():
    # Testfall 1: Überprüfen der Fakultät von 0
    n_1 = 0
    expected_result_1 = 1
    assert factorial(n_1) == expected_result_1

    # Testfall 2: Überprüfen der Fakultät von 1
    n_2 = 1
    expected_result_2 = 1
    assert factorial(n_2) == expected_result_2

    # Testfall 3: Überprüfen der Fakultät von 5
    n_3 = 5
    expected_result_3 = 120
    assert factorial(n_3) == expected_result_3

    # Testfall 4: Überprüfen der Fakultät von 10
    n_4 = 10
    expected_result_4 = 3628800
    assert factorial(n_4) == expected_result_4

    print("Alle Tests erfolgreich durchgeführt.")


# Führe die Unit-Tests aus
test_factorial()

Die Unit-Tests umfassen verschiedene Testfälle, einschließlich der Fakultät von 0, 1, 5 und 10. Die erwarteten Ergebnisse werden festgelegt und mit den tatsächlichen Ergebnissen der factorial-Funktion verglichen. Wenn alle Tests erfolgreich sind, wird die Meldung "Alle Tests erfolgreich durchgeführt" ausgegeben. Andernfalls wird eine Fehlermeldung angezeigt, die angibt, welcher Test fehlgeschlagen ist.

4. Aufgabe: Summe der Primzahlen

Prompt:

Führe für folgenden Code unit tests durch:

def sum_of_primes(limit): 
 	prime_numbers = [] 
 	for num in range(2, limit + 1): 
 		is_prime = True 
 		for divisor in range(2, int(num ** 0.5) + 1): 
 			if num % divisor == 0: 
 				is_prime = False 
 				break 
 		if is_prime: 
 			prime_numbers.append(num) 
 	return sum(prime_numbers)

Ergebnis ChatGPT:

Entschuldigung, aber als textbasiertes KI-Modell kann ich den Code nicht direkt ausführen oder Unit-Tests durchführen. Ich kann jedoch den Code analysieren und Ihnen helfen, Testfälle zu definieren, die Sie selbst ausführen können. Hier sind einige Beispiele für Testfälle für die Funktion sum_of_primes:

def test_sum_of_primes():
    # Testfall 1: Überprüfen der Summe aller Primzahlen bis 10
    limit_1 = 10
    expected_result_1 = 17  # 2 + 3 + 5 + 7
    assert sum_of_primes(limit_1) == expected_result_1

    # Testfall 2: Überprüfen der Summe aller Primzahlen bis 20
    limit_2 = 20
    expected_result_2 = 77  # 2 + 3 + 5 + 7 + 11 + 13 + 17 + 19
    assert sum_of_primes(limit_2) == expected_result_2

    # Testfall 3: Überprüfen der Summe aller Primzahlen bis 50
    limit_3 = 50
    expected_result_3 = 328  # 2 + 3 + 5 + 7 + 11 + 13 + 17 + 19 + 23 + 29 + 31 + 37 + 41 + 43 + 47
    assert sum_of_primes(limit_3) == expected_result_3

    print("Alle Tests erfolgreich durchgeführt.")


# Führe die Unit-Tests aus
test_sum_of_primes()

Sie können die Funktion test_sum_of_primes aufrufen, um die definierten Testfälle auszuführen und sicherzustellen, dass die Funktion sum_of_primes die erwarteten Ergebnisse liefert.

Fazit