# Import the libraries

# My essential data science toolkit
import time 
import sys
import numpy as np  # The backbone of numerical computing
import matplotlib.pyplot as plt  # For creating insightful visualizations

# Enable inline plotting for Jupyter notebooks
%matplotlib inline

print("NumPy version:", np.__version__)
print("Environment ready for numerical computing!")

# My custom visualization functions for vector operations
# These help me understand the geometric interpretation of array operations

def plot_three_vectors(u, z, v):
    """
    Visualize three vectors to understand addition operations.
    I use this to see how vector addition works geometrically.
    """
    ax = plt.axes()
    ax.arrow(0, 0, *u, head_width=0.05, color='red', head_length=0.1, label='Vector u')
    plt.text(*(u + 0.1), 'u', fontsize=12, fontweight='bold')
    
    ax.arrow(0, 0, *v, head_width=0.05, color='blue', head_length=0.1, label='Vector v')
    plt.text(*(v + 0.1), 'v', fontsize=12, fontweight='bold')
    
    ax.arrow(0, 0, *z, head_width=0.05, color='green', head_length=0.1, label='Result z')
    plt.text(*(z + 0.1), 'z=u+v', fontsize=12, fontweight='bold')
    
    plt.ylim(-2, 2)
    plt.xlim(-2, 2)
    plt.grid(True, alpha=0.3)
    plt.title('Vector Addition Visualization')
    plt.axhline(y=0, color='k', linewidth=0.5)
    plt.axvline(x=0, color='k', linewidth=0.5)

def plot_two_vectors(a, b):
    """
    Compare two vectors side by side.
    Perfect for understanding relationships between different vectors.
    """
    ax = plt.axes()
    ax.arrow(0, 0, *a, head_width=0.05, color='red', head_length=0.1)
    plt.text(*(a + 0.1), 'a', fontsize=12, fontweight='bold')
    
    ax.arrow(0, 0, *b, head_width=0.05, color='blue', head_length=0.1)
    plt.text(*(b + 0.1), 'b', fontsize=12, fontweight='bold')
    
    plt.ylim(-2, 2)
    plt.xlim(-2, 2)
    plt.grid(True, alpha=0.3)
    plt.title('Vector Comparison')
    plt.axhline(y=0, color='k', linewidth=0.5)
    plt.axvline(x=0, color='k', linewidth=0.5)

print("Visualization functions loaded successfully!")

# A typical mixed-type Python list from my early programming days

my_mixed_data = ["score", 85, "grade", "A", 92]
print("My mixed list:", my_mixed_data)
print("List type:", type(my_mixed_data))

# Accessing elements the traditional way
print("Element at index 0:", my_mixed_data[0])
print("Element at index 1:", my_mixed_data[1])
print("Element at index 2:", my_mixed_data[2])
print("Element at index 3:", my_mixed_data[3])
print("Element at index 4:", my_mixed_data[4])

print("\nThis approach works, but becomes inefficient for large numerical datasets!")

a[0]: 0
a[1]: 1
a[2]: two
a[3]: 3
a[4]: 4

# The foundation of my numerical computing toolkit

import numpy as np
print("NumPy imported - ready for high-performance numerical operations!")

# Creating my first NumPy array
my_scores = np.array([85, 88, 92, 79, 95])
print("My NumPy array:", my_scores)
print("Array type:", type(my_scores))
print("Element type:", my_scores.dtype)
print("Array shape:", my_scores.shape)

array([0, 1, 2, 3, 4])

# Accessing individual scores
print("First score:", my_scores[0])
print("Second score:", my_scores[1])
print("Third score:", my_scores[2])
print("Fourth score:", my_scores[3])
print("Fifth score:", my_scores[4])

print("\nBut NumPy offers much more powerful ways to work with this data!")

a[0]: 0
a[1]: 1
a[2]: 2
a[3]: 3
a[4]: 4

