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?

  • @chemacortesEnglish
    13•10 months ago

    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=[])
      • @chemacortes
        8•10 months ago

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