You’d always want to use varname: type_description = initial_value pattern. It’s readable, is the same pattern you use in method params, and linters and IDEs recognize this pattern. And it makes sense for the type description be on the left side of the assignment operator, together with the variable it’s describing.

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

I find like you that the first one is strange.

But I think that both are useless because you can put what you want in a list in python.

thing = List[str]()
type(thing)
# 
stuff: List[str] = []
type(stuff)
# 

But in other hand it’s helpful in IDE to get some warning like Expected type 'str' (matched generic type '_T'), got 'int' instead.

Soooo, in the end I say that I choose this one thing: list[str] = [] because it looks more widely used and easily readable.

Is there a pep for this first form?

You can’t do the first in Python 3.8

the second works if you swap list for List