No modelo do Django, QuerySets, vejo que há a __gte __ltpara valores comparativos, mas existe um __ne/ !=/ <>( não é igual a ?)

Quero filtrar usando um não é igual a:

Exemplo:

Model:
    bool a;
    int x;

eu quero

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

A !=sintaxe não está correta. Eu tentei __ne, <>.

Acabei usando:

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

Talvez objetos Q possam ser úteis para esse problema. Eu nunca os usei, mas parece que eles podem ser negados e combinados como expressões python normais.

Atualização: Acabei de experimentar, parece funcionar muito bem:

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

Sua consulta parece ter um duplo negativo; você deseja excluir todas as linhas em que x não é 5; portanto, em outras palavras, você deseja incluir todas as linhas em que x É 5. Acredito que isso funcionará.

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

Para responder sua pergunta específica, não existe um "não é igual a", mas provavelmente porque o django tem os métodos "filter" e "exclude" disponíveis para que você sempre possa alternar a lógica para obter o resultado desejado.

a field=valuesintaxe nas consultas é uma abreviação de field__exact=value. Isto é, o Django coloca operadores de consulta nos campos de consulta nos identificadores . O Django suporta os seguintes operadores:

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

Tenho certeza de que, combinando-os com os objetos Q, como Dave Vogt sugere e usando filter()ou exclude()como Jason Baker sugere, você obterá exatamente o que precisa para praticamente qualquer consulta possível.

É fácil criar uma pesquisa personalizada com o Django 1.7. Há um __neexemplo de pesquisa na documentação oficial do Django .

Você precisa criar a própria pesquisa primeiro:

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

Então você precisa registrá-lo:

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

E agora você pode usar a __nepesquisa em suas consultas como esta:

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

No Django 1.9 / 1.10, existem três opções.

1. Cadeia excludeefilter

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

2. Use Q()objetos e o ~operador

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

3. Registrar uma função de pesquisa 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

   O register_lookupdecorador foi adicionado no Django 1.8 e permite a pesquisa personalizada como de costume:

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

Enquanto com os modelos, você pode filtrar com =, __gt, __gte, __lt, __lte, você não pode usar ne, !=ou <>. No entanto, você pode obter uma melhor filtragem usando o objeto Q.

Você pode evitar o encadeamento QuerySet.filter()e QuerySet.exlude(), e usar isto:

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

Decisão de projeto pendente. Enquanto isso, useexclude()

O rastreador de problemas do Django possui a notável entrada # 5763 , intitulada "Queryset não possui um operador de filtro" diferente de "" . É notável porque (em abril de 2016) foi "aberto há 9 anos" (na idade da pedra do Django), "fechado há 4 anos" e "alterado pela última vez há 5 meses".

Leia a discussão, é interessante. Basicamente, algumas pessoas argumentam que __nedevem ser adicionadas, enquanto outras dizem que exclude()é mais claro e, portanto __ne , não devem ser adicionadas.

(Eu concordo com o anterior, porque o último argumento é mais ou menos equivalente a dizer Python não deve ter !=porque tem ==e notjá ...)

Usando excluir e filtrar

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

Você deve usar filtere excludeassim

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

O último bit de código excluirá todos os objetos em que x! = 5 e a é True. Tente o seguinte:

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

Lembre-se, o sinal = na linha acima está atribuindo False ao parâmetro ae o número 5 ao parâmetro x. Não está verificando a igualdade. Portanto, não há realmente nenhuma maneira de usar o símbolo! = Em uma chamada de consulta.

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

selecione * da tabelax onde a! = 0 e x! = 5

Django-model-values (disclosure: author) fornece uma implementação da pesquisa NotEqual , como nesta resposta . Ele também fornece suporte sintático para ele:

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

O que você está procurando são todos os objetos que possuem a=false ou x=5 . No Django, |serve como ORoperador entre conjuntos de consultas:

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

Isso dará o resultado desejado.

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

para não igualar você pode usar ~em uma consulta igual. obviamente, Qpode ser usado para alcançar a consulta igual.

Cuidado com muitas respostas incorretas para esta pergunta!

A lógica de Gerard está correta, embora retorne uma lista em vez de um conjunto de consultas (o que pode não importar).

Se você precisar de um conjunto de consultas, use Q:

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