J'ai un modèle qui représente des peintures que je présente sur mon site. Sur la page Web principale, j'aimerais en montrer quelques-uns: le plus récent, celui qui n'a pas été visité la plupart du temps, le plus populaire et un aléatoire.

J'utilise Django 1.0.2.

Alors que les 3 premiers d'entre eux sont faciles à tirer en utilisant les modèles django, le dernier (aléatoire) me cause des problèmes. Je peux ofc le coder à mon avis, à quelque chose comme ceci:

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

Cela ne ressemble pas à quelque chose que j'aimerais avoir à mon avis - cela fait entièrement partie de l'abstraction de la base de données et devrait être dans le modèle. De plus, ici, je dois m'occuper des enregistrements supprimés (alors le nombre de tous les enregistrements ne me couvrira pas toutes les valeurs clés possibles) et probablement beaucoup d'autres choses.

D'autres options comment je peux le faire, de préférence d'une manière ou d'une autre à l'intérieur de l'abstraction du modèle?

L'utilisation order_by('?')tuera le serveur db le deuxième jour de production. Un meilleur moyen est quelque chose comme ce qui est décrit dans Obtenir une ligne aléatoire à partir d'une base de données relationnelle .

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]

Utilisez simplement:

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

Il est documenté dans l' API QuerySet .

Les solutions avec order_by ('?') [: N] sont extrêmement lentes même pour les tables de taille moyenne si vous utilisez MySQL (ne connaissez pas les autres bases de données).

order_by('?')[:N] sera traduit en SELECT ... FROM ... WHERE ... ORDER BY RAND() LIMIT N requête.

Cela signifie que pour chaque ligne de la table, la fonction RAND () sera exécutée, puis la table entière sera triée en fonction de la valeur de cette fonction, puis les N premiers enregistrements seront renvoyés. Si vos tables sont petites, c'est très bien. Mais dans la plupart des cas, il s'agit d'une requête très lente.

J'ai écrit une fonction simple qui fonctionne même si les identifiants ont des trous (certaines lignes ont été supprimées):

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]

C'est plus rapide que order_by ('?') Dans presque tous les cas.

Voici une solution simple:

from random import randint

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

Vous pouvez créer un gestionnaire sur votre modèle pour faire ce genre de chose. D'abord comprendre ce qu'est un gestionnaire est, la Painting.objectsméthode est un gestionnaire qui contient all(), filter(), get(), etc. Créer votre propre gestionnaire vous permet d' effectuer une pré-filtrage des résultats et ont tous les mêmes méthodes, ainsi que vos propres méthodes personnalisées, le travail sur les résultats .

EDIT : j'ai modifié mon code pour refléter la order_by['?']méthode. Notez que le gestionnaire renvoie un nombre illimité de modèles aléatoires. Pour cette raison, j'ai inclus un peu de code d'utilisation pour montrer comment obtenir un seul modèle.

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.

Usage

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

Enfin, vous pouvez avoir de nombreux managers sur vos modèles, alors n'hésitez pas à créer un LeastViewsManager()ou MostPopularManager().

Les autres réponses sont potentiellement lentes (utilisation order_by('?')) ou utilisent plus d'une requête SQL. Voici un exemple de solution sans ordre et avec une seule requête (en supposant Postgres):

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

Sachez que cela provoquera une erreur d'index si la table est vide. Écrivez-vous une fonction d'assistance indépendante du modèle pour vérifier cela.

Juste une idée simple comment je le fais:

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

Juste pour noter un cas particulier (assez courant), s'il y a une colonne auto-incrémentée indexée dans la table sans suppression, la façon optimale de faire une sélection aléatoire est une requête comme:

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

qui suppose une telle colonne nommée id pour table. Dans django, vous pouvez le faire en:

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

dans lequel vous devez remplacer appname par le nom de votre application.

En général, avec une colonne id, le order_by ('?') Peut être fait beaucoup plus rapidement avec:

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

Ceci est fortement recommandé Obtenir une ligne aléatoire à partir d'une base de données relationnelle

Parce que l'utilisation de django orm pour faire une telle chose rendra votre serveur db en colère, surtout si vous avez une table Big Data: |

Et la solution est de fournir un Model Manager et d'écrire la requête SQL à la main;)

Mettre à jour :

Une autre solution qui fonctionne sur n'importe quel backend de base de données, même non-rel, sans écrire personnalisé ModelManager. Obtenir des objets aléatoires à partir d'un ensemble de requêtes dans Django

Vous souhaiterez peut-être utiliser la même approche que celle que vous utiliseriez pour échantillonner n'importe quel itérateur, en particulier si vous prévoyez d'échantillonner plusieurs éléments pour créer un ensemble d'échantillons . @MatijnPieters et @DzinX ont beaucoup réfléchi à ceci:

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

Une approche beaucoup plus simple consiste simplement à filtrer le jeu d'enregistrements d'intérêt et à random.sampleen sélectionner autant que vous le souhaitez:

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

Notez que vous devez avoir du code en place pour vérifier qu'il my_querysetn'est pas vide; random.samplerenvoie ValueError: sample larger than populationsi le premier argument contient trop peu d'éléments.

Salut, j'avais besoin de sélectionner un enregistrement aléatoire à partir d'un ensemble de requêtes dont la longueur que je devais également signaler (c'est-à-dire que la page Web a produit l'élément décrit et lesdits enregistrements sont restés)

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

a pris deux fois moins de temps (0,7 s contre 1,7 s) que:

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

J'imagine que cela évite de tirer toute la requête avant de sélectionner l'entrée aléatoire et rend mon système suffisamment réactif pour une page consultée à plusieurs reprises pour une tâche répétitive où les utilisateurs veulent voir le compte à rebours item_count.

Méthode d'auto-incrémentation de la clé primaire sans suppression

Si vous avez une table où la clé primaire est un entier séquentiel sans espaces, la méthode suivante devrait fonctionner:

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

Cette méthode est beaucoup plus efficace que les autres méthodes ici qui itèrent sur toutes les lignes de la table. Bien que cela nécessite deux requêtes de base de données, les deux sont triviales. De plus, c'est simple et ne nécessite pas la définition de classes supplémentaires. Cependant, son applicabilité est limitée aux tables avec une clé primaire auto-incrémentée où les lignes n'ont jamais été supprimées, de sorte qu'il n'y a pas de lacunes dans la séquence d'identifiants.

Dans le cas où des lignes ont été supprimées comme des espaces, cette méthode peut toujours fonctionner si elle est réessayée jusqu'à ce qu'une clé primaire existante soit sélectionnée au hasard.

Références

• 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

J'ai une solution très simple, créer un gestionnaire personnalisé:

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

puis ajoutez le modèle:

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

Maintenant, vous pouvez l'utiliser:

Example.objects.random()