📘 NumPy Basics: Arrays and Operations

Welcome to the amazing world of NumPy! 🎉 If you’ve ever tried to work with large datasets in pure Python and felt like you were swimming through molasses, NumPy is about to become your new best friend! 🏊‍♂️💨

NumPy (Numerical Python) is like giving your Python superpowers when it comes to working with numbers. Think of it as upgrading from a bicycle 🚲 to a sports car 🏎️ when dealing with mathematical operations!

📚 Understanding NumPy Arrays

NumPy arrays are like Python lists, but on steroids! 💪 While Python lists are great for general purposes, NumPy arrays are specifically designed for numerical computations.

Why NumPy Arrays? 🤔

Imagine you’re organizing a massive music festival 🎪:

• Python lists = Organizing attendees one by one at the gate
• NumPy arrays = Having pre-assigned sections where everyone knows exactly where to go!

import numpy as np

# 🐌 Python list operation (slow for large data)
python_list = [1, 2, 3, 4, 5]
squared_list = [x**2 for x in python_list]  # One by one...

# 🚀 NumPy array operation (super fast!)
numpy_array = np.array([1, 2, 3, 4, 5])
squared_array = numpy_array**2  # All at once! Whoosh!

print(f"Python list result: {squared_list}")  # [1, 4, 9, 16, 25]
print(f"NumPy array result: {squared_array}")  # [ 1  4  9 16 25]

🔧 Basic Syntax and Usage

Let’s start with the basics - creating and manipulating NumPy arrays! 🎯

Creating Arrays 🏗️

import numpy as np

# 📦 Creating arrays from lists
simple_array = np.array([1, 2, 3, 4, 5])
print(f"Simple array: {simple_array}")  # 👋 Hello, array!

# 🎲 Creating arrays with built-in functions
zeros_array = np.zeros(5)  # [0. 0. 0. 0. 0.] - Like empty boxes! 📦
ones_array = np.ones(5)    # [1. 1. 1. 1. 1.] - All filled! ✨
range_array = np.arange(0, 10, 2)  # [0 2 4 6 8] - Skip counting! 🦘

# 🎨 Creating 2D arrays (matrices)
matrix = np.array([[1, 2, 3],
                   [4, 5, 6],
                   [7, 8, 9]])
print("2D Array (Matrix):")
print(matrix)  # Like a spreadsheet! 📊

Basic Operations 🧮

# 🎯 Element-wise operations
arr1 = np.array([1, 2, 3, 4])
arr2 = np.array([5, 6, 7, 8])

# ➕ Addition
sum_array = arr1 + arr2  # [6, 8, 10, 12]

# ✖️ Multiplication
product_array = arr1 * arr2  # [5, 12, 21, 32]

# 🎪 Broadcasting - NumPy's magic trick!
scaled_array = arr1 * 10  # [10, 20, 30, 40] - Multiply all at once!

print(f"Addition: {sum_array}")
print(f"Multiplication: {product_array}")
print(f"Scaled by 10: {scaled_array}")

💡 Practical Examples

Let’s dive into some real-world examples that show NumPy’s power! 🌟

Example 1: Grade Calculator 📊

import numpy as np

# 🎓 Student test scores for a class
test_scores = np.array([
    [85, 92, 78, 95],  # Student 1
    [79, 88, 91, 87],  # Student 2
    [92, 95, 89, 94],  # Student 3
    [68, 75, 82, 79],  # Student 4
    [95, 98, 92, 96]   # Student 5
])

# 📈 Calculate statistics
student_averages = np.mean(test_scores, axis=1)  # Average per student
test_averages = np.mean(test_scores, axis=0)     # Average per test

print("🎯 Student Averages:")
for i, avg in enumerate(student_averages):
    print(f"  Student {i+1}: {avg:.1f}% {'🌟' if avg >= 90 else '📚'}")

print("\n📝 Test Averages:")
test_names = ['Math', 'Science', 'English', 'History']
for test, avg in zip(test_names, test_averages):
    print(f"  {test}: {avg:.1f}%")

