Python 允许可选属性的协议

Question

Suppose I have a protocol Foo .

from typing import Protocol, Optional


class Foo(Protocol):
    val: Optional[int]

And a function like the following:

def func(obj: Foo) -> None:
    if obj.val is not None:
        print(obj.val)

I would expect that either ImplA and ImplB (shown below) should be an acceptable argument for func , since val: int is a more specific than val: Optional[int] .

class ImplA:
    val: int


class ImplB:
    val: Optional[int]

a = ImplA()
b = ImplB()

func(a)  # Argument 1 to "func" has incompatible type "ImplA"; expected "Foo"
func(b)  # It works

As it doesn't work, I have to define Bar and take the union of both classes. However, is there a way to construct a protocol such that both val: Optional[int] and val: int will be accepted without Union ?

class Bar(Protocol):
    val: int

def func(obj: Union[Foo, Bar]): ...

EDIT:

To achieve this, we need to make sure that the type of val is covariant. As far as I see now, it looks like that Protocol defines it to be an invariant. Is it thus impossible to achieve my requirements?

Answer 1

The problem is that you have defined not only a covariant getter, but a contravariant setter. Consider the following:

def func2(obj: Foo) -> None:
    if obj.val is not None:
        print(obj.val)
        obj.val = None  # Fine: val is optional in Foo

x = ImplA(val = 10)
func2(x)  # is x a valid Foo?
print(x.val + 1)  # runtime error!

By the type definition of ImplA, x.val is int so the typechecker must allow the final print. But func2 is valid, as it's only using protocol methods. The only way to prevent this code typechecking is to prevent x being passed to func2. This makes sense as it doesn't have the None-accepting val setter used in func2.

The following will work as you intended:

class Foo(Protocol):
  @property
  def val(self) -> Optional[int]:
    ...

With this definition, the typechecker will complain at the final line of func2 , as it is no longer able to access a setter. Your original example will now typecheck.

---

By the way, I used the terms "covariant" and "contravariant" because you did, and they do feel right, but technically your type isn't covariant or contravariant at all because it's not generic. We could fix that with explicit use of a TypeVar:

T_co = TypeVar("T_co", covariant=True)

class Foo(Protocol, Generic[T_co]):
  val: T_co

This would fail typechecking right here as, now your intent is obvious, the typechecker can tell you your definition is not covariant.

Answer 2

I ran your code and it raised an error for both func(a) and func(b). The error is related to

if obj.val is not none:

because none of the objects have the attribute "val". I tested the code with Python 3.9.9.

I modified the clause to test if the object has the attribute val, hopefully this helps.

from typing import Protocol, Optional


class Foo(Protocol):
    val: Optional[int]


def func(obj: Foo) -> None:
    if hasattr(obj, 'val'):
        print(obj.val)
    else:
        print(f"{obj} variable val is undefined")


class ImplA:
    val: int


class ImplB:
    val: Optional[int]


print("Accessing func with ImplA and ImplB before initializing val")
a = ImplA()
b = ImplB()
func(a)
func(b)

print("Accessing func with ImplA and ImplB after initializing val")
a = ImplA()
a.val = 2
b = ImplB()
b.val = 20
func(a)
func(b)