Python 检查Django中的OneToOneField是否为None

我有两个这样的模型：

class Type1Profile(models.Model):
    user = models.OneToOneField(User, unique=True)
    ...


class Type2Profile(models.Model):
    user = models.OneToOneField(User, unique=True)
    ...

如果用户有Type1或Type2配置文件，我需要执行以下操作：

if request.user.type1profile != None:
    # do something
elif request.user.type2profile != None:
    # do something else
else:
    # do something else

但是，对于没有type1或type2配置文件的用户，执行这样的代码会产生以下错误：

Type1Profile matching query does not exist.

如何检查用户的配置文件类型

---

谢谢

使用try/except块怎么样

def get_profile_or_none(user, profile_cls):

    try:
        profile = getattr(user, profile_cls.__name__.lower())
    except profile_cls.DoesNotExist:
        profile = None

    return profile

然后，像这样使用

u = request.user
if get_profile_or_none(u, Type1Profile) is not None:
    # do something
elif get_profile_or_none(u, Type2Profile) is not None:
    # do something else
else:
    # d'oh!

我想您可以将此作为一个通用函数来获取任何反向OneToOne实例，给定一个原始类（此处：您的配置文件类）和一个相关实例（此处：request.user）。

要检查（OneToOne）关系是否存在，您可以使用

hasattr

函数：

if hasattr(request.user, 'type1profile'):
    # do something
elif hasattr(request.user, 'type2profile'):
    # do something else
else:
    # do something else

---

使用

选择相关的

>>> user = User.objects.select_related('type1profile').get(pk=111)
>>> user.type1profile
None

只需测试模型上的相应字段的
None
ness，就可以查看特定模型中可为空的一对一关系是否为空，但前提是您在一对一关系起源的模型上进行测试。例如，给定这两个类

class Place(models.Model):
    name = models.CharField(max_length=50)
    address = models.CharField(max_length=80)

class Restaurant(models.Model):  # The class where the one-to-one originates
    place = models.OneToOneField(Place, blank=True, null=True)
    serves_hot_dogs = models.BooleanField()
    serves_pizza = models.BooleanField()

…要查看
餐厅
是否有
场所
，我们可以使用以下代码：

>>> r = Restaurant(serves_hot_dogs=True, serves_pizza=False)
>>> r.save()
>>> if r.place is None:
>>>    print "Restaurant has no place!"
Restaurant has no place!

要查看
地点
是否有
餐厅
，重要的是要了解在
地点
的实例上引用
餐厅
属性会引发一个
餐厅。如果没有相应的餐厅，则不会出现异常。这是因为Django使用
QuerySet.get（）
在内部执行查找。例如：

>>> p2 = Place(name='Ace Hardware', address='1013 N. Ashland')
>>> p2.save()
>>> p2.restaurant
Traceback (most recent call last):
    ...
DoesNotExist: Restaurant matching query does not exist.

在这种情况下，Occam的剃须刀占了上风，确定<代码>场所<代码>是否有<代码>餐厅<代码>的最佳方法将是标准<代码>尝试<代码>/<代码>，除了所述的<代码>构造

虽然Jocee建议使用
hasattr
在实践中有效，但它实际上只是偶然起作用，因为
hasattr
抑制了所有异常（包括
DoesNotExist
），而不是像它应该的那样只抑制
AttributeError
。正如所指出的，在Python3.2中，实际上根据以下票证更正了此行为：。此外，尽管听起来有点固执己见，但我相信上面的
try
/
除外
结构更能代表Django的工作方式，而使用
hasattr
可能会给新手带来麻烦，这可能会造成FUD并传播坏习惯

编辑合理的妥协对我来说也是合理的。
我喜欢，因为它太简单了

if hasattr(request.user, 'type1profile'):
    # do something
elif hasattr(request.user, 'type2profile'):
    # do something else
else:
    # do something else

其他评论者担心它可能无法与某些版本的Python或Django一起使用，但将此技术作为选项之一：

您还可以使用hasattr来避免异常捕获的需要：

当然，文档还显示了异常捕获技术：

p2没有关联餐厅：

我同意捕捉异常可以让事情变得更清楚，但对我来说似乎更混乱。也许这是一个合理的妥协

