Dans le modèle Django QuerySets, je vois qu'il y a un __gtet __ltpour les valeurs comparatives, mais y a-t-il un __ne/ !=/ <>( pas égal ?)

Je veux filtrer en utilisant un pas égal à:

Exemple:

Model:
    bool a;
    int x;

Je voudrais

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

La !=syntaxe n'est pas correcte. J'ai essayé __ne, <>.

J'ai fini par utiliser:

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

Peut-être que les objets Q pourraient être utiles pour ce problème. Je ne les ai jamais utilisés, mais il semble qu'ils puissent être annulés et combinés un peu comme les expressions python normales.

Mise à jour: je viens de l'essayer, cela semble assez bien fonctionner:

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

Votre requête semble avoir un double négatif, vous voulez exclure toutes les lignes où x n'est pas 5, donc en d'autres termes, vous voulez inclure toutes les lignes où x EST 5. Je pense que cela fera l'affaire.

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

Pour répondre à votre question spécifique, il n'y a pas de "pas égal à", mais c'est probablement parce que django a à la fois des méthodes "filtrer" et "exclure" disponibles, vous pouvez donc toujours changer de logique pour obtenir le résultat souhaité.

la field=valuesyntaxe dans les requêtes est un raccourci pour field__exact=value. C'est-à-dire que Django place les opérateurs de requête sur les champs de requête dans les identifiants . Django prend en charge les opérateurs suivants:

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

Je suis sûr qu'en les combinant avec les objets Q comme le suggère Dave Vogt et en utilisant filter()ou exclude()comme Jason Baker le suggère, vous obtiendrez exactement ce dont vous avez besoin pour à peu près n'importe quelle requête possible.

Il est facile de créer une recherche personnalisée avec Django 1.7. Il existe un __neexemple de recherche dans la documentation officielle de Django .

Vous devez d'abord créer la recherche elle-même:

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

Ensuite, vous devez l'enregistrer:

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

Et maintenant, vous pouvez utiliser la __nerecherche dans vos requêtes comme ceci:

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

Dans Django 1.9 / 1.10, il y a trois options.

1. Chaîne excludeetfilter

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

2. Utiliser des Q()objets et l' ~opérateur

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

3. Enregistrer une fonction de recherche personnalisée

   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

   Le register_lookupdécorateur a été ajouté dans Django 1.8 et permet une recherche personnalisée comme d'habitude:

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

Alors que les modèles, vous pouvez filtrer avec =, __gt, __gte, __lt, __lte, vous ne pouvez pas utiliser ne, !=ou <>. Cependant, vous pouvez obtenir un meilleur filtrage lors de l'utilisation de l'objet Q.

Vous pouvez éviter de chaîner QuerySet.filter()et QuerySet.exlude(), et utiliser ceci:

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

Décision de conception en attente. Pendant ce temps, utilisezexclude()

Le tracker de problème Django a l' entrée remarquable # 5763 , intitulée "Queryset n'a pas d'opérateur de filtre" différent " . Il est remarquable car (en avril 2016) il a été "ouvert il y a 9 ans" (à l'âge de pierre de Django), "fermé il y a 4 ans", et "modifié depuis 5 mois".

Lisez la discussion, c'est intéressant. Fondamentalement, certaines personnes soutiennent __nequ'il faudrait ajouter tandis que d'autres disent que exclude()c'est plus clair et ne__ne devrait donc pas être ajouté.

(Je suis d'accord avec le premier, car le dernier argument équivaut à peu près à dire que Python ne devrait pas avoir !=parce qu'il l'a fait ==et notdéjà ...)

Utilisation d'exclusion et de filtre

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

Vous devez utiliser filteret excludeaimer ceci

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

Le dernier bit de code exclura tous les objets où x! = 5 et a est True. Essaye ça:

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

N'oubliez pas que le signe = dans la ligne ci-dessus attribue la valeur False au paramètre a et le nombre 5 au paramètre x. Il ne s'agit pas de vérifier l'égalité. Ainsi, il n'y a vraiment aucun moyen d'utiliser le symbole! = Dans un appel de requête.

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

sélectionnez * dans le tableaux où a! = 0 et x! = 5

Django-model-values (divulgation: auteur) fournit une implémentation de la recherche NotEqual , comme dans cette réponse . Il fournit également un support syntaxique pour cela:

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

Ce que vous recherchez, ce sont tous les objets qui ont soit a=false ou x=5 . Dans Django, |sert d' ORopérateur entre les ensembles de requêtes:

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

Cela donnera le résultat souhaité.

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

pour pas égal, vous pouvez utiliser ~sur une requête égale. évidemment, Qpeut être utilisé pour atteindre la requête égale.

Attention aux nombreuses réponses incorrectes à cette question!

La logique de Gerard est correcte, bien qu'elle renvoie une liste plutôt qu'un ensemble de requêtes (ce qui peut ne pas avoir d'importance).

Si vous avez besoin d'un ensemble de requêtes, utilisez Q:

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