Python NumPy: How to Convert a Dictionary to a NumPy Array in Python

Learn how to convert Python dictionaries to NumPy arrays for numerical computations, including handling keys/values, structured arrays, and common pitfalls.

Converting a Python dictionary to a NumPy array is a common task when you need to transition from key-value data structures to numerical arrays for mathematical computations, data analysis, or machine learning. NumPy arrays offer significant performance advantages over dictionaries for numerical operations, and understanding how to bridge these two data structures is essential.

In this guide, you'll learn multiple methods to convert dictionaries to NumPy arrays, handle different data types, and choose the right approach for your specific use case.

Basic Conversion Using `np.array()`

The most straightforward approach is to extract the dictionary's key-value pairs with dict.items(), convert them to a list, and pass the list to np.array().

import numpy as np

data = {1: 'tutorial', 2: 'reference', 3: '.com'}

pairs = list(data.items())
arr = np.array(pairs)

print(arr)
print(f"Shape: {arr.shape}")
print(f"Dtype: {arr.dtype}")

Output:

[['1' 'tutorial']
 ['2' 'reference']
 ['3' '.com']]
Shape: (3, 2)
Dtype: <U21

Step-by-step breakdown:

data.items() returns key-value pairs as tuples: [(1, 'tutorial'), (2, 'reference'), (3, '.com')].
list() converts the view object to a list.
np.array() creates a 2D array where each row is a key-value pair.

Converting Only Keys or Values

Often, you don't need both keys and values in the array. You can convert them separately:

import numpy as np

data = {'a': 10, 'b': 20, 'c': 30, 'd': 40}

keys_array = np.array(list(data.keys()))
print(f"Keys:   {keys_array}")

values_array = np.array(list(data.values()))
print(f"Values: {values_array}")
print(f"Dtype:  {values_array.dtype}")

Output:

Keys:   ['a' 'b' 'c' 'd']
Values: [10 20 30 40]
Dtype:  int64

Converting only the values is particularly useful when you need a numeric array for mathematical operations:

import numpy as np

scores = {'math': 92, 'science': 88, 'english': 95, 'history': 78}

values = np.array(list(scores.values()))

print(f"Scores: {values}")
print(f"Mean:   {values.mean():.2f}")
print(f"Max:    {values.max()}")
print(f"Std:    {values.std():.2f}")

Output:

Scores: [92 88 95 78]
Mean:   88.25
Max:    95
Std:    6.42

Converting a Numeric Dictionary to a 2D Array

When both keys and values are numeric, you get a clean numeric array:

import numpy as np

data = {1: 100, 2: 200, 3: 300, 4: 400}

arr = np.array(list(data.items()))

print(arr)
print(f"Shape: {arr.shape}")
print(f"Dtype: {arr.dtype}")

print(f"\nColumn sums: {arr.sum(axis=0)}")
print(f"Row sums:    {arr.sum(axis=1)}")

Output:

[[  1 100]
 [  2 200]
 [  3 300]
 [  4 400]]
Shape: (4, 2)
Dtype: int64

Column sums: [  10 1000]
Row sums:    [101 202 303 404]

Using Structured Arrays for Mixed Types

When your dictionary has different data types for keys and values (e.g., string keys and numeric values), a structured array preserves type information instead of converting everything to strings:

import numpy as np

data = {'Alice': 92.5, 'Bob': 88.0, 'Charlie': 95.3}

dtype = np.dtype([('name', 'U10'), ('score', 'f8')])

arr = np.array(list(data.items()), dtype=dtype)

print(arr)
print(f"\nNames:  {arr['name']}")
print(f"Scores: {arr['score']}")
print(f"Mean score: {arr['score'].mean():.2f}")

Output:

[('Alice', 92.5) ('Bob', 88. ) ('Charlie', 95.3)]

Names:  ['Alice' 'Bob' 'Charlie']
Scores: [92.5 88.  95.3]
Mean score: 91.93

Converting a Dictionary of Lists to a 2D Array

A common pattern is a dictionary where each value is a list of numbers, representing columns of data:

import numpy as np

data = {
    'temperature': [72, 75, 68, 71],
    'humidity': [45, 50, 55, 48],
    'pressure': [1013, 1010, 1015, 1012]
}

arr = np.column_stack(list(data.values()))

print("Array:")
print(arr)
print(f"\nShape: {arr.shape}")
print(f"Column names: {list(data.keys())}")

Output:

