Python Type Alias Statements

Intermediate

Python can give a descriptive name to a type expression with the type statement. A type alias is a named description of an existing type expression; it does not create a new runtime class.

Create a type alias

The basic form is type Point = tuple[float, float]. The name on the left becomes the alias, and the expression on the right describes the aliased type.

1
2
3
4

type Point = tuple[float, float]

origin: Point = (0.0, 0.0)
print(origin)

Use an alias in an annotation

A type alias can be used anywhere an annotation expression can be used. This keeps function signatures shorter and gives related values a shared vocabulary.

1
2
3
4
5
6
7

type Coordinates = tuple[float, float]

def distance_from_origin(point: Coordinates) -> float:
    x, y = point
    return (x * x + y * y) ** 0.5

print(distance_from_origin((3.0, 4.0)))

An alias can name a larger type expression

The right-hand side can be a type expression built from other types. Aliases are especially useful when the same long expression would otherwise be repeated.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

type UserId = int
type UserRecord = tuple[UserId, str]
type UserTable = dict[UserId, UserRecord]

users: UserTable = {
    7: (7, "Ada"),
    8: (8, "Grace"),
}

print(users[7])

The alias is a TypeAliasType object

Executing a type statement creates a type-alias object. Its value can be inspected through the alias object's metadata, including its name and underlying type expression.

1
2
3
4
5

type Point = tuple[float, float]

print(Point.__name__)
print(type(Point).__name__)
print(Point.__value__)

Type aliases are evaluated lazily

The value of a type alias is evaluated lazily in its annotation scope. This means the referenced type expression does not have to be evaluated at the moment the alias statement runs.

1
2
3
4

type FutureName = LaterName

LaterName = str
print(FutureName.__value__)

Type aliases do not enforce runtime types

A type alias is not a runtime validation rule. Using an alias in an annotation does not make Python automatically reject values of another type; annotations remain descriptive metadata unless some other tool or explicit code performs checking.

1
2
3
4
5
6

type UserId = int

def show_user(user_id: UserId):
    print(user_id)

show_user("guest")

Do not confuse type with type()

The word type in a type-alias statement is a soft keyword. It does not replace the built-in type() function, which still asks about an object's runtime type.

1
2
3
4
5

type UserId = int

value = 42
print(type(value).__name__)
print(UserId.__name__)

Key idea

The type statement gives an existing type expression a reusable name. It creates a type-alias object, evaluates the alias value lazily, and improves the readability of annotations without creating a new runtime class or enforcing types by itself.