# Checking the overall array type
array_type = type(my_scores)
print("Array type:", array_type)
print("This tells me I'm working with a NumPy ndarray (n-dimensional array)")

numpy.ndarray

# Check the type of the values stored in numpy array

a.dtype

# Understanding the element data type
data_type = my_scores.dtype
print("Element data type:", data_type)
print("This means each element is a 64-bit integer")
print("Memory efficient and perfect for mathematical operations!")

dtype('int64')

# Create a numpy array

my_gpa_data = np.array([3.85, 3.92, 3.76, 3.88, 3.95])
print("My GPA data:", my_gpa_data)
print("Data type:", my_gpa_data.dtype)

# Confirming it's still a NumPy array
print("Array type:", type(my_gpa_data))
print("Same NumPy ndarray type, different element precision")

numpy.ndarray

# Examining the float data type
print("Float data type:", my_gpa_data.dtype)
print("This gives me 64-bit precision for accurate decimal calculations")
print("Perfect for statistical analysis and data science!")

# Check the value type

b.dtype

dtype('float64')

# Sample test scores that need correction
test_scores = np.array([78, 85, 92, 88, 91])
print("Original test scores:", test_scores)

array([20,  1,  2,  3,  4])

# Correcting the first score
test_scores[0] = 82  # Updated from 78 to 82
print("Corrected scores:", test_scores)
print("Successfully updated the first score!")

array([100,   1,   2,   3,   4])

scores = [90, 85, 75, 60, 0]

# Updating the last score

test_scores[4] = 94  # Improved from 91 to 94
print("Final updated scores:", test_scores)
print("Data correction complete!")

array([100,   1,   2,   3,   0])

# Extracting middle three scores (indices 1, 2, 3)
middle_scores = test_scores[1:4]
print("Original scores:", test_scores)
print("Middle three scores:", middle_scores)
print("Slicing notation: [1:4] means start at index 1, stop before index 4")

array([1, 2, 3])

# Original test scores
test_scores = [85, 90, 75, 80, 70]

# Displaying original scores
print("Original test scores:", test_scores)

# Batch updating the last two scores (bonus points scenario)
test_scores[3:5] = 95, 98  # Giving bonus points
print("After bonus adjustment:", test_scores)
print("Successfully updated multiple scores at once!")

array([100,   1,   2, 300, 400])

# Create the index list

# Selecting specific positions (first, third, and fourth scores)
selected_indices = [0, 2, 3]
print("Index list for selection:", selected_indices)

# Fancy indexing - selecting specific elements
selected_scores = test_scores[selected_indices]
print("Original scores:", test_scores)
print("Selected scores:", selected_scores)
print("This technique is invaluable for data analysis!")

array([100,   2, 300])

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

# Applying grade curve to selected scores
test_scores[selected_indices] = 90, 97, 99
print("After grade curve application:", test_scores)
print("Selective updates make data manipulation very flexible!")

array([100000,      1, 100000, 100000,    400])

# Sample dataset for attribute exploration
my_data = np.array([75, 82, 88, 91, 79, 86, 93, 77, 85, 90])
print("My dataset:", my_data)
print("Let's explore its properties...")

array([0, 1, 2, 3, 4])

# Get the size of numpy array

a.size

# Understanding dataset size
data_size = my_data.size
print(f"Number of data points: {data_size}")
print(f"Perfect sample size for basic statistical analysis!")

5

# Get the number of dimensions of numpy array

a.ndim

# Checking array dimensions
dimensions = my_data.ndim
print(f"Number of dimensions: {dimensions}")
print("One dimension means this is a simple vector - perfect for basic analysis!")

1

# Get the shape/size of numpy array

a.shape

# Understanding array shape
array_shape = my_data.shape
print(f"Array shape: {array_shape}")
print(f"This confirms I have {array_shape[0]} elements in a 1D structure")

(5,)

# Create a numpy array

a = np.array([1, -1, 1, -1])




