উত্তর:
হ্যাঁ, অনুসন্ধানের জন্য এখানে একটি উত্তরপ্য অ্যারে array, এবং একটি মান দেওয়া উত্তর রয়েছে item:
itemindex = numpy.where(array==item)ফলাফলটি প্রথমে সমস্ত সারি সূচক, তারপরে সমস্ত কলাম সূচক সহ একটি টুপল।
উদাহরণস্বরূপ, যদি কোনও অ্যারে দুটি মাত্রা হয় এবং এতে আপনার আইটেমটি দুটি স্থানে থাকে
array[itemindex[0][0]][itemindex[1][0]]আপনার আইটেমের সমান হবে এবং তাই হবে
array[itemindex[0][1]][itemindex[1][1]]rows, columns = np.where(array==item); first_idx = sorted([r for r, c in zip(rows, columns) if c == 0])[0]
np.argwhereএখানে কিছুটা বেশি দরকারী হবে:itemindex = np.argwhere(array==item)[0]; array[tuple(itemindex)]
whereযে কোনও অ্যারেতে কাজ করে এবং 3 ডি অ্যারে ইত্যাদি ব্যবহার করার সময় 3 টি দৈর্ঘ্যের দ্বিগুণ ফিরে আসবে
আপনার যদি কেবলমাত্র একটি মানটির প্রথম উপস্থিতির সূচক প্রয়োজন হয় তবে আপনি ব্যবহার করতে পারেন nonzero(বা where, যা এই ক্ষেত্রে একই জিনিসটির সমান):
>>> t = array([1, 1, 1, 2, 2, 3, 8, 3, 8, 8])
>>> nonzero(t == 8)
(array([6, 8, 9]),)
>>> nonzero(t == 8)[0][0]
6আপনার যদি অনেকগুলি মানগুলির প্রথম সূচকের প্রয়োজন হয় তবে আপনি স্পষ্টত বারবার উপরের মতোই করতে পারেন তবে একটি কৌশল আছে যা দ্রুত হতে পারে। নিম্নলিখিত প্রতিটি অনুচ্ছেদের প্রথম উপাদান সূচকগুলি সন্ধান করে :
>>> nonzero(r_[1, diff(t)[:-1]])
(array([0, 3, 5, 6, 7, 8]),)লক্ষ্য করুন যে এটি 3s এবং পরবর্তী 8s এর উভয় অনুচ্ছেদের উভয়ের সূচনা খুঁজে পেয়েছে:
[ 1 , 1, 1, 2 , 2, 3 , 8 , 3 , 8 , 8]
সুতরাং এটি প্রতিটি মানের প্রথম উপস্থিতি সন্ধানের চেয়ে কিছুটা আলাদা । আপনার প্রোগ্রামে tআপনি যা চান তা পেতে আপনি একটি সাজানো সংস্করণ দিয়ে কাজ করতে সক্ষম হতে পারেন:
>>> st = sorted(t)
>>> nonzero(r_[1, diff(st)[:-1]])
(array([0, 3, 5, 7]),)r_?
r_; বা, আরও স্পষ্টভাবে, এটি প্রতিটি অক্ষের সাথে টুকরো টুকরোকে সংমিশ্রণে অনুবাদ করে। আমি hstackপরিবর্তে ব্যবহার করতে পারে ; এটি কম বিভ্রান্তিকর হতে পারে। আরও তথ্যের জন্য ডকুমেন্টেশন দেখুন r_। এছাড়াও আছে একটি c_।
vals, locs = np.unique(t, return_index=True)
আপনি একটি নুমপি অ্যারে বাতাসে তালিকাতে রূপান্তর করতে এবং এর সূচকটি পেতে পারেন। উদাহরণ স্বরূপ,
l = [1,2,3,4,5] # Python list
a = numpy.array(l) # NumPy array
i = a.tolist().index(2) # i will return index of 2
print iএটি মুদ্রণ করবে 1।
[find_list.index(index_list[i]) for i in range(len(index_list))]
find_listএকটি NumPy অ্যারেতে object(অথবা কিছু আরও নির্দিষ্ট করে সঠিক) এবং শুধু কি find_arr[index_list]।
একটি খুব পারফরম্যান্ট এবং সহজ যোগ করতে numbanp.ndenumerateপ্রথম সূচকটি অনুসন্ধানের ভিত্তিতে বিকল্প :
from numba import njit
import numpy as np
@njit
def index(array, item):
for idx, val in np.ndenumerate(array):
if val == item:
return idx
# If no item was found return None, other return types might be a problem due to
# numbas type inference.এটি বেশ দ্রুত এবং বহুমাত্রিক অ্যারেগুলির সাথে প্রাকৃতিকভাবে ডিল করে :
>>> arr1 = np.ones((100, 100, 100))
>>> arr1[2, 2, 2] = 2
>>> index(arr1, 2)
(2, 2, 2)
>>> arr2 = np.ones(20)
>>> arr2[5] = 2
>>> index(arr2, 2)
(5,)এটি ব্যবহার বা ব্যবহারের কোনও পদ্ধতির তুলনায় এটি আরও দ্রুত হতে পারে (কারণ এটি অপারেশনকে সংক্ষিপ্তসার্কিট করছে) ।np.wherenp.nonzero
তবে np.argwhereএছাড়াও মোকাবেলা পারে অত্যন্ত শৃঙ্খলার বহুমাত্রিক অ্যারে সঙ্গে (ম্যানুয়ালি একটি tuple সামনে ছুঁড়ে আপনার যা দরকার হবে এবং তা না স্বল্প circuited করা হয়েছে) কিন্তু যদি কোন মিল খুঁজে পাওয়া যায় এটা ব্যর্থ হবে:
>>> tuple(np.argwhere(arr1 == 2)[0])
(2, 2, 2)
>>> tuple(np.argwhere(arr2 == 2)[0])
(5,)@njitএর একটি সংক্ষিপ্ত রূপটি হ'ল jit(nopython=True)প্রথম রান করার সময় ফাংশনটি ফ্লাইটটি অন ফ্লাইটে সম্পূর্ণরূপে সংকলিত হবে যাতে পাইথন ইন্টারপ্রেটার কল সম্পূর্ণভাবে মুছে ফেলা হয়।
যদি আপনি এটিকে অন্য কোনও সূচী হিসাবে ব্যবহার করতে চলেছেন তবে অ্যারেগুলি সম্প্রচারযোগ্য হলে আপনি বুলিয়ান সূচকগুলি ব্যবহার করতে পারেন; আপনার সুস্পষ্ট সূচকের দরকার নেই। এটি করার নিখুঁত সহজ উপায় হ'ল একটি সত্য মানের উপর ভিত্তি করে সূচক।
other_array[first_array == item]যে কোনও বুলিয়ান অপারেশন কাজ করে:
a = numpy.arange(100)
other_array[first_array > 50]ননজারো পদ্ধতিতে বুলিয়ানও লাগে:
index = numpy.nonzero(first_array == item)[0][0]দুটি জিরো হ'ল সূচকগুলির দ্বিগুণ জন্য (ধরে নিলে প্রথম_আরে 1 ডি হয়) এবং তারপরে সূচকের অ্যারেতে প্রথম আইটেম।
l.index(x)সর্বনিম্ন i টি ফেরৎ দেয় যে আমি তালিকার x এর প্রথম উপস্থিতির সূচক।
কেউ নিরাপদে ধরে নিতে পারেন যে index()পাইথনের ফাংশনটি এমনভাবে বাস্তবায়িত হয়েছে যাতে এটি প্রথম ম্যাচটি সন্ধান করার পরে বন্ধ হয়ে যায় এবং এর ফলে সর্বোত্তম গড় পারফরম্যান্স হয়।
নুমপি অ্যারেতে প্রথম ম্যাচের পরে থামার উপাদান খুঁজে পাওয়ার জন্য একটি পুনরুক্তি ( এনডেনিউরেট ) ব্যবহার করুন।
In [67]: l=range(100)
In [68]: l.index(2)
Out[68]: 2NumPy অ্যারে:
In [69]: a = np.arange(100)
In [70]: next((idx for idx, val in np.ndenumerate(a) if val==2))
Out[70]: (2L,)নোট করুন যে উভয় পদ্ধতি index()এবং nextউপাদানটি খুঁজে পাওয়া না গেলে একটি ত্রুটি ফেরান। এর সাথে next, উপাদানটি খুঁজে পাওয়া যায় না, এমন ক্ষেত্রে একটি বিশেষ মান ফেরত দিতে দ্বিতীয় তর্কটি ব্যবহার করতে পারে eg
In [77]: next((idx for idx, val in np.ndenumerate(a) if val==400),None)NumPy ( argmax, whereএবং nonzero) এর মধ্যে অন্যান্য ফাংশন রয়েছে যা অ্যারেতে উপাদান খুঁজে পেতে ব্যবহার করা যেতে পারে, তবে তাদের সকলেরই সমস্ত উপস্থিতি সন্ধান করার জন্য পুরো অ্যারেটি দিয়ে যাওয়ার প্রবণতা রয়েছে, সুতরাং প্রথম উপাদানটি খুঁজে পাওয়ার জন্য এটি অনুকূলিত হয় না। এছাড়াও মনে রাখবেন whereএবং nonzeroরিটার্ন অ্যারে, তাই আপনি সূচক পেতে প্রথম উপাদান নির্বাচন করতে হবে।
In [71]: np.argmax(a==2)
Out[71]: 2
In [72]: np.where(a==2)
Out[72]: (array([2], dtype=int64),)
In [73]: np.nonzero(a==2)
Out[73]: (array([2], dtype=int64),)সন্ধান করা%timeit আইটেমি অ্যারের শুরুতে ( আইপিথন শেল ব্যবহার করে ) যখন বড় অ্যারের জন্য সমাধানটি একটি পুনরুক্তি ব্যবহারকারীর দ্বারা সমাধান করা দ্রুত হয় :
In [285]: a = np.arange(100000)
In [286]: %timeit next((idx for idx, val in np.ndenumerate(a) if val==0))
100000 loops, best of 3: 17.6 µs per loop
In [287]: %timeit np.argmax(a==0)
1000 loops, best of 3: 254 µs per loop
In [288]: %timeit np.where(a==0)[0][0]
1000 loops, best of 3: 314 µs per loopএটি ওপেন নম্পপি গিটহাব ইস্যু ।
আরও দেখুন: নম্পি : মানটির প্রথম সূচকটি দ্রুত সন্ধান করুন
%timeit next((idx for idx, val in np.ndenumerate(a) if val==99999))কাজ করে না ? আপনি যদি ভাবছেন যে এটি কেন 1000 গুণ বেশি ধীর - এটি কারণ ন্যাপি অ্যারেগুলিতে পাইথন লুপগুলি কুখ্যাতভাবে ধীর।
argmaxএবং whereএই ক্ষেত্রে অনেক দ্রুত হয় (অ্যারে শেষে উপাদান অনুসন্ধান করা হয়েছে)
এক-মাত্রিক সাজানো অ্যারেগুলির জন্য, numpy.searchsorted যা NumPy পূর্ণসংখ্যা (অবস্থান) প্রদান করে তা ব্যবহার করা আরও অনেক সহজ এবং দক্ষ ও (লগ (এন)) হবে । উদাহরণ স্বরূপ,
arr = np.array([1, 1, 1, 2, 3, 3, 4])
i = np.searchsorted(arr, 3)অ্যারে ইতিমধ্যে বাছাই করা হয়েছে তা নিশ্চিত করুন
ফিরে আসা সূচকগুলিতে আমি আসলে অনুসন্ধানের উপাদানটি রেখেছি কিনা তাও পরীক্ষা করে দেখুন, যেহেতু অনুসন্ধানের মূল উদ্দেশ্য সূচকগুলি সন্ধান করা যেখানে উপাদানগুলি শৃঙ্খলা বজায় রাখতে হবে।
if arr[i] == 3:
print("present")
else:
print("not present")যে কোনও মানদণ্ডে সূচী করতে আপনি নীচের মতো কিছু করতে পারেন:
In [1]: from numpy import *
In [2]: x = arange(125).reshape((5,5,5))
In [3]: y = indices(x.shape)
In [4]: locs = y[:,x >= 120] # put whatever you want in place of x >= 120
In [5]: pts = hsplit(locs, len(locs[0]))
In [6]: for pt in pts:
.....: print(', '.join(str(p[0]) for p in pt))
4, 4, 0
4, 4, 1
4, 4, 2
4, 4, 3
4, 4, 4এবং list.index () কী করে তা করার জন্য এখানে একটি দ্রুত ফাংশন রয়েছে, যদি এটি না পাওয়া যায় তবে ব্যতিক্রম বাড়াবে না। সাবধান - এটি বড় অ্যারেগুলিতে সম্ভবত খুব ধীর। আপনি সম্ভবত এটি একটি পদ্ধতি হিসাবে ব্যবহার করতে চাইলে আপনি সম্ভবত বানরটিকে এই অ্যারেতে প্যাচ করতে পারেন।
def ndindex(ndarray, item):
if len(ndarray.shape) == 1:
try:
return [ndarray.tolist().index(item)]
except:
pass
else:
for i, subarray in enumerate(ndarray):
try:
return [i] + ndindex(subarray, item)
except:
pass
In [1]: ndindex(x, 103)
Out[1]: [4, 0, 3]এনপি.হোয়ার () থেকে প্রথম উপাদানটি নির্বাচনের বিকল্প হ'ল গণনার সাথে জেনারেটর এক্সপ্রেশন ব্যবহার করা যেমন:
>>> import numpy as np
>>> x = np.arange(100) # x = array([0, 1, 2, 3, ... 99])
>>> next(i for i, x_i in enumerate(x) if x_i == 2)
2একটি দ্বিমাত্রিক অ্যারের জন্য যেটি করবে:
>>> x = np.arange(100).reshape(10,10) # x = array([[0, 1, 2,... 9], [10,..19],])
>>> next((i,j) for i, x_i in enumerate(x)
... for j, x_ij in enumerate(x_i) if x_ij == 2)
(0, 2)এই পদ্ধতির সুবিধাটি হ'ল এটি প্রথম ম্যাচের সন্ধান পাওয়ার পরে অ্যারের উপাদানগুলি পরীক্ষা করা বন্ধ করে দেয়, যেখানে এনপি.হোমেনার ম্যাচের জন্য সমস্ত উপাদান পরীক্ষা করে। জেনারেটর এক্সপ্রেশনটি দ্রুততর হবে যদি অ্যারেতে শুরুর দিকে মিল থাকে।
Noneফ্যালব্যাক হিসাবে ফিরে আসে তবে তা হয়ে উঠত next((i for i, x_i in enumerate(x) if x_i == 2), None)।
NumPy এ প্রচুর অপারেশন রয়েছে যা সম্ভবত এটি সম্পাদন করার জন্য একত্র করা যেতে পারে। এটি আইটেমের সমতুল্য উপাদানগুলির সূচকগুলি ফিরিয়ে দেবে:
numpy.nonzero(array - item)তারপরে আপনি তালিকার প্রথম উপাদানগুলিকে একক উপাদান পেতে পারেন।
Numpy_indexed প্যাকেজ (দাবিত্যাগ, আমি সংশ্লিষ্ট লেখক নই) numpy.ndarray জন্য list.index একটি ভেক্টরকৃত সমতুল্য উপস্থিত রয়েছে; এটাই:
sequence_of_arrays = [[0, 1], [1, 2], [-5, 0]]
arrays_to_query = [[-5, 0], [1, 0]]
import numpy_indexed as npi
idx = npi.indices(sequence_of_arrays, arrays_to_query, missing=-1)
print(idx) # [2, -1]এই সমাধানটির কার্যকারিতাটিকে ভেক্টরাইজ করা হয়েছে, নাদাররেয়গুলিকে সাধারণীকরণ করা হয়েছে এবং হারিয়ে যাওয়া মানগুলির সাথে সম্পর্কিত বিভিন্ন পদ্ধতি রয়েছে।
দ্রষ্টব্য: এটি অজগর ২.7 সংস্করণের জন্য
সমস্যাটি মোকাবেলা করতে আপনি একটি ল্যাম্বদা ফাংশন ব্যবহার করতে পারেন এবং এটি NumPy অ্যারে এবং তালিকার উভয় ক্ষেত্রেই কাজ করে।
your_list = [11, 22, 23, 44, 55]
result = filter(lambda x:your_list[x]>30, range(len(your_list)))
#result: [3, 4]
import numpy as np
your_numpy_array = np.array([11, 22, 23, 44, 55])
result = filter(lambda x:your_numpy_array [x]>30, range(len(your_list)))
#result: [3, 4]এবং আপনি ব্যবহার করতে পারেন
result[0]ফিল্টার উপাদানগুলির প্রথম সূচক পেতে।
পাইথন ৩.6 এর জন্য ব্যবহার করুন
list(result)পরিবর্তে
result<filter object at 0x0000027535294D30>পাইথন 3 এ ফলাফল (পাইথন 3.6.3 এ পরীক্ষিত)। পাইথন 3 এর জন্য সম্ভবত আপডেট করবেন?