Array Control and Iteration

🎮 NumPy Array Control & Iteration: Becoming the Master of Your Data

Imagine you’re a chef in a kitchen. You have bowls of ingredients (arrays). Sometimes you want to mix ingredients right in the bowl. Sometimes you want to check if a bowl is clean or dirty. Sometimes things go wrong and you need to handle mistakes. And sometimes you need to taste every single ingredient one by one. That’s exactly what we’re learning today!

🥣 In-Place Operations: Mixing Right in the Bowl

The Story

Picture this: You have a bowl of numbers. You want to double every number.

The old way: Get a new bowl, pour doubled numbers into it, throw away the old bowl.

The smart way: Just double everything inside the same bowl. No new bowl needed!

This is in-place operations. We change the array directly without making a copy. It saves memory and is faster!

How It Works

import numpy as np

# Create our bowl of numbers
numbers = np.array([1, 2, 3, 4, 5])

# OLD WAY: Creates a new array (wastes memory)
result = numbers * 2  # new bowl!

# IN-PLACE WAY: Changes the original
numbers *= 2  # same bowl, doubled!
print(numbers)  # [2, 4, 6, 8, 10]

The Magic Operators

Using NumPy Functions In-Place

arr = np.array([1.0, 2.0, 3.0])

# The out= parameter does in-place!
np.sqrt(arr, out=arr)  # Same array now has square roots
print(arr)  # [1.0, 1.414..., 1.732...]

# add() with out parameter
a = np.array([1, 2, 3])
b = np.array([4, 5, 6])
np.add(a, b, out=a)  # Result goes into 'a'
print(a)  # [5, 7, 9]

⚠️ Watch Out!

# This WON'T work in-place:
arr = arr + 5  # Creates new array!

# This WILL work in-place:
arr += 5  # Modifies original!

🏷️ Array Flags: The Label on Your Bowl

The Story

Every bowl in your kitchen has a label. Is it microwave-safe? Can you write on it? Is it yours or borrowed?

NumPy arrays have flags - labels that tell you important things about the array.

Check Your Flags

arr = np.array([[1, 2, 3],
                [4, 5, 6]])

print(arr.flags)

This shows:

C_CONTIGUOUS : True
F_CONTIGUOUS : False
OWNDATA : True
WRITEABLE : True
ALIGNED : True

What Each Flag Means

