Ho un modello che rappresenta i dipinti che presento sul mio sito. Sulla pagina web principale vorrei mostrarne alcuni: il più recente, uno che non è stato visitato per la maggior parte del tempo, il più popolare e uno a caso.

Sto usando Django 1.0.2.

Mentre i primi 3 sono facili da usare con i modelli django, l'ultimo (casuale) mi dà qualche problema. Posso ofc codificarlo a mio avviso, a qualcosa del genere:

number_of_records = models.Painting.objects.count()
random_index = int(random.random()*number_of_records)+1
random_paint = models.Painting.get(pk = random_index)

Non sembra qualcosa che mi piacerebbe avere a mio avviso, questo è interamente parte dell'astrazione del database e dovrebbe essere nel modello. Inoltre, qui devo occuparmi dei record rimossi (quindi il numero di tutti i record non mi coprirà tutti i possibili valori chiave) e probabilmente molte altre cose.

Altre opzioni su come posso farlo, preferibilmente in qualche modo all'interno dell'astrazione del modello?

L'utilizzo order_by('?')ucciderà il server db il secondo giorno di produzione. Un modo migliore è qualcosa di simile a quello descritto in Ottenere una riga casuale da un database relazionale .

from django.db.models.aggregates import Count
from random import randint

class PaintingManager(models.Manager):
    def random(self):
        count = self.aggregate(count=Count('id'))['count']
        random_index = randint(0, count - 1)
        return self.all()[random_index]

Usa semplicemente:

MyModel.objects.order_by('?').first()

È documentato nell'API QuerySet .

Le soluzioni con order_by ('?') [: N] sono estremamente lente anche per le tabelle di medie dimensioni se usi MySQL (non conosci altri database).

order_by('?')[:N]sarà tradotto in SELECT ... FROM ... WHERE ... ORDER BY RAND() LIMIT Nquery.

Significa che per ogni riga nella tabella verrà eseguita la funzione RAND (), quindi l'intera tabella verrà ordinata in base al valore di questa funzione e quindi verranno restituiti i primi N record. Se i tuoi tavoli sono piccoli, va bene. Ma nella maggior parte dei casi si tratta di una query molto lenta.

Ho scritto una funzione semplice che funziona anche se gli ID hanno buchi (alcune righe sono state cancellate):

def get_random_item(model, max_id=None):
    if max_id is None:
        max_id = model.objects.aggregate(Max('id')).values()[0]
    min_id = math.ceil(max_id*random.random())
    return model.objects.filter(id__gte=min_id)[0]

È più veloce di order_by ('?') In quasi tutti i casi.

Ecco una soluzione semplice:

from random import randint

count = Model.objects.count()
random_object = Model.objects.all()[randint(0, count - 1)] #single random object

Potresti creare un manager sul tuo modello per fare questo genere di cose. Per capire prima che cosa è un manager, il Painting.objectsmetodo è un manager che contiene all(), filter(),get() , ecc Creare il proprio Manager consente di pre-filtro risultati e hanno tutti gli stessi metodi, così come i propri metodi personalizzati, il lavoro sui risultati .

EDIT : ho modificato il mio codice per riflettere il order_by['?']metodo. Si noti che il gestore restituisce un numero illimitato di modelli casuali. Per questo motivo ho incluso un po 'di codice di utilizzo per mostrare come ottenere un solo modello.

from django.db import models

class RandomManager(models.Manager):
    def get_query_set(self):
        return super(RandomManager, self).get_query_set().order_by('?')

class Painting(models.Model):
    title = models.CharField(max_length=100)
    author = models.CharField(max_length=50)

    objects = models.Manager() # The default manager.
    randoms = RandomManager() # The random-specific manager.

uso

random_painting = Painting.randoms.all()[0]

Infine, puoi avere molti manager sui tuoi modelli, quindi sentiti libero di creare un LeastViewsManager()o MostPopularManager().

Le altre risposte sono potenzialmente lente (utilizzando order_by('?')) o utilizzano più di una query SQL. Ecco una soluzione di esempio senza ordini e solo una query (presupponendo Postgres):

Model.objects.raw('''
    select * from {0} limit 1
    offset floor(random() * (select count(*) from {0}))
'''.format(Model._meta.db_table))[0]

Tenere presente che ciò genererà un errore di indice se la tabella è vuota. Scrivi a te stesso una funzione di supporto indipendente dal modello per verificarlo.

Solo una semplice idea di come lo faccio:

def _get_random_service(self, professional):
    services = Service.objects.filter(professional=professional)
    i = randint(0, services.count()-1)
    return services[i]

Solo per notare un caso speciale (abbastanza comune), se nella tabella è presente una colonna di incremento automatico indicizzata senza eliminazioni, il modo ottimale per effettuare una selezione casuale è una query come:

SELECT * FROM table WHERE id = RAND() LIMIT 1

che assume tale colonna denominata id per table. In django puoi farlo tramite:

Painting.objects.raw('SELECT * FROM appname_painting WHERE id = RAND() LIMIT 1')

