Introduction

To create a pandas DataFrame from a NumPy array with custom row labels and column names, pass index= and columns= to the DataFrame constructor. If one array column should become the DataFrame index, that is a separate step: either use that column as the index argument when constructing, or create the frame first and then call set_index.

The Basic Constructor

The normal pattern is:

1import numpy as np
2import pandas as pd
3
4arr = np.array([
5    [10, 20, 30],
6    [40, 50, 60],
7    [70, 80, 90],
8])
9
10index_labels = ["row1", "row2", "row3"]
11column_labels = ["A", "B", "C"]
12
13df = pd.DataFrame(arr, index=index_labels, columns=column_labels)
14print(df)

Output:

1       A   B   C
2row1  10  20  30
3row2  40  50  60
4row3  70  80  90

This is the direct answer when you already know the row labels and column headers.

Index Labels Are Not The Same As An Index Column

A common source of confusion is the phrase "index column." In pandas, the index is not just another data column with a special name. It is the row label structure of the frame.

If your NumPy array already contains a first column that should become the index, you usually split that column away from the data columns.

1import numpy as np
2import pandas as pd
3
4arr = np.array([
5    [101, 10, 20],
6    [102, 40, 50],
7    [103, 70, 80],
8])
9
10index_values = arr[:, 0]
11data_values = arr[:, 1:]
12
13column_labels = ["score", "rank"]
14
15df = pd.DataFrame(data_values, index=index_values, columns=column_labels)
16print(df)

Output:

1     score  rank
2101     10    20
3102     40    50
4103     70    80

This is often the cleanest approach when the leftmost array column is an identifier.

Alternative: Create Then set_index

If you want to keep the array structure intact first and assign names afterward, you can build the frame and then promote a column into the index.

1import numpy as np
2import pandas as pd
3
4arr = np.array([
5    [101, 10, 20],
6    [102, 40, 50],
7    [103, 70, 80],
8])
9
10columns = ["id", "score", "rank"]
11df = pd.DataFrame(arr, columns=columns)
12df = df.set_index("id")
13
14print(df)

This is more readable when the input data naturally includes the identifier as just another column at first.

Make Sure Dimensions Match

The index and columns lists must match the array shape:

• number of row labels must equal number of rows
• number of column labels must equal number of columns used in the frame

Example of correct dimensions:

arr.shape == (3, 3)
len(index_labels) == 3
len(column_labels) == 3

If those lengths do not align, pandas raises an error because it cannot assign labels consistently.

NumPy Dtypes Still Matter

A pandas DataFrame built from a NumPy array often inherits a common dtype from that array. If the array mixes strings and numbers, NumPy may upcast everything to a single broader dtype such as string or object.

1import numpy as np
2import pandas as pd
3
4arr = np.array([
5    ["A", 10],
6    ["B", 20],
7], dtype=object)
8
9df = pd.DataFrame(arr, columns=["name", "value"])
10print(df.dtypes)

That behavior comes from NumPy first, then pandas. If the result types matter, inspect them after construction.

When A Structured Source Is Better Than Raw Arrays

If your data already has named fields semantically, a dictionary, record array, or list of dictionaries may be clearer than a plain positional array. A raw NumPy array is good for dense numeric data, but the more meaning each column carries, the more helpful explicit labels become.

Still, for numeric matrices, pd.DataFrame(arr, index=..., columns=...) is exactly the right API.

Common Pitfalls

• Confusing row labels in index= with a real data column inside the frame.
• Passing the wrong number of column names for the array width.
• Forgetting to slice off the identifier column before using it as the index.
• Assuming pandas will infer meaningful column names from a plain NumPy array.
• Ignoring dtype coercion when the NumPy array mixes incompatible value types.

Summary

• Use pd.DataFrame(arr, index=..., columns=...) to assign row labels and column headers directly.
• If one array column should become the index, either split it out before construction or call set_index afterward.
• Make sure the lengths of index and columns match the actual array dimensions.
• Remember that pandas inherits a lot of dtype behavior from the underlying NumPy array.
• For dense numeric matrices, the direct constructor is usually the cleanest solution.