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 are viewing a single comment's thread
view the rest of the comments

[–] chemacortes 13 points 1 year ago (1 children)

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=[])

[–] ExperimentalGuy 1 points 1 year ago (1 children)

How do u get this output

[–] chemacortes 8 points 1 year ago (1 children)

With the dump function:

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))

[–] ExperimentalGuy 0 points 1 year ago

Preesh