# 🏆 Find the top performer
top_student = np.argmax(student_averages) + 1
print(f"\n🥇 Top student: Student {top_student} with {student_averages[top_student-1]:.1f}%!")

Example 2: Shopping Cart Analysis 🛒

import numpy as np

# 🛍️ Products: [price, quantity]
shopping_data = np.array([
    [2.99, 5],   # 🍎 Apples
    [1.49, 10],  # 🥕 Carrots
    [3.99, 2],   # 🥛 Milk
    [5.99, 3],   # 🍞 Bread
    [4.49, 4]    # 🧀 Cheese
])

prices = shopping_data[:, 0]
quantities = shopping_data[:, 1]

# 💰 Calculate totals
item_totals = prices * quantities
total_cost = np.sum(item_totals)
total_items = np.sum(quantities)

print("🛒 Shopping Cart Summary:")
products = ['Apples', 'Carrots', 'Milk', 'Bread', 'Cheese']
for product, total in zip(products, item_totals):
    print(f"  {product}: ${total:.2f}")

print(f"\n💳 Total: ${total_cost:.2f}")
print(f"📦 Items: {int(total_items)}")

# 🎯 Apply discount for bulk purchase
if total_items > 20:
    discount = total_cost * 0.1
    final_cost = total_cost - discount
    print(f"🎉 Bulk discount: -${discount:.2f}")
    print(f"✨ Final total: ${final_cost:.2f}")

Example 3: Weather Data Analysis 🌡️

import numpy as np

# 📅 Daily temperatures for a week (morning, afternoon, evening)
temperatures = np.array([
    [18, 25, 20],  # Monday
    [17, 24, 19],  # Tuesday
    [19, 26, 21],  # Wednesday
    [20, 28, 22],  # Thursday
    [21, 30, 23],  # Friday
    [22, 31, 24],  # Saturday
    [23, 32, 25]   # Sunday
])

# 📊 Analysis
daily_avg = np.mean(temperatures, axis=1)
time_avg = np.mean(temperatures, axis=0)

print("🌡️ Weekly Weather Report:")
days = ['Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat', 'Sun']
for day, avg in zip(days, daily_avg):
    emoji = '🌞' if avg > 24 else '⛅' if avg > 20 else '🌥️'
    print(f"  {day}: {avg:.1f}°C {emoji}")

print(f"\n⏰ Temperature by time of day:")
times = ['Morning', 'Afternoon', 'Evening']
for time, avg in zip(times, time_avg):
    print(f"  {time}: {avg:.1f}°C")

# 🔥 Find the hottest day
hottest_day = days[np.argmax(daily_avg)]
print(f"\n🔥 Hottest day: {hottest_day} with {daily_avg.max():.1f}°C!")

🚀 Advanced Concepts

Ready to level up? Let’s explore some advanced NumPy features! 🎮

Array Reshaping and Slicing 🔄

import numpy as np

# 🎲 Create a 1D array
original = np.arange(12)
print(f"Original: {original}")

# 🔄 Reshape into different dimensions
matrix_3x4 = original.reshape(3, 4)
matrix_2x6 = original.reshape(2, 6)

print("\n📐 3x4 Matrix:")
print(matrix_3x4)

print("\n📐 2x6 Matrix:")
print(matrix_2x6)

# 🔪 Advanced slicing
data = np.array([[1, 2, 3, 4],
                 [5, 6, 7, 8],
                 [9, 10, 11, 12]])

# Get specific elements
corners = data[[0, 2], [0, 3]]  # Top-left and bottom-right
print(f"\n🎯 Corner elements: {corners}")  # [1, 12]

# Get every other element
alternating = data[::2, ::2]  # Skip rows and columns
print("\n🦘 Every other element:")
print(alternating)

Mathematical Functions 🧮

import numpy as np

# 📊 Sample data
data = np.array([1, 4, 9, 16, 25])

# 🎯 Mathematical operations
sqrt_data = np.sqrt(data)      # Square root
log_data = np.log(data)        # Natural logarithm
exp_data = np.exp(data[:3])    # Exponential (first 3 to avoid overflow)

