En el modelo de Django QuerySets, veo que hay un __gty __ltpara valores comparativos, pero ¿hay un __ne/ !=/ <>( no es igual ?)

Quiero filtrar usando un no igual:

Ejemplo:

Model:
    bool a;
    int x;

quiero

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

La !=sintaxis no es correcta. Probé __ne, <>.

Terminé usando:

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

Quizás los objetos Q podrían ser de ayuda para este problema. Nunca los he usado, pero parece que se pueden negar y combinar de manera muy similar a las expresiones normales de Python.

Actualización: acabo de probarlo, parece funcionar bastante 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>, ...]

Su consulta parece tener un doble negativo, desea excluir todas las filas donde x no es 5, por lo tanto, en otras palabras, desea incluir todas las filas donde x ES 5. Creo que esto hará el truco.

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

Para responder a su pregunta específica, no existe un "no igual a", pero probablemente sea porque django tiene disponibles los métodos de "filtro" y "exclusión", por lo que siempre puede cambiar la ronda lógica para obtener el resultado deseado.

La field=valuesintaxis en las consultas es una abreviatura de field__exact=value. Es decir que Django coloca operadores de consulta en campos de consulta en los identificadores . Django es compatible con los siguientes operadores:

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

Estoy seguro de que al combinarlos con los objetos Q como sugiere Dave Vogt y al usar filter()o exclude()como Jason Baker sugiere , obtendrá exactamente lo que necesita para cualquier consulta posible.

Es fácil crear una búsqueda personalizada con Django 1.7. Hay un __neejemplo de búsqueda en la documentación oficial de Django .

Primero debe crear la búsqueda en sí:

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

Entonces necesitas registrarlo:

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

Y ahora puede usar la __nebúsqueda en sus consultas de esta manera:

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

En Django 1.9 / 1.10 hay tres opciones.

1. Cadena excludeyfilter

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

2. Usa Q()objetos y el ~operador

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

3. Registrar una función de búsqueda personalizada

   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

   El register_lookupdecorador se agregó en Django 1.8 y permite la búsqueda personalizada como de costumbre:

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

Mientras que con los modelos, puede filtrar con =, __gt, __gte, __lt, __lte, no se puede utilizar ne, !=o <>. Sin embargo, puede lograr un mejor filtrado al usar el objeto Q.

Usted puede evitar el encadenamiento QuerySet.filter()y QuerySet.exlude(), y usar esto:

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

Pendiente decisión de diseño. Mientras tanto, useexclude()

El rastreador de problemas de Django tiene la notable entrada # 5763 , titulada "Queryset no tiene un operador de filtro" no igual " . Es notable porque (a partir de abril de 2016) se "abrió hace 9 años" (en la edad de piedra de Django), "se cerró hace 4 años" y "se modificó por última vez hace 5 meses".

Lea la discusión, es interesante. Básicamente, algunas personas discuten__ne que se debe agregar mientras que otras dicen que exclude()es más claro y, por __ne lo tanto , no se debe agregar.

(Estoy de acuerdo con el anterior, ya que este último argumento es más o menos equivalente a decir Python no debe tener !=, ya que tiene ==y notque ya ...)

Usando excluir y filtrar

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

Deberías usar filtery excludeasí

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

El último bit de código excluirá todos los objetos donde x! = 5 y a es True. Prueba esto:

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

Recuerde, el signo = en la línea anterior está asignando False al parámetro a y el número 5 al parámetro x. No es verificar la igualdad. Por lo tanto, no hay realmente ninguna forma de usar el símbolo! = En una llamada de consulta.

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

seleccione * de tablex donde a! = 0 yx! = 5

Django-model-values (revelación: autor) proporciona una implementación de la búsqueda NotEqual , como en esta respuesta . También proporciona soporte sintáctico para ello:

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

Lo que está buscando son todos los objetos que tienen a=false o x=5 . En Django, |sirve como ORoperador entre conjuntos de consultas:

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

Esto le dará el resultado deseado.

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

para no igual puede usar ~en una consulta igual. obviamente, Qpuede usarse para llegar a la consulta igual.

¡Cuidado con muchas respuestas incorrectas a esta pregunta!

La lógica de Gerard es correcta, aunque devolverá una lista en lugar de un conjunto de consultas (lo que podría no importar).

Si necesita un conjunto de consultas, use Q:

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