Python Pandas Series Tutorial with Examples

The Pandas Series is one of the primary data structures in the Pandas library.

It is a one-dimensional labeled array capable of holding any data type, such as integers, floats, strings, and even Python objects.

A Series is similar to a column in an Excel sheet or a single column in a DataFrame. Each element in a Series is associated with a label, called an index.

In this tutorial, we will cover:

1. Creating a Series
2. Accessing Data in a Series
3. Performing Operations on Series
4. Series Methods for Analysis
5. Applying Functions to Series
6. Handling Missing Data in a Series

Let's go through each section with code examples.

1. Creating a Series

There are several ways to create a Series in Pandas, such as using a Python list, dictionary, NumPy array, or scalar value.

Example 1: Creating a Series from a List

import pandas as pd

# Create a Series from a list
data = [10, 20, 30, 40, 50]
series = pd.Series(data)
print(series)

Output:

0    10
1    20
2    30
3    40
4    50
dtype: int64

• Explanation: Pandas automatically assigns an index to each element, starting from 0.

Example 2: Creating a Series with Custom Index

# Create a Series with a custom index
data = [100, 200, 300, 400]
index = ['A', 'B', 'C', 'D']
series = pd.Series(data, index=index)
print(series)

Output:

A    100
B    200
C    300
D    400
dtype: int64

• Explanation: You can specify custom labels (index) for each element. Here, A, B, C, and D are used as indexes.

Example 3: Creating a Series from a Dictionary

# Create a Series from a dictionary
data = {'x': 5, 'y': 10, 'z': 15}
series = pd.Series(data)
print(series)

Output:

x     5
y    10
z    15
dtype: int64

• Explanation: When creating a Series from a dictionary, the keys become the index, and the values become the data.

Example 4: Creating a Series with a Scalar Value

# Create a Series with a scalar value
scalar_series = pd.Series(5, index=['a', 'b', 'c'])
print(scalar_series)

Output:

a    5
b    5
c    5
dtype: int64

• Explanation: This creates a Series where every element is the same value (5), and custom indices are specified.

2. Accessing Data in a Series

You can access elements in a Series using either indexing or slicing.

Example 5: Accessing Elements by Position

# Access elements by position
data = [10, 20, 30, 40]
series = pd.Series(data)
print(series[1])  # Access the element at index 1

Output:

20

Example 6: Accessing Elements by Label

# Access elements by label
data = [100, 200, 300]
index = ['a', 'b', 'c']
series = pd.Series(data, index=index)
print(series['b'])  # Access element with index 'b'

Output:

200

Example 7: Slicing a Series

# Slicing a Series
data = [1, 2, 3, 4, 5]
series = pd.Series(data, index=['a', 'b', 'c', 'd', 'e'])
print(series['b':'d'])  # Slice from 'b' to 'd' (inclusive)

Output:

b    2
c    3
d    4
dtype: int64

• Explanation: When slicing by label, the end index is inclusive.

3. Performing Operations on Series

Series operations are element-wise, which means you can apply arithmetic operations directly.

Example 8: Basic Arithmetic Operations

# Basic arithmetic operations
series1 = pd.Series([1, 2, 3])
series2 = pd.Series([10, 20, 30])

# Addition
print(series1 + series2)

# Subtraction
print(series1 - series2)

Output:

0    11
1    22
2    33
dtype: int64
0    -9
1   -18
2   -27
dtype: int64

Example 9: Applying Operations with a Scalar

# Applying operations with a scalar
series = pd.Series([1, 2, 3])
print(series * 10)

Output:

0    10
1    20
2    30
dtype: int64

• Explanation: Each element in the Series is multiplied by 10.

4. Series Methods for Analysis

Pandas Series has built-in methods for quick data analysis.

Example 10: Summary Statistics

# Summary statistics
series = pd.Series([10, 20, 30, 40, 50])
print("Sum:", series.sum())
print("Mean:", series.mean())
print("Max:", series.max())
print("Min:", series.min())

Output:

Sum: 150
Mean: 30.0
Max: 50
Min: 10

• Explanation: These methods help quickly analyze numerical data in a Series.

Example 11: Using value_counts() to Count Unique Values

# Count unique values
data = ['apple', 'banana', 'apple', 'orange', 'banana', 'apple']
series = pd.Series(data)
print(series.value_counts())

Output:

apple     3
banana    2
orange    1
dtype: int64

5. Applying Functions to Series

You can apply custom functions to Series using the apply() method or by using functions like map() and lambda.

Example 12: Applying a Function with apply()

# Applying a custom function to each element
series = pd.Series([1, 4, 9, 16, 25])

# Square root function
import math
print(series.apply(math.sqrt))

Output:

0    1.0
1    2.0
2    3.0
3    4.0
4    5.0
dtype: float64

• Explanation: apply(math.sqrt) applies the math.sqrt function to each element in the Series.

Example 13: Using Lambda Functions

# Using lambda functions
series = pd.Series([10, 20, 30])
print(series.apply(lambda x: x * 2))  # Multiply each element by 2

Output:

0    20
1    40
2    60
dtype: int64

• Explanation: apply(lambda x: x * 2) multiplies each element by 2.

6. Handling Missing Data in a Series

Pandas Series can handle missing data (NaN), and there are methods to fill or drop missing values.

Example 14: Detecting Missing Values

# Detecting missing values
series = pd.Series([1, None, 3, None, 5])
print(series.isnull())  # Returns True for NaN values

Output:

0    False
1     True
2    False
3     True
4    False
dtype: bool

Example 15: Filling Missing Values

# Filling missing values
series = pd.Series([1, None, 3, None, 5])
print(series.fillna(0))  # Replace NaN values with 0

Output:

0    1.0
1    0.0
2    3.0
3    0.0
4    5.0
dtype: float64

• Explanation: fillna(0) replaces all NaN values with 0.

Example 16: Dropping Missing Values

# Dropping missing values
series = pd.Series([1, None, 3, None, 5])
print(series.dropna())  # Remove rows with NaN values

Output:

0    1.0
2    3.0
4    5.0
dtype: float64

• Explanation: dropna() removes any element that has NaN.

Summary of Key Pandas Series Concepts

Conclusion

In this tutorial, we explored the Pandas Series object, covering:

• Creating Series from various data sources (lists, dictionaries, scalars).
• Accessing and slicing Series data.
• Performing arithmetic operations on Series.
• Applying functions and handling missing data.