ऐरे एलिमेंट वार ऑपरेशंस

Question

मेरे पास एक ही आकार के दो इनपुट एरे एक्स और वाई हैं। मुझे अपने प्रत्येक तत्व को फ़ंक्शन के माध्यम से मिलान करने वाले इंडेक्स के साथ चलाने की आवश्यकता है, फिर परिणाम को उन इंडेक्स पर तीसरे सरणी z में संग्रहीत करें। इसे पूरा करने के लिए सबसे महत्वपूर्ण तरीका क्या है? अभी मेरे पास चार चार लूप हैं - मुझे यकीन है कि एक आसान तरीका है।

x = [[2, 2, 2], 
    [2, 2, 2], 
    [2, 2, 2]] 

y = [[3, 3, 3], 
    [3, 3, 3], 
    [3, 3, 1]] 

def elementwise_function(element_1,element_2): 
    return (element_1 + element_2) 

z = [[5, 5, 5], 
    [5, 5, 5], 
    [5, 5, 3]] 

मुझे भ्रमित हो रहा है क्योंकि मेरा कार्य केवल व्यक्तिगत डेटा जोड़े पर ही काम करेगा। मैं बस समारोह में एक्स और वाई सरणी पास नहीं कर सकता।

Answer 1

numpy.vectorize का उपयोग करके एक NumPy- जागरूक फ़ंक्शन बनाने का एक "आसान तरीका" है। एक "ufunc" तत्व तत्व के लिए NumPy शब्दावली है (दस्तावेज here देखें)। numpy.vectorize का उपयोग करने से आप अपने स्वयं के ufunc को बनाने के लिए अपने तत्व-दर-तत्व फ़ंक्शन का उपयोग कर सकते हैं, जो अन्य NumPy ufuncs (जैसे मानक परिवर्धन, आदि) के समान काम करता है: ufunc सरणी स्वीकार करेगा और यह प्रत्येक जोड़ी पर आपका फ़ंक्शन लागू करेगा तत्वों के, यह मानक NumPy कार्यों, आदि जैसे सरणी आकार प्रसारण करेगा। documentation page में कुछ उपयोग उदाहरण हैं जो सहायक हो सकते हैं।

Answer 2

(मैं अपने सरल अजगर list बारे में बात कर, नहीं numpy.array अनुमान लगा रहा हूँ)

Recursion हमेशा हमारे जीवन को आसान बनाने:

def operate_on_Narray(A, B, function): 
    try: 
     return [operate_on_Narray(a, b, function) for a, b in zip(A, B)] 
    except TypeError as e: 
     # Not iterable 
     return function(A, B) 

उपयोग:

>>> x = [[2, 2, 2], 
...  [2, 2, 2], 
...  [2, 2, 2]] 
>>> 
>>> y = [[3, 3, 3], 
...  [3, 3, 3], 
...  [3, 3, 1]] 
>>> operate_on_Narray(x, y, lambda a, b: a+b) 
[[5, 5, 5], [5, 5, 5], [5, 5, 3]] 

यह में काम करेंगे किसी अन्य प्रकार की आयामी सरणी:

>>> operate_on_Narray([1, 2, 3], [4, 5, 6], lambda a, b: a*b) 
[4, 10, 18] 

Answer 3

एक पायथन 2.7.3 दुभाषिया सत्र से निम्नलिखित प्रतिलेख 2 डी-मैट्रिक्स तत्वों के लिए एक तत्व के अनुसार ऑपरेशन लागू करने के लिए बिल्टिन फ़ंक्शन map का उपयोग दिखाता है। (नोट: operator.addapplier के दूसरे प्रयोग में लैम्ब्डा अभिव्यक्ति के लिए elementwise_function प्रश्न में निर्दिष्ट करने के लिए बराबर है, और यह भी बराबर है।)

>>> import operator 
>>> def applier(a, b, op): 
...  return map(lambda ro: map(op, ro[0], ro[1]), zip(a,b)) 
... 
>>> applier(x, y, operator.add) 
[[5, 5, 2], [5, 4, 5], [6, 5, 5]] 
>>> x; y 
[[2, 2, 1], [2, 2, 2], [3, 2, 2]] 
[[3, 3, 1], [3, 2, 3], [3, 3, 3]] 
>>> applier(x, y, lambda p,q: p+q) 
[[5, 5, 2], [5, 4, 5], [6, 5, 5]] 
>>> applier(x, y, lambda p,q: p-q) 
[[-1, -1, 0], [-1, 0, -1], [0, -1, -1]] 
>>> applier(x, y, lambda p,q: p*q) 
[[6, 6, 1], [6, 4, 6], [9, 6, 6]]