{"id":616,"date":"2022-01-14T22:56:25","date_gmt":"2022-01-14T22:56:25","guid":{"rendered":"https:\/\/zerotobyte.com\/?p=616"},"modified":"2022-01-14T22:56:26","modified_gmt":"2022-01-14T22:56:26","slug":"django-queryset-set-operations-aggregations-q-and-f-objects-explained","status":"publish","type":"post","link":"https:\/\/zerotobyte.com\/django-queryset-set-operations-aggregations-q-and-f-objects-explained\/","title":{"rendered":"Django QuerySet – Set Operations, Aggregations, Q and F Objects Explained"},"content":{"rendered":"\n

Continuing on the previous article<\/a>, where I explained Django queryset and how to make basic queries, now we\u2019ll go through some more advanced queries. This time focus will be on set operations, aggregations, and optimization techniques<\/strong> along with the best practices for using the Django QuerySet. The theory will be followed by practical examples that you can reference to and use for your own Django projects. <\/p>\n\n\n\n

To persist the application data, you\u2019ll usually have to store data in a relational database such as PostgreSQL, MySQL, or SQLite. Django QuerySet API helps you communicate with the database. Methods provided by the QuerySet API are used to execute different operations on data residing in the database. After performing actions, these methods usually return a collection of queries, also known as a queryset<\/strong>. <\/p>\n\n\n\n

An important thing to highlight is that querysets are lazy, meaning the database will not be queried until a specific action evaluates the queryset. Evaluation can come in a few different forms like iterating or slicing the queryset, converting the queryset to the list, etc.\u00a0<\/p>\n\n\n\n

As we already went through the basic CRUD queries in the previous article, the focus will now be on slightly more advanced queries. So, let\u2019s start then!<\/p>\n\n\n\n

Using Django QuerySet API – Advanced Queries<\/h2>\n\n\n\n

In the sections below, I\u2019ll explain how to apply set operations on querysets, how to get aggregated results from the database, what are Q and F objects and how to use them.<\/p>\n\n\n\n

I\u2019ll use the Book and Author models to demonstrate mentioned query techniques.<\/p>\n\n\n\n

class Author(models.Model):\n    name = models.CharField(max_length=100)\n\nclass Book(models.Model):\n    title = models.CharField(max_length=255)\n    published_date = models.DateTimeField(null=True)\n    authors = models.ManyToManyField(Author)\n    num_pages = models.IntegerField()<\/pre>\n\n\n\n
Apply migrations for the models above to be able to use them in the interactive shell. First, execute the makemigrations<\/code> command to generate the migration files.<\/p>\n\n\n\n
$ python manage.py makemigrations<\/pre>\n\n\n\n
Then apply these newly created migrations by running the migrate<\/code> command. This will propagate changes to the database, or more precisely, create the book<\/code> and author<\/code> tables in the database. Database migrations are already covered in this article<\/a> I wrote.<\/p>\n\n\n\n
$ python manage.py migrate<\/pre>\n\n\n\n
Start the shell by executing the following command in your terminal:<\/p>\n\n\n\n
$ python manage.py shell<\/pre>\n\n\n\n
Before using the Book and Author models, you must import them first.<\/p>\n\n\n\n
>>> from library.models import Book, Author<\/pre>\n\n\n\n
Set operations over Django queryset<\/h3>\n\n\n\n
Querysets can be combined as any other sets. You can execute the union, intersection, and difference operations over them<\/strong>. The only requirement is that querysets should contain the same fields and datatypes.  <\/p>\n\n\n\n
Union operation<\/h4>\n\n\n\n
The union operator is applied by calling the union()<\/code> method. The result is a queryset containing all other querysets combined<\/strong>.<\/p>\n\n\n\n
>>> q1 = Book.objects.filter(id__lte=2)\n>>> q1\n<QuerySet [<Book: Book object (1)>]>\n>>> q2 = Book.objects.filter(id__gte=2)\n>>> q2\n<QuerySet [<Book: Book object (2)>, <Book: Book object (3)>]>\n\n>>> q1.union(q2).order_by('id')\n<QuerySet [<Book: Book object (1)>, <Book: Book object (2)>, <Book: Book object (3)>]><\/pre>\n\n\n\n
Intersection operation<\/h4>\n\n\n\n
The intersection operator is applied by calling the intersection()<\/code> method. This method will return a queryset that contains only shared results between combined querysets<\/strong>.<\/p>\n\n\n\n
>>> q1 = Book.objects.filter(id__lte=2)\n>>> q1\n<QuerySet [<Book: Book object (1)>, <Book: Book object (2)>]>\n>>> q2 = Book.objects.filter(id__gte=2)\n>>> q2\n<QuerySet [<Book: Book object (2)>, <Book: Book object (3)>]>\n\n\n>>> q1.intersection(q2).order_by('id')\n<QuerySet [<Book: Book object (2)>]><\/pre>\n\n\n\n
Difference operation<\/h4>\n\n\n\n
The difference operator is applied by calling the difference()<\/code> method. The returned result will contain only elements of a first queryset that are not shared in other querysets<\/strong>.<\/p>\n\n\n\n
>>> q1 = Book.objects.filter(id__lte=2)\n>>> q1\n<QuerySet [<Book: Book object (1)>, <Book: Book object (2)>]>\n>>> q2 = Book.objects.filter(id__gte=2)\n>>> q2\n<QuerySet [<Book: Book object (2)>, <Book: Book object (3)>]>\n\n>>> q1.difference(q2).order_by('id')\n<QuerySet [<Book: Book object (1)>]><\/pre>\n\n\n\n
Aggregation<\/h3>\n\n\n\n
Let\u2019s first address what aggregation is in the context of querysets. As you already know, Django queryset is a collection of queries that return objects from a database. Sometimes you\u2019ll want to calculate a specific value derived from returned objects. This value can be anything – total count of objects, average value, range of values, etc. <\/p>\n\n\n\n
Django helps you calculate those values by giving you the aggregate()<\/code> and annotate()<\/code> methods. These methods accept aggregation functions responsible for calculating and returning a dictionary of calculated values<\/strong>. You can see the complete list of aggregation functions<\/a> in Django\u2019s official documentation.<\/p>\n\n\n\n
The major difference between the aggregate()<\/code> and annotate()<\/code> methods is in what items each method uses to calculate a summary. The aggregate()<\/code> method is used to derive the resulting value from the entire QuerySet<\/strong>, while the annotate()<\/code> method derives values for each item of a QuerySet individually<\/strong>. It may be confusing at first but don\u2019t worry; I\u2019ll demonstrate how both methods work in the following examples.<\/p>\n\n\n\n
Django\u2019s aggregate() method<\/h4>\n\n\n\n
We\u2019ll start with a basic example whose goal is to count the number of Book objects in the database. You can calculate the total count in many different ways, but we\u2019ll use the aggregate()<\/code> method in this example. Notice the import of the Count<\/code> aggregation function, which will be responsible for counting all object occurrences for a specific field name. The returned result is a dictionary containing the key comprised of a field name and function name and its calculated value.<\/p>\n\n\n\n
>>> from django.db.models import Count\n>>> Book.objects.aggregate(Count('id'))\n{'id__count': 3}<\/pre>\n\n\n\n
You can also manually define the name of a returned value by specifying the keyword argument. For example, here we want to assign a \u201cbooks_total\u201d name to the returned value.<\/p>\n\n\n\n
>>> Book.objects.aggregate(books_total=Count('id'))\n{'books_total': 3}<\/pre>\n\n\n\n
If we wanted to calculate the total number of pages for all Book objects, we could use the Sum<\/code> aggregation function. This aggregation function sums all values for a given field cumulatively.<\/p>\n\n\n\n
>>> from django.db.models import Sum\n>>> Book.objects.aggregate(num_pages_total=Sum('num_pages'))\n{'num_pages_total': 674}<\/pre>\n\n\n\n
Aggregation methods can be combined with any other method that returns a queryset. So, for example, you can first apply filtering, then calculate the total count of books based on a filtered result.<\/p>\n\n\n\n
>>> Book.objects.filter(title__startswith='Fahrenheit').aggregate(books_total=Count('id'))\n{'books_total': 1}<\/pre>\n\n\n\n
To return multiple aggregated values, you need to pass multiple arguments to the aggregate()<\/code> method. A returned dictionary will contain multiple keys with its values.<\/p>\n\n\n\n
>>> from django.db.models import Sum, Min\n>>> Book.objects.aggregate(Count('id'), Min('published_date'))\n{'id__count': 3, 'published_date__min': datetime.datetime(1953, 10, 13, 0, 0, tzinfo=<UTC>)}<\/pre>\n\n\n\n
Django\u2019s annotate() method<\/h4>\n\n\n\n
If your goal is to summarize values for each queryset item<\/strong>, you should use the annotate()<\/code> method. The annotate()<\/code> method calculates a specific value and assigns it to the returned object. Arguments passed to the method define what extra fields will be added to the returned objects.<\/strong><\/p>\n\n\n\n
NOTE<\/strong> - The output of the annotate()<\/strong> method is a queryset since it does not aggregate the whole queryset but only values for an individual queryset item.<\/pre>\n\n\n\n
In our example, notice that the authors<\/code> field in a Book model is a ManyToManyField<\/code>; therefore, each book can have one or more authors. A perfect use-case for the annotate()<\/code> method is to calculate how many authors contributed to each Book in a queryset and assign that value to each Book object. To do that, we\u2019ll use the annotate()<\/code> method with the Count<\/code> aggregation function.<\/p>\n\n\n\n
>>> from django.db.models import Count\n>>> qs = Book.objects.annotate(num_authors=Count('authors'))\n>>> qs\n<QuerySet [<Book: Book object (1)>, <Book: Book object (2)>, <Book: Book object (3)>]>\n>>> qs[0].num_authors\n1<\/pre>\n\n\n\n
The annotate()<\/code> method returned a queryset. Evaluating that queryset retrieved the values from the database. For example, when we try to access the num_authors<\/code> field of the first element, we get an actual value representing the number of authors. The num_authors<\/code> field was added to the returned object because we passed it as an argument to the annotate()<\/code> method.<\/p>\n\n\n\n
Another example could be to retrieve Book objects with an extra field having titles transformed to uppercase letters. Again, we\u2019ll use the annotate()<\/code> method, but we\u2019ll use the Upper<\/code> database function this time.<\/p>\n\n\n\n
>>> from django.db.models.functions import Upper\n>>> qs = Book.objects.annotate(upper_title=Upper('title'))\n>>> qs[0].upper_title\n\"THE HITCHHIKER'S GUIDE TO THE GALAXY\"<\/pre>\n\n\n\n
HINT<\/strong> - Database functions such as Upper, Lower, Concat, Length, Substr<\/strong>, etc., allow you to move some of the logic from Django to the database. That can boost the performance and make the implemented logic cleaner.<\/pre>\n\n\n\n
Q objects<\/h3>\n\n\n\n
When you need more flexibility in combining different and more complex queries, Q objects could help you. Q objects encapsulate a collection of keyword arguments representing particular SQL conditions<\/strong> and can be combined by the standard logic operators such as &<\/code> (AND<\/code>), |<\/code> (OR<\/code>), and ~<\/code> (NOT<\/code>). Like the filter()<\/code> method, the Q object accepts arguments as a combination of field and lookuptype names separated by the double-underscore (__<\/code>) sign.<\/p>\n\n\n\n
Notice that by chaining multiple filter()<\/code> calls on a given queryset, you\u2019ll get the same behavior as you if you used the AND<\/code> operator on all individual filter()<\/code> calls combined. But what if you wanted to use the OR<\/code> operator when filtering results? I\u2019ll show you how to do it by using the Q objects.<\/p>\n\n\n\n
Let\u2019s say we want to return objects with the title including \u201cfahrenheit\u201d or \u201cgalaxy\u201d. Again, we call the filter()<\/code> method, only this time we do not pass the argument directly to it but use the Q objects. Each filtering criteria is encapsulated into its Q object, and by applying the |<\/code> (OR<\/code>) operator, we get the desired result.<\/p>\n\n\n\n
>>> from django.db.models import Q\n>>> qs = Book.objects.filter(Q(title__icontains='fahrenheit') | Q(title__icontains='galaxy'))\n>>> qs\n<QuerySet [<Book: Book object (1)>, <Book: Book object (3)>]>\n>>> qs.values_list('title')\n<QuerySet [(\"The Hitchhiker's Guide to the Galaxy\",), (\"Fahrenheit 451\",)]><\/pre>\n\n\n\n
Another common use-case could be if we want to, for example, exclude all objects that have titles containing the word \u201cfahrenheit\u201d. This time we use the ~<\/code> (NOT<\/code>) operator before the Q object. It will negate the expression defined by the Q object and return all objects that do not satisfy the Q expression.<\/p>\n\n\n\n
>>> from django.db.models import Q\n>>> qs = Book.objects.filter(~Q(title__icontains='fahrenheit'))\n>>> qs\n<QuerySet [<Book: Book object (1)>, <Book: Book object (2)>]>\n>>> qs.values_list('title')\n<QuerySet [(\"The Hitchhiker's Guide to the Galaxy\",), ('Do Androids Dream of Electric Sheep?',)]><\/pre>\n\n\n\n
F objects<\/h3>\n\n\n\n
Similar to how the Q object represents an SQL condition, the F object represents the value of a model field or annotation.<\/strong> While performing some usual Django ORM operations, the model and its values must first load into Python memory. Then the field value is usually updated and again saved to the database. The F object ensures that the field value is updated directly in the database without loading it into the memory first.<\/strong><\/p>\n\n\n\n
This can be a considerable advantage because performing the operation directly in the database requires fewer queries. Also, this behavior prevents possible race conditions.<\/p>\n\n\n\n
To demonstrate how the F objects work, imagine that the new book edition with the id=1<\/code> was published and the number of pages needs to be updated. We would do that using Django in a classic way:<\/p>\n\n\n\n
>>> book = Book.objects.get(id=1)\n>>> book.num_pages\n208\n>>> book.num_pages += 1\n>>> book.save()\n>>> book.num_pages\n209<\/pre>\n\n\n\n
The disadvantage of the above method is that it uses Django\u2019s ORM to update the value; therefore, it loads the value into memory and holds it until it saves the changes. <\/p>\n\n\n\n
We can achieve the same update much more efficiently using an F object. For example, let\u2019s take a look at the following code snippet.<\/p>\n\n\n\n
>>> from django.db.models import F\n>>> book = Book.objects.get(id=1)\n>>> book.num_pages = F('num_pages') + 1\n>>> book.num_pages\n<CombinedExpression: F(num_pages) + Value(1)>\n>>> book.save()\n>>> book.refresh_from_db()\n>>> book.num_pages\n209<\/pre>\n\n\n\n
There are a few major differences in the execution of this code snippet compared to the previous one. First, we passed the field name as an argument to the F object, which means a new SQL expression was created involving the defined field. If we print the value of the num_pages<\/code> field, you can see it\u2019s not a number anymore but an expression. This expression is evaluated after the save()<\/code> method is called.\u00a0<\/p>\n\n\n\n
Under the hood, it will execute the generated SQL expression without loading anything into Python memory.<\/strong> An updated value will be correctly displayed only after refreshing the object with the refresh_from_db()<\/code> method.<\/p>\n\n\n\n
WARNING<\/strong> - Changes defined by the F objects are applied every time the save()<\/strong> method is executed. So, if you call the save()<\/strong> method two times consecutively, it will update the value twice, even if you defined the F expression only once. For that reason, do not forget to use the refresh_from_db()<\/strong> method to reset the F expression and protect field values from inconsistent behavior.<\/pre>\n\n\n\n
Summary<\/h2>\n\n\n\n
Django has some really useful methods for communicating with the database. For example, Django\u2019s QuerySet methods include set operations, aggregation functions, abstracted SQL expressions, etc. When it is best to apply these advanced techniques mostly depends on the use-case you are handling. <\/p>\n\n\n\n
To recap, with set operations, you can combine different querysets via the union, intersection, and difference functions.<\/strong> Aggregation functions are used when specific values should be derived from the queryset results or even individual queryset objects.<\/strong> For example, you can calculate count, sum, average, min, max, and many other values for a given queryset. Optimization can be achieved by using the Q and F objects, which are abstractions of SQL commands.<\/strong> That way, fewer queries are usually executed, and possible issues with the race conditions can be avoided. <\/p>\n\n\n\n
I recommend you to deep-dive into Django\u2019s official documentation to learn about the queryset methods. Reading this blog will also help you upgrade your skills to become a true Django master.<\/p>\n\n\n\n
Until next time lads!<\/p>\n","protected":false},"excerpt":{"rendered":"
Continuing on the previous article, where I explained Django queryset and how to make basic queries, now we\u2019ll go through … <\/p>\n
Read more<\/a><\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"closed","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[7],"tags":[8,19],"yoast_head":"\nDjango QuerySet - Set Operations, Aggregations, Q and F Objects Explained - ZeroToByte<\/title>\n<meta name=\"description\" content=\"In part 2 article about Django queryset you'll learn how to use set operations, aggregations, and optimized queries via Q and F objects.\" \/>\n<meta name=\"robots\" content=\"index, follow, max-snippet:-1, max-image-preview:large, max-video-preview:-1\" \/>\n<link rel=\"canonical\" href=\"https:\/\/zerotobyte.com\/django-queryset-set-operations-aggregations-q-and-f-objects-explained\/\" \/>\n<meta property=\"og:locale\" content=\"en_US\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"Django QuerySet - Set Operations, Aggregations, Q and F Objects Explained - ZeroToByte\" \/>\n<meta property=\"og:description\" content=\"In part 2 article about Django queryset you'll learn how to use set operations, aggregations, and optimized queries via Q and F objects.\" \/>\n<meta property=\"og:url\" content=\"https:\/\/zerotobyte.com\/django-queryset-set-operations-aggregations-q-and-f-objects-explained\/\" \/>\n<meta property=\"og:site_name\" content=\"ZeroToByte\" \/>\n<meta property=\"article:published_time\" content=\"2022-01-14T22:56:25+00:00\" \/>\n<meta property=\"article:modified_time\" content=\"2022-01-14T22:56:26+00:00\" \/>\n<meta name=\"author\" content=\"Erik Matosevic\" \/>\n<meta name=\"twitter:card\" content=\"summary_large_image\" \/>\n<meta name=\"twitter:label1\" content=\"Written by\" \/>\n\t<meta name=\"twitter:data1\" content=\"Erik Matosevic\" \/>\n\t<meta name=\"twitter:label2\" content=\"Est. reading time\" \/>\n\t<meta name=\"twitter:data2\" content=\"10 minutes\" \/>\n<script type=\"application\/ld+json\" class=\"yoast-schema-graph\">{\"@context\":\"https:\/\/schema.org\",\"@graph\":[{\"@type\":\"WebPage\",\"@id\":\"https:\/\/zerotobyte.com\/django-queryset-set-operations-aggregations-q-and-f-objects-explained\/\",\"url\":\"https:\/\/zerotobyte.com\/django-queryset-set-operations-aggregations-q-and-f-objects-explained\/\",\"name\":\"Django QuerySet - Set Operations, Aggregations, Q and F Objects Explained - ZeroToByte\",\"isPartOf\":{\"@id\":\"https:\/\/zerotobyte.com\/#website\"},\"datePublished\":\"2022-01-14T22:56:25+00:00\",\"dateModified\":\"2022-01-14T22:56:26+00:00\",\"author\":{\"@id\":\"https:\/\/zerotobyte.com\/#\/schema\/person\/53b9b5b312b9a3f60de94957151fa829\"},\"description\":\"In part 2 article about Django queryset you'll learn how to use set operations, aggregations, and optimized queries via Q and F objects.\",\"breadcrumb\":{\"@id\":\"https:\/\/zerotobyte.com\/django-queryset-set-operations-aggregations-q-and-f-objects-explained\/#breadcrumb\"},\"inLanguage\":\"en-US\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\/\/zerotobyte.com\/django-queryset-set-operations-aggregations-q-and-f-objects-explained\/\"]}]},{\"@type\":\"BreadcrumbList\",\"@id\":\"https:\/\/zerotobyte.com\/django-queryset-set-operations-aggregations-q-and-f-objects-explained\/#breadcrumb\",\"itemListElement\":[{\"@type\":\"ListItem\",\"position\":1,\"name\":\"Home\",\"item\":\"https:\/\/zerotobyte.com\/\"},{\"@type\":\"ListItem\",\"position\":2,\"name\":\"Django QuerySet – Set Operations, Aggregations, Q and F Objects Explained\"}]},{\"@type\":\"WebSite\",\"@id\":\"https:\/\/zerotobyte.com\/#website\",\"url\":\"https:\/\/zerotobyte.com\/\",\"name\":\"ZeroToByte\",\"description\":\"Become a Better Dev!\",\"potentialAction\":[{\"@type\":\"SearchAction\",\"target\":{\"@type\":\"EntryPoint\",\"urlTemplate\":\"https:\/\/zerotobyte.com\/?s={search_term_string}\"},\"query-input\":\"required name=search_term_string\"}],\"inLanguage\":\"en-US\"},{\"@type\":\"Person\",\"@id\":\"https:\/\/zerotobyte.com\/#\/schema\/person\/53b9b5b312b9a3f60de94957151fa829\",\"name\":\"Erik Matosevic\",\"image\":{\"@type\":\"ImageObject\",\"inLanguage\":\"en-US\",\"@id\":\"https:\/\/zerotobyte.com\/#\/schema\/person\/image\/\",\"url\":\"https:\/\/secure.gravatar.com\/avatar\/a668cef49bb3689c76ca19c86791c12d?s=96&d=mm&r=g\",\"contentUrl\":\"https:\/\/secure.gravatar.com\/avatar\/a668cef49bb3689c76ca19c86791c12d?s=96&d=mm&r=g\",\"caption\":\"Erik Matosevic\"},\"sameAs\":[\"https:\/\/zerotobyte.com\"],\"url\":\"https:\/\/zerotobyte.com\/author\/erik\/\"}]}<\/script>\n<!-- \/ Yoast SEO plugin. -->","yoast_head_json":{"title":"Django QuerySet - Set Operations, Aggregations, Q and F Objects Explained - ZeroToByte","description":"In part 2 article about Django queryset you'll learn how to use set operations, aggregations, and optimized queries via Q and F objects.","robots":{"index":"index","follow":"follow","max-snippet":"max-snippet:-1","max-image-preview":"max-image-preview:large","max-video-preview":"max-video-preview:-1"},"canonical":"https:\/\/zerotobyte.com\/django-queryset-set-operations-aggregations-q-and-f-objects-explained\/","og_locale":"en_US","og_type":"article","og_title":"Django QuerySet - Set Operations, Aggregations, Q and F Objects Explained - ZeroToByte","og_description":"In part 2 article about Django queryset you'll learn how to use set operations, aggregations, and optimized queries via Q and F objects.","og_url":"https:\/\/zerotobyte.com\/django-queryset-set-operations-aggregations-q-and-f-objects-explained\/","og_site_name":"ZeroToByte","article_published_time":"2022-01-14T22:56:25+00:00","article_modified_time":"2022-01-14T22:56:26+00:00","author":"Erik Matosevic","twitter_card":"summary_large_image","twitter_misc":{"Written by":"Erik Matosevic","Est. reading time":"10 minutes"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"WebPage","@id":"https:\/\/zerotobyte.com\/django-queryset-set-operations-aggregations-q-and-f-objects-explained\/","url":"https:\/\/zerotobyte.com\/django-queryset-set-operations-aggregations-q-and-f-objects-explained\/","name":"Django QuerySet - Set Operations, Aggregations, Q and F Objects Explained - ZeroToByte","isPartOf":{"@id":"https:\/\/zerotobyte.com\/#website"},"datePublished":"2022-01-14T22:56:25+00:00","dateModified":"2022-01-14T22:56:26+00:00","author":{"@id":"https:\/\/zerotobyte.com\/#\/schema\/person\/53b9b5b312b9a3f60de94957151fa829"},"description":"In part 2 article about Django queryset you'll learn how to use set operations, aggregations, and optimized queries via Q and F objects.","breadcrumb":{"@id":"https:\/\/zerotobyte.com\/django-queryset-set-operations-aggregations-q-and-f-objects-explained\/#breadcrumb"},"inLanguage":"en-US","potentialAction":[{"@type":"ReadAction","target":["https:\/\/zerotobyte.com\/django-queryset-set-operations-aggregations-q-and-f-objects-explained\/"]}]},{"@type":"BreadcrumbList","@id":"https:\/\/zerotobyte.com\/django-queryset-set-operations-aggregations-q-and-f-objects-explained\/#breadcrumb","itemListElement":[{"@type":"ListItem","position":1,"name":"Home","item":"https:\/\/zerotobyte.com\/"},{"@type":"ListItem","position":2,"name":"Django QuerySet – Set Operations, Aggregations, Q and F Objects Explained"}]},{"@type":"WebSite","@id":"https:\/\/zerotobyte.com\/#website","url":"https:\/\/zerotobyte.com\/","name":"ZeroToByte","description":"Become a Better Dev!","potentialAction":[{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https:\/\/zerotobyte.com\/?s={search_term_string}"},"query-input":"required name=search_term_string"}],"inLanguage":"en-US"},{"@type":"Person","@id":"https:\/\/zerotobyte.com\/#\/schema\/person\/53b9b5b312b9a3f60de94957151fa829","name":"Erik Matosevic","image":{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/zerotobyte.com\/#\/schema\/person\/image\/","url":"https:\/\/secure.gravatar.com\/avatar\/a668cef49bb3689c76ca19c86791c12d?s=96&d=mm&r=g","contentUrl":"https:\/\/secure.gravatar.com\/avatar\/a668cef49bb3689c76ca19c86791c12d?s=96&d=mm&r=g","caption":"Erik Matosevic"},"sameAs":["https:\/\/zerotobyte.com"],"url":"https:\/\/zerotobyte.com\/author\/erik\/"}]}},"_links":{"self":[{"href":"https:\/\/zerotobyte.com\/wp-json\/wp\/v2\/posts\/616"}],"collection":[{"href":"https:\/\/zerotobyte.com\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/zerotobyte.com\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/zerotobyte.com\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/zerotobyte.com\/wp-json\/wp\/v2\/comments?post=616"}],"version-history":[{"count":6,"href":"https:\/\/zerotobyte.com\/wp-json\/wp\/v2\/posts\/616\/revisions"}],"predecessor-version":[{"id":622,"href":"https:\/\/zerotobyte.com\/wp-json\/wp\/v2\/posts\/616\/revisions\/622"}],"wp:attachment":[{"href":"https:\/\/zerotobyte.com\/wp-json\/wp\/v2\/media?parent=616"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/zerotobyte.com\/wp-json\/wp\/v2\/categories?post=616"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/zerotobyte.com\/wp-json\/wp\/v2\/tags?post=616"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}