Nel modello QuerySet di Django, vedo che c'è un __gte __ltper valori comparativi, ma c'è un __ne/ !=/ <>( non è uguale ?)

Voglio filtrare usando un non uguale:

Esempio:

Model:
    bool a;
    int x;

Voglio

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

La !=sintassi non è corretta. Ho provato __ne, <>.

Ho finito per usare:

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

Forse gli oggetti Q potrebbero essere di aiuto per questo problema. Non li ho mai usati ma sembra che possano essere negati e combinati in modo molto simile alle normali espressioni di pitone.

Aggiornamento: l'ho appena provato, sembra funzionare abbastanza bene:

>>> 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>, ...]

La tua query sembra avere un doppio negativo, vuoi escludere tutte le righe in cui x non è 5, quindi in altre parole vuoi includere tutte le righe in cui x È 5. Credo che questo farà il trucco.

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

Per rispondere alla tua domanda specifica, non esiste "non uguale a", ma probabilmente perché django ha entrambi i metodi "filtro" ed "esclusione" disponibili in modo da poter sempre cambiare la logica per ottenere il risultato desiderato.

la field=valuesintassi nelle query è una scorciatoia per field__exact=value. Ciò significa che Django colloca gli operatori di query sui campi di query negli identificatori . Django supporta i seguenti operatori:

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

Sono sicuro combinandoli con gli oggetti Q come suggerisce Dave Vogt e usando filter()o exclude()come suggerisce Jason Baker otterrai esattamente quello che ti serve per qualsiasi possibile query.

È facile creare una ricerca personalizzata con Django 1.7. C'è un __neesempio di ricerca nella documentazione ufficiale di Django .

Devi prima creare la ricerca stessa:

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

Quindi è necessario registrarlo:

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

E ora puoi utilizzare la __nericerca nelle tue query in questo modo:

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

In Django 1.9 / 1.10 ci sono tre opzioni.

1. Catena excludeefilter

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

2. Usa gli Q()oggetti e l' ~operatore

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

3. Registra una funzione di ricerca personalizzata

   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

   Il register_lookupdecoratore è stato aggiunto in Django 1.8 e consente la ricerca personalizzata come al solito:

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

Mentre con i modelli, è possibile filtrare con =, __gt, __gte, __lt, __lte, non è possibile utilizzare ne, !=o <>. Tuttavia, è possibile ottenere un filtro migliore utilizzando l'oggetto Q.

Puoi evitare il concatenamento QuerySet.filter()e QuerySet.exlude(), e usare questo:

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

In attesa di decisione di progettazione. Nel frattempo, usaexclude()

Il tracker di problemi di Django ha la notevole voce # 5763 , intitolata "Queryset non ha un operatore di filtro" non uguale " . È notevole perché (ad aprile 2016) è stato "aperto 9 anni fa" (nell'età della pietra di Django), "chiuso 4 anni fa" e "modificato l'ultima volta 5 mesi fa".

Leggi la discussione, è interessante. Fondamentalmente, alcune persone sostengono che __nedovrebbe essere aggiunto, mentre altri dicono che exclude()è più chiaro e quindi non__ne dovrebbe essere aggiunto.

(Concordo con il primo, perché il secondo argomento è approssimativamente equivalente a dire che Python non dovrebbe avere !=perché ha ==e notgià ...)

Utilizzando exclude e filter

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

Dovresti usare filtere excludecosì

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

L'ultimo bit di codice esclude tutti gli oggetti in cui x! = 5 e a è True. Prova questo:

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

Ricorda, il segno = nella riga sopra sta assegnando False al parametro a e il numero 5 al parametro x. Non sta verificando l'uguaglianza. Pertanto, non esiste alcun modo per utilizzare il simbolo! = In una chiamata di query.

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

seleziona * da tablex dove a! = 0 e x! = 5

Django-model-valori (divulgazione: autore) fornisce un'implementazione della ricerca NotEqual , come in questa risposta . Fornisce inoltre supporto sintattico per esso:

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

Quello che stai cercando sono tutti gli oggetti che hanno a=false o x=5 . In Django, |funge da ORoperatore tra le query:

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

Questo darà il risultato desiderato.

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

per non uguale è possibile utilizzare ~su una query uguale. ovviamente, Qpuò essere usato per raggiungere la query uguale.

Fai attenzione a molte risposte errate a questa domanda!

La logica di Gerard è corretta, anche se restituirà un elenco piuttosto che un queryset (che potrebbe non avere importanza).

Se hai bisogno di un queryset, usa Q:

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