Skip Navigation

User banner
Posts
0
Comments
3
Joined
2 yr. ago

  • Sequence now lives at collections.abc. BTW, float is not a supertype of int (issubclass(int, float) == False). Normaly, It is acceptable to use int instead of float, but speaking of variance, it is more precise to use numbers.Real:

     python
        
    issubclass(Integral, Real) == True
    issubclass(int, Real) == True
    issubclass(float, Real) == True
    issubclass(complex, Real) == False
    
      
  • With the dump function:

     python
        
    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))
    
      
  • 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]()

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

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