Pandas Series — Creation, Indexing, Operations & Methods

A Pandas Series is a one-dimensional labelled array capable of holding data of any type — integers, floats, strings, booleans, or Python objects. It has two components:

• Index: Labels for each element. If not specified, defaults to 0, 1, 2, ...
• Values: The actual data stored in the Series.

import pandas as pd

s = pd.Series([10, 20, 30, 40, 50])
print(s)
# Output:
# 0    10
# 1    20
# 2    30
# 3    40
# 4    50
# dtype: int64

The left column (0, 1, 2...) is the index; the right column is the values. The last line shows the dtype (data type).

Method 1 — From a Python List

s1 = pd.Series([10, 20, 30, 40, 50])
# Default index: 0, 1, 2, 3, 4

# With custom index
s2 = pd.Series([10, 20, 30], index=['a', 'b', 'c'])
print(s2)
# a    10
# b    20
# c    30
# dtype: int64

Method 2 — From a Python Dictionary

Dictionary keys become the index; values become the data.

marks = pd.Series({'Maths': 95, 'Science': 88, 'English': 76})
print(marks)
# Maths      95
# Science    88
# English    76
# dtype: int64

Method 3 — From a NumPy Array (ndarray)

import numpy as np

arr = np.array([100, 200, 300])
s3 = pd.Series(arr, index=['a', 'b', 'c'])
print(s3)
# a    100
# b    200
# c    300
# dtype: int64

Method 4 — From a Scalar Value

A single value repeated for all index positions — index is mandatory when creating from scalar.

s4 = pd.Series(5, index=[0, 1, 2, 3])
print(s4)
# 0    5
# 1    5
# 2    5
# 3    5
# dtype: int64

s = pd.Series([10,20,30,40,50], index=['a','b','c','d','e'])

print(s.head(3))   # First 3 elements
# a    10
# b    20
# c    30
# dtype: int64

print(s.tail(2))   # Last 2 elements
# d    40
# e    50
# dtype: int64

print(s.head())    # Default: first 5 elements
print(s.tail())    # Default: last 5 elements

Key point: Default value of n in both head() and tail() is 5.

There are three ways to access elements in a Series:

s = pd.Series([10,20,30,40,50], index=['a','b','c','d','e'])

# Single element access
print(s['b'])          # 20  (label-based)
print(s.loc['b'])      # 20  (same)
print(s.iloc[1])       # 20  (position: index 1)

# Slicing — label-based (END INCLUDED)
print(s.loc['b':'d'])
# b    20
# c    30
# d    40   ← 'd' IS included

# Slicing — position-based (END EXCLUDED)
print(s.iloc[1:4])
# b    20
# c    30
# d    40   ← position 4 (e) is NOT included

Boolean indexing filters a Series by applying a condition — only elements satisfying the condition are returned.

marks = pd.Series([45, 78, 90, 55, 88],
                  index=['A', 'B', 'C', 'D', 'E'])

# Get all marks greater than 60
print(marks[marks > 60])
# B    78
# C    90
# E    88
# dtype: int64

# Multiple conditions using & (and) | (or)
print(marks[(marks >= 50) & (marks <= 80)])
# B    78
# D    55
# dtype: int64

Important: Use & (not and) and | (not or) for element-wise operations on Series. Always wrap each condition in parentheses ().

Arithmetic Operations

Operations are applied element-wise — and aligned by index label, not position.

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

print(s1 + s2)   # a=11, b=22, c=33
print(s1 * s2)   # a=10, b=40, c=90
print(s1 - s2)   # a=9,  b=18, c=27
print(s1 / s2)   # a=10.0, b=10.0, c=10.0

# Scalar operations
print(s1 + 5)    # a=15, b=25, c=35
print(s1 * 2)    # a=20, b=40, c=60

Index Alignment — NaN for Mismatched Labels

# When indices don't match, result is NaN
s3 = pd.Series([10, 20, 30], index=['a', 'b', 'c'])
s4 = pd.Series([1,  2,  3],  index=['b', 'c', 'd'])

print(s3 + s4)
# a     NaN    ← 'a' only in s3
# b    21.0   ← 20 + 1
# c    32.0   ← 30 + 2
# d     NaN   ← 'd' only in s4
# dtype: float64

Statistical Methods