in cui è necessario sostituire il nome app con il nome dell'applicazione.

In generale, con una colonna id, order_by ('?') Può essere eseguito molto più velocemente con:

Paiting.objects.raw(
        'SELECT * FROM auth_user WHERE id>=RAND() * (SELECT MAX(id) FROM auth_user) LIMIT %d' 
    % needed_count)

Questo è altamente raccomandato Ottenere una riga casuale da un database relazionale

Perché usare django orm per fare una cosa del genere, farà arrabbiare il tuo server db specialmente se hai una tabella di big data: |

E la soluzione è fornire un Model Manager e scrivere manualmente la query SQL;)

Aggiornare :

Un'altra soluzione che funziona su qualsiasi back-end di database anche su quelli non rel senza scrivere personalizzati ModelManager. Ottenere oggetti casuali da un Queryset in Django

Potresti voler utilizzare lo stesso approccio che utilizzeresti per campionare qualsiasi iteratore, specialmente se prevedi di campionare più elementi per creare un set di campioni . @MatijnPieters e @DzinX ci hanno pensato molto:

def random_sampling(qs, N=1):
    """Sample any iterable (like a Django QuerySet) to retrieve N random elements

    Arguments:
      qs (iterable): Any iterable (like a Django QuerySet)
      N (int): Number of samples to retrieve at random from the iterable

    References:
      @DZinX:  https://stackoverflow.com/a/12583436/623735
      @MartinPieters: https://stackoverflow.com/a/12581484/623735
    """
    samples = []
    iterator = iter(qs)
    # Get the first `N` elements and put them in your results list to preallocate memory
    try:
        for _ in xrange(N):
            samples.append(iterator.next())
    except StopIteration:
        raise ValueError("N, the number of reuested samples, is larger than the length of the iterable.")
    random.shuffle(samples)  # Randomize your list of N objects
    # Now replace each element by a truly random sample
    for i, v in enumerate(qs, N):
        r = random.randint(0, i)
        if r < N:
            samples[r] = v  # at a decreasing rate, replace random items
    return samples

Un approccio molto più semplice a questo comporta semplicemente il filtraggio fino al recordset di interesse e l'utilizzo random.sampleper selezionare il numero desiderato:

from myapp.models import MyModel
import random

my_queryset = MyModel.objects.filter(criteria=True)  # Returns a QuerySet
my_object = random.sample(my_queryset, 1)  # get a single random element from my_queryset
my_objects = random.sample(my_queryset, 5)  # get five random elements from my_queryset

Si noti che è necessario disporre di un codice per verificare che my_querysetnon sia vuoto; random.sampleritorna ValueError: sample larger than populationse il primo argomento contiene troppi elementi.

Ciao, dovevo selezionare un record casuale da un queryset di cui avrei dovuto riferire anche la lunghezza (ovvero la pagina web ha prodotto l'elemento descritto e ha detto che i record sono rimasti)

q = Entity.objects.filter(attribute_value='this or that')
item_count = q.count()
random_item = q[random.randomint(1,item_count+1)]

ha impiegato la metà (0,7 secondi contro 1,7 secondi) di:

item_count = q.count()
random_item = random.choice(q)

Immagino che eviti di tirare giù l'intera query prima di selezionare la voce casuale e abbia reso il mio sistema abbastanza reattivo per una pagina a cui si accede ripetutamente per un'attività ripetitiva in cui gli utenti vogliono vedere il conto alla rovescia di item_count.

Metodo per l'incremento automatico della chiave primaria senza eliminazioni

Se hai una tabella in cui la chiave primaria è un numero intero sequenziale senza spazi vuoti, dovrebbe funzionare il seguente metodo:

import random
max_id = MyModel.objects.last().id
random_id = random.randint(0, max_id)
random_obj = MyModel.objects.get(pk=random_id)

Questo metodo è molto più efficiente di altri metodi qui che ripetono tutte le righe della tabella. Mentre richiede due query sul database, entrambe sono banali. Inoltre, è semplice e non richiede la definizione di classi extra. Tuttavia, l'applicabilità è limitata alle tabelle con una chiave primaria a incremento automatico in cui le righe non sono mai state eliminate, in modo tale che non vi siano spazi vuoti nella sequenza di ID.

Nel caso in cui le righe siano state eliminate in modo tale da essere vuoti, questo metodo potrebbe comunque funzionare se viene riprovato fino a quando una chiave primaria esistente viene selezionata casualmente.

Riferimenti

• https://stackoverflow.com/a/10836811/4651668
• https://stackoverflow.com/a/2118712/4651668
• https://stackoverflow.com/a/39751708/4651668
• https://github.com/greenelab/hetmech-backend/pull/48

Ho una soluzione molto semplice, crea un gestore personalizzato:

class RandomManager(models.Manager):
    def random(self):
        return random.choice(self.all())

e quindi aggiungere nel modello:

class Example(models.Model):
    name = models.CharField(max_length=128)
    objects = RandomManager()

Ora puoi usarlo:

Example.objects.random()