Labeled Data Structures

Choose the structure that matches the data

Every analysis starts with a container decision, and getting it right early saves a great deal of repair work later. The question is not how many values do I have but how many labeled axes does this data need.

A Series is a one-dimensional labeled array that can hold any data type. Its axis labels form the index, so a value remains associated with a label rather than only with a numeric position. A DataFrame is a two-dimensional labeled structure whose columns may have different data types. It has an index for row labels and columns for column labels.

Think of one weather station. Daily rainfall, one number per date, is a Series: each value stays tied to its date through the index. Add temperature, wind speed and a text quality flag for the same dates, and you now have four variables sharing one set of row labels — that is a DataFrame, and the text flag can sit next to the numeric columns because columns may carry different dtypes.

The advantage of labels is that they survive operations. A value linked to the label 2026-03-11 keeps that link when the data is filtered, joined or reordered. A bare positional array offers no such guarantee, which is why the labeled structure is the starting point rather than an accessory.

Create a Series from a dictionary, an array, or a scalar

A Series can be created from a dictionary, an array, or a scalar. The three inputs differ in one respect that matters more than any other: where the labels come from.

When an array is paired with an explicit index, the index must have the same length; without one, pandas creates labels from zero through one less than the data length. So an array of five values with no index arrives labeled 0, 1, 2, 3, 4.

A scalar requires an index and is repeated to match that index. pd.Series(0.0, index=['a','b','c','d','e']) is therefore a compact way to create a five-value Series pre-filled with the same starting number — the index sets the length, and the single value is broadcast to fill it.

A dictionary supplies labels from its keys, while an explicitly supplied index selects and orders matching dictionary values and introduces missing values for absent keys. That last behavior is the useful one: pass an index of the labels you want, and you get exactly those labels, in your order, with a missing value wherever the dictionary had nothing to offer. Nothing is invented and nothing extra sneaks in.

Create a DataFrame from labeled inputs

A DataFrame accepts a wide range of inputs, which is convenient but makes it worth knowing what each one implies for the labels. Suitable inputs include dictionaries of one-dimensional arrays, lists, dictionaries or Series; a two-dimensional NumPy array; structured arrays; a Series; and another DataFrame.

Two of those inputs cover most everyday work, and they behave differently:

• In a dictionary of equal-length lists or arrays, dictionary keys become columns and pandas creates a range index unless explicit row labels are supplied.
• In a dictionary of Series, pandas aligns the Series by label and uses the union of their indexes.

A dictionary whose keys name variables is a direct way to construct DataFrame columns, and those columns may retain different dtypes.

The difference is worth a moment. Lists carry no labels, so pandas can only stack them side by side and number the rows. Series do carry labels, so pandas honors them: rows are matched by label, and the result keeps every label seen in any of the inputs.

So a dictionary holding one Series labeled a, b and another labeled b, c produces a table with rows a, b and c. No observed label is dropped, and a cell with no value on one side is simply marked missing.

Make lengths and labels agree before you construct

Constructors are strict about length for a good reason: a table whose columns disagree about how many rows exist is not a table. pd.Series([1, 3, 5]) produces a one-dimensional object with a default range index, and pd.DataFrame(array, index=rows, columns=cols) attaches explicit row and column labels to a two-dimensional array — but both only work when the pieces fit.

When constructing from arrays or lists, all column arrays must have the same length, and any explicit index must match that length.

Two habits prevent nearly every construction error:

1. Reconcile the columns first, so they all report the same number of values.
2. Build the index to that same length, then pass it.

If two variable lists disagree — say four values against five — the fix belongs upstream in the data, not in the constructor. Neither padding the short list nor trimming the long one is something pandas will quietly do on your behalf, and neither is something you should do without deciding what the missing observation actually means.

Expect alignment by label, not by position

Operations between Series align values by index label. This is the behavior that most repays understanding, because it quietly does the right thing in cases where positional arithmetic would produce a plausible-looking wrong answer.

An operation between differently indexed Series returns the union of their indexes, and a label missing from either operand produces a missing result at that label. This differs from treating the values as anonymous positions.

Take a series of readings labeled a, b, c and a second labeled b, c, d. Adding them gives four results:

Two things happen here, and both are deliberate. Nothing observed is discarded: a and d stay in the result. And nothing is invented: where only one side has a number, the result says missing instead of guessing. Positional arithmetic would instead have paired a with b and b with c — three tidy numbers, all of them wrong.

Inspect the structure before analysis

A short inspection before any real work tells you whether the object is what you think it is. Four attributes cover it, and each answers a different question.

Use shape to inspect axis dimensions. Use index for Series labels and DataFrame row labels, and use columns for DataFrame column labels. Use dtypes to inspect the dtype of every DataFrame column; a Series has one dtype, since a Series has only one column of values to describe.

Reading these four is also how you record the schema of a table before changing it — which matters most right before a conversion that will not preserve it.

Ask for an underlying array only when you need one

Sometimes a library outside pandas needs the raw values. There are two ways to hand them over, and they are not interchangeable.

Use .array when the ExtensionArray backing a Series or Index is required. Use to_numpy() when a NumPy array is required.

The second one has consequences. DataFrame.to_numpy() omits row and column labels and may coerce heterogeneous columns to a common NumPy dtype. That conversion may copy data, especially when the common dtype is object.

A NumPy array has a single dtype and no labels, so a mixed table cannot survive the trip intact. Text and numbers together must meet somewhere, and that common ground is usually object — which is also the case most likely to copy the data rather than share it.

The order to work in follows from that:

1. Inspect shape, index, columns and dtypes, so the schema is on record.
2. Convert.
3. Treat the resulting array as values only, and do not read its single dtype as evidence that the source columns already agreed.

That last point catches people out. A uniform output dtype can be the result of coercion, not proof that coercion never happened. Inspect shape, labels, dtypes, and only then request an underlying array representation.

Key takeaways

• Match the container to the axes: use a Series for one-dimensional labeled values and a DataFrame for two-dimensional labeled columns, where each column may hold a different dtype.
• Know where the labels come from: an array takes an index you supply or a default range, a dictionary takes its keys, and a scalar requires an index and is repeated across it.
• Match constructor inputs, explicit labels, and lengths before creating an object; a dictionary of equal-length lists gets a range index, while a dictionary of Series is aligned by label and keeps the union of the indexes.
• Expect Series operations to align by labels rather than anonymous positions, returning the union and marking a label missing from either side.
• Inspect shape, labels, dtypes, and only then request an underlying array representation — to_numpy() drops the labels, may coerce mixed columns, and may copy.