If you don’t want to import the related model class, you can:

except MyModel.related_field.RelatedObjectDoesNotExist:

or

except my_model_instance._meta.model.related_field.RelatedObjectDoesNotExist:

where related_field is the field name.

Let’s say we have the following models:

class MainModel(Model):
    pass

class RelatedModel(Model):
    main = OneToOneField(MainModel, null=True, related_name="related")

You can get a RelatedObjectDoesNotExist exception with MainModel().related.

You have three options for catching this exception, which you can find by looking at .__class__.__mro__ of the exception:

1. MainModel.related.RelatedObjectDoesNotExist
2. RelatedModel.DoesNotExist
3. django.core.exceptions.ObjectDoesNotExist

MainModel.related.RelatedObjectDoesNotExist

RelatedObjectDoesNotExist is what the question is looking for, but is specific to a nullable OneToOneField:

try:
    # Your code here
except MainModel.related.RelatedObjectDoesNotExist:
    # Handle exception

RelatedModel.DoesNotExist

Model.DoesNotExist is the parent class of RelatedObjectDoesNotExist. To catch it requires you to be able to import the model in question, but is a more generically useful code pattern.

try:
    # Your code here
except OtherModel.DoesNotExist:
    # Handle exception

django.core.exceptions.ObjectDoesNotExist

ObjectDoesNotExist is the parent class of Model.DoesNotExist. This will catch this exception for any model, which is helpful if you don’t know what model will raise the exception:

from django.core.exceptions import ObjectDoesNotExist

try:
    # Your code here
except ObjectDoesNotExist:
    # Handle exception

The RelatedObjectDoesNotExist exception is created dynamically at runtime. Here is the relevant code snippet for the ForwardManyToOneDescriptor and ReverseOneToOneDescriptor descriptors:

@cached_property
def RelatedObjectDoesNotExist(self):
    # The exception can't be created at initialization time since the
    # related model might not be resolved yet; `self.field.model` might
    # still be a string model reference.
    return type(
        'RelatedObjectDoesNotExist',
        (self.field.remote_field.model.DoesNotExist, AttributeError),
        {}
    )

So the exception inherits from <model name>.DoesNotExist and AttributeError. In fact, the complete MRO for this exception type is:

[<class 'django.db.models.fields.related_descriptors.RelatedObjectDoesNotExist'>, 
<class '<model module path>.DoesNotExist'>,
<class 'django.core.exceptions.ObjectDoesNotExist'>,
<class 'AttributeError'>,
<class 'Exception'>,
<class 'BaseException'>,
<class 'object'>]

The basic takeaway is you can catch <model name>.DoesNotExist, ObjectDoesNotExist (import from django.core.exceptions) or AttributeError, whatever makes the most sense in your context.

Little bit late but helpful for others.

2 ways to handle this.

1st :

When we need to catch exception

>>> from django.core.exceptions import ObjectDoesNotExist
>>> try:
>>>     p2.restaurant
>>> except ObjectDoesNotExist:
>>>     print("There is no restaurant here.")
There is no restaurant here.

2nd:
When don’t want to handle exception

>>> hasattr(p2, 'restaurant')
False

tdelaney’s answer is great for regular code paths, but if you need to know how to catch this exception in tests:

from django.core.exceptions import ObjectDoesNotExist

...

    def testCompanyRequired(self):
        with self.assertRaises(ObjectDoesNotExist):
            employee = Employee.objects.create()