Pandas Series Basics

You've got your DataFrame working, but every column in it is actually a pandas Series — the building block of almost all pandas operations. If you don't understand Series, you'll find yourself fighting with your data instead of working with it. This lesson demystifies the Series, showing you how to create, inspect, and manipulate one-dimensional labeled data with confidence. By the end, you'll be able to leverage Series for fast, readable data analysis — and you'll have a solid foundation for the DataFrames that come next.

The problem this lesson solves

When you first load a CSV or Excel file into pandas, you get a DataFrame — a two-dimensional table. But if you look at any single column, you're actually looking at a Series. Many beginners treat a Series like a plain Python list and get stuck: indexing behaves differently, operations are vectorized (they run on the whole series at once), and missing values (NaN) appear out of nowhere. This confusion leads to slow loops, wrong results, and frustration.

Consider this common scenario:

import pandas as pd

# Load some data
sales = pd.DataFrame({'product': ['A', 'B', 'C'],
                      'revenue': [100, 200, 150]})

# Try to add 10% to each revenue value
for i in range(len(sales)):
    sales['revenue'][i] = sales['revenue'][i] * 1.1

This works, but it's slow, verbose, and non-idiomatic. The pandas way is vectorized and elegant:

sales['revenue'] = sales['revenue'] * 1.1

Without understanding Series, you'll never unlock that power. This lesson closes that gap.

Core concept / mental model

Think of a Series as a labeled one-dimensional array — a single column of data with an index that labels each element. It's like a Python dictionary where the keys are the index labels and the values are the data, but with a twist: the index is ordered and can be non-unique (though it usually isn't).

• Data: any numpy data type — ints, floats, strings, booleans, even Python objects.
• Index: a sequence of labels (default: integer 0 to n-1). You can set custom labels.
• dtype: the data type of the values, inferred automatically (e.g., int64, float64, object).

Visualize it like a spine with labels on one side:

index →  0   100
         1   200
         2   150

The Series is the fundamental building block of the DataFrame. When you select a column from a DataFrame, you get a Series back. Operations on a Series are vectorized — they apply to every element in one go, using optimized C code under the hood.

How it works step by step

Here’s the logical sequence to master Series basics:

1. Create a Series from a list, dictionary, or scalar.
2. Inspect it — look at values, index, dtype, and size.
3. Access data — by position (integer) or by label.
4. Perform operations — arithmetic, comparisons, aggregation.
5. Handle missing values — detect and fill or drop them.

Cause and effect: when you create a Series, pandas builds a numpy array for data and an Index object for labels. Operations use the index to align data — that’s why a Series can handle non-contiguous labels. If you do math between two Series, pandas aligns them by label, not by position, which is powerful but can surprise you if labels differ.

Hands-on walkthrough

Let’s build a Series step by step and run through the core operations.

Creating a Series

import pandas as pd

# From a list (default integer index)
s = pd.Series([10, 20, 30, 40])
print(s)

Output:

0    10
1    20
2    30
3    40
dtype: int64

You can also supply custom labels:

s_named = pd.Series([10, 20, 30], index=['a', 'b', 'c'])
print(s_named)

Output:

a    10
b    20
c    30
dtype: int64

Or from a dictionary — keys become the index:

d = {'apple': 5, 'banana': 3, 'cherry': 8}
fruit_series = pd.Series(d)
print(fruit_series)

Output:

apple     5
banana    3
cherry    8
dtype: int64

Inspecting a Series

print(s_named.values)    # array([10, 20, 30])
print(s_named.index)     # Index(['a', 'b', 'c'], dtype='object')
print(s_named.dtype)     # int64
print(s_named.size)      # 3
print(s_named.head(2))   # first 2 rows

Indexing and selection

You can access elements by position (like a list) or by label (like a dict):

# By label
print(s_named['b'])      # 20

# By position
print(s_named.iloc[1])   # 20

# Slicing by label (inclusive)
print(s_named['a':'c'])  # a 10, b 20, c 30

# Boolean indexing
print(s_named[s_named > 15])  # b 20, c 30

Pro tip: Use .loc for label-based access and .iloc for position-based access. They are explicit and avoid ambiguity.

Basic operations

Series operations are vectorized — no loops needed:

revenue = pd.Series([100, 200, 150], index=['Mon', 'Tue', 'Wed'])
costs = pd.Series([80, 120, 90], index=['Mon', 'Tue', 'Wed'])

# Arithmetic
print(revenue * 1.1)         # scaling
print(revenue + costs)       # element-wise addition

# Comparisons
print(revenue > 120)         # boolean Series

# Aggregation
print(revenue.sum())         # 450
print(revenue.mean())        # 150.0
print(revenue.max())         # 200

Output (last few lines):

Mon    180
Tue    320
Wed    240
dtype: int64

Plus a boolean Series and the aggregate numbers.

Handling missing values

Real data is messy — you’ll get NaN.

s_missing = pd.Series([1, None, 3], index=['x', 'y', 'z'])
print(s_missing.isna())      # False, True, False
print(s_missing.fillna(0))   # replace NaN with 0
print(s_missing.dropna())    # drop NaN rows

Compare options / when to choose what

When working with a series, you have several ways to access and manipulate data. Here’s a quick comparison:

When to choose what: - Use .iloc when you care about the position (e.g., first element). - Use .loc when you have meaningful labels (e.g., dates, names). - Use boolean masks for filtering. - For fast arithmetic, rely on vectorized operations — avoid Python loops.

Troubleshooting & edge cases

Index misalignment — When you add two Series with different indices, pandas aligns them by label, resulting in NaN where labels don't match.

s1 = pd.Series([1, 2], index=['a', 'b'])
s2 = pd.Series([10, 20], index=['b', 'c'])
print(s1 + s2)

Output:

a    NaN
b    12.0
c    NaN
dtype: float64

KeyError — Accessing a label that doesn’t exist raises an error. Use .get() to avoid it:

print(s_named.get('z', 'not found'))

Wrong dtype — Mixing strings and numbers in a Series can turn everything into object, breaking math. Check dtype early.

Setting with chained indexing — In DataFrames, df['col'][i] = value can trigger a SettingWithCopyWarning. Use .loc instead.

Performance — Looping over a Series is slow. Always prefer vectorized operations or apply() for more complex logic.

What you learned & what's next

You now understand the pandas Series: how to create it, inspect it, index it, and perform basic operations. You can apply vectorized arithmetic, filter with boolean masks, and handle missing values. These skills are the foundation for all pandas data work.

Next in the track, you'll move to DataFrames — the two-dimensional structure built from Series. You'll learn how to combine multiple Series into a DataFrame, manipulate columns, and perform more complex analyses. With your Series grasp, the leap to DataFrames will feel natural.

Keep this cheat sheet in mind: a Series is a labeled array; operations are vectorized; indexes align; missing data is normal — deal with it early.