Syntax

Final may be used in one of several forms:

• With an explicit type, using the syntaxFinal[<type>]. Example:

  ID:Final[float]=1

• With no type annotation. Example:

  ID:Final=1

  The typechecker should apply its usual type inference mechanisms todetermine the type ofID (here, likely,int). Note that unlike forgeneric classes this isnot the same asFinal[Any].

• In class bodies and stub files you can omit the right hand side and just writeID:Final[float]. If the right hand side is omitted, there mustbe an explicit type argument toFinal.
• Finally, asself.id:Final=1 (also optionally with a type insquare brackets). This is allowedonly in__init__ methods, sothat the final instance attribute is assigned only once when aninstance is created.

Semantics and examples

The two main rules for defining a final name are:

• There can beat most one final declaration per module or class fora given attribute. There can’t be separate class-level and instance-levelconstants with the same name.
• There must beexactly one assignment to a final name.

This means a type checker should prevent further assignments to finalnames in type-checked code:

fromtypingimportFinalRATE:Final=3000classBase:DEFAULT_ID:Final=0RATE=300# Error: can't assign to final attributeBase.DEFAULT_ID=1# Error: can't override a final attribute

Note that a type checker need not allowFinal declarations inside loopssince the runtime will see multiple assignments to the same variable insubsequent iterations.

Additionally, a type checker should prevent final attributes frombeing overridden in a subclass:

fromtypingimportFinalclassWindow:BORDER_WIDTH:Final=2.5...classListView(Window):BORDER_WIDTH=3# Error: can't override a final attribute

A final attribute declared in a class body without an initializer mustbe initialized in the__init__ method (except in stub files):

classImmutablePoint:x:Final[int]y:Final[int]# Error: final attribute without an initializerdef__init__(self)->None:self.x=1# Good

Type checkers should infer a final attribute that is initialized ina class body as being a class variable. Variables should not be annotatedwith bothClassVar andFinal.

Final may only be used as the outermost type in assignments or variableannotations. Using it in any other position is an error. In particular,Final can’t be used in annotations for function arguments:

x:List[Final[int]]=[]# Error!deffun(x:Final[List[int]])->None:# Error!...

Note that declaring a name as final only guarantees that the name willnot be re-bound to another value, but does not make the valueimmutable. Immutable ABCs and containers may be used in combinationwithFinal to prevent mutating such values:

x:Final=['a','b']x.append('c')# OKy:Final[Sequence[str]]=['a','b']y.append('x')# Error: "Sequence[str]" has no attribute "append"z:Final=('a','b')# Also works

Type checkers should treat uses of a final name that was initializedwith a literal as if it was replaced by the literal. For example, thefollowing should be allowed:

fromtypingimportNamedTuple,FinalX:Final="x"Y:Final="y"N=NamedTuple("N",[(X,int),(Y,int)])