Array:
[[  72   45 1013]
 [  75   50 1010]
 [  68   55 1015]
 [  71   48 1012]]

Shape: (4, 3)
Column names: ['temperature', 'humidity', 'pressure']

An alternative using np.array() directly on the values produces rows instead of columns:

import numpy as np

data = {
    'temperature': [72, 75, 68, 71],
    'humidity': [45, 50, 55, 48]
}

arr_rows = np.array(list(data.values()))
print(f"As rows (shape {arr_rows.shape}):")
print(arr_rows)

arr_cols = arr_rows.T
print(f"\nAs columns (shape {arr_cols.shape}):")
print(arr_cols)

Output:

As rows (shape (2, 4)):
[[72 75 68 71]
 [45 50 55 48]]

As columns (shape (4, 2)):
[[72 45]
 [75 50]
 [68 55]
 [71 48]]

Handling Nested Dictionaries

When dealing with nested dictionaries, the conversion depends on what structure you need:

import numpy as np

students = {
    'Alice': {'math': 90, 'science': 85, 'english': 92},
    'Bob': {'math': 78, 'science': 88, 'english': 80},
    'Charlie': {'math': 95, 'science': 91, 'english': 87}
}

names = list(students.keys())
subjects = list(students['Alice'].keys())
grades = np.array([list(scores.values()) for scores in students.values()])

print(f"Students: {names}")
print(f"Subjects: {subjects}")
print(f"\nGrades array:")
print(grades)
print(f"\nAverage per student: {grades.mean(axis=1)}")
print(f"Average per subject: {grades.mean(axis=0)}")

Output:

Students: ['Alice', 'Bob', 'Charlie']
Subjects: ['math', 'science', 'english']

Grades array:
[[90 85 92]
 [78 88 80]
 [95 91 87]]

Average per student: [89. 82. 91.]
Average per subject: [87.66666667 88.         86.33333333]

Common Pitfalls

Mixed Types Without Structured Arrays

When keys and values have different types, NumPy converts everything to strings, making numeric operations impossible:

import numpy as np

data = {'Alice': 90, 'Bob': 85}
arr = np.array(list(data.items()))

print(f"Dtype: {arr.dtype}")  # <U21
print(arr[:, 1].sum())        # Tries string concatenation, not addition

Output:

Dtype: <U21
TypeError: the resolved dtypes are not compatible with add.reduce. Resolved (dtype('<U21'), dtype('<U21'), dtype('<U42'))

Solution

Convert only the values to an array, or use structured arrays:

import numpy as np

data = {'Alice': 90, 'Bob': 85}

values = np.array(list(data.values()))
print(f"Sum: {values.sum()}")  # 175

structured = np.array(
    list(data.items()),
    dtype=[('name', 'U10'), ('score', 'i4')]
)

print("Structured array:")
print(structured)

print(f"Sum: {structured['score'].sum()}")  # 175

Output:

Sum: 175
Structured array: [('Alice', 90) ('Bob', 85)]
Sum: 175

Quick Comparison of Methods

Method	Best For	Preserves Types	Output Shape
`np.array(list(d.items()))`	Simple key-value pairs	❌ (casts to common type)	(n, 2)
`np.array(list(d.values()))`	Numeric values only	✅	(n,) or (n, m)
`np.column_stack(list(d.values()))`	Dict of lists → columns	✅	(rows, cols)
Structured array	Mixed types (string + numeric)	✅	(n,) with named fields

Conclusion

Converting a Python dictionary to a NumPy array can be done in several ways depending on your data and goals:

Convert key-value pairs with np.array(list(d.items())) for a simple 2D array of pairs.
Convert only values with np.array(list(d.values())) when you need a clean numeric array for computations.
Use np.column_stack() when dictionary values are lists that should become columns in a 2D array.
Use structured arrays when you need to preserve different data types for keys and values within a single array.

For most data analysis and machine learning tasks, converting only the dictionary's values to a NumPy array is the most practical approach, as it gives you a clean numeric array ready for mathematical operations.

Python NumPy: How to Convert a Dictionary to a NumPy Array in Python

Basic Conversion Using np.array()

Converting Only Keys or Values

Converting a Numeric Dictionary to a 2D Array

Using Structured Arrays for Mixed Types

Converting a Dictionary of Lists to a 2D Array

Handling Nested Dictionaries

Common Pitfalls

Quick Comparison of Methods

Conclusion

Basic Conversion Using `np.array()`