print(f"Original: {data}")
print(f"Square root: {sqrt_data}")
print(f"Logarithm: {log_data}")
print(f"Exponential: {exp_data}")

# 📈 Trigonometry
angles = np.array([0, np.pi/4, np.pi/2, np.pi])
sin_values = np.sin(angles)
cos_values = np.cos(angles)

print("\n🌊 Trigonometry:")
for angle, sin_val, cos_val in zip(angles, sin_values, cos_values):
    print(f"  Angle {angle:.2f}: sin={sin_val:.2f}, cos={cos_val:.2f}")

⚠️ Common Pitfalls and Solutions

Let’s learn from common mistakes so you can avoid them! 🛡️

Pitfall 1: Shape Mismatch 🔺

# ❌ Wrong way - shape mismatch
arr1 = np.array([1, 2, 3])
arr2 = np.array([[4, 5, 6]])  # Note: 2D array!

try:
    result = arr1 + arr2  # This will cause an error!
except ValueError as e:
    print(f"❌ Error: {e}")

# ✅ Right way - ensure compatible shapes
arr1 = np.array([1, 2, 3])
arr2 = np.array([4, 5, 6])  # 1D array
result = arr1 + arr2
print(f"✅ Result: {result}")  # [5 7 9]

# 🎯 Or use reshape
arr2_fixed = arr2.reshape(-1)  # Flatten to 1D

Pitfall 2: Data Type Issues 🔢

# ❌ Wrong way - integer division surprises
arr = np.array([1, 2, 3, 4, 5])
result = arr / 2  # Might not do what you expect with integers!

# ✅ Right way - be explicit about data types
arr_float = np.array([1, 2, 3, 4, 5], dtype=float)
result = arr_float / 2
print(f"✅ Float division: {result}")  # [0.5 1.  1.5 2.  2.5]

# 🎯 Or convert when needed
arr_int = np.array([1, 2, 3, 4, 5])
result = arr_int.astype(float) / 2

Pitfall 3: Modifying Views vs Copies 👀

# ❌ Wrong way - unexpected modifications
original = np.array([1, 2, 3, 4, 5])
view = original[:3]  # This is a view, not a copy!
view[0] = 999
print(f"❌ Original modified: {original}")  # [999 2 3 4 5] - Oops!

# ✅ Right way - use copy when needed
original = np.array([1, 2, 3, 4, 5])
safe_copy = original[:3].copy()  # Explicit copy
safe_copy[0] = 999
print(f"✅ Original unchanged: {original}")  # [1 2 3 4 5] - Safe!

🛠️ Best Practices

Follow these tips to write clean, efficient NumPy code! 💎

1. Use Vectorized Operations 🚀

# ❌ Slow way - using loops
def slow_square(arr):
    result = []
    for x in arr:
        result.append(x ** 2)
    return np.array(result)

# ✅ Fast way - vectorized operations
def fast_square(arr):
    return arr ** 2  # NumPy handles the loop internally!

# 🏁 Performance comparison
large_array = np.arange(10000)
# fast_square is about 100x faster! 🚀

2. Choose the Right Data Type 📊

# 💾 Memory-efficient data types
small_ints = np.array([1, 2, 3], dtype=np.int8)    # -128 to 127
big_floats = np.array([1.5, 2.5], dtype=np.float64)  # High precision

# 🎯 Use appropriate types for your data
ages = np.array([25, 30, 35], dtype=np.uint8)      # Ages don't need big integers
prices = np.array([19.99, 29.99], dtype=np.float32)  # Money needs decimals

3. Use NumPy’s Built-in Functions 🔧

# ❌ Don't reinvent the wheel
def my_mean(arr):
    return sum(arr) / len(arr)

# ✅ Use NumPy's optimized functions
arr = np.array([1, 2, 3, 4, 5])
mean = np.mean(arr)      # Faster and more accurate
median = np.median(arr)  # Built-in and tested
std = np.std(arr)        # Statistical functions ready to use!

🧪 Hands-On Exercise

