Data structure

Ensures efficient per-ID storage of unique string labels and ordered float measurements.

Data analysis: storing per-experiment feature flags and time-series measurements Machine learning: associating sample IDs with unique class labels and prediction confidence lists Bioinformatics: mapping gene IDs to sets of ontology terms and lists of expression values

Scientific computing, data processing pipelines, ORM models

mapping: Dict[int, Tuple[Set[str], List[float]]] = {key: (set_items, list_values)}

...: Dict[int, Tuple[Set[str], List[float]]] = {...: (..., ...)}

mapping: any valid identifier, key: int, set_items: Set[str], list_values: List[float]

• Used with loops that update the set and list
• functions that aggregate per-ID metrics
• and serialization libraries that handle nested collections.

• Using Dict[int
• List[float]] when duplicate strings are allowed (simpler but loses uniqueness)
• using a custom class with set and list fields (more explicit but heavier).

Using mutable default arguments like `lookup: Dict[int, Tuple[Set[str], List[float]]] = {}` in function signatures, causing shared state across calls Confusing the order of set and list in the tuple, leading to type errors when accessing elements Assuming the tuple is mutable and attempting to modify its elements directly Using a list instead of a set for the first element, allowing duplicate string labels Forgetting to import `Dict`, `Tuple`, `Set`, `List` from the typing module

Dict[int, List[float]]: simpler mapping without deduplication set for labels Tuple[Set[str], List[float]]: returning two separate collections rather than a keyed map Dict[int, Dict[str, float]]: mapping IDs to a dictionary of label-to-value pairs

Coming from Java: may expect Map<Integer, Tuple<Set<String>, List<Double>>> but need to import proper types from java.util and use concrete classes Coming from JavaScript: may use plain objects with nested arrays and Sets, forgetting TypeScript's strict tuple typing Coming from C++: may try to use std::pair<std::unordered_set<std::string>, std::vector<double>> without considering hash function requirements

• Dict[int
• List[X]]
• Dict[int
• Set[X]]
• Tuple[Set[X]
• List[Y]]

Do not use when the set of strings needs frequent ordering or when the list requires uniqueness—choose appropriate data structures per operation The tuple adds minimal overhead; however, frequent updates to the set or list may cause reallocation costs similar to using separate containers If the key type is not hashable (e.g., a list), the dictionary construction will fail at runtime

Enables clear, type-safe representation of complex per-ID metadata, reducing bugs related to mismatched data structures and improving code maintainability.

Think of a library catalog: each book ID maps to a set of unique subject tags and a list of checkout timestamps.

The type annotation is optional at runtime but aids static analysis and IDE autocomplete.

Consider using a dataclass or pandas DataFrame for richer querying and manipulation