graph TD
    A["Array Flags"] --> B["C_CONTIGUOUS"]
    A --> C["F_CONTIGUOUS"]
    A --> D["OWNDATA"]
    A --> E["WRITEABLE"]
    A --> F["ALIGNED"]

    B --> B1["Stored row-by-row<br/>Like reading a book"]
    C --> C1["Stored column-by-column<br/>Like reading down"]
    D --> D1[Owns its memory<br/>It's your bowl!]
    E --> E1["Can be modified&lt;br/&gt;Not locked"]
    F --> F1["Memory is aligned&lt;br/&gt;Works fast"]

Simple Explanations

Checking Individual Flags

arr = np.array([1, 2, 3])

# Check one flag at a time
print(arr.flags.writeable)    # True
print(arr.flags.c_contiguous) # True
print(arr.flags.owndata)      # True

Making an Array Read-Only

arr = np.array([1, 2, 3])
arr.flags.writeable = False  # Lock it!

arr[0] = 99  # ERROR! Can't write!

This is great for protecting important data!

Views Don’t Own Data

original = np.array([1, 2, 3, 4, 5])
view = original[1:4]  # A view, not a copy

print(view.flags.owndata)  # False - borrowed bowl!
print(original.flags.owndata)  # True - owns it

🚨 Error Handling in NumPy: When Things Go Wrong

The Story

What happens when you try to divide by zero? Or take the square root of -1? In regular math, everything explodes. NumPy is smarter - it lets you control what happens!

The Three Ways NumPy Can React

graph TD
    A["Something Goes Wrong"] --> B{What Should NumPy Do?}
    B --> C["warn - Tell me but continue"]
    B --> D["raise - Stop everything!"]
    B --> E["ignore - Stay quiet"]

Common Errors

import numpy as np

# Division by zero
result = np.array([1, 2, 3]) / np.array([1, 0, 1])
print(result)  # [1.0, inf, 3.0] - gives infinity!

# Invalid operation (0/0)
result = np.array([0, 1]) / np.array([0, 1])
print(result)  # [nan, 1.0] - gives nan (not a number)

# Square root of negative
result = np.sqrt(np.array([-1, 4]))
print(result)  # [nan, 2.0] - gives nan

Control Error Behavior with seterr

# See current settings
print(np.geterr())
# {'divide': 'warn', 'over': 'warn', ...}

# Change settings
np.seterr(divide='ignore')  # Quiet about divide
np.seterr(invalid='raise')  # Crash on invalid

# Set all at once
np.seterr(all='warn')  # Warn about everything

Error Types

Temporary Error Settings

# Only change settings for one section
with np.errstate(divide='ignore'):
    result = np.array([1, 2]) / np.array([0, 1])
    # No warning here!

# Back to normal settings outside the block

Checking for Bad Values

arr = np.array([1, np.nan, np.inf, 2])

print(np.isnan(arr))   # [False, True, False, False]
print(np.isinf(arr))   # [False, False, True, False]
print(np.isfinite(arr))# [True, False, False, True]

🔄 Iterating with nditer: Tasting Every Ingredient

The Story

You’re a chef who needs to taste every ingredient in every bowl. With regular loops, it’s slow and clumsy. nditer is like having a robot helper that efficiently goes through everything!

The Basic Way (Slow)

arr = np.array([[1, 2],
                [3, 4]])

# Old way - works but slow
for row in arr:
    for item in row:
        print(item)

The nditer Way (Fast & Smart)

arr = np.array([[1, 2],
                [3, 4]])

# Smart way - flat iteration
for x in np.nditer(arr):
    print(x)  # 1, 2, 3, 4

Modifying Values with nditer

arr = np.array([[1, 2],
                [3, 4]])

# Use op_flags to modify
for x in np.nditer(arr, op_flags=['readwrite']):
    x[...] = x * 2  # Double each value!

print(arr)  # [[2, 4], [6, 8]]

The x[...] Magic

Why x[...] instead of x = x * 2?

• x = something creates a new variable
• x[...] = something changes the actual array value

Think of it like writing on a sticky note vs. writing in the actual book!

Control the Order

arr = np.array([[1, 2, 3],
                [4, 5, 6]])

# C-order (row by row)
print("C-order:")
for x in np.nditer(arr, order='C'):
    print(x, end=' ')  # 1 2 3 4 5 6

# Fortran-order (column by column)
print("\nF-order:")
for x in np.nditer(arr, order='F'):
    print(x, end=' ')  # 1 4 2 5 3 6

Getting Index While Iterating

arr = np.array([[1, 2],
                [3, 4]])

# Track the index with flags
it = np.nditer(arr, flags=['multi_index'])
for x in it:
    print(f"Index {it.multi_index}: {x}")

# Output:
# Index (0, 0): 1
# Index (0, 1): 2
# Index (1, 0): 3
# Index (1, 1): 4

External Loop for Performance

arr = np.array([[1, 2, 3, 4],
                [5, 6, 7, 8]])

# Process in chunks (faster!)
for x in np.nditer(arr, flags=['external_loop'],
                   order='C'):
    print(x)  # [1 2 3 4 5 6 7 8]

Iterating Multiple Arrays Together

a = np.array([1, 2, 3])
b = np.array([4, 5, 6])

# Both at the same time!
for x, y in np.nditer([a, b]):
    print(f"{x} + {y} = {x + y}")

# Output:
# 1 + 4 = 5
# 2 + 5 = 7
# 3 + 6 = 9

🎯 Quick Summary

graph TD
    A["Array Control & Iteration"] --> B["In-Place Ops"]
    A --> C["Array Flags"]
    A --> D["Error Handling"]
    A --> E["nditer"]

    B --> B1["+=, -=, *=, /=<br/>out= parameter"]
    C --> C1["WRITEABLE<br/>OWNDATA<br/>C_CONTIGUOUS"]
    D --> D1["seterr#40;#41;<br/>errstate#40;#41;<br/>isnan#40;#41;, isinf#40;#41;"]
    E --> E1["Flat iteration<br/>multi_index<br/>readwrite"]

🚀 You Made It!

You now know how to:

✅ Modify arrays without wasting memory (in-place operations)

✅ Check array properties (flags)

✅ Handle mathematical errors gracefully (error handling)

✅ Efficiently loop through any array (nditer)

You’re becoming a NumPy master! These skills will make your code faster, safer, and smarter. Keep practicing! 🎉