टेस्ट करें यदि सुन्न सरणी में केवल शून्य हो

Question

हम शून्य के रूप में शून्य के साथ एक सुस्पष्ट सरणी को आरंभीकृत करते हैं:

np.zeros((N,N+1))

लेकिन हम यह कैसे जांचते हैं कि क्या किसी दिए गए n * n में एक सार सरणी मैट्रिक्स शून्य है।
यदि सभी मान वास्तव में शून्य हैं, तो विधि को केवल एक सच्चे लौटने की आवश्यकता है।

Answer 1

की जाँच करें numpy.count_nonzero ।

>>> np.count_nonzero(np.eye(4))
4
>>> np.count_nonzero([[0,1,7,0,0],[3,0,0,2,19]])
5

Comments

आप केवल तभी not np.count_nonzero(np.eye(4))लौटना चाहेंगे Trueजब सभी मान 0.

— जे। मार्टिनोट-लेगार्दे

Answer 2

यहां पोस्ट किए गए अन्य उत्तर काम करेंगे, लेकिन उपयोग करने के लिए सबसे स्पष्ट और सबसे कुशल फ़ंक्शन है numpy.any():

>>> all_zeros = not np.any(a)

या

>>> all_zeros = not a.any()

• यह अधिक पसंद किया जाता है numpy.all(a==0)क्योंकि यह कम रैम का उपयोग करता है। (यह a==0शब्द द्वारा निर्मित अस्थायी सरणी की आवश्यकता नहीं है ।)
• इसके अलावा, यह तेजी से है numpy.count_nonzero(a)क्योंकि यह तुरंत वापस आ सकता है जब पहला गैर-अक्ष तत्व पाया गया हो।
  • संपादित करें: जैसा कि @Rachel ने टिप्पणी में बताया है, np.any()अब "शॉर्ट-सर्किट" तर्क का उपयोग नहीं करता है, इसलिए आपको छोटे सरणियों के लिए गति का लाभ दिखाई नहीं देगा।

Comments

एक मिनट पहले के रूप में, numpy के anyऔर allकर नहीं शॉर्ट सर्किट। मेरा मानना ​​है कि वे चीनी के लिए logical_or.reduceऔर हैं logical_and.reduce। एक-दूसरे से और मेरे लघु-चित्रण की तुलना करें is_in: all_false = np.zeros(10**8) all_true = np.ones(10**8) %timeit np.any(all_false) 91.5 ms ± 1.82 ms per loop %timeit np.any(all_true) 93.7 ms ± 6.16 ms per loop %timeit is_in(1, all_true) 293 ns ± 1.65 ns per loop

— राहेल

यह एक महान बिंदु है, धन्यवाद। यह कम-सर्किटिंग तरह लग रहा है प्रयोग किया जाता व्यवहार हो सकता है, लेकिन यह है कि कुछ बिंदु पर खो गया था। इस सवाल के जवाब में कुछ दिलचस्प चर्चा है ।

— स्टुअर्ट बर्ग

Answer 3

यदि आपके पास एक सरणी है, तो मैं यहाँ np.all का उपयोग करूंगा:

>>> np.all(a==0)

Comments

मुझे यह पसंद है कि यह उत्तर गैर शून्य मानों के लिए भी जांचता है। उदाहरण के लिए, कोई जाँच कर सकता है कि क्या किसी सरणी के सभी तत्व एक जैसे हैं np.all(a==a[0])। आपका बहुत बहुत धन्यवाद!

— एग्नास

Answer 4

जैसा कि एक अन्य उत्तर कहता है, आप सत्य / झूठे मूल्यांकन का लाभ उठा सकते हैं यदि आप जानते हैं कि 0आपके सरणी में संभवतः एकमात्र मिथ्या तत्व है। किसी सरणी में सभी तत्व गलत हैं, यदि उसमें कोई सत्य तत्व नहीं हैं। *

>>> a = np.zeros(10)
>>> not np.any(a)
True

हालांकि, उत्तर ने दावा किया कि anyआंशिक रूप से शॉर्ट-सर्कुलेटिंग के कारण अन्य विकल्पों की तुलना में तेज था। 2018 तक, नेम्पी allऔर any शॉर्ट-सर्किट नहीं ।

यदि आप इस तरह का काम करते हैं, तो अपने स्वयं के लघु-संचरित संस्करणों का उपयोग करना बहुत आसान है numba:

import numba as nb

# short-circuiting replacement for np.any()
@nb.jit(nopython=True)
def sc_any(array):
    for x in array.flat:
        if x:
            return True
    return False

# short-circuiting replacement for np.all()
@nb.jit(nopython=True)
def sc_all(array):
    for x in array.flat:
        if not x:
            return False
    return True

शॉर्ट-सर्कुलेटिंग न होने पर भी ये Numpy के संस्करणों की तुलना में तेज़ होते हैं। count_nonzeroसबसे धीमा है।

प्रदर्शन की जांच करने के लिए कुछ इनपुट:

import numpy as np

n = 10**8
middle = n//2
all_0 = np.zeros(n, dtype=int)
all_1 = np.ones(n, dtype=int)
mid_0 = np.ones(n, dtype=int)
mid_1 = np.zeros(n, dtype=int)
np.put(mid_0, middle, 0)
np.put(mid_1, middle, 1)
# mid_0 = [1 1 1 ... 1 0 1 ... 1 1 1]
# mid_1 = [0 0 0 ... 0 1 0 ... 0 0 0]

जाँच:

## count_nonzero
%timeit np.count_nonzero(all_0) 
# 220 ms ± 8.73 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)
%timeit np.count_nonzero(all_1)
# 150 ms ± 4.56 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)

### all
# np.all
%timeit np.all(all_1)
%timeit np.all(mid_0)
%timeit np.all(all_0)
# 56.8 ms ± 3.41 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)
# 57.4 ms ± 1.76 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)
# 55.9 ms ± 2.13 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)

# sc_all
%timeit sc_all(all_1)
%timeit sc_all(mid_0)
%timeit sc_all(all_0)
# 44.4 ms ± 2.49 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)
# 22.7 ms ± 599 µs per loop (mean ± std. dev. of 7 runs, 10 loops each)
# 288 ns ± 6.36 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)

### any
# np.any
%timeit np.any(all_0)
%timeit np.any(mid_1)
%timeit np.any(all_1)
# 60.7 ms ± 1.38 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)
# 60 ms ± 287 µs per loop (mean ± std. dev. of 7 runs, 10 loops each)
# 57.7 ms ± 1.12 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)

# sc_any
%timeit sc_any(all_0)
%timeit sc_any(mid_1)
%timeit sc_any(all_1)
# 41.7 ms ± 1.24 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)
# 22.4 ms ± 1.51 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)
# 287 ns ± 12.7 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)

* सहायक allऔर anyसमकक्ष:

np.all(a) == np.logical_not(np.any(np.logical_not(a)))
np.any(a) == np.logical_not(np.all(np.logical_not(a)))
not np.all(a) == np.any(np.logical_not(a))
not np.any(a) == np.all(np.logical_not(a))

Answer 5

यदि आप किसी अन्य संख्यात्मक कार्य पर चेतावनी से बचने के लिए सभी शून्य के लिए परीक्षण कर रहे हैं, तो एक कोशिश में लाइन लपेटकर, ब्लॉक को छोड़कर उस ऑपरेशन से पहले शून्य के लिए परीक्षण करने से बचेंगे, जिसमें आप रुचि रखते हैं।

try: # removes output noise for empty slice 
    mean = np.mean(array)
except:
    mean = 0