To statically type‑annotate a variable, function parameter, or return value that holds a collection of (list of ints, dict of string→float) pairs, enabling type checkers to enforce the structure of the data.

Communicates to readers and type checkers that the data consists of a set of unique entries, each entry pairing an ordered list of integer IDs with a mapping of string keys to float values, useful for representing e.g., feature vectors with integer identifiers.

Used when annotating variables, function arguments, or return types that hold a set of such (list, dict) pairs, e.g., when processing batches of feature vectors, grouping data by ID lists, or storing intermediate results in type‑checked code.

Found in type annotations within function signatures, variable declarations, class attributes, or return type expressions in Python code that uses the typing module (e.g., `from typing import Set, Tuple, List, Dict`).

Set[Tuple[List[int], Dict[str, float]]]

Set of Tuple containing List[int] and Dict[str, float]

Set[Tuple[List<X>, Dict<Y, Z>]] where X = int, Y = str, Z = float

• typing.Set
• typing.Tuple
• typing.List
• typing.Dict
• List[int]
• Dict[str
• float]

• Set[Tuple[List[int]
• Mapping[str
• float]]] (using Mapping)
• AbstractSet[Tuple[List[int]
• Dict[str
• float]]]
• MutableSet[Tuple[List[int]
• Dict[str
• float]]]

Forgetting to import typing.Set/Tuple/List/Dict; using a plain list instead of Set; placing a mutable list directly inside a set (which would cause a runtime TypeError because lists are unhashable); confusing Dict with Mapping; assuming the annotation is valid at runtime for actual set construction.

List[Tuple[List[int], Dict[str, float]]] (list instead of set), Set[Tuple[List[float], Dict[str, int]]] (swapped int/float), Set[Tuple[List[int], Dict[str, int]]] (integer values in dict).

Assuming the annotation permits a runtime set containing unhashable lists; forgetting that a tuple containing a list is unhashable, so actual set construction would fail unless the inner list is replaced with a hashable type (e.g., tuple).

• type annotations for collections
• typing patterns

The annotation describes a collection of unique pairs where each pair consists of a list of integers and a dictionary mapping strings to floats. Because lists are unhashable, such a value cannot be stored in an actual Python set at runtime; the type is meaningful only for static type checkers. At runtime one would need to use frozenset or convert the inner list to a tuple.

Signals that the data represents a set of unique records, each record comprising an ordered list of integer identifiers and a mapping of string keys to floating‑point values, typical for representing feature vectors or weighted attributes associated with integer IDs.

Set of list-dict pairs

Note: The inner list makes the tuple unhashable, so this type is only meaningful for static type checking (using typing.Set). At runtime you would need to use frozenset or replace the list with a hashable type such as a tuple.

Set[Tuple[Tuple[int, ...], Dict[str, float]]] # replace inner list with a tuple of ints to make the elements hashable for actual set usage