import numpy as np

# Same data, different containers
python_list = [1, 2, 3, 4, 5]
numpy_array = np.array([1, 2, 3, 4, 5])

print("Python list:", python_list)
print("NumPy array:", numpy_array)
print()

print("List type:", type(python_list))
print("Array type:", type(numpy_array))
print()

# The magic difference - operations on entire array!
print("Multiply by 2:")
print("List needs loop:", [x * 2 for x in python_list])
print("Array is vectorized:", numpy_array * 2)

import numpy as np
import time

# Performance comparison with medium-sized data
size = 100000

# Create test data
python_list = list(range(size))
numpy_array = np.arange(size)

print(f"Testing with {size:,} numbers")
print()

# Time list operation
start_time = time.time()
list_result = [x * 2 + 1 for x in python_list]
list_time = time.time() - start_time

# Time array operation  
start_time = time.time()
array_result = numpy_array * 2 + 1
array_time = time.time() - start_time

print(f"List operation time: {list_time:.4f} seconds")
print(f"Array operation time: {array_time:.4f} seconds")
print(f"Array is {list_time/array_time:.1f}x faster!")

import numpy as np

# Lists can mix types
mixed_list = [1, 2.5, "hello", True, [1, 2]]
print("Mixed list:", mixed_list)
print("List allows any types!")
print()

# Arrays require same type
try:
    # This will convert everything to strings
    mixed_array = np.array([1, 2.5, "hello", True])
    print("Mixed array:", mixed_array)
    print("Array dtype:", mixed_array.dtype)
except:
    print("Array creation failed")

print()

# Numeric type promotion
int_list = [1, 2, 3]
mixed_numeric = [1, 2.5, 3]

int_array = np.array(int_list)
float_array = np.array(mixed_numeric)

print("Integer array:", int_array, "dtype:", int_array.dtype)
print("Float array:", float_array, "dtype:", float_array.dtype)

import numpy as np

# Sample data
list1 = [1, 2, 3, 4]
list2 = [10, 20, 30, 40]
array1 = np.array([1, 2, 3, 4])
array2 = np.array([10, 20, 30, 40])

print("List 1:", list1)
print("List 2:", list2)
print("Array 1:", array1)
print("Array 2:", array2)
print()

# Addition behaves differently!
print("List addition (concatenation):", list1 + list2)
print("Array addition (element-wise):", array1 + array2)
print()

# Multiplication differences
print("List multiplication (repetition):", list1 * 2)
print("Array multiplication (scaling):", array1 * 2)
print()

# Arrays support element-wise operations
print("Array element-wise operations:")
print("Subtraction:", array2 - array1)
print("Division:", array2 / array1)
print("Power:", array1 ** 2)

import numpy as np

# 2D data comparison
matrix_list = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
matrix_array = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])

print("Matrix as nested list:")
print(matrix_list)
print()

print("Matrix as NumPy array:")
print(matrix_array)
print()

# Accessing elements
print("Accessing element [1,2]:")
print("List way:", matrix_list[1][2])
print("Array way:", matrix_array[1, 2])
print()

# Operations on entire matrix
print("Add 10 to all elements:")
# List way - need nested loops
list_plus_10 = [[cell + 10 for cell in row] for row in matrix_list]
print("List result:", list_plus_10)

# Array way - vectorized
array_plus_10 = matrix_array + 10
print("Array result:")
print(array_plus_10)

import numpy as np
import sys

# Create comparable data structures
size = 1000
python_list = list(range(size))
numpy_array = np.arange(size)

# Calculate memory usage
list_memory = sys.getsizeof(python_list) + sum(sys.getsizeof(item) for item in python_list)
array_memory = numpy_array.nbytes + sys.getsizeof(numpy_array)

print(f"Data size: {size:,} integers")
print(f"List memory: {list_memory:,} bytes")
print(f"Array memory: {array_memory:,} bytes")
print(f"Array uses {list_memory/array_memory:.1f}x less memory!")
print()

# Memory per element
print(f"Memory per element:")
print(f"List: {list_memory/size:.1f} bytes per integer")
print(f"Array: {array_memory/size:.1f} bytes per integer")

import numpy as np

# Arrays have rich mathematical functionality
data = np.array([1, 4, 9, 16, 25])

print("Original data:", data)
print("Square roots:", np.sqrt(data))
print("Logarithms:", np.log(data))
print("Sine values:", np.sin(data))
print()

# Statistical operations
print("Statistics:")
print(f"Mean: {np.mean(data):.1f}")
print(f"Standard deviation: {np.std(data):.1f}")
print(f"Minimum: {np.min(data)}")
print(f"Maximum: {np.max(data)}")
print()

# These operations would require importing math module 
# and writing loops for Python lists!
print("Lists would need:")
print("import math")
print("sqrt_list = [math.sqrt(x) for x in python_list]")
print("Much more verbose and slower!")

import numpy as np

# Simulated daily temperature readings for a month
temperatures = np.array([
    22, 24, 23, 25, 27, 26, 24,  # Week 1
    23, 21, 22, 25, 28, 29, 27,  # Week 2  
    26, 24, 23, 22, 20, 21, 23,  # Week 3
    25, 27, 28, 30, 29, 28, 26   # Week 4
])

print("Temperature Analysis (°C)")
print("=" * 30)
print(f"Temperatures: {temperatures}")
print()

# Easy statistical analysis with arrays
print(f"Average temperature: {np.mean(temperatures):.1f}°C")
print(f"Hottest day: {np.max(temperatures)}°C")
print(f"Coldest day: {np.min(temperatures)}°C")
print(f"Temperature range: {np.max(temperatures) - np.min(temperatures)}°C")
print(f"Standard deviation: {np.std(temperatures):.1f}°C")
print()

# Find days above average
above_average = temperatures > np.mean(temperatures)
hot_days = temperatures[above_average]
print(f"Days above average: {len(hot_days)} days")
print(f"Hot day temperatures: {hot_days}")

# This would be much more complex with Python lists!