Comment dois-je faire un pas égal dans Django queryset de filtrage?

Dans Django modèle QuerySets, je vois qu'il y a un __gt et __lt pour comparative des valeurs, mais est-il une __ne/!=/<> (pas égale?)

Je veux filtrer à l'aide d'un pas égal:

Exemple:

Model:
    bool a;
    int x;

Je veux

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

La != n'est pas la syntaxe 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)
  • Aurait résultats = Modèle.objets.exclure(a=vrai).filtre(x=5) ont travaillé?
  • Pas de. Votre requête exclut tous les a=true d'abord, puis applique la x=5 filtre sur le reste. Le but de la requête nécessaire seulement ceux avec a=true et x!=5. La différence étant que tous ceux avec a=true et x=5 sont également filtrés.
InformationsquelleAutor MikeN | 2009-03-26
  1. 605

    Peut-être Q objets pourrait être de l'aide pour ce problème. Je n'ai jamais utilisé, mais il semble qu'ils peuvent être réduites à néant et combiné comme normale des expressions python.

    Mise à jour: j'ai Juste essayé, il semble fonctionner assez bien:

    >>> 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>, ...]
    InformationsquelleAutor Dave Vogt
  2. 536

    Votre requête semble avoir un double négatif, vous souhaitez exclure toutes les lignes où x n'est pas un 5, en d'autres mots que vous souhaitez inclure toutes les lignes où x EST 5. Je crois que ça va faire l'affaire. 

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

    Pour répondre à votre question précise, il n'existe pas "n'est pas égal à" mais c'est probablement parce que django a deux "filtre" et "exclure" les méthodes disponibles de sorte que vous pouvez toujours basculer la logique ronde pour obtenir le résultat souhaité.

    • J'ai peut-être tort, mais je pense que la requête doit être results = Model.objects.filter(a=true).exclude(x=5)
    • Je pense que vous avez mal lu la requête d'origine. d4nt version est correcte, parce que l'OP veut les exclure(a=Vrai) et nier l'exclusion de x=5 (c'est à dire l'inclure).
    • Je pense que cela est faux parce que d'une instance (x=4, a=false) seraient exclues à tort.
    • Juste pour dire, l'ordre des questions afin objects.exclude(**filter1).filter(**filter2) donne des résultats différents de objects.filter(**filter1).exclude(**filter2), tandis que ~Q obtiendrez toujours correcte de la négation à l'intérieur de objects.filter(**filter_with_Q)
    • Cela ne semble pas juste. J'ai juste essayé moi-même, et l'ordre de exclude et filter des appels à ne pas faire de différence significative. L'ordre des conditions dans le WHERE clause de changements, mais comment est-ce que la matière?
    • afin d'exclure et le filtre n'a pas d'importance.
    • Cela peut échouer si vous êtes le filtrage sur les champs d'objet.

    InformationsquelleAutor d4nt
  3. 114

    la field=value la syntaxe des requêtes est un raccourci pour field__exact=value. C'est-à-dire que Django met opérateurs de requête sur les champs de requête dans les identificateurs. 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 que par la combinaison de ces derniers avec les objets Q comme Dave Vogt suggère et à l'aide de filter() ou exclude() comme Jason Baker suggère vous obtiendrez exactement ce que vous avez besoin pour n'importe quelle requête.

    • merci c'est génial . j'ai utilisé quelque chose comme cela tg=Tag.objects.filter(user=request.user).exclude(name__regex=r'^(public|url)$') et il fonctionne.
    • veuillez garder à l'esprit que pas toutes les bases de données de soutien que la syntaxe regex 🙂
    • j'en icontains, iexact et similaire signifie "ignorer la casse". Ce n'est pas pour "inverse".
    • Il est intéressant de noter que lorsque vous utilisez exclude() avec plusieurs termes, vous pouvez composer de la proposition avec les OR de l'opérateur, par exemple exclude(Q(field1__queryop1=value1) | Q(field2__queryop2=value2)) afin d'exclure les résultats dans les deux conditions.
    InformationsquelleAutor SingleNegationElimination
  4. 86

    Il est facile de créer un personnalisé de recherche avec Django 1.7. Il y a un __ne de recherche exemple dans Django documentation officielle.

    Vous avez besoin pour créer la recherche elle-même d'abord:

    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 le __ne de recherche de vos requêtes comme ceci:

    results = Model.objects.exclude(a=True, x__ne=5)
    InformationsquelleAutor Dmitrii Mikhailov
  5. 80

    Dans Django 1.9/1.10 il y a trois options.

    1. De la chaîne exclure et filtre

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

    2. Utilisation Q() objets et la ~ de l'opérateur

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

    3. Enregistrer un 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

      La register_lookup décorateur a été ajouté dans Django 1.8 et
      permet personnalisé de recherche comme d'habitude:

      results = Model.objects.exclude(a=True, x__ne=5)
    • object_list = QuerySet.filtre(~Q(a=Vrai), x=5) : n'oubliez pas de garder toutes les autres conditions ne contenant pas de Q après ceux contenant Q.
    • A)vous permettra de filtrer sur un plus petit ensemble de données après l'exclusion à l'aide de ~Q est donc plus efficace. B) probablement le séquençage de l'inverse ne fonctionne pas .. dun savoir .. dun rappelez-vous!
    InformationsquelleAutor ilse2005
  6. 40

    Alors qu'avec les Modèles, vous pourrez filtrer avec =, __gt, __gte, __lt, __lte, vous ne pouvez pas utiliser ne, != ou <>. Cependant, vous pouvez réaliser un meilleur filtrage à l'aide de la Q objet.

    Vous pouvez éviter le chaînage QuerySet.filter() et QuerySet.exlude(), et de l'utiliser:

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

    En attente de décision de conception. Pendant ce temps, l'utilisation exclude()

    Le Django issue tracker a la remarquable entrée #5763,
    intitulé "Queryset ne pas avoir un "pas égal" opérateur de filtre".
    Il est remarquable que (dès avril 2016), il a été
    "a ouvert il y a 9 ans" (dans le Django de l'âge de pierre),
    "fermé il y a 4 ans", et
    "dernière modification le il y a 5 mois".

    Lire par le biais de la discussion, il est intéressant.
    Fondamentalement, certaines personnes affirment __ne doit être ajouté
    alors que d'autres disent exclude() est plus clair et donc __ne
    devrait pas être ajouté.

    (Je suis d'accord avec l'ancien, parce que le dernier argument est
    à peu près équivalent à dire que Python ne devrait pas avoir != parce que
    il a == et not déjà...)

    InformationsquelleAutor Lutz Prechelt
  8. 15

    Vous devez utiliser filter et exclude comme ce

    results = Model.objects.exclude(a=true).filter(x=5)
    InformationsquelleAutor outoftime
  9. 14

    À l'aide d'exclusion et de filtre

    results = Model.objects.filter(x=5).exclude(a=true)
    InformationsquelleAutor jincy mariam
  10. 8

    Le dernier bit de code, d'exclure tous les objets où x!=5 et a est Vrai. Essayez ceci:

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

    Rappelez-vous, le signe = dans la ligne ci-dessus est d'attribuer des Faux pour le paramètre a et le numéro 5 pour le paramètre "x". Ce n'est pas la vérification de l'égalité. Ainsi, il n'est pas vraiment possible d'utiliser la != symbole de dans une requête d'appel.

    • Ce n'est pas à 100% la même chose car il pourrait également être Null valeurs de ces champs.
    • Cela renvoie uniquement les éléments qui ont un=False et x=5, mais dans la question d'une instance (un=false, x=4) serait incluse.
    • results = Model.objects.filter(a__in=[False,None],x=5)
    InformationsquelleAutor Jason Baker
  11. 6

    Ce que vous cherchez sont tous les objets qui ont a=false ou x=5. Dans Django, | sert OR opérateur entre querysets:

    results = Model.objects.filter(a=false)|Model.objects.filter(x=5)
    InformationsquelleAutor Gerard
  12. 6

    résultats = Modèle.objets.filtre(a = Vrai).exclusion(x = 5)

    Generetes ce sql: 

    sélectionnez * à partir de tablex où un != 0 et x !=5

    sql dépend de la façon dont votre Vrai/Faux champ est représenté, et le moteur de base de données. Le django code est tout ce que vous devez bien.

    InformationsquelleAutor M. Dasn
  13. 6

    Django-modèle-valeurs (divulgation: l'auteur) fournit une mise en œuvre de la NotEqual de recherche, comme dans cette réponse. Il fournit également syntaxique support:

    from model_values import F
Model.objects.exclude(F.x != 5, a=True)
    InformationsquelleAutor A. Coady
  14. 0

    Watch out pour beaucoup de mauvaises réponses à cette question!

    Gerard logique est correcte, mais il sera de retour une liste plutôt qu'un queryset (ce qui n'a pas d'importance).

    Si vous avez besoin d'un queryset, utilisez Q:

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