print("Performance data:", performance_data)performance_data = np.array([85, 78, 92, 88, 76, 94, 81, 87])

Let me demonstrate some essential statistical operations I use regularly in my data analysis:# Sample data representing performance variations
### Statistical Analysis with NumPy

# Get the mean of numpy array

mean = a.mean()
mean

# Calculating mean performance
average_performance = performance_data.mean()
print(f"Average performance: {average_performance:.2f}")
print("This gives me the central tendency of my data")

0.0

# Measuring performance variability

# Get the standard deviation of numpy array
standard_deviation = a.std()
standard_deviation

performance_std = performance_data.std()
print(f"Standard deviation: {performance_std:.2f}")
print("This tells me how consistent the performance is")

1.0

# Create a numpy array

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

# New dataset for range analysis
sales_data = np.array([150, 280, 190, 340, 220])
print("Sales data (in thousands):", sales_data)

array([-1,  2,  3,  4,  5])

# Finding peak performance

# Get the biggest value in the numpy array
max_b = b.max()

max_sales = sales_data.max()
print(f"Highest sales: ${max_sales}k")
print("This identifies my best performing period")

5

# Identifying lowest performance
min_sales = sales_data.min()
print(f"Lowest sales: ${min_sales}k")
print(f"Range: ${min_sales}k to ${max_sales}k")
print("This shows the full performance spectrum")

# Get the smallest value in the numpy array

min_b = b.min()
min_b

-1

import numpy as np

# First metric vector (e.g., morning sales)
morning_sales = np.array([120, 85])
print("Morning sales vector:", morning_sales)

array([1, 0])

v = np.array([0, 1])
v

# Second metric vector (e.g., afternoon sales)
afternoon_sales = np.array([80, 140])
print("Afternoon sales vector:", afternoon_sales)

array([0, 1])

# Vector addition - combining daily sales

daily_total = morning_sales + afternoon_sales
print("Morning sales:", morning_sales)
print("Afternoon sales:", afternoon_sales)
print("Total daily sales:", daily_total)
print("Element-wise addition: [120+80, 85+140] = [200, 225]")

array([1, 1])

# Visualizing vector addition geometrically
plot_three_vectors(morning_sales, daily_total, afternoon_sales)
plt.title("Sales Vector Addition: Morning + Afternoon = Daily Total")
plt.xlabel("Sales Metric 1")
plt.ylabel("Sales Metric 2")
plt.show()

# Base performance metrics
base_metrics = np.array([100, 85])
print("Base performance metrics:", base_metrics)

array([1, 2])

# Numpy Array Multiplication

# Base metrics
base_metrics = 100

# Applying 20% increase (multiplying by 1.2)
projected_metrics = 1.2 * base_metrics
print("Base metrics:", base_metrics)
print("20% increase projection:", projected_metrics)
print("Each element scaled by the same factor")

array([2, 4])

# Quantity sold per product
quantities = np.array([50, 30])
print("Quantities sold:", quantities)

array([1, 2])

# Create a numpy array

v = np.array([3, 2])
v

# Unit prices per product
unit_prices = np.array([25, 40])
print("Unit prices:", unit_prices)

array([3, 2])

# Calculate the production of two numpy arrays

# Calculate revenue per product
revenue_per_product = quantities * unit_prices
print("Quantities:", quantities)
print("Unit prices:", unit_prices)
print("Revenue per product:", revenue_per_product)
print("Calculation: [50×25, 30×40] = [1250, 1200]")
print(f"Total revenue: ${revenue_per_product.sum()}")

array([3, 4])

# Calculate dot product for correlation analysis

dot_result = np.dot(quantities, unit_prices)

print("Quantities:", quantities)
print("Unit prices:", unit_prices)
print("Dot product:", dot_result)
print("Formula: (50×25) + (30×40) = 1250 + 1200 = 2450")
print("This single number captures the relationship between quantity and price!")

7

