Can Python 3.x enforce that a method param is a specific class instance/object? (ala PHP)

Question

Python, being dynamically typed, has no provision for type-hinting on method parameters. However, PHP, also being dynamically typed, does have a provision for type-hinting that a method parameter is at least an instance of a class (or that it is an instance of a class that inherits from a defined class).

public class Foo()
{
    public function __construct($qux, ...)
    {
        $this->qux = qux;
        ...
    }
}

public class Bar() 
{
    // "Type Hinting" done here enforcing 
    // that $baz is an instance of Foo
    public function __construct(Foo $baz, ...)
    {
        $this->baz = $baz;
        ...
    }
}

Is there a similar way of enforcing that a method param is a specific instance in Python?

If not, is the proper convention to simply assert?

class Foo(object):
    def __init__(self, qux=None, ...):
        self.qux = qux
        ...


class Bar(object):
    def __init__(self, baz=None, ...):
        # "Type Hinting" done here as `assert`, and
        # requires catch of AssertionError elsewhere
        assert isinstance(baz, Foo)

        self.baz = baz
        ...

If this is style of using assert is incorrect/inelegant/"not pythonic", what should I do instead?

Answer 1

Not out of the box. You can, however, combine parameter annotations with function decorators to almost effortlessly write your own.

Keep in mind, however, that the whole idea of duck typing is to avoid this kind of logic.

Answer 2

There is a strong convention in Python to embrace the Duck Typing idiom, which in this case would mean that you would call the appropriate attributes from the baz object without explicitly checking its type. This has many benefits, including better support for polymorphism and arguably more readable / less verbose code.

If you tried to access an attribute which the object does not support, a AttributeError exception is raised. Therefore you could place this inside a try/except block and catch any AttributeError when appropriate - this is characteristic of another Python idiom called 'Easier to ask forgiveness than permission'

try:
    baz.foo
except AttributeError:
    # handle the exception

Some other questions that cover this topic

• Is it Pythonic to check function argument types?
• Type checking of arguments Python
• Productivity gains of duck typing
• What is the EAFP principle in Python?