NumPy - np.count_nonzero()

import numpy as np

# Basic usage
arr = np.array([0, 1, 2, 0, 3, 0, 4])
count = np.count_nonzero(arr)
print(f"Non-zero elements: {count}")  # Output: 4

# Multi-dimensional arrays
matrix = np.array([[0, 1, 2],
                   [3, 0, 4],
                   [0, 5, 6]])
total_nonzero = np.count_nonzero(matrix)
print(f"Total non-zero: {total_nonzero}")  # Output: 6

# Create sample data
data = np.array([[1, 0, 3, 0],
                 [0, 2, 0, 4],
                 [5, 0, 0, 6]])

# Count along axis 0 (columns)
col_counts = np.count_nonzero(data, axis=0)
print(f"Non-zero per column: {col_counts}")  # [2, 1, 1, 2]

# Count along axis 1 (rows)
row_counts = np.count_nonzero(data, axis=1)
print(f"Non-zero per row: {row_counts}")  # [2, 2, 2]

# Using keepdims to preserve shape
col_counts_keepdims = np.count_nonzero(data, axis=0, keepdims=True)
print(f"Shape with keepdims: {col_counts_keepdims.shape}")  # (1, 4)
print(f"Shape without keepdims: {col_counts.shape}")  # (4,)

# 3D array: (depth, rows, cols)
cube = np.random.randint(0, 5, size=(3, 4, 5))

# Count along different axes
depth_counts = np.count_nonzero(cube, axis=0)  # Shape: (4, 5)
row_counts = np.count_nonzero(cube, axis=1)    # Shape: (3, 5)
col_counts = np.count_nonzero(cube, axis=2)    # Shape: (3, 4)

# Count along multiple axes
plane_counts = np.count_nonzero(cube, axis=(1, 2))  # Shape: (3,)
print(f"Non-zero per depth layer: {plane_counts}")

# Temperature data analysis
temperatures = np.array([22.5, 18.3, 25.7, 31.2, 19.8, 28.4, 33.1])

# Count temperatures above threshold
hot_days = np.count_nonzero(temperatures > 30)
print(f"Days above 30°C: {hot_days}")  # 2

# Count within range
comfortable = np.count_nonzero((temperatures >= 20) & (temperatures <= 28))
print(f"Comfortable temperature days: {comfortable}")  # 3

# Complex conditions
extreme = np.count_nonzero((temperatures < 15) | (temperatures > 35))
print(f"Extreme temperature days: {extreme}")  # 0

# Sales data: (weeks, days, stores)
sales = np.random.randint(0, 1000, size=(4, 7, 5))

# Count days with sales > 500 per store
high_sales_days = np.count_nonzero(sales > 500, axis=(0, 1))
print(f"High sales days per store: {high_sales_days}")

# Count stores with any day > 800
stores_with_peaks = np.count_nonzero(np.any(sales > 800, axis=(0, 1)))
print(f"Stores with peak sales: {stores_with_peaks}")

# Percentage of high-performing days
total_days = sales.shape[0] * sales.shape[1]
high_perf_pct = (np.count_nonzero(sales > 700, axis=(0, 1)) / total_days) * 100
print(f"High performance percentage per store: {high_perf_pct}")

import time

# Large dataset
large_array = np.random.randint(0, 10, size=10_000_000)

# Method 1: np.count_nonzero
start = time.perf_counter()
count1 = np.count_nonzero(large_array)
time1 = time.perf_counter() - start

# Method 2: sum of boolean array
start = time.perf_counter()
count2 = np.sum(large_array != 0)
time2 = time.perf_counter() - start

# Method 3: Python loop (don't do this)
start = time.perf_counter()
count3 = sum(1 for x in large_array if x != 0)
time3 = time.perf_counter() - start

print(f"np.count_nonzero: {time1:.4f}s")
print(f"np.sum(arr != 0): {time2:.4f}s")
print(f"Python loop: {time3:.4f}s")
print(f"Speedup: {time3/time1:.1f}x")

# Special values behavior
special = np.array([0, 0.0, -0.0, np.nan, np.inf, -np.inf, None, ''])

# NaN and Inf are non-zero
print(f"Count: {np.count_nonzero(special)}")  # 4 (nan, inf, -inf, None)

# Filtering NaN before counting
data_with_nan = np.array([1.0, np.nan, 2.0, 0.0, np.nan, 3.0])
valid_nonzero = np.count_nonzero(data_with_nan[~np.isnan(data_with_nan)])
print(f"Valid non-zero: {valid_nonzero}")  # 3

# Boolean arrays
bool_arr = np.array([True, False, True, False])
print(f"True count: {np.count_nonzero(bool_arr)}")  # 2

# Empty strings vs non-empty
str_arr = np.array(['', 'a', '', 'b', ''])
print(f"Non-empty strings: {np.count_nonzero(str_arr)}")  # 2

# Simulated sensor data with missing readings (represented as 0)
np.random.seed(42)
sensor_data = np.random.choice([0, 1, 2, 3, 4, 5], 
                               size=(30, 24, 10),  # 30 days, 24 hours, 10 sensors
                               p=[0.15, 0.17, 0.17, 0.17, 0.17, 0.17])

# Data quality metrics
total_readings = sensor_data.size
valid_readings = np.count_nonzero(sensor_data)
missing_pct = (1 - valid_readings / total_readings) * 100

print(f"Total readings: {total_readings}")
print(f"Valid readings: {valid_readings}")
print(f"Missing data: {missing_pct:.2f}%")

# Per-sensor reliability
sensor_uptime = np.count_nonzero(sensor_data, axis=(0, 1))
sensor_uptime_pct = (sensor_uptime / (30 * 24)) * 100
print(f"\nSensor uptime percentages:")
for i, uptime in enumerate(sensor_uptime_pct):
    print(f"  Sensor {i}: {uptime:.1f}%")

# Identify problematic time periods
hourly_valid = np.count_nonzero(sensor_data, axis=(0, 2))
problematic_hours = np.where(hourly_valid < 8)[0]
print(f"\nHours with <80% sensor coverage: {problematic_hours}")

# Daily data quality score
daily_coverage = np.count_nonzero(sensor_data, axis=(1, 2)) / (24 * 10) * 100
low_quality_days = np.where(daily_coverage < 80)[0]
print(f"Days with <80% coverage: {low_quality_days}")

# Memory-efficient conditional counting
large_data = np.random.randn(1000, 1000, 100)  # ~800MB

# Inefficient: creates boolean array copy
# count = np.count_nonzero(large_data[large_data > 0])

# Efficient: uses boolean mask directly
count_positive = np.count_nonzero(large_data > 0)
count_negative = np.count_nonzero(large_data < 0)
count_near_zero = np.count_nonzero(np.abs(large_data) < 0.1)

print(f"Positive: {count_positive}")
print(f"Negative: {count_negative}")
print(f"Near zero: {count_near_zero}")

# Combining with axis for efficient aggregation
positive_per_slice = np.count_nonzero(large_data > 0, axis=(0, 1))
print(f"Average positive per slice: {positive_per_slice.mean():.0f}")