子类覆盖具有父属性子类型的属性

Question

class B:
    pass


class InheritsB1(B):
    pass


class InheritsB2(B):
    pass


class A:
    prop: list[B]


class InheritsA1(A):
    prop: list[InheritsB1]


class InheritsA2(A):
    prop: list[InheritsB2]

With this code mypy raises Incompatible types in assignment (expression has type "List[InheritsB2]", base class "A" defined the type as "List[B]") .

How can I make this work?

InheritsB1 is a subclass of B , so list[InheritsB1] is always a list of B . How can I tell mypy that it's not incompatible? Or, how can I tell mypy that the prop in A is "list of B or any specific subclass of B "?

I understand the issue here: mypy trouble with inheritance of objects in lists . But in this case I want the prop object to be a list of a specific instances ( B or any subclass of B ). I know it will never be mixed, as in it will always be list[B] or list[SubclassOfB1] or list[SubclassOfB2] , never list[SubclassOfB1 | SubclassOfB2] list[SubclassOfB1 | SubclassOfB2] . How can I do this?

Answer 1

You linked a post that essentially addresses the issue, but you seem to still be confused:

InheritsB1 is a subclass of B , so list[InheritsB1] is always a list of B .

This is not true. To quote fromthis section of PEP 484:

By default generic types are considered invariant in all type variables

The theorysection on variance in PEP 483 attempts to explain the concepts in much greater detail. I suggest you read through PEP 483 as well as PEP 484, if you want to get more serious about type safety.

The mypy complaint is justified and unless you want to follow the tip provided by mypy and change the type to something covariant like Sequence instead, you will have to work a bit more with generics yourself.

---

How best to solve your particular conundrum depends on other factors around your classes that are still ambiguous in your original post.

But one option might be to make A generic in terms of a type variable that has an upper bound of B . Then, if you want to define a subclass of A to hold elements of a specific subtype of B , there would be no problem:

from typing import Generic, TypeVar


_BType = TypeVar("_BType", bound="B")


class B:
    pass


class SubB(B):
    pass


class A(Generic[_BType]):
    attribute: list[_BType]


class SubA(A[SubB]):
    # attribute: list[SubB]
    ...


reveal_type(SubA().attribute)  # Revealed type is "builtins.list[SubB]"

Note that in this setup, you don't even have to override/annotate SubA.attribute (which is why I commented it out) because you specify the type argument for A to be SubB during inheritance, which means that SubA is no longer generic and attribute will always be inferred as list[SubB] .

The code is type safe (passes mypy --strict ), but it still may or may not be practical for you, depending on what other requirements you have for the classes involved. If you provide more details, I can try to amend my answer to better suit your setup.