[Django]-Django get a random object

Improving on all of the above:

from random import choice

pks = A.objects.values_list('pk', flat=True)
random_pk = choice(pks)
random_obj = A.objects.get(pk=random_pk)

We first get a list of potential primary keys without loading any Django object, then we randomly choose one primary key, and then we load the chosen object only.

The second bit of code is correct, but can be slower, because in SQL that generates an ORDER BY RANDOM() clause that shuffles the entire set of results, and then takes a LIMIT based on that.

The first bit of code still has to evaluate the entire set of results. E.g., what if your random_idx is near the last possible index?

A better approach is to pick a random ID from your database, and choose that (which is a primary key lookup, so it’s fast). We can’t assume that our every id between 1 and MAX(id) is available, in the case that you’ve deleted something. So following is an approximation that works out well:

import random

# grab the max id in the database
max_id = A.objects.order_by('-id')[0].id

# grab a random possible id. we don't know if this id does exist in the database, though
random_id = random.randint(1, max_id + 1)

# return an object with that id, or the first object with an id greater than that one
# this is a fast lookup, because your primary key probably has a RANGE index.
random_object = A.objects.filter(id__gte=random_id)[0]

How about calculating maximal primary key and getting random pk?

The book ‘Django ORM Cookbook’ compares execution time of the following functions to get random object from a given model.

from django.db.models import Max
from myapp.models import Category

def get_random():
    return Category.objects.order_by("?").first()

def get_random3():
    max_id = Category.objects.all().aggregate(max_id=Max("id"))['max_id']
    while True:
        pk = random.randint(1, max_id)
        category = Category.objects.filter(pk=pk).first()
        if category:
            return category

Test was made on a million DB entries:

In [14]: timeit.timeit(get_random3, number=100)
Out[14]: 0.20055226399563253

In [15]: timeit.timeit(get_random, number=100)
Out[15]: 56.92513192095794

See source.

After seeing those results I started using the following snippet:

from django.db.models import Max
import random

def get_random_obj_from_queryset(queryset):
    max_pk = queryset.aggregate(max_pk=Max("pk"))['max_pk']
    while True:
        obj = queryset.filter(pk=random.randint(1, max_pk)).first()
        if obj:
            return obj

So far it did do the job as long as there is an id.
Notice that the get_random3 (get_random_obj_from_queryset) function won’t work if you replace model id with uuid or something else. Also, if too many instances were deleted the while loop will slow the process down.

Yet another way:

pks = A.objects.values_list('pk', flat=True)
random_idx = randint(0, len(pks)-1)
random_obj = A.objects.get(pk=pks[random_idx])

Works even if there are larger gaps in the pks, for example if you want to filter the queryset before picking one of the remaining objects at random.

EDIT: fixed call of randint (thanks to @Quique). The stop arg is inclusive.

https://docs.python.org/3/library/random.html#random.randint

I’m sharing my latest test result with Django 2.1.7, PostgreSQL 10.

students = Student.objects.all()
for i in range(500):
    student = random.choice(students)
    print(student)

# 0.021996498107910156 seconds

for i in range(500):
    student = Student.objects.order_by('?')[0]
    print(student)

# 0.41299867630004883 seconds

It seems that random fetching with random.choice() is about 2x faster.

Taking Django’s lazy database access into account, the naive time for selecting a random element basically comes down to the time it takes to run len(A.obejcs.all()).

On the database I am trying this out on, it takes a few seconds to do this.

The solution sugested below is instant.

A better way is to wrap the query in a Paginator object:

import random
from django.core.paginator import Paginator, Page


paginator = Paginator(Sample.objects.all().order_by('pk'), 25)
random_page = paginator.get_page(random.choice(paginator.page_range))
random_sample = random.choice(random_page.object_list)

The 25 pages per pagination is just a guess for a good value.

So basically, we choose a random page, and in that page we choose a random sample.

in python for getting a random member of a iterable object like list,set, touple or anything else you can use random module.

random module have a method named choice, this method get a iterable object and return a one of all members randomly.

so becouse random.choice want a iterable object you can use this method for queryset in django.

first import the random module:

import random

then create a list:

my_iterable_object = [1, 2, 3, 4, 5, 6]

or create a query_set like this:

my_iterable_object = mymodel.objects.filter(name='django')

and for getting a random member of your iterable object use choice method:

random_member = random.choice(my_iterable_object)
print(random_member) # my_iterable_object is [1, 2, 3, 4, 5, 6]

3

full code:

import random

my_list = [1, 2, 3, 4, 5, 6]

random.choice(my_list)

2

import random


def get_random_obj(model, length=-1):
    if length == -1:
        length = model.objects.count()

    return model.objects.all()[random.randint(0, length - 1)]


#to use this function
random_obj = get_random_obj(A)