Im Django-Modell QuerySets sehe ich, dass es ein __gtund __ltfür Vergleichswerte gibt, aber gibt es ein __ne/ !=/ <>( nicht gleich ?)

Ich möchte mit einem ungleich herausfiltern:

Beispiel:

Model:
    bool a;
    int x;

ich möchte

results = Model.objects.exclude(a=true, x!=5)

Die !=Syntax ist nicht korrekt. Ich habe es versucht __ne, <>.

Am Ende habe ich verwendet:

results = Model.objects.exclude(a=true, x__lt=5).exclude(a=true, x__gt=5)

Vielleicht könnten Q-Objekte bei diesem Problem hilfreich sein. Ich habe sie nie benutzt, aber es scheint, dass sie wie normale Python-Ausdrücke negiert und kombiniert werden können.

Update: Ich habe es gerade ausprobiert, es scheint ziemlich gut zu funktionieren:

>>> from myapp.models import Entry
>>> from django.db.models import Q

>>> Entry.objects.filter(~Q(id = 3))

[<Entry: Entry object>, <Entry: Entry object>, <Entry: Entry object>, ...]

Ihre Abfrage scheint doppelt negativ zu sein. Sie möchten alle Zeilen ausschließen, in denen x nicht 5 ist. Mit anderen Worten, Sie möchten alle Zeilen einschließen, in denen x 5 ist. Ich glaube, dies wird den Trick tun.

results = Model.objects.filter(x=5).exclude(a=true)

Um Ihre spezifische Frage zu beantworten, gibt es kein "ungleich", aber das liegt wahrscheinlich daran, dass in django sowohl "Filter" - als auch "Ausschluss" -Methoden verfügbar sind, sodass Sie jederzeit einfach die Logik umschalten können, um das gewünschte Ergebnis zu erzielen.

Die field=valueSyntax in Abfragen ist eine Abkürzung für field__exact=value. Das heißt, Django setzt Abfrageoperatoren auf Abfragefelder in den Bezeichnern . Django unterstützt die folgenden Operatoren:

exact
iexact
contains
icontains
in
gt
gte
lt
lte
startswith
istartswith
endswith
iendswith
range
year
month
day
week_day
isnull
search
regex
iregex

Ich bin sicher, indem ich diese mit den Q-Objekten als kombiniere Dave Vogt vorschlägt und verwendet, filter()oder exclude()wenn Jason Baker vorschlägt, erhalten Sie genau das, was Sie für nahezu jede mögliche Abfrage benötigen.

Mit Django 1.7 ist es einfach, eine benutzerdefinierte Suche zu erstellen. Es gibt ein __neSuchbeispiel in der offiziellen Dokumentation von Django .

Sie müssen zuerst die Suche selbst erstellen:

from django.db.models import Lookup

class NotEqual(Lookup):
    lookup_name = 'ne'

    def as_sql(self, qn, connection):
        lhs, lhs_params = self.process_lhs(qn, connection)
        rhs, rhs_params = self.process_rhs(qn, connection)
        params = lhs_params + rhs_params
        return '%s <> %s' % (lhs, rhs), params

Dann müssen Sie es registrieren:

from django.db.models.fields import Field
Field.register_lookup(NotEqual)

Und jetzt können Sie die __neSuche in Ihren Abfragen folgendermaßen verwenden:

results = Model.objects.exclude(a=True, x__ne=5)

In Django 1.9 / 1.10 gibt es drei Möglichkeiten.

1. Kette excludeundfilter

   results = Model.objects.exclude(a=true).filter(x=5)

2. Verwenden Sie Q()Objekte und den ~Operator

   from django.db.models import Q
   object_list = QuerySet.filter(~Q(a=True), x=5)

