my_dict.update({k: v*2 for k, v in other.items()})

Built-in Data Structures

Meaning

Updates a dictionary with key-value pairs from another dictionary, where each value is transformed (e.g., doubled) via a dictionary comprehension. This pattern merges transformed data into an existing dict in a single readable line.

Primary Function

Dictionary manipulation

Communicative Purpose

Applies a transformation to values from one dictionary and merges them into another.

Pattern

target_dict.update({key: value_expr for key, val in source_dict.items()})

Core Structure

target_dict.update({...: ... for ..., ... in source_dict.items()})

Função primária

Dictionary manipulation

Propósito comunicativo

Applies a transformation to values from one dictionary and merges them into another.

Situações de gatilho

Data processing: merging configuration overrides into a base config; Game development: updating player scores with bonus multipliers; Financial analysis: adjusting price dictionaries with discount factors

Contextos

Python codebases, data processing scripts, config merging, game scoring, financial calculations.

Padrão

target_dict.update({key: value_expr for key, val in source_dict.items()})

Estrutura central

target_dict.update({...: ... for ..., ... in source_dict.items()})

Slots de substituição

target_dict: identifier; key_expr: expression (often the key variable); value_expr: expression using the value variable; key_var: identifier for iteration key; value_var: identifier for iteration value; source_dict: identifier

Colocados típicos

.items()
dict comprehension
.update()

Substituições comuns

Using a loop: for k
v in other.items(): my_dict[k] = v*2
Creating a temporary dict then updating: my_dict.update({k: v*2 for k
v in other.items()})
Using the merge operator (Python 3.9+): my_dict |= {k: v*2 for k
v in other.items()}

Erros comuns

Assuming .update() returns a new dict (it returns None); forgetting that the transformation is evaluated per item and may have side effects; using the comprehension incorrectly as a statement; expecting the original source dict to be modified.

Similar / contraste

my_dict = {k: v*2 for k, v in other.items()} (creates a new dict) vs .update (mutates in-place); using the merge operator: my_dict |= {k: v*2 for k, v in other.items()} (Python 3.9+).

Interferências

Coming from JavaScript: might expect Object.assign‑like syntax; from Java: might think of Map.putAll with transformed entries.

Família do chunk

dict comprehension
dictionary update
merge operator

Nuance

The transformation expression is evaluated for each item; if costly, consider precomputing. For very large source dicts, building a new dict and assigning may be clearer than updating in-place.

Efeito pragmático

Allows concise, readable inline transformation and merge without explicit loops, reducing boilerplate and making intent explicit.

Dica de memória

Double values and slap them into the dict.

Nota

Note that .update() returns None, so it cannot be chained; the transformation expression is evaluated per item.

Upgrade path

my_dict |= {k: v*2 for k, v in other.items()} # Python 3.9+ merge operator

Frequência: MediumFormulaicidade: Semi-fixedTipo de construção: Dictionary comprehension update patternPrioridade de aquisição: Active recallPrioridade de output: BothTag de espaçamento: Medium-term

Examples

scores = {'alice': 10, 'bob': 5} bonus = {'alice': 2, 'bob': 3} scores.update({k: v*2 for k, v in bonus.items()}) print(scores) # {'alice': 40, 'bob': 20}

config = {'timeout': 30, 'retries': 3} env_overrides = {'timeout': 10, 'retries': 1} # Double override values before applying config.update({k: v*2 for k, v in env_overrides.items()}) print(config) # {'timeout': 40, 'retries': 2}

prices = {'apple': 1.2, 'banana': 0.8} sale_factors = {'apple': 0.5, 'banana': 0.75} # Apply sale: price * factor prices.update({k: v * sale_factors[k] for k, v in prices.items() if k in sale_factors}) print(prices) # {'apple': 0.6, 'banana': 0.6}