Django: récupère un objet de la base de données, ou 'None' si rien ne correspond

Existe-t-il une fonction Django qui me permettra d'obtenir un objet de la base de données, ou None si rien ne correspond?

En ce moment, j'utilise quelque chose comme:

foo = Foo.objects.filter(bar=baz)
foo = len(foo) > 0 and foo.get() or None

Mais ce n'est pas très clair et c'est compliqué d'en avoir partout.

Dans Django 1.6, vous pouvez utiliser la first()méthode Queryset. Il renvoie le premier objet correspondant à l'ensemble de requêtes, ou None s'il n'y a pas d'objet correspondant.

Usage:

p = Article.objects.order_by('title', 'pub_date').first()

Il y a deux façons de faire ça;

try:
    foo = Foo.objects.get(bar=baz)
except model.DoesNotExist:
    foo = None

Ou vous pouvez utiliser un wrapper:

def get_or_none(model, *args, **kwargs):
    try:
        return model.objects.get(*args, **kwargs)
    except model.DoesNotExist:
        return None

Appelez ça comme ça

foo = get_or_none(Foo, baz=bar)

Pour ajouter un exemple de code à la réponse de sorki (j'ajouterais ceci en commentaire, mais c'est mon premier article, et je n'ai pas assez de réputation pour laisser des commentaires), j'ai implémenté un gestionnaire personnalisé get_or_none comme ceci:

from django.db import models

class GetOrNoneManager(models.Manager):
    """Adds get_or_none method to objects
    """
    def get_or_none(self, **kwargs):
        try:
            return self.get(**kwargs)
        except self.model.DoesNotExist:
            return None

class Person(models.Model):
    name = models.CharField(max_length=255)
    objects = GetOrNoneManager()

Et maintenant je peux faire ceci:

bob_or_none = Person.objects.get_or_none(name='Bob')

Vous pouvez également essayer d'utiliser django ennuyeux (il a une autre fonction utile!)

installez-le avec:

pip install django-annoying

from annoying.functions import get_object_or_None
get_object_or_None(Foo, bar=baz)

Donnez à Foo son gestionnaire personnalisé . C'est assez simple: mettez simplement votre code en fonction dans le gestionnaire personnalisé, définissez le gestionnaire personnalisé dans votre modèle et appelez-le avec Foo.objects.your_new_func(...).

Si vous avez besoin d'une fonction générique (pour l'utiliser sur n'importe quel modèle, pas seulement avec un gestionnaire personnalisé), écrivez la vôtre et placez-la quelque part sur votre chemin python et importez-la, pas plus compliquée.

Que ce soit via un gestionnaire ou une fonction générique, vous voudrez peut-être aussi attraper 'MultipleObjectsReturned' dans l'instruction TRY, car la fonction get () lèvera cela si vos kwargs récupèrent plus d'un objet.

S'appuyant sur la fonction générique:

def get_unique_or_none(model, *args, **kwargs):
    try:
        return model.objects.get(*args, **kwargs)
    except (model.DoesNotExist, model.MultipleObjectsReturned), err:
        return None

et dans le gestionnaire:

class GetUniqueOrNoneManager(models.Manager):
    """Adds get_unique_or_none method to objects
    """
    def get_unique_or_none(self, *args, **kwargs):
        try:
            return self.get(*args, **kwargs)
        except (self.model.DoesNotExist, self.model.MultipleObjectsReturned), err:
            return None

Voici une variante de la fonction d'assistance qui vous permet de passer éventuellement une QuerySetinstance, au cas où vous voudriez obtenir l'objet unique (le cas échéant) à partir d'un ensemble de requêtes autre que l'ensemble de allrequêtes d'objets du modèle (par exemple, à partir d'un sous-ensemble d'éléments enfants appartenant à un instance parent):

def get_unique_or_none(model, queryset=None, *args, **kwargs):
    """
        Performs the query on the specified `queryset`
        (defaulting to the `all` queryset of the `model`'s default manager)
        and returns the unique object matching the given
        keyword arguments.  Returns `None` if no match is found.
        Throws a `model.MultipleObjectsReturned` exception
        if more than one match is found.
    """
    if queryset is None:
        queryset = model.objects.all()
    try:
        return queryset.get(*args, **kwargs)
    except model.DoesNotExist:
        return None

Cela peut être utilisé de deux manières, par exemple:

1. obj = get_unique_or_none(Model, *args, **kwargs) comme discuté précédemment
2. obj = get_unique_or_none(Model, parent.children, *args, **kwargs)

Je pense que dans la plupart des cas, vous pouvez simplement utiliser:

foo, created = Foo.objects.get_or_create(bar=baz)

Seulement s'il n'est pas critique qu'une nouvelle entrée soit ajoutée dans la table Foo (les autres colonnes auront les valeurs None / par défaut)