3. Registrieren Sie eine benutzerdefinierte Suchfunktion

   from django.db.models import Lookup
   from django.db.models.fields import Field
   
   @Field.register_lookup
   class NotEqual(Lookup):
       lookup_name = 'ne'
   
       def as_sql(self, compiler, connection):
           lhs, lhs_params = self.process_lhs(compiler, connection)
           rhs, rhs_params = self.process_rhs(compiler, connection)
           params = lhs_params + rhs_params
           return '%s <> %s' % (lhs, rhs), params

   Der register_lookupDekorateur wurde in Django 1.8 hinzugefügt und ermöglicht die benutzerdefinierte Suche wie gewohnt:

   results = Model.objects.exclude(a=True, x__ne=5)

Während bei den Modellen können Sie mit Filtern =, __gt, __gte, __lt, __lte, können Sie nicht verwenden ne, !=oder <>. Sie können jedoch eine bessere Filterung bei Verwendung des Q-Objekts erzielen.

Sie können eine Verkettung vermeiden QuerySet.filter()und Folgendes QuerySet.exlude()verwenden:

from django.db.models import Q
object_list = QuerySet.filter(~Q(field='not wanted'), field='wanted')

Ausstehende Entwurfsentscheidung. In der Zwischenzeit verwendenexclude()

Der Django Issue Tracker hat den bemerkenswerten Eintrag # 5763 mit dem Titel "Queryset hat keinen" ungleichen "Filteroperator" . Es ist bemerkenswert, weil es (Stand April 2016) "vor 9 Jahren eröffnet" (in der Django-Steinzeit), "vor 4 Jahren geschlossen" und "vor 5 Monaten zuletzt geändert" wurde.

Lesen Sie die Diskussion durch, es ist interessant. Grundsätzlich argumentieren manche Leute __nesollten hinzugefügt werden , während andere sagen , exclude()klarer und daher __ne sollte nicht hinzugefügt werden.

(Ich stimme dem ersteren zu, weil das letztere Argument in etwa der Aussage entspricht, dass Python nicht haben sollte, !=weil es hat ==und notbereits ...)

Verwenden Sie Ausschließen und Filtern

results = Model.objects.filter(x=5).exclude(a=true)

Sie sollten dies verwenden filterund excludemögen

results = Model.objects.exclude(a=true).filter(x=5)

Das letzte Codebit schließt alle Objekte aus, bei denen x! = 5 und a True ist. Versuche dies:

results = Model.objects.filter(a=False, x=5)

Denken Sie daran, dass das Zeichen = in der obigen Zeile dem Parameter a False und dem Parameter x die Nummer 5 zuweist. Es geht nicht um Gleichheit. Daher gibt es keine Möglichkeit, das Symbol! = In einem Abfrageaufruf zu verwenden.

results = Model.objects.filter (a = True) .exclude (x = 5)

Wählen Sie * aus Tabellex, wobei a! = 0 und x! = 5

Django-Modellwerte (Offenlegung: Autor) bieten eine Implementierung der NotEqual- Suche, wie in dieser Antwort . Es bietet auch syntaktische Unterstützung dafür:

from model_values import F
Model.objects.exclude(F.x != 5, a=True)

Was Sie suchen, sind alle Objekte, die entweder a=false oder haben x=5 . |Dient in Django als OROperator zwischen Abfragesätzen:

results = Model.objects.filter(a=false)|Model.objects.filter(x=5)

Dies ergibt das gewünschte Ergebnis.

from django.db.models import Q
results = Model.objects.exclude(Q(a=True) & ~Q(x=5))

für ungleich können Sie ~für eine gleiche Abfrage verwenden. kann natürlich Qverwendet werden, um die gleiche Abfrage zu erreichen.

Achten Sie auf viele falsche Antworten auf diese Frage!

Gerards Logik ist korrekt, gibt jedoch eher eine Liste als einen Abfragesatz zurück (was möglicherweise keine Rolle spielt).

Wenn Sie ein Abfrageset benötigen, verwenden Sie Q:

from django.db.models import Q
results = Model.objects.filter(Q(a=false) | Q(x=5))