>>> print(Restaurant.objects.filter(place=p2).first())
None

这只是按地点查询
餐厅
对象。如果那个地方没有餐厅，它将返回
None

这里有一个可执行代码片段供您使用。如果您安装了Python、Django和SQLite3，那么应该只运行它。我使用Python2.7、Python3.4、Django 1.9.2和SQLite3.8.2对其进行了测试

# Tested with Django 1.9.2
import sys

import django
from django.apps import apps
from django.apps.config import AppConfig
from django.conf import settings
from django.core.exceptions import ObjectDoesNotExist
from django.db import connections, models, DEFAULT_DB_ALIAS
from django.db.models.base import ModelBase

NAME = 'udjango'


def main():
    setup()

    class Place(models.Model):
        name = models.CharField(max_length=50)
        address = models.CharField(max_length=80)

        def __str__(self):              # __unicode__ on Python 2
            return "%s the place" % self.name

    class Restaurant(models.Model):
        place = models.OneToOneField(Place, primary_key=True)
        serves_hot_dogs = models.BooleanField(default=False)
        serves_pizza = models.BooleanField(default=False)

        def __str__(self):              # __unicode__ on Python 2
            return "%s the restaurant" % self.place.name

    class Waiter(models.Model):
        restaurant = models.ForeignKey(Restaurant)
        name = models.CharField(max_length=50)

        def __str__(self):              # __unicode__ on Python 2
            return "%s the waiter at %s" % (self.name, self.restaurant)

    syncdb(Place)
    syncdb(Restaurant)
    syncdb(Waiter)

    p1 = Place(name='Demon Dogs', address='944 W. Fullerton')
    p1.save()
    p2 = Place(name='Ace Hardware', address='1013 N. Ashland')
    p2.save()
    r = Restaurant(place=p1, serves_hot_dogs=True, serves_pizza=False)
    r.save()

    print(r.place)
    print(p1.restaurant)

    # Option 1: try/except
    try:
        print(p2.restaurant)
    except ObjectDoesNotExist:
        print("There is no restaurant here.")

    # Option 2: getattr and hasattr
    print(getattr(p2, 'restaurant', 'There is no restaurant attribute.'))
    if hasattr(p2, 'restaurant'):
        print('Restaurant found by hasattr().')
    else:
        print('Restaurant not found by hasattr().')

    # Option 3: a query
    print(Restaurant.objects.filter(place=p2).first())


def setup():
    DB_FILE = NAME + '.db'
    with open(DB_FILE, 'w'):
        pass  # wipe the database
    settings.configure(
        DEBUG=True,
        DATABASES={
            DEFAULT_DB_ALIAS: {
                'ENGINE': 'django.db.backends.sqlite3',
                'NAME': DB_FILE}},
        LOGGING={'version': 1,
                 'disable_existing_loggers': False,
                 'formatters': {
                    'debug': {
                        'format': '%(asctime)s[%(levelname)s]'
                                  '%(name)s.%(funcName)s(): %(message)s',
                        'datefmt': '%Y-%m-%d %H:%M:%S'}},
                 'handlers': {
                    'console': {
                        'level': 'DEBUG',
                        'class': 'logging.StreamHandler',
                        'formatter': 'debug'}},
                 'root': {
                    'handlers': ['console'],
                    'level': 'WARN'},
                 'loggers': {
                    "django.db": {"level": "WARN"}}})
    app_config = AppConfig(NAME, sys.modules['__main__'])
    apps.populate([app_config])
    django.setup()
    original_new_func = ModelBase.__new__

    @staticmethod
    def patched_new(cls, name, bases, attrs):
        if 'Meta' not in attrs:
            class Meta:
                app_label = NAME
            attrs['Meta'] = Meta
        return original_new_func(cls, name, bases, attrs)
    ModelBase.__new__ = patched_new


def syncdb(model):
    """ Standard syncdb expects models to be in reliable locations.

    Based on https://github.com/django/django/blob/1.9.3
    /django/core/management/commands/migrate.py#L285
    """
    connection = connections[DEFAULT_DB_ALIAS]
    with connection.schema_editor() as editor:
        editor.create_model(model)

main()

