GCI World September 2026 Session 2 During Lecture

Main ideas / lessons conveyed

Purpose of the series (GCI lecture track)

• Lecture 2 focuses on efficient data manipulation in Python using NumPy.
• Across the next three lectures, the course covers different Python libraries commonly used for data science.
• This lecture specifically covers:
  • 1D arrays (creation, universal functions, broadcasting, aggregation, indexing)
  • 2D arrays (axis handling, indexing/slicing, advanced/boolean indexing)
• It intentionally skips:
  • 3D+ arrays
  • deeper machine learning model building
  • deep linear algebra

---

Review of key Python basics needed before NumPy

Before working with NumPy, you should already be comfortable with:

• Variables: names that reference objects/values.
• Operators: arithmetic and comparison operators.
• Collections:
  • Lists (ordered; elements accessed by index)
  • 2D lists as “lists of lists”
• Indexing/slicing to extract elements or subarrays.
• for-loops to repeat operations over iterables.

---

What data mining / analytics workflow is (high-level framing)

• Data mining: discovering/extracting insights from large datasets.
• A framework described as Christm follows a progression:
  • business problem → data preparation → modeling → evaluation → expansion of findings
• NumPy’s role here: basic data manipulation to turn raw data into analysis-ready data.

---

What NumPy is and why it matters

• NumPy is designed for large multi-dimensional arrays via numpy.ndarray.
• Core performance/enabling ideas:
  • Universal functions (ufuncs) enable elementwise operations without explicit loops
  • NumPy is primarily written in C, making it fast
  • It is a broad scientific computing function library
• Key contrast:
  • NumPy array math like A + B performs elementwise addition
  • Python list + concatenates lists instead (not elementwise)

---

How to work with arrays in NumPy (conceptual methodology)

• Import NumPy
  • Common alias: import numpy as np
• Create arrays
  • Convert list-like data into NumPy arrays using np.array(...)
• Convert back to lists
  • Use .tolist()
• Use ufuncs / elementwise operations
  • Addition/subtraction/multiplication/division apply element-by-element
  • Supports many math functions (exp/log/trig, etc.)
• Handle numerical quirks
  • Division by zero yields inf / -inf and warnings rather than stopping with an exception

---

1D arrays

Main features

• Array length: len(array)
• Shape: array.shape (dimensions info)
• Universal elementwise math
  • Example ideas:
    • convert units: array / 10
    • derived arrays: tmax - tmin
• Conditional / comparison operations
  • Comparisons like A == B and A > B produce boolean arrays used for filtering

---

Broadcasting (explicit concept + behavior rules)

• Broadcasting lets operations work between arrays/scalars of different shapes by automatically expanding the smaller operand when compatible.
• Examples described:
  • Array + scalar: scalar is repeated to match array shape
  • Incompatible shapes: broadcasting fails when neither dimension is 1 (e.g., sizes 5 and 2)
• Broadcasting is also stated to apply beyond 1D (to multi-dimensional arrays and advanced indexing rules).

---

Aggregate/statistics functions

• Examples: max, sum, mean, standard deviation
• In NumPy, these are computed efficiently and (for multi-dimensional arrays) can be computed along specified axes.

---

Indexing and slicing in 1D

• Basic indexing
  • A[i] (0-based)
• Negative indexing
  • -1 is the last element, -2 is second-to-last, etc.
• Slicing
  • start:end:step (end is exclusive)
  • Defaults apply when start/end/step are omitted
  • Example idea: 1:7:2 extracts elements at indices 1, 3, 5

---

2D arrays

Main features

• Creation
  • Nest lists to create rows/columns (matrix structure)
  • Use np.array and also reshape to reorganize elements into desired dimensions
    • total element count must match
    • can use -1 in reshape to infer one dimension
• Universal functions extend to 2D
  • Elementwise arithmetic on corresponding cells
• Axis concept (crucial for 2D)
  • axis 0: typically rows direction
  • axis 1: columns direction
  • Many operations (especially aggregation) require specifying axis
• 2D aggregation by axis
  • np.max(..., axis=0): column-wise aggregation (one value per column)
  • np.max(..., axis=1): row-wise aggregation
  • Similar behavior applies to sum/min/mean/std, etc.

---

2D indexing: basic, advanced, boolean

• Basic 2D indexing
  • A[row_index, col_index]
  • Negative indexing works similarly
