Skip to main content

How to Apply Functions to Keys in Python Dictionary

Manipulating dictionary keys, such as normalizing strings, converting data types, or adding prefixes, is a common task in data preprocessing. Unlike values, dictionary keys must be unique and immutable. Consequently, you cannot modify keys in place; you must create a new dictionary with the transformed keys.

This guide covers the most efficient methods to apply functions to dictionary keys, primarily using dictionary comprehensions, and highlights critical pitfalls regarding key collisions.

The most Pythonic and efficient way to transform keys is using a dictionary comprehension. This creates a new dictionary by iterating over the original items and applying a transformation to the key.

Basic Syntax​

new_dict = {transform(k): v for k, v in original_dict.items()}

Example: Normalizing String Keys​

A common use case is converting all keys to lowercase to ensure consistency.

raw_data = {
    "Name": "Alice",
    "AGE": 30,
    "Job_Title": "Engineer"
}

# ✅ Apply .lower() to every key
normalized_data = {k.lower(): v for k, v in raw_data.items()}

print(f"Original: {raw_data}")
print(f"Normalized: {normalized_data}")

Output:

Original: {'Name': 'Alice', 'AGE': 30, 'Job_Title': 'Engineer'}
Normalized: {'name': 'Alice', 'age': 30, 'job_title': 'Engineer'}

Method 2: Applying Custom Functions​

For logic more complex than built-in string methods, you can define a custom helper function and call it within the comprehension.

def clean_key(key):
    """Adds a prefix and removes whitespace."""
    return f"user_{key.strip()}"

user_input = {
    "  id  ": 101,
    "name": "Bob"
}

# ✅ Apply the custom function 'clean_key'
cleaned_dict = {clean_key(k): v for k, v in user_input.items()}

print(cleaned_dict)

Output:

{'user_id': 101, 'user_name': 'Bob'}

Handling Key Collisions (Data Loss Risk)​

A critical risk when transforming keys is key collision. Since dictionary keys must be unique, if your transformation results in two different original keys producing the same new key, the last one processed will overwrite the previous one.

Example of Problem​

data = {
    "apple": 1,
    "APPLE": 2,  # Distinct key in original dict
    "Apple": 3   # Distinct key in original dict
}

# ⛔️ Warning: Transforming to lowercase makes these keys identical
# Only the last value encountered will remain
collision_result = {k.lower(): v for k, v in data.items()}

print(collision_result)

Output:

{'apple': 3}
warning

In the example above, data for keys 1 and 2 was lost because "apple", "APPLE", and "Apple" all mapped to "apple". Always audit your keys for potential collisions before applying reductive transformations (like lowercasing).

Solution: Manual Conflict Handling​

If preserving all data is critical, you may need a logic check or aggregation strategy instead of a direct overwrite.

data = {"apple": 1, "APPLE": 2}
safe_dict = {}

for k, v in data.items():
    new_key = k.lower()
    if new_key in safe_dict:
        # Handle collision (e.g., sum values, keep list, or raise error)
        safe_dict[new_key] += v
    else:
        safe_dict[new_key] = v

print(f"Aggregated: {safe_dict}")

Output:

Aggregated: {'apple': 3}

Method 3: Filtering and Transforming Simultaneously​

You can combine key transformation with filtering logic to create a clean subset of your data in a single pass.

Example: Convert Numeric String Keys to Integers​

Suppose you have a dictionary with mixed keys, and you only want to keep keys that represent numbers, converting them to integers.

raw_inputs = {
    "100": "Success",
    "404": "Not Found",
    "metadata": "skip this",
    "500": "Error"
}

# ✅ Transform (str -> int) AND Filter (isdigit check)
status_codes = {
    int(k): v 
    for k, v in raw_inputs.items() 
    if k.isdigit()
}

print(status_codes)

Output:

{100: 'Success', 404: 'Not Found', 500: 'Error'}

Conclusion​

To apply functions to dictionary keys in Python:

  1. Use Dictionary Comprehensions: {func(k): v for k, v in d.items()} is the standard, most readable approach.
  2. Ensure Key Validity: Remember that keys must remain immutable types (strings, numbers, tuples).
  3. Beware of Collisions: If your function maps multiple old keys to the same new key (e.g., lower()), data will be overwritten. Validate your inputs or implement collision handling if this is a risk.

Table of Contents