Time to practice what you’ve learned! 🎯

🎯 Challenge: Student Grade Analysis

Create a program that analyzes student performance data:

1. Create a 2D array with 5 students and 4 test scores each
2. Calculate each student’s average score
3. Find which test was the hardest (lowest average)
4. Identify students who need help (average < 70)
5. Apply a 5-point curve to all scores

Bonus: Create a “report card” showing letter grades (A: 90+, B: 80-89, C: 70-79, D: 60-69, F: <60)

Solution

import numpy as np

# 📚 Student test scores (5 students, 4 tests)
scores = np.array([
    [72, 85, 68, 90],   # Student 1
    [88, 92, 85, 87],   # Student 2
    [65, 70, 72, 68],   # Student 3
    [95, 98, 92, 96],   # Student 4
    [58, 62, 65, 60]    # Student 5
])

print("📊 Original Scores:")
print(scores)

# 📈 Calculate averages
student_averages = np.mean(scores, axis=1)
test_averages = np.mean(scores, axis=0)

print("\n🎓 Student Averages:")
for i, avg in enumerate(student_averages):
    print(f"  Student {i+1}: {avg:.1f}%")

# 🔍 Find hardest test
hardest_test = np.argmin(test_averages) + 1
print(f"\n📝 Hardest test: Test {hardest_test} (avg: {test_averages[hardest_test-1]:.1f}%)")

# 🆘 Identify students needing help
struggling_students = np.where(student_averages < 70)[0] + 1
if len(struggling_students) > 0:
    print(f"\n⚠️ Students needing help: {struggling_students}")

# 📈 Apply 5-point curve
curved_scores = np.minimum(scores + 5, 100)  # Cap at 100
curved_averages = np.mean(curved_scores, axis=1)

print("\n🎯 After 5-point curve:")
for i, (orig, curved) in enumerate(zip(student_averages, curved_averages)):
    print(f"  Student {i+1}: {orig:.1f}% → {curved:.1f}%")

# 🏆 Letter grades
def get_letter_grade(score):
    if score >= 90: return 'A'
    elif score >= 80: return 'B'
    elif score >= 70: return 'C'
    elif score >= 60: return 'D'
    else: return 'F'

print("\n📋 Report Card (with curve):")
for i, avg in enumerate(curved_averages):
    grade = get_letter_grade(avg)
    emoji = {'A': '🌟', 'B': '✨', 'C': '👍', 'D': '📚', 'F': '🆘'}[grade]
    print(f"  Student {i+1}: {avg:.1f}% - Grade: {grade} {emoji}")

# 📊 Class statistics
print(f"\n📈 Class Statistics:")
print(f"  Highest average: {curved_averages.max():.1f}%")
print(f"  Lowest average: {curved_averages.min():.1f}%")
print(f"  Class average: {curved_averages.mean():.1f}%")

🎓 Key Takeaways

Congratulations! You’ve just mastered the basics of NumPy! 🎉 Let’s recap what you’ve learned:

1. NumPy arrays are super-fast for numerical operations 🚀
2. Vectorized operations beat loops every time ⚡
3. Broadcasting lets you work with arrays of different shapes 🎪
4. Built-in functions save time and prevent errors 🛡️
5. Data types matter for performance and memory 💾

Remember:

• NumPy is the foundation of data science in Python 📊
• Practice with real data to build intuition 🎯
• Don’t be afraid to experiment - that’s how you learn! 🧪

🤝 Next Steps

You’re doing amazing! 🌟 Here’s what to explore next:

1. Advanced Indexing - Master fancy indexing and boolean masks 🎭
2. Linear Algebra - Dive into matrix operations with NumPy 🔢
3. Random Numbers - Learn NumPy’s random module for simulations 🎲
4. Performance Tips - Optimize your code for maximum speed ⚡

Next tutorial: Pandas DataFrames for Data Analysis 🐼

Keep coding, keep learning, and remember - you’ve got this! 💪 Every data scientist started exactly where you are now. The journey of a thousand analyses begins with a single array! 🚀

Happy NumPy-ing! 🎉