我使用的是has_attr和is None的组合：

class DriverLocation(models.Model):
    driver = models.OneToOneField(Driver, related_name='location', on_delete=models.CASCADE)

class Driver(models.Model):
    pass

    @property
    def has_location(self):
        return not hasattr(self, "location") or self.location is None

如果你有模型的话

class UserProfile(models.Model):
    user = models.OneToOneField(User, unique=True)

对于任何用户，您只需要知道UserProfile是否存在，这是从数据库角度使用现有查询的最有效方法

Exists查询将只返回布尔值，而不是像hasattr（request.user，'type1profile'）
那样的反向属性访问-这将生成获取查询，并返回完整的对象表示

为此，您需要向用户模型添加一个属性

class User(AbstractBaseUser)

@property
def has_profile():
    return UserProfile.objects.filter(user=self.pk).exists()

智能方法之一是添加自定义字段OneToOneOrNoneField和使用it[适用于Django>=1.9]

from django.db.models.fields.related_descriptors import ReverseOneToOneDescriptor
from django.core.exceptions import ObjectDoesNotExist
from django.db import models


class SingleRelatedObjectDescriptorReturnsNone(ReverseOneToOneDescriptor):
    def __get__(self, *args, **kwargs):
        try:
            return super().__get__(*args, **kwargs)
        except ObjectDoesNotExist:
            return None


class OneToOneOrNoneField(models.OneToOneField):
    """A OneToOneField that returns None if the related object doesn't exist"""
    related_accessor_class = SingleRelatedObjectDescriptorReturnsNone

    def __init__(self, *args, **kwargs):
        kwargs.setdefault('null', True)
        kwargs.setdefault('blank', True)
        super().__init__(*args, **kwargs)

实施

class Restaurant(models.Model):  # The class where the one-to-one originates
    place = OneToOneOrNoneField(Place)
    serves_hot_dogs = models.BooleanField()
    serves_pizza = models.BooleanField()

用法

r = Restaurant(serves_hot_dogs=True, serves_pizza=False)
r.place  # will return None

感谢您提供此解决方案。不幸的是，这并不总是有效。如果您现在或将来想使用
select_related（）
，或者甚至想确保您还可以处理其他地方可能发生的其他类型的魔法，您必须按如下方式扩展测试：
if hasattr（object，'onetoonerevrelatetr'）和object.onetoonerevrelatetr！=无
请注意，在Python<3.2中，
hasattr
将吞噬数据库查找过程中发生的所有异常，而不仅仅是
DoesNotExist
。这可能已损坏，而不是您想要的。不使用Python2.7。即使OneToOne不存在，它也会返回一个django.db.models.fields.related.RelatedManager对象。@alartur您使用的是哪个django版本？django 1.5。但我用一种完全不同的方式实现了我想做的事情，从而解决了我的特殊问题。我知道它是这样工作的，但select_的这种行为真的被记录下来了吗？我只是在Django 1.9.2中试过了，对于django 1.8，您需要使用
SingleRelatedObjectDescriptor
，而不是像这样从django.db.models.fields.related导入SingleRelatedObjectDescriptor

from django.db.models.fields.related_descriptors import ReverseOneToOneDescriptor
from django.core.exceptions import ObjectDoesNotExist
from django.db import models


class SingleRelatedObjectDescriptorReturnsNone(ReverseOneToOneDescriptor):
    def __get__(self, *args, **kwargs):
        try:
            return super().__get__(*args, **kwargs)
        except ObjectDoesNotExist:
            return None


class OneToOneOrNoneField(models.OneToOneField):
    """A OneToOneField that returns None if the related object doesn't exist"""
    related_accessor_class = SingleRelatedObjectDescriptorReturnsNone

    def __init__(self, *args, **kwargs):
        kwargs.setdefault('null', True)
        kwargs.setdefault('blank', True)
        super().__init__(*args, **kwargs)

class Restaurant(models.Model):  # The class where the one-to-one originates
    place = OneToOneOrNoneField(Place)
    serves_hot_dogs = models.BooleanField()
    serves_pizza = models.BooleanField()

r = Restaurant(serves_hot_dogs=True, serves_pizza=False)
r.place  # will return None