Python模块是否应该导入其语义上依赖的模块？

Question

Should Python modules import the modules they semantically depend on?

For example:

module a :

class A(object):
    ...
    def foo(self):
        ...

module b :

import a

def f(a_instance):
    a_instance.foo()
    ...

The first line of module b is unnecessary, strictly speaking, but I wonder if it's considered good form in Python?

Answer 1

b semantically depends on nothing .

quite literally, the only thing that def f depends on is that a_instance produces an attribute .foo that is a callable. Full stop.

It doesn't matter if you pass in A() or AChild() or even a MagicMock .

This is what the phrase "duck typing" means. Consider:

def is_a_duck(duck_candidate):
    duck_candidate.looks_like_a_duck()
    duck_candidate.walks_like_a_duck()
    duck_candidate.quacks_like_a_duck()
    print('This is a duck')
    return True

If you create something that .looks_like_a_duck() , and .walks_like_a_duck() and .quacks_like_a_duck() , then as far as we're concert, it's a duck!

class Person:
    def looks_like_a_duck(self): pass
    def walks_like_a_duck(self): pass
    def quacks_like_a_duck(self): pass

class FakeDuck:
    def looks_like_a_duck(self): pass
    def walks_like_a_duck(self): pass
    def quacks_like_a_duck(self): print('Quack quack quack')

def funcy_duck():
    funcy_duck.looks_like_a_duck = lambda: None
    funcy_duck.walks_like_a_duck = lambda: None
    funcy_duck.quacks_like_a_duck = lambda: None
    return funcy_duck

print(is_a_duck(Person())
print(is_a_duck(FakeDuck())

try:
    print(is_a_duck(funcy_duck))
except AttributeError:
    print('not a duck yet')
    funcy_duck()

print(is_a_duck(funcy_duck))

These are all ducks - it doesn't matter if you define them in ducks.py , or different files, or even dump them as pickles and load them up later. They're all ducks as far as our function is concerned. There's no semantic dependencies on anything but what attributes and behavior our argument has.