# Sample test scores needing adjustment
raw_scores = np.array([88, 92, 76, 85])
print("Raw test scores:", raw_scores)

array([ 1,  2,  3, -1])

# Applying bonus points to all scores
adjusted_scores = raw_scores + 5
print("Raw scores:", raw_scores)
print("Adjusted scores (+5 bonus):", adjusted_scores)
print("Broadcasting automatically applies the operation to every element!")

array([2, 3, 4, 0])

# The value of pie

np.pi

Let me create an array of important angles in radians for trigonometric analysis:

3.141592653589793

import numpy as np

# Key angles in radians for analysis
key_angles = np.array([0, np.pi/4, np.pi/2, np.pi, 3*np.pi/2, 2*np.pi])
print("Key angles (radians):", key_angles)
print("Corresponding degrees:", key_angles * 180 / np.pi)

# Create the numpy array in radians

x = np.array([0, np.pi/2 , np.pi])

Now I can apply trigonometric functions to analyze wave patterns, cycles, or periodic behavior:

---

## Data Generation with Linspace

# Calculate the sin of each elements

y = np.sin(x)
y

array([0.0000000e+00, 1.0000000e+00, 1.2246468e-16])

# Makeup a numpy array within [-2, 2] and 5 elements

np.linspace(-2, 2, num=5)

# Increasing the number of points gives me finer resolution - perfect for smooth plotting:

array([-2., -1.,  0.,  1.,  2.])

# Makeup a numpy array within [-2, 2] and 9 elements

import numpy as np

# For plotting mathematical functions, I typically use 100 or more points to ensure smooth curves:
x = np.linspace(-2, 2, num=100)

array([-2. , -1.5, -1. , -0.5,  0. ,  0.5,  1. ,  1.5,  2. ])

# Makeup a numpy array within [0, 2π] and 100 elements 

x = np.linspace(0, 2*np.pi, num=100)

Now I can apply any mathematical function to create beautiful, smooth curves:

import numpy as np
import matplotlib.pyplot as plt

# Generate x values
x = np.linspace(-2 * np.pi, 2 * np.pi, 1000)

# Calculate the sine of x list
y = np.sin(x)

# Create beautiful sine wave visualization
plt.figure(figsize=(12, 6))
plt.plot(x, y, 'b-', linewidth=2, label='sin(x)')
plt.grid(True, alpha=0.3)
plt.xlabel('x (radians)', fontsize=12)
plt.ylabel('sin(x)', fontsize=12)
plt.title('My Smooth Sine Wave Using NumPy Linspace', fontsize=14, fontweight='bold')
plt.axhline(y=0, color='k', linewidth=0.5)
plt.axvline(x=0, color='k', linewidth=0.5)
plt.legend()

# Add key points
key_x = np.array([0, np.pi/2, np.pi, 3*np.pi/2, 2*np.pi])
key_y = np.sin(key_x)
plt.scatter(key_x, key_y, color='red', s=50, zorder=5)

plt.tight_layout()
plt.show()

print("This demonstrates the power of NumPy for mathematical visualization!")

# Plot the result

plt.plot(x, y)

---

## Putting It All Together: Practice Exercises

[<matplotlib.lines.Line2D at 0x7fd1d145e550>]

# Write your code below and press Shift+Enter to execute

u = np.array([1, 0])
v = np.array([0, 1])
d = u-v
d
---

array([ 1, -1])

# Write your code below and press Shift+Enter to execute

z = np.array([2, 4])
d = -2*z
d

**Exercise 3:** Element-wise multiplication for selective analysis

I want to apply different weights to different data points:

array([-4, -8])

import numpy as np
import matplotlib.pyplot as plt

