I often find myself defining function args with list[SomeClass] type and think “do I really care that it’s a list? No, tuple or Generator is fine, too”. I then tend to use Iterable[SomeClass] or Collection[SomeClass]. But when it comes to str, I really don’t like that solution, because if you have this function:
def foo(bar: Collection[str]) -> None:
pass
Then calling foo("hello") is fine, too, because “hello” is a collection of strings with length 1, which would not be fine if I just used list[str] in the first place.
What would you do in a situation like this?
Kids these days and their type hinting. Back in my day, all objects were ducks, and we liked it!
🦆
I’m rusty on my type hints because I’ve been living in lua land lately, but from ye olde PEP 20
Explicit is better than implicit.
I’d combine them so the hint was something like
Union[Collection[str], str]But what if you actually don’t want
strto be valid?Oh, I had it backwards! I tried to mess with the hint and couldn’t find anything, maybe an assert?
from typing import Collection def foo(bar: Collection[str]): assert not isinstance(bar, str) print(bar)
deleted by creator
I know that
IterableandCollectionaren’t the same. My point is, that if you useIterable[str]orCollection[str]as a more flexible alternative tolist[str]you no longer have any type-hinting support protecting against passing in a plain string and you could end up with a subtle bug by unexpectedly looping over['f', 'o', 'o']instead of['foo'].Strings are just a pain… Common solution is a runtime guard or doc comment. Can maybe try an overload and annotate a string param with NoReturn and an @throws doc comment.
Been awhile since doing python, but even that might not work since string satisfies both overloads. I recall having issues with unions where types were not discrete. I may have solved by ordering the overloads differently so string is considered first, but again, its been awhile.
Look at the official docs. There is a table part way down stating which methods are available for each. I pick the one closest to how I use it. So if I’m not mutating I’ll use Sequence over List to inform the caller I’m treating as immutable and to safe guard myself from mutating it in my implementation via static type analysis.
strmatches most of these contracts, though, requiring additional checks if astrwas passed or one of these collections containing strings.
I’m not sure why you wouldn’t just use packing to pass in a list of some objects that you need iterate over? Isn’t it normally bad form to pass lists as arguments? I feel like I’ve read this somewhere but can’t cite it
Yes, that’s a good alternative for
Collection[str]but not so much forIterable[str]as you lose the lazyness of Generators.




