类型提示预期布尔值且始终为空列表

Question

I have a list that I only need to check if it's empty or not.

check = [] and True
print(check) # prints []

check = [1] and True
print(check) # prints True

I only want to use check in an if statement to check the truthiness of the variable, like so:

if check:
    print('Passed')

Should I type hint it like this?

from typing import Literal, Union
check: Union[Literal[True], Literal[[]]] = [] and True

I don't even know if this how to annotate an always empty list, but the annotation itself seems silly, because to the reader, it only matters about the truthiness of it. Ideally I would just want check: bool = [] and True , but the statement doesn't always return a bool so it seems incorrect.

There is also this option to turn it into a bool :

check: bool = not not [] and True

or

check: bool =  bool([]) and True

but these seem like extra work for no reason, since I just need the truthiness and that is acquired regardless of whether I get an empty list or False .

So, what is the proper way to annotate that a statement is to be interpreted only in a boolean context, if itself does not return a bool? Do I just convert it to be boolean and annotate with bool , or do I use something like Union[Literal[True], Literal[[]]] ? And a side note, I don't know if Literal[[]] is even the proper way to annotate an always empty list (or if it's possible at all).

Answer 1

I think the correct way to annotate it is to use Union[List, bool] but Type Hints would'nt do data validation to check if the list is empty - for that take a look at PyDantic explored in this question

from typing import List, Union


def check_list(my_list: Union[List, bool]):
    if my_list:
        print("got truth")
    else:
        print("got false")

Answer 2

Core Python allows for dynamic typing. If you know that you only want to use check in a boolean context annotate it with bool and use and True .

check: bool
check = [] and True    # will contain []
...
check = [1] and True   # will contain True

This gives no warnings when I test it in PyCharm.

You can also use:

check: bool = [] and True    # will contain []
...
check: bool = [1] and True   # will contain True

which gives no warning either...

Answer 3

This almost feels like an inherently bad candidate for type-checking, to me. In this specific situation, you don't actually care about the type of the value returned, so long as you can call bool on it to test for its truthiness. Unless you're working with pandas / numpy or similar, there are very few python objects you can't call bool on — it doesn't require the presence of the __bool__ method or anything — so you can't use the usual solution for duck-typing, which would be to use typing.Protocol . (See, for example, the SupportsInt and SupportsRound classes in the typing module, both of which test for the presence of certain methods.)

As a result, I'd argue a hint of typing.Any would be just as informative and correct as a more elaborate one like typing.Union[list, bool] . The extra information in the second one is entirely redundant for your purposes, it would seem to me.