Вы можете использовать объекты Q для этого. Их можно инвертировать с помощью оператора ~. и объединены так же, как и обычные выражения Python:

from myapp.models import Entry
from django.db.models import Q

Entry.objects.filter(~Q(id=3))

вернет все записи, кроме одной (й) с 3 в качестве идентификатора:

[<Entry: Entry object>, <Entry: Entry object>, <Entry: Entry object>, ...]

Ваш запрос имеет двойной отрицательный результат, вы хотите исключить все строки, где x не равно 5, то есть, другими словами, вы хотите включить все строки, где x равно 5. Я считаю, что это поможет :

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

Чтобы ответить на ваш конкретный вопрос, нет равных поиску по полю, но это, вероятно, связано с тем, что в Django есть как filter и доступны методы exclude, поэтому вы всегда можете просто переключить логику вокруг, чтобы получить желаемый результат.

синтаксис field=value в запросах является сокращением для field__exact=value. То есть Django помещает операторы запроса в поля запроса в идентификаторы. Django поддерживает следующие операторы:

exact
iexact
contains
icontains
in
gt
gte
lt
lte
startswith
istartswith
endswith
iendswith
range

date
year
iso_year
month
day
week
week_day
iso_week_day
quarter
time
hour
minute
second

isnull
regex
iregex

Я уверен, объединив их с объектами Q как Дэйв Фогт предлагает и использовать filter() или exclude() в качестве Джейсон Бейкер предлагает, вы получите именно то, что вам нужно, практически для любого возможного запроса.

Есть три варианта:

1. Цепочка exclude и filter

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

2. Используйте Q() объекты и _ 5_ оператор

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

3. Зарегистрируйте пользовательскую функцию поиска

   from django.db.models import Lookup
   from django.db.models 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
   

   Что можно использовать как обычно:

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

Создать собственный поиск легко, есть пример __ne поиска в Официальная документация Django.

Сначала вам нужно создать сам поиск:

from django.db.models import 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

Тогда вам необходимо его зарегистрировать:

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

И теперь вы можете использовать поиск __ne в своих запросах следующим образом:

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

Хотя вы можете фильтровать модели с помощью =, __gt, __gte, __lt, __lte, вы не можете использовать ne или !=. Однако вы можете добиться лучшей фильтрации с помощью объекта Q.

Вы можете избежать цепочки QuerySet.filter() и QuerySet.exclude() и использовать это:

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

Ожидается дизайнерское решение. Между тем используйте exclude()

В системе отслеживания проблем Django есть замечательная запись № 5763, озаглавленная "Queryset не имеет значения" не равно " оператор фильтра ". Это примечательно, потому что (по состоянию на апрель 2016 года) он был «открыт 9 лет назад» (в каменном веке Джанго), «закрыт 4 года назад» и «последний раз изменялся 5 месяцев назад».

Прочтите обсуждение, это интересно. По сути, некоторые люди утверждают, что __ne следует добавлять, в то время как другие говорят, что exclude() более ясный и, следовательно, __ne не следует добавлять.

(Я согласен с первым, потому что последний аргумент примерно эквивалентен тому, что Python не должен иметь !=, потому что он уже имеет == и not ...)

Использование исключения и фильтра

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

Вы должны использовать filter и exclude вот так

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

Django-model-values ​​ (раскрытие: автор) предоставляет реализацию поиск NotEqual, как в этот ответ. Он также обеспечивает его синтаксическую поддержку:

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

Это даст желаемый результат.

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

для не равно вы можете использовать ~ в равном запросе. очевидно, что Q можно использовать для достижения одинакового запроса.

Последний бит кода исключит все объекты, где x! = 5 и a равно True. Попробуй это:

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

Помните, что знак = в приведенной выше строке присваивает False параметру a и цифру 5 параметру x. Это не проверка на равенство. Таким образом, на самом деле нет никакого способа использовать символ! = В вызове запроса.

Вы ищете все объекты с a=false или x=5. В Django | служит оператором OR между наборами запросов:

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

Следите за множеством неправильных ответов на этот вопрос!

Логика Джерарда верна, хотя он вернет список, а не набор запросов (что может не иметь значения).

Если вам нужен набор запросов, используйте Q:

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

Если нам нужно исключить / отрицать на основе подзапроса, который мы можем использовать,

Условный фильтр:

Когда условное выражение возвращает логическое значение, его можно использовать непосредственно в фильтрах. Здесь non_unique_account_type возвращает логическое значение. Но, тем не менее, мы можем использовать его в фильтре.

>>> non_unique_account_type = Client.objects.filter(
...     account_type=OuterRef('account_type'),
... ).exclude(pk=OuterRef('pk')).values('pk')
>>> Client.objects.filter(~Exists(non_unique_account_type))

В терминах SQL он оценивается как:

SELECT * FROM client c0
WHERE NOT EXISTS (
  SELECT c1.id
  FROM client c1
  WHERE c1.account_type = c0.account_type AND NOT c1.id = c0.id
)