নমপি অ্যারেতে কেবল শূন্য রয়েছে কিনা তা পরীক্ষা করুন

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

আপনি যদি সমস্ত মান 0 হয় কেবল তখনই not np.count_nonzero(np.eye(4))ফিরে আসতে চানTrue

— জে। মার্টিনট-লেগার্ড

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)কারণ প্রথম ননজারো উপাদানটি পাওয়া গেলে এটি তত্ক্ষণাত্ ফিরে আসতে পারে।
  • সম্পাদনা: @ রাচেল মন্তব্যগুলিতে যেমন উল্লেখ করেছেন, np.any()আর "শর্ট সার্কিট" যুক্তি ব্যবহার করে না, তাই আপনি ছোট অ্যারেগুলির জন্য গতির সুবিধা দেখতে পাবেন না।

Comments

এক মিনিট আগে, নম্পি 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(a==0)

Comments

আমি পছন্দ করি যে এই উত্তরটি শূন্যহীন মানগুলির জন্যও চেক করে। উদাহরণস্বরূপ, কেউ অ্যারেতে থাকা সমস্ত উপাদান একরকম কিনা তা পরীক্ষা করতে পারে np.all(a==a[0])। অনেক ধন্যবাদ!

— আয়নাস

এই সমাধানটিও তুলনায় কিছুটা দক্ষ np.count_nonzero। % টাইমিট নাম্বার_অফ_নোন_জারোস = এনপি.কাউন্ট_অনজারো (জিরোস_ভেক্টর) 18.2 18s ± 386 এনএস প্রতি লুপ (মানে ± স্ট্যান্ড। runs রানের প্রতি, 100000 লুপ প্রতিটি)% সময়সীমার নাম_আর_অন_জার_স = এনপি.ল ((জিরোস_ভেকটার == 0)) ±.৩১µµ লুপ প্রতি 41.6 এনএস (অর্থাত্ runs রানের গড় dev রানের ডেভড, প্রতিটি ১০০০০০ লুপ)

— আইপি

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

সংক্ষিপ্ত-সার্কিট না হলেও এগুলি নিম্পির সংস্করণগুলির চেয়ে দ্রুততর হয়ে থাকে। 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

যদি আপনি অন্য শূন্য ফাংশন সম্পর্কে সতর্কতা এড়াতে সমস্ত শূন্যগুলির জন্য পরীক্ষা করে থাকেন তবে লাইনটি একটি চেষ্টা করে জড়িয়ে রাখুন, ব্লক ব্যতীত আপনি যে অপারেশনটিতে আগ্রহী সেটির আগে জিরোদের জন্য পরীক্ষা করা সংরক্ষণ করবে ie

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