# Define the function to plot two vectors
def plot_two_vectors(u, v):
    plt.quiver(0, 0, u[0], u[1], angles='xy', scale_units='xy', scale=1, color = 'r', label='u',linewidth=1.5)
    plt.quiver(0, 0, v[0], v[1], angles='xy', scale_units='xy', scale=1, color = 'b', label='v',linewidth=1.5)
    plt.xlim(-2, 2)
    plt.ylim(-2, 2)
    plt.grid()
    plt.legend()

# Write your code below and press Shift+Enter to execute
u = np.array([1, 2, 3, 4, 5]) 
v = np.array([1, 0, 1, 0, 1])
u*v

# Vector relationship analysis
vector_u = np.array([-1, 1])
vector_v = np.array([1, 1])

# Calculate dot product
dot_product = np.dot(vector_u, vector_v)

# Visualize the vectors
plot_two_vectors(vector_u, vector_v)
plt.title('Vector Analysis: Checking Orthogonality')
plt.show()

print(f"Vector u: {vector_u}")
print(f"Vector v: {vector_v}")
print(f"Dot product: {dot_product}")
print(f"Angle relationship: {'Orthogonal (90°)' if dot_product == 0 else 'Not orthogonal'}")

array([1, 0, 3, 0, 5])

# Write your code below and press Shift+Enter to execute
# Write your code below and press Shift+Enter to execute
u = np.array([-1,1]) 
v = np.array([1,1])
Plotvec2(u, v)
print("The dot product is", np.dot(u,v))

---

The dot product is 0

# Write your code below and press Shift+Enter to execute
u = np.array([1,0]) 
v = np.array([0,1])
Plotvec2(u, v)
print("The dot product is", np.dot(u,v))

**Theoretical Insight:** Understanding Dot Product Patterns

Why do some vector pairs give zero dot products while others don't?

The dot product is 0

# Write your code below and press Shift+Enter to execute
u = np.array([1,1]) 
v = np.array([0,1])
Plotvec2(u, v)
print("The dot product is", np.dot(u,v))

The dot product is 1

My NumPy 1D Arrays Journey: Mastering Numerical Computing in Python¶

Why NumPy Arrays Changed My Data Science Game

Table of Contents

My Learning Path Today¶

What I'll Explore:¶

Setting Up My NumPy Environment {#setup}¶

From Python Lists to NumPy Arrays: My Journey {#transition}¶

The NumPy Revolution in My Workflow¶

Understanding NumPy Arrays: My Foundation {#fundamentals}¶

Understanding Data Types: Why They Matter in My Analysis¶

Modifying Array Values: Dynamic Data Updates¶

Array Slicing: My Tool for Data Extraction¶

Advanced Indexing: Selecting Specific Elements¶

Essential Array Attributes: Understanding My Data¶

Mathematical Operations: Where NumPy Shines¶

NumPy Array Operations: My Mathematical Toolkit {#operations}¶

Vector Addition: Combining Data Streams¶

Array Multiplication

Scalar Multiplication: Scaling My Data¶

Product of Two Numpy Arrays

Element-wise Multiplication: Combining Datasets¶

Dot Product: Measuring Similarity and Projection¶

Adding Constant to a Numpy Array

Broadcasting: Adding Constants Efficiently¶

Mathematical Functions: My Scientific Computing Arsenal {#math-functions}¶

Mathematical Functions

Mathematical constant π¶

Trigonometric analysis¶

Linspace: My Tool for Data Generation {#linspace}¶

Linspace

Creating evenly spaced samples¶

Higher resolution sampling¶

High-resolution data for smooth plotting¶

Generate smooth sine wave data¶

Practical Exercises: Testing My NumPy Skills {#practice}¶

Quiz on 1D Numpy Array

Performance difference analysis¶

Inverting growth data to show decline scenario¶

Classic orthogonal vectors¶

Non-orthogonal vector analysis¶

My Journey Summary and Next Steps¶

My Key Takeaways from NumPy 1D Arrays {#conclusion}¶

Technical Mastery Achieved:¶

Why This Matters for My Projects:¶

My Next Learning Goals:¶

Personal Reflection¶