Django: Ottieni un oggetto dal DB, o "Nessuno" se nulla corrisponde

Esiste una funzione Django che mi consentirà di ottenere un oggetto dal database o Nessuno se nulla corrisponde?

In questo momento sto usando qualcosa del tipo:

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

Ma non è molto chiaro ed è complicato avere ovunque.

In Django 1.6 puoi usare il first()metodo Queryset. Restituisce il primo oggetto abbinato dal set di query o Nessuno se non esiste un oggetto corrispondente.

Uso:

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

Ci sono due modi per farlo;

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

Oppure puoi usare un wrapper:

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

Chiamalo così

foo = get_or_none(Foo, baz=bar)

Per aggiungere un codice di esempio alla risposta di sorki (lo aggiungerei come commento, ma questo è il mio primo post e non ho abbastanza reputazione per lasciare commenti), ho implementato un gestore personalizzato get_or_none in questo modo:

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()

E ora posso farlo:

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

Puoi anche provare a usare django fastidioso (ha altre utili funzioni!)

installalo con:

pip install django-annoying

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

Dai a Foo il suo gestore personalizzato . È abbastanza semplice: metti il ​​tuo codice in funzione nel gestore personalizzato, imposta il gestore personalizzato nel tuo modello e chiamalo conFoo.objects.your_new_func(...) .

Se hai bisogno di una funzione generica (per usarla su qualsiasi modello non solo con il gestore personalizzato) scrivi la tua e posizionala da qualche parte nel tuo percorso python e importala, non più disordinato.

Che lo si faccia tramite un gestore o una funzione generica, potresti anche voler catturare 'MultipleObjectsReturned' nell'istruzione TRY, poiché la funzione get () lo solleverà se i tuoi kwarg recuperano più di un oggetto.

Basandosi sulla funzione generica:

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

e nel gestore:

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

Ecco una variazione sulla funzione di supporto che ti consente di passare facoltativamente QuerySetun'istanza, nel caso in cui desideri ottenere l'oggetto univoco (se presente) da un set di query diverso dal set di query di alloggetti del modello (ad esempio da un sottoinsieme di elementi figlio appartenenti a un istanza genitore):

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

Questo può essere utilizzato in due modi, ad esempio:

1. obj = get_unique_or_none(Model, *args, **kwargs) come discusso in precedenza
2. obj = get_unique_or_none(Model, parent.children, *args, **kwargs)

Penso che nella maggior parte dei casi puoi semplicemente usare:

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

Solo se non è fondamentale che una nuova voce venga aggiunta nella tabella Foo (le altre colonne avranno i valori Nessuno / predefinito)