Schlüssel des maximalen Werts

Einführung

In Python sind Wörterbücher (dictionaries) eine nützliche Datenstruktur, die es Ihnen ermöglicht, Schlüssel-Wert-Paare zu speichern. Manchmal müssen Sie möglicherweise den Schlüssel des maximalen Werts in einem Wörterbuch finden. In dieser Herausforderung werden Sie eine Funktion schreiben, die ein Wörterbuch als Argument nimmt und den Schlüssel des maximalen Werts im Wörterbuch zurückgibt.

Erstellen der Basisfunktion

Beginnen wir mit der Erstellung des Kernteils unserer Funktion. Wir werden sie Schritt für Schritt aufbauen. Zunächst erstellen Sie eine Datei mit dem Namen key_of_max.py. Sie können den integrierten LabEx-Code-Editor oder einen terminalbasierten Editor wie nano oder vim verwenden. Fügen Sie in der Datei key_of_max.py den folgenden Code hinzu:

def key_of_max(d):
  """
  Gibt den Schlüssel zurück, der dem maximalen Wert im Wörterbuch 'd' zugeordnet ist.

  Wenn mehrere Schlüssel denselben maximalen Wert haben, kann einer beliebiger von ihnen zurückgegeben werden.
  """
  return max(d, key=d.get)

Hier ist eine Schritt-für-Schritt-Analyse:

• def key_of_max(d):: Dies definiert eine Funktion mit dem Namen key_of_max. Sie nimmt ein Argument d entgegen, das das Wörterbuch darstellt, mit dem wir arbeiten werden.
• return max(d, key=d.get): Dies ist der Kern der Funktion. Analysieren wir ihn Schritt für Schritt:
  • max(d,...): Die integrierte max()-Funktion sucht das größte Element. Standardmäßig sucht max(), wenn Sie ihm ein Wörterbuch übergeben, nach dem größten Schlüssel (alphabetisch). Das möchten wir nicht; wir möchten den Schlüssel, der dem größten Wert zugeordnet ist.
  • key=d.get: Dies ist der entscheidende Teil. Das key-Argument sagt der max()-Funktion, wie sie die Elemente vergleichen soll. d.get ist eine Methode von Wörterbüchern. Wenn Sie d.get(ein_schluessel) aufrufen, gibt es den Wert zurück, der mit ein_schluessel verknüpft ist. Indem wir key=d.get setzen, sagen wir der max()-Funktion: "Vergleiche die Elemente im Wörterbuch d anhand ihrer Werte, nicht ihrer Schlüssel." Die max()-Funktion gibt dann den Schlüssel zurück, der diesem maximalen Wert entspricht.

Behandlung des Falls eines leeren Wörterbuchs

Unsere aktuelle Funktion hat ein Problem: Sie stürzt ab, wenn das Eingabewörterbuch d leer ist. Lassen Sie uns das beheben. Ändern Sie die Datei key_of_max.py so, dass sie wie folgt aussieht:

def key_of_max(d):
  """
  Gibt den Schlüssel zurück, der dem maximalen Wert im Wörterbuch 'd' zugeordnet ist.

  Wenn mehrere Schlüssel denselben maximalen Wert haben, kann einer beliebiger von ihnen zurückgegeben werden.
  """
  if not d:  ## Check if the dictionary is empty
      return None
  return max(d, key=d.get)

Die hinzugefügten Zeilen tun Folgendes:

• if not d:: In Python wird ein leeres Wörterbuch als "falsch" (falsy) angesehen. Diese if-Anweisung prüft, ob das Wörterbuch d leer ist.
• return None: Wenn das Wörterbuch leer ist, gibt es keinen maximalen Wert. Daher geben wir None zurück. Dies ist eine Standardmethode, um das Fehlen eines Werts in Python anzuzeigen. Dadurch wird verhindert, dass die max()-Funktion einen Fehler auslöst.

Dies ist ein entscheidender Schritt beim Schreiben robuster Code: Berücksichtigen Sie immer Randfälle!

Erstellen von Unittests: Grundlegende Tests

Jetzt schreiben wir einige Tests, um sicherzustellen, dass unsere Funktion korrekt funktioniert. Wir verwenden das unittest-Modul von Python. Erstellen Sie eine neue Datei mit dem Namen test_key_of_max.py und fügen Sie den folgenden Code hinzu:

import unittest
from key_of_max import key_of_max  ## Import our function

class TestKeyOfMax(unittest.TestCase):

    def test_basic_case(self):
        self.assertEqual(key_of_max({'a': 4, 'b': 0, 'c': 13}), 'c')

    def test_another_case(self):
        self.assertEqual(key_of_max({'apple': 10, 'banana': 5, 'orange': 10}), 'apple')

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

Erklärung:

1. import unittest: Importiert das Testframework.
2. from key_of_max import key_of_max: Importiert die Funktion, die wir testen möchten.
3. class TestKeyOfMax(unittest.TestCase):: Definiert eine Testklasse. Testklassen gruppieren verwandte Tests zusammen.
4. def test_basic_case(self):: Definiert eine Testmethode. Jede Testmethode überprüft einen bestimmten Aspekt unserer Funktion. Die Namen von Testmethoden müssen mit test_ beginnen.
5. self.assertEqual(...): Dies ist eine Behauptung (assertion). Sie prüft, ob zwei Werte gleich sind. Wenn sie nicht gleich sind, schlägt der Test fehl. In diesem Fall überprüfen wir, ob key_of_max({'a': 4, 'b': 0, 'c': 13}) 'c' zurückgibt, was es tun sollte.
6. def test_another_case(self):: Fügt einen weiteren Testfall hinzu, um den Schlüssel des maximalen Werts zu überprüfen, der möglicherweise nicht eindeutig ist.
7. if __name__ == '__main__': unittest.main(): Diese Standard-Idiomatik in Python führt die Tests aus, wenn Sie das Skript direkt ausführen (z.B. python3 test_key_of_max.py).

Führen Sie die Tests in Ihrem Terminal aus: python3 test_key_of_max.py. Sie sollten eine Ausgabe sehen, die anzeigt, dass die beiden Tests bestanden wurden.

python3 test_key_of_max.py

----------------------------------------------------------------------
Ran 2 tests in 0.000s

OK

Testen des leeren Wörterbuchs (Randfall)

Fügen wir einen speziellen Test für den Fall eines leeren Wörterbuchs hinzu. Fügen Sie diese Methode zur TestKeyOfMax-Klasse in der Datei test_key_of_max.py hinzu:

    def test_empty_dictionary(self):
        self.assertIsNone(key_of_max({}))

• self.assertIsNone(...): Diese Behauptung (assertion) prüft, ob der Wert genau None ist. Dies ist wichtig, da self.assertEqual(..., None) für Dinge, die zu None ausgewertet werden, aber nicht tatsächlich None sind, bestanden werden könnte. assertIsNone ist strenger.

Führen Sie die Tests erneut aus (python3 test_key_of_max.py). Alle drei Tests (die beiden grundlegenden Tests und der Test für das leere Wörterbuch) sollten jetzt bestanden werden.

python3 test_key_of_max.py

----------------------------------------------------------------------
Ran 3 tests in 0.000s

OK

Testen mit ausschließlich negativen Werten

Als letzten Test behandeln wir den Fall, in dem alle Werte im Wörterbuch negativ sind. Fügen Sie diese Methode zu TestKeyOfMax hinzu:

    def test_all_negative_values(self):
        self.assertEqual(key_of_max({'x': -5, 'y': -2, 'z': -10}), 'y')

Dieser Test stellt sicher, dass unsere Funktion den wenigsten negativen Wert (der in diesem Fall der maximale Wert ist) korrekt erkennt und den zugehörigen Schlüssel zurückgibt.

Führen Sie die Tests ein letztes Mal aus (python3 test_key_of_max.py). Alle vier Tests sollten bestanden werden. Dies gibt uns ein hohes Maß an Vertrauen, dass unsere Funktion korrekt funktioniert.

Ihre vollständige test_key_of_max.py-Datei sollte jetzt wie folgt aussehen:

import unittest
from key_of_max import key_of_max

class TestKeyOfMax(unittest.TestCase):

    def test_basic_case(self):
        self.assertEqual(key_of_max({'a': 4, 'b': 0, 'c': 13}), 'c')

    def test_another_case(self):
        self.assertEqual(key_of_max({'apple': 10, 'banana': 5, 'orange': 10}), 'apple')

    def test_empty_dictionary(self):
        self.assertIsNone(key_of_max({}))

    def test_all_negative_values(self):
        self.assertEqual(key_of_max({'x': -5, 'y': -2, 'z': -10}), 'y')

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

Führen Sie die Tests erneut aus (python3 test_key_of_max.py). Alle vier Tests sollten bestanden werden. Dies gibt uns ein hohes Maß an Vertrauen, dass unsere Funktion korrekt funktioniert.

python3 test_key_of_max.py

----------------------------------------------------------------------
Ran 4 tests in 0.000s

OK

Zusammenfassung

In diesem Lab haben Sie eine Python-Funktion namens key_of_max entwickelt, um den Schlüssel zu finden, der dem größten Wert in einem Wörterbuch zugeordnet ist. Sie haben gelernt, wie Sie die max()-Funktion mit einem benutzerdefinierten key-Argument verwenden können, und Sie haben den wichtigen Randfall eines leeren Wörterbuchs behandelt. Sie haben auch gründliche Unittests mit dem unittest-Modul geschrieben, die grundlegende Fälle, leere Wörterbücher und Wörterbücher mit ausschließlich negativen Werten abdecken. Diese Kombination aus funktionellem Code und umfassenden Tests zeigt gute Softwareentwicklungspraktiken auf.