__(Doppelte Unterstriche) was ist das?

In Django werden __(doppelte Unterstriche) verwendet, um Datenbankabfragen über Beziehungsfelder zwischen Modellen zu erstellen. Kurz gesagt, sie werden verwendet, um auf Felder zuzugreifen, die mit anderen Tabellen verbunden sind, oder um Daten mit bestimmten Bedingungen zu filtern.

Zum Beispiel, wenn zwei oder mehr Modelle durch ForeignKey oder OneToOneField verbunden sind, können wir auf die gewünschten Felder über diese Beziehung zugreifen. Hierbei fungiert __ als eine Art "Verbindungsglied", mit dem wir die Felder verschiedener Modelle wie eine Kette miteinander verknüpfen.

Beispiel: Verwendung von __ in Beziehungen zwischen Modellen

Betrachten wir ein einfaches Beispiel. Angenommen, das Profile Modell ist mit dem User Modell verbunden und das Benutzer-Modell hat ein username-Feld. Wir können das Profile Modell verwenden, um bestimmte Profile basierend auf dem username des User Modells zu filtern.

Modelldefinition:

from django.db import models
from django.contrib.auth.models import AbstractUser

class CustomUser(AbstractUser):
    pass

class Profile(models.Model):
    user = models.OneToOneField(CustomUser, on_delete=models.CASCADE)
    bio = models.TextField()

Im obigen Beispiel hat das Profile Modell eine 1:1 Beziehung zum CustomUser. Jetzt sehen wir, wie wir mit __ auf die Felder des CustomUser im Profile zugreifen können.

Abfrage mit __:

# Profile-Objekte filtern basierend auf dem username von CustomUser
profiles = Profile.objects.filter(user__username='jesse')

Hierbei ist user__username der Schlüssel. user ist das Feld, das mit dem CustomUser des Profile Modells verbunden ist, und um auf das username-Feld zuzugreifen, verbinden wir es mit __. Dadurch können wir aus dem Profile Modell die Daten basierend auf dem username des CustomUser abrufen.

Verschiedene Verwendungen von __

__ wird nicht nur verwendet, um auf Felder zuzugreifen, sondern auch häufig zur Festlegung von Bedingungen. Django bietet verschiedene Filtering-Funktionen, um Bedingungen in Querysets festzulegen, und die meisten werden durch __ realisiert. Häufig verwendete Bedingungen sind:

• exact: Sucht nach Werten, die exakt übereinstimmen. (kann weggelassen werden, da dies der Standard ist)
• icontains: Sucht nach Werten, die unabhängig von Groß- und Kleinschreibung enthalten sind.
• gt, lt, gte, lte: Bedingungen zum Finden von Werten, die größer oder kleiner sind (greater than, less than).
• startswith, endswith: Sucht nach Werten, die mit einer bestimmten Zeichenkette beginnen oder enden.

Beispiel: Verschiedene Filterbedingungen

# Alle Profile abfragen, deren Benutzer-E-Mail 'gmail.com' enthält
profiles_with_gmail = Profile.objects.filter(user__email__icontains='gmail.com')

# Abfrage der Profile, deren Benutzer-ID größer als 10 ist
profiles_with_id_gt_10 = Profile.objects.filter(user__id__gt=10)

# Abfrage der Profile, deren username mit 'jesse' beginnt
profiles_starting_with_jesse = Profile.objects.filter(user__username__startswith='jesse')

Durch __ Zugriff auf mehrere Beziehungsebenen

Eine der leistungsstärksten Funktionen von Django ist die Möglichkeit, Daten über mehrere Modelle hinweg mit __ zu abrufen, auch wenn mehrere Modelle miteinander verbunden sind. Stellen wir uns zum Beispiel vor, dass ein Order Modell mit Profile verbunden ist und das Profile wiederum mit CustomUser verbunden ist.

Beispiel für ein mehrstufiges Beziehungsmodell:

class Order(models.Model):
    profile = models.ForeignKey(Profile, on_delete=models.CASCADE)
    order_date = models.DateTimeField()
    amount = models.DecimalField(max_digits=10, decimal_places=2)

Jetzt nehmen wir an, dass wir die Daten aus Order basierend auf dem username des CustomUser abrufen möchten.

Filtern in Mehrfachbeziehungen:

# Bestellungen abrufen, bei denen der username von CustomUser 'jesse' ist
orders_for_user = Order.objects.filter(profile__user__username='jesse')

Hier können wir mithilfe von profile__user__username über mehrere Beziehungsebenen auf das Feld des CustomUser zugreifen. Die Beziehung zwischen Order → Profile → CustomUser wird einfach durch __ verbunden und so können wir das Filtern umsetzen.

Zusammenfassung

• __ wird verwendet, um Felder durch Beziehungen zwischen Modellen zu referenzieren.
• Wir können verschiedene Abfragebedingungen festlegen, um Daten zu filtern.
• Durch das Verbinden von Feldern mehrerer Beziehungen können komplexe Abfragen einfach behandelt werden.

Jetzt, da Sie die Rolle und Verwendung von __ verstanden haben, sollten Sie in der Lage sein, stärkere Abfragen im Django ORM zu erstellen. Wenn Sie die relationale Struktur der Datenbank im Hinterkopf behalten und dieses Symbol angemessen einsetzen, werden Sie in der Lage sein, effiziente Datenverarbeitung und komplexe Beziehungen einfach zu handhaben.