• Slicing in 2D
  • Colon : selects all elements along an axis
  • Examples:
    • take a column: A[:, j]
    • take submatrices: using slices like A[i:j, k:l]
• Advanced indexing
  • Extract scattered elements (non-contiguous)
  • Rules mentioned:
    • Axis-wise indexing: provide index sets per axis
    • Shape/position preservation: output shape relates to index arrangement
    • Omitting notation: simplified forms can improve readability (broadcasting-style)
• Boolean indexing
  • Build a boolean mask from conditions (e.g., A % 3 == 0)
  • Filter with the mask (returns only matching elements)
  • Notebook context:
    • In precipitation data, sentinel value 9999.9 indicates missing/incorrect data
    • Boolean indexing filters these out or identifies them

---

Instructional / methodology bullet list (as presented)

NumPy setup

• Import NumPy:
  • import numpy as np
• (Optional alternative import):
  • from numpy import <module or function> (conceptually mentioned)

---

Create and convert arrays

• Create a NumPy ND array:
  • a = np.array(list_like_input)
• Convert ND array back to a Python list:
  • a_list = a.tolist()

---

Elementwise computation using ufuncs

• Perform arithmetic directly:
  • C = A + B (elementwise)
  • Same idea for subtraction and multiplication
• Use NumPy math functions (conceptually):
  • exponential, trigonometric, logarithmic operations, etc.

---

Broadcasting approach

• Add/multiply scalars with arrays:
  • scalar is broadcast to match array shape
• For two arrays of different shapes:
  • broadcasting works only when dimensions are compatible (typically one dimension is 1)
  • otherwise it raises an error

---

Aggregation/statistics

• Use aggregate functions:
  • np.max(array), np.sum(array), np.mean(array), np.std(array) (conceptually)
• For multi-dimensional arrays:
  • use axis=... to choose row-wise vs column-wise reductions
  • optionally use keepdims=True to preserve dimensionality

---

Indexing and slicing (1D then 2D)

• 1D basic indexing
  • A[i] (0-based)
  • A[-1] for last element
• 1D slicing
  • A[start:end:step] (end exclusive)
  • omit start/end/step for defaults
• 2D basic indexing
  • A[row, col]
• 2D slicing
  • A[:, j] means “all rows at column j”
  • A[i:j, k:l] extracts a submatrix
• 2D advanced indexing
  • Provide row indices and column indices as separate index lists/arrays
  • Ensure understanding of output shape preservation
  • Use simplified indexing notation (broadcasting-compatible) when possible
• 2D boolean indexing
  • Create a mask:
    • mask = <condition on A>
  • Filter:
    • A[mask]

---

Notebook practice workflow (examples discussed)

Practice question 2.1 (conceptual steps)

• Create two 1D arrays of length 3:
  • even numbers (e.g., [2,4,6])
  • odd numbers (e.g., [1,3,5])
• Confirm array type is numpy.ndarray
• Perform addition and verify it is elementwise:
  • NumPy: [2,4,6] + [1,3,5] → [3,7,11]
• Contrast with Python list behavior:
  • list + concatenates instead of adding elementwise

Practice question 2.2 (conceptual steps for Mondays in January)

• Extract maximum temperatures for all Mondays using slicing rules:
  • account for the fact that Jan 1 is a Friday
  • step through days at 7-day intervals
• Compute:
  • mean/average maximum over those Mondays
  • standard deviation over those Mondays

General approach recommended

• If information feels heavy:
  • focus on the easier parts first
• Then revisit recordings/slides and practice.

---

Dataset usage described

• Uses a public Noah dataset (weather observations).
• Dataset structure:
  • 2D table where rows are entries and columns are attributes such as:
    • station name, elevation, latitude/longitude, date fields, etc.
  • Includes columns for:
    • maximum temperature (Tmax)
    • minimum temperature (Tmin)
    • precipitation (PRCP)
• Data loading:
  • np.loadtxt mentioned to load the dataset as raw
• In-lecture usage:
  • selects the first week
  • later uses January 2010 for indexing/slicing practice

---

Speakers / sources featured

• Lecture instructor / presenter (unnamed in subtitles):
  • leads the NumPy lecture and explains concepts
• Session leader / additional instructor voice (unnamed):
  • appears during practice segments and discusses notebook access/practice guidance
• Dataset source:
  • NOAA / Noah dataset (as referenced in subtitles)
• Framework mentioned:
  • “Christm” (acronym/term as spoken; exact expansion not provided in subtitles)