Practice Now
Python
Dictionary
Programming
Data Extraction
Python Tips

How to extract all values from a dictionary in Python?

Data Structures & Algorithms practice on Codemia

Step through 300 algorithm problems with animated visualisers that show the data structure changing as the code runs.

Practice algorithms
Data StructuresPython

Introduction

Extracting dictionary values is simple in Python, but the right pattern depends on whether you need a live view, a concrete list, filtered values, or values from nested data. The values() method is the baseline, then you adapt for your processing needs. Understanding view behavior prevents subtle bugs in mutable workflows.

Basic Extraction With values()

dict.values() returns a dynamic view object, not a separate list copy.

python
1data = {"a": 10, "b": 20, "c": 30}
2vals = data.values()
3
4print(vals)
5print(list(vals))

Because it is a view, it reflects dictionary updates:

python
data["d"] = 40
print(list(vals))

Use this when you want lightweight iteration and do not need independent storage.

Convert to List or Tuple When Snapshot Is Needed

If later dictionary mutations should not affect extracted values, materialize a copy.

python
1data = {"x": 1, "y": 2}
2snapshot = list(data.values())
3
4data["z"] = 3
5print(snapshot)        # [1, 2]
6print(list(data.values()))  # [1, 2, 3]

tuple(data.values()) is another option when immutability is useful.

Filter Values During Extraction

Often you only need values matching criteria.

python
data = {"u1": 120, "u2": 45, "u3": 300, "u4": 70}
high = [v for v in data.values() if v >= 100]
print(high)

For type-based filtering in mixed dictionaries:

python
mixed = {"a": 1, "b": "ok", "c": 2.5, "d": "x"}
nums = [v for v in mixed.values() if isinstance(v, (int, float))]
print(nums)

This is common in data-cleaning pipelines.

Extract Values From Nested Dictionaries

For nested structures, a recursive helper gives full control.

python
1def extract_values(obj):
2    values = []
3    if isinstance(obj, dict):
4        for v in obj.values():
5            values.extend(extract_values(v))
6    elif isinstance(obj, list):
7        for item in obj:
8            values.extend(extract_values(item))
9    else:
10        values.append(obj)
11    return values
12
13payload = {
14    "user": {"name": "Ava", "age": 30},
15    "tags": ["ml", "python"],
16    "active": True,
17}
18
19print(extract_values(payload))

This collects all terminal values across dict and list nesting.

Streaming Values With Generators

For large data, prefer generators to avoid large intermediate lists.

python
1def iter_values(d: dict):
2    for value in d.values():
3        yield value
4
5big = {str(i): i for i in range(1_000_000)}
6first_ten = []
7for idx, value in enumerate(iter_values(big)):
8    if idx == 10:
9        break
10    first_ten.append(value)
11
12print(first_ten)

Generator-based patterns are memory efficient and composable.

Integrating With DataFrames

When values represent a feature vector or metric list, extraction often feeds directly into data libraries.

python
1import pandas as pd
2
3metrics = {"accuracy": 0.93, "precision": 0.91, "recall": 0.89}
4df = pd.DataFrame(list(metrics.items()), columns=["metric", "value"])
5print(df)

Using items() may be better than values-only extraction if labels are also needed.

Order and Determinism Considerations

Python dictionaries preserve insertion order in modern versions. If value order matters for model inputs or tests, make sure insertion order is deterministic or sort by key before extraction.

python
1data = {\"b\": 2, \"a\": 1, \"c\": 3}\nordered_values = [data[k] for k in sorted(data.keys())]\nprint(ordered_values)\n```
2
3Explicit ordering prevents environment-specific differences and keeps serialized outputs stable.
4It also makes regression tests easier to maintain when output comparisons are strict.
5
6## Common Pitfalls
7- Assuming `values()` returns an immutable snapshot.
8- Converting to list repeatedly in hot loops without need.
9- Ignoring mixed value types before numerical operations.
10- Writing complex nested extraction without helper functions.
11- Discarding keys when downstream processing still needs mapping context.
12
13## Summary
14- '`dict.values()` provides a dynamic, efficient view of dictionary values.'
15- Use `list()` or `tuple()` for stable snapshots.
16- Apply comprehensions for filtered value extraction.
17- Use recursion or generators for nested and large structures.
18- Keep keys with `items()` when value context matters.
Related reading
Course
Intermediate
27 lessons
15 hours
DSA Fundamentals

Master algorithmic patterns and data structures through hands-on LeetCode-style problems - from arrays and hashing to dynamic programming and advanced graphs.

View the course
Track what you have practised

A free account saves your progress, solutions and study plan across every problem on Codemia.

Data Structures & Algorithms practice on Codemia

Step through 300 algorithm problems with animated visualisers that show the data structure changing as the code runs.

Practice algorithms
Codemia
© 2026 Codemia
Resources
Legal
Social
All Rights Reserved.