Pandas: NumPy where() से DataFrame फ़िल्टर करना

Pandas DataFrame को NumPy के np.where() फ़ंक्शन से फ़िल्टर करना। यह जटिल शर्तों के लिए वेक्टराइज़्ड ऑपरेशन प्रदान करता है।

np.where() सिंटैक्स

np.where(condition, value_if_true, value_if_false)
# या केवल शर्त के साथ (इंडेक्स लौटाता है)
np.where(condition)

उदाहरण

import pandas as pd
import numpy as np

dataFrame = pd.DataFrame({
    "Product": ["SmartTV", "ChromeCast", "Speaker", "Earphone"],
    "Opening_Stock": [300, 700, 1200, 1500],
    "Closing_Stock": [200, 500, 1000, 900]
})

print("DataFrame:\n", dataFrame)

# 1. दो शर्तें: Opening_Stock >= 700 AND Closing_Stock < 1000
condition1 = (dataFrame['Opening_Stock'] >= 700) & (dataFrame['Closing_Stock'] < 1000)
resValues1 = np.where(condition1)
print(f"\nशर्त 1 इंडेक्स: {resValues1[0]}")
print("फ़िल्टर्ड DataFrame:\n", dataFrame.loc[resValues1])

# 2. तीन शर्तें: Opening_Stock >= 500 AND Closing_Stock < 1000 AND Product 'C' से शुरू
condition2 = (
    (dataFrame['Opening_Stock'] >= 500) & 
    (dataFrame['Closing_Stock'] < 1000) & 
    (dataFrame['Product'].str.startswith('C'))
)
resValues2 = np.where(condition2)
print(f"\nशर्त 2 इंडेक्स: {resValues2[0]}")
print("फ़िल्टर्ड DataFrame:\n", dataFrame.loc[resValues2])

# 3. np.where से नया कॉलम बनाएं
dataFrame['Stock_Status'] = np.where(
    dataFrame['Closing_Stock'] > dataFrame['Opening_Stock'],
    'Increased',
    'Decreased'
)
print("\nस्टॉक स्टेटस कॉलम के साथ:\n", dataFrame)

आउटपुट

DataFrame:
   Closing_Stock  Opening_Stock    Product
0            200            300     SmartTV
1            500            700  ChromeCast
2           1000           1200    Speaker
3            900           1500   Earphone

शर्त 1 इंडेक्स: [1 3]
फ़िल्टर्ड DataFrame:
   Closing_Stock  Opening_Stock    Product
1            500            700  ChromeCast
3            900           1500   Earphone

शर्त 2 इंडेक्स: [1]
फ़िल्टर्ड DataFrame:
   Closing_Stock  Opening_Stock    Product
1            500            700  ChromeCast

स्टॉक स्टेटस कॉलम के साथ:
   Closing_Stock  Opening_Stock    Product Stock_Status
0            200            300     SmartTV   Decreased
1            500            700  ChromeCast   Decreased
2           1000           1200    Speaker   Decreased
3            900           1500   Earphone   Decreased

np.where() vs बूलियन इंडेक्सिंग

बूलियन इंडेक्सिंग (Pandas नेटिव, सुझाया गया)

# सरल और पठनीय
mask = (dataFrame['Opening_Stock'] >= 700) & (dataFrame['Closing_Stock'] < 1000)
filtered = dataFrame[mask]
# या सीधे
filtered = dataFrame[(dataFrame['Opening_Stock'] >= 700) & (dataFrame['Closing_Stock'] < 1000)]

np.where() के फायदे

• इंडेक्स सरणी लौटाता है (अन्य ऑपरेशन्स के लिए उपयोगी)
• तीन आर्गुमेंट रूप: सशर्त मान असाइनमेंट np.where(cond, true_val, false_val)
• NumPy सरणियों के साथ अंतर्क्रिया
• एकाधिक शर्तों के लिए नेस्टेड np.where

नेस्टेड np.where (केस स्टेटमेंट जैसा)

# नेस्टेड शर्तें: यदि A तो X, अन्यथा यदि B तो Y, अन्यथा Z
dataFrame['Category'] = np.where(
    dataFrame['Opening_Stock'] >= 1000,
    'High',
    np.where(
        dataFrame['Opening_Stock'] >= 500,
        'Medium',
        'Low'
    )
)
print("\nश्रेणी कॉलम:\n", dataFrame[['Product', 'Opening_Stock', 'Category']])

आउटपुट

श्रेणी कॉलम:
      Product  Opening_Stock Category
0     SmartTV            300      Low
1  ChromeCast            700   Medium
2    Speaker           1200     High
3   Earphone           1500     High

Pandas query() के साथ तुलना

# query() - स्ट्रिंग आधारित, पठनीय
result_query = dataFrame.query('Opening_Stock >= 700 and Closing_Stock < 1000')

# np.where - प्रोग्रामेटिक, डायनामिक शर्तों के लिए बेहतर
condition = (dataFrame['Opening_Stock'] >= 700) & (dataFrame['Closing_Stock'] < 1000)
result_where = dataFrame.loc[np.where(condition)]

# दोनों समान परिणाम देते हैं
print(result_query.equals(result_where))  # True

प्रदर्शन तुलना

import timeit

# बड़ा DataFrame
big_df = pd.DataFrame({
    'A': np.random.randint(0, 1000, 100000),
    'B': np.random.randint(0, 1000, 100000),
    'C': np.random.randint(0, 1000, 100000)
})

# समय मापें
t_bool = timeit.timeit(lambda: big_df[(big_df['A'] > 500) & (big_df['B'] < 500)], number=10)
t_where = timeit.timeit(lambda: big_df.loc[np.where((big_df['A'] > 500) & (big_df['B'] < 500))], number=10)
t_query = timeit.timeit(lambda: big_df.query('A > 500 and B < 500'), number=10)

print(f"बूलियन इंडेक्सिंग: {t_bool:.4f}s")
print(f"np.where: {t_where:.4f}s")
print(f"query: {t_query:.4f}s")

सामान्य परिणाम

बूलियन इंडेक्सिंग: 0.0123s
np.where: 0.0118s
query: 0.0156s

प्रदर्शन समान है; पठनीयता और उपयोग के मामले के अनुसार चुनें।