如何帮助Mypy理解“如果不是这样”的结构？

Question

I use a simple method for handling arguments that can either be strings or lists of strings. It is intentionally not robust to errors, but is a quick one-liner.

This method works fine in normal Python, but mypy does not handle its types well and raises an error:

def dosomething(ext: Union[str, Iterable[str]] = ".txt"):
    exts: Tuple[str, ...] = (ext, ) if isinstance(ext, str) else ext

Error: Incompatible types in assignment (expression has type "object", variable has type "Tuple[str, ...]")

Investigating the issue, I see that mypy does not manage to reduce the available type options with the if isinstance else structure:

def dosomething(ext: Union[str, Iterable[str]] = ".txt"):
    exts = (ext, ) if isinstance(ext, str) else ext
    reveal_type(exts)  # Revealed type is 'builtins.object'

Seeing mypy fall back to object is a surprise to me, but I suspect this may be because a str is also Iterable[str] .

I would like to find a way to avoid this surprising situation by helping mypy while keeping the simplicity.

Answer 1

This comes down to the issue of how mypy infers the type for conditional expressions. In simple contexts the expression a if predicate else b is inferred to be the supertype of a and b . In the case of str and Iterable[str] this is builtins.object .

x = reveal_type(1 if bool() else "str")
# Revealed type is 'builtins.object'

One exception is if mypy can resolve the predicate to True or False, then the type gets narrowed to the correct branch:

x = reveal_type(1 if True else "str")
# Revealed type is 'builtins.int'

One would expect that isinstance checks could be resolved to True or False by mypy, but it seems that this has not been implemented yet. I think it would be a very reasonable feature request.

However, we can make use of a nice feature of conditional expression typing, which is that it is context aware. So if the conditional expression is used in a context where a different type is expected, and both sides of the conditional fulfill that type, then type checking passes. This has been discussed here in the context of Union types, but in your case both branches satisfy Iterable[str] :

exts: Iterable[str] = (ext, ) if isinstance(ext, str) else ext

So the key is just specifying the type of exts explicitely.