Has using 'thing = liststr' instead of 'thing: list[str] = []' any downsides?
Has using 'thing = liststr' instead of 'thing: list[str] = []' any downsides?
I have seen some people prefer to create a list of strings by using thing = list[str]() instead of thing: list[str] = []. I think it looks kinda weird, but maybe that's just because I have never seen that syntax before. Does that have any downsides?
It is also possible to use this for dicts: thing = dict[str, SomeClass](). Looks equally weird to me. Is that widely used? Would you use it? Would you point it out in a code review?
You're viewing a single thread.
The first one, has a implicit call to the constructor that need infer the type annotation of the result. BTW, the second form is a direct statement with a explicit type annotation, more recommended. When you see the AST of both statements, you can see the overload of calling the constructor and the use of AnnAssign (assign with type annotation) vs Assign:
thing = list[str]()Module( body=[ Assign( targets=[ Name(id='thing', ctx=Store())], value=Call( func=Subscript( value=Name(id='list', ctx=Load()), slice=Name(id='str', ctx=Load()), ctx=Load()), args=[], keywords=[]))], type_ignores=[])
thing: list[str] = []Module( body=[ AnnAssign( target=Name(id='thing', ctx=Store()), annotation=Subscript( value=Name(id='list', ctx=Load()), slice=Name(id='str', ctx=Load()), ctx=Load()), value=List(elts=[], ctx=Load()), simple=1)], type_ignores=[])How do u get this output
With the
dumpfunction:from ast import dump, parse st = parse("thing = list[str]()") print(dump(st, indent=4)) st = parse("thing: list[str] = []") print(dump(st, indent=4))Preesh