Interactive Session 3C

Arrays and Series

An illustration depicting the idea of arrays and series. MidJourney 5

Getting Started

Before we begin our interactive session, please follow these steps to set up your Jupyter Notebook:

  1. Open JupyterLab and create a new notebook:
    • Click on the + button in the top left corner
    • Select Python 3.10.0 from the Notebook options
  2. Rename your notebook:
    • Right-click on the Untitled.ipynb tab
    • Select β€œRename”
    • Name your notebook with the format: Session_XY_Topic.ipynb (Replace X with the day number and Y with the session number)
  3. Add a title cell:
    • In the first cell of your notebook, change the cell type to β€œMarkdown”
    • Add the following content (replace the placeholders with the actual information):
# Day X: Session Y - [Session Topic]

[Link to session webpage]

Date: [Current Date]
  1. Add a code cell:
    • Below the title cell, add a new cell
    • Ensure it’s set as a β€œCode” cell
    • This will be where you start writing your Python code for the session
  2. Throughout the session:
    • Take notes in Markdown cells
    • Copy or write code in Code cells
    • Run cells to test your code
    • Ask questions if you need clarification
Caution

Remember to save your work frequently by clicking the save icon or using the keyboard shortcut (Ctrl+S or Cmd+S).

Let’s begin our interactive session!

Introduction

In this interactive session, we’ll explore the most essential aspects of NumPy arrays and Pandas Series. These fundamental data structures are crucial for data manipulation and analysis in Python. We’ll focus on the key concepts that are most relevant for beginning data scientists. We’re also going to assume that you will primarily work with Pandas DataFrames and Series, so we won’t spend too much time on the details of NumPy arrays.

Let’s start by importing the necessary libraries:

Code 
import numpy as np
import pandas as pd

NumPy Arrays: The Foundation

NumPy arrays are the building blocks for many data structures in Python, including Pandas Series and DataFrames. Let’s explore their basic properties and operations.

Creating NumPy Arrays

Code 
# Create a 1D array
arr_1d = np.array([1, 2, 3, 4, 5])
print("1D array:", arr_1d)

# Create a 2D array
arr_2d = np.array([[1, 2, 3], [4, 5, 6]])
print("2D array:\n", arr_2d)
1D array: [1 2 3 4 5]
2D array:
 [[1 2 3]
 [4 5 6]]

Basic Array Operations

Code 
# Array arithmetic
print("Array + 2:", arr_1d + 2)
print("Array * 2:", arr_1d * 2)

# Array statistics
print("Mean:", np.mean(arr_1d))
print("Sum:", np.sum(arr_1d))
Array + 2: [3 4 5 6 7]
Array * 2: [ 2  4  6  8 10]
Mean: 3.0
Sum: 15

Now it’s your turn! Create a NumPy array of your favorite numbers and calculate its standard deviation (np.std()).

Pandas Series: Building on NumPy

Pandas Series are one-dimensional labeled arrays built on top of NumPy arrays. They’re like a column in a spreadsheet or a single column of a DataFrame.

Creating Pandas Series

Code 
# Create a Series from a list
s1 = pd.Series([1, 2, 3, 4, 5])
print("Series from list:\n", s1)

# Create a Series with custom index
s2 = pd.Series([10, 20, 30, 40, 50], index=['a', 'b', 'c', 'd', 'e'])
print("\nSeries with custom index:\n", s2)
Series from list:
 0    1
1    2
2    3
3    4
4    5
dtype: int64

Series with custom index:
 a    10
b    20
c    30
d    40
e    50
dtype: int64

Basic Series Operations

Code 
# Accessing elements
print("Element at index 'c':", s2['c'])
print("First three elements:\n", s2[:3])

# Series arithmetic
print("\nSeries + 5:\n", s2 + 5)

# Series statistics
print("\nMean:", s2.mean())
print("Median:", s2.median())
Element at index 'c': 30
First three elements:
 a    10
b    20
c    30
dtype: int64

Series + 5:
 a    15
b    25
c    35
d    45
e    55
dtype: int64

Mean: 30.0
Median: 30.0

Your turn! Create a Pandas Series representing daily temperatures for a week. Use the days of the week as the index. Then, calculate and print the maximum temperature.

Comparing NumPy Arrays and Pandas Series

Let’s explore some key differences and similarities between NumPy arrays and Pandas Series.

Code 
# Create a NumPy array and a Pandas Series with the same data
np_arr = np.array([1, 2, 3, 4, 5])
pd_series = pd.Series([1, 2, 3, 4, 5])

print("NumPy array:", np_arr)
print("Pandas Series:\n", pd_series)

# Demonstrate label-based indexing in Pandas Series
pd_series.index = ['a', 'b', 'c', 'd', 'e']
print("\nPandas Series with custom index:\n", pd_series)
print("Value at index 'c':", pd_series['c'])

# Show that NumPy operations work on Pandas Series
print("\nSquare root of Pandas Series:\n", np.sqrt(pd_series))
NumPy array: [1 2 3 4 5]
Pandas Series:
 0    1
1    2
2    3
3    4
4    5
dtype: int64

Pandas Series with custom index:
 a    1
b    2
c    3
d    4
e    5
dtype: int64
Value at index 'c': 3

Square root of Pandas Series:
 a    1.000000
b    1.414214
c    1.732051
d    2.000000
e    2.236068
dtype: float64

Now it’s your turn! Create a NumPy array and a Pandas Series, both containing the same data (use any numbers you like). Then, calculate the mean of both and compare the results. Are they the same? Why or why not?

Conclusion

In this session, we’ve covered the essential aspects of NumPy arrays and Pandas Series. Remember:

  1. NumPy arrays are the foundation for numerical computing in Python.
  2. Pandas Series build on NumPy arrays, adding labeled axes and additional functionality.
  3. Both support fast operations on entire datasets without explicit loops.
  4. Pandas Series are particularly useful for labeled data and seamlessly integrate with DataFrames.

As you continue your journey in data science, you’ll find these structures invaluable for efficient data manipulation and analysis.

End interactive session 3C