नम्पी में 0 डी सरणी क्यों स्केलर नहीं मानी जाती हैं?

Question

निश्चित रूप से एक 0 डी सरणी स्केलर है, लेकिन नम्पी ऐसा नहीं लगता है ... क्या मुझे कुछ याद आ रही है या क्या मैं अवधारणा को गलत समझ रहा हूं?

>>> foo = numpy.array(1.11111111111, numpy.float64) 
>>> numpy.ndim(foo) 
0 
>>> numpy.isscalar(foo) 
False 
>>> foo.item() 
1.11111111111 

Answer 1

किसी को इसके बारे में बहुत मुश्किल नहीं सोचना चाहिए। यह मानसिक स्वास्थ्य और व्यक्ति की दीर्घायु के लिए अंततः बेहतर है।

न्यूम्पी स्केलर-प्रकारों के साथ उत्सुक स्थिति इस तथ्य से बाहर थी कि 1x1 मैट्रिक्स को स्केलर प्रकारों में अपनाने के लिए कोई सुंदर और सुसंगत तरीका नहीं है। हालांकि गणितीय रूप से वे एक ही बात हैं, वे बहुत अलग कोड से संभाले जाते हैं।

यदि आप कोई भी वैज्ञानिक कोड कर रहे हैं, तो अंततः आप max(a) जैसी चीजों को सभी आकारों, यहां तक ​​कि स्केलर के मैट्रिस पर काम करने के लिए चाहते हैं। गणितीय रूप से, यह उम्मीद करने के लिए एक पूरी तरह समझदार बात है। हालांकि प्रोग्रामर के लिए इसका मतलब है कि जो भी प्रस्तुत करता है, उसमें स्मालर्स को .shape और .ndim attirbute होना चाहिए, इसलिए कम से कम ufuncs को Numpy में 21 संभावित स्केलर प्रकारों के लिए अपने इनपुट पर स्पष्ट प्रकार की जांच करने की आवश्यकता नहीं है।

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

नम्पी डेवलपर का समाधान अपने स्वयं के स्केलरी प्रकार के लिए दोनों एंड्रैय और पायथन स्केलर्स से उत्तराधिकारी होना है, ताकि सभी स्केलरों में भी .shape, .ndim, .T, आदि आदि हो। 1x1 मैट्रिक्स अभी भी वहां होगा, लेकिन यदि आप जानते हैं कि आप एक स्केलर से निपटेंगे तो इसका उपयोग निराश हो जाएगा। इस सिद्धांत में ठीक से काम करना चाहिए, कभी कभी आप अभी भी कुछ स्थानों पर जहां वे पेंट रोलर के साथ याद किया देख सकता था, और बदसूरत धर्मशाला सभी के लिए संपर्क में हैं देखने के लिए:

>>> from numpy import * 
>>> a = array(1) 
>>> b = int_(1) 
>>> a.ndim 
0 
>>> b.ndim 
0 
>>> a[...] 
array(1) 
>>> a[()] 
1 
>>> b[...] 
array(1) 
>>> b[()] 
1 

वहाँ वास्तव में कोई कारण नहीं क्यों a[...] और a[()] चाहिए विभिन्न चीजें वापस करें, लेकिन यह करता है। इसे बदलने के लिए प्रस्ताव हैं, लेकिन ऐसा लगता है कि वे 1x1 सरणी के लिए नौकरी खत्म करना भूल गए हैं।

एक संभावित रूप से बड़ा, और संभवतः गैर-हल करने योग्य मुद्दा यह तथ्य है कि बेवकूफ स्केलर अपरिवर्तनीय हैं। इसलिए एक अंडाकार में एक स्केलर "छिड़काव", गणितीय रूप से एक स्केलर में एक सरणी को ध्वस्त करने के आसन्न ऑपरेशन, लागू करने के लिए एक पिटा है। आप वास्तव में एक Numpy अदिश विकसित नहीं कर सकते हैं, यह परिभाषा के द्वारा एक ndarray में डाला जा सकता है, यहां तक ​​कि newaxis हालांकि रहस्यमय तरीके से इस पर काम करता है:

मैटलैब में

>>> b[0,1,2,3] = 1 
Traceback (most recent call last): 
    File "<stdin>", line 1, in <module> 
TypeError: 'numpy.int32' object does not support item assignment 
>>> b[newaxis] 
array([1]) 

, एक अदिश का आकार बढ़ रहा है एक पूरी तरह से स्वीकार्य और बेवक़ूफ़ है ऑपरेशन। Numpy में आपको a = array(a) हर जगह आपको लगता है आपको स्केलर से शुरू करने और सरणी के साथ समाप्त होने की संभावना होगी।मैं समझता हूं कि क्यों पाउथन के साथ अच्छा खेलने के लिए नोम्पी को इस तरह से होना चाहिए, लेकिन यह इस तथ्य को नहीं बदलेगा कि कई नए स्विचर इस बारे में गहराई से उलझन में हैं। कुछ लोगों के पास इस व्यवहार से संघर्ष करने और अंततः दृढ़ता से चलने की स्पष्ट याददाश्त होती है, जबकि अन्य लोग जो बहुत दूर चले जाते हैं, आम तौर पर कुछ गहरे आकार के मानसिक निशान के साथ छोड़ दिए जाते हैं जो अक्सर अपने सबसे निर्दोष सपनों को हराते हैं। यह सभी के लिए एक बदसूरत स्थिति है। दार्शनिक परिचय के लिए

Answer 2

आप एक छोटा सा अलग ढंग से अदिश सरणी बनाने के लिए:

>>> x = numpy.float64(1.111) 
>>> x 
1.111 
>>> numpy.isscalar(x) 
True 
>>> numpy.ndim(x) 
0 

यह क्या आप एक विशुद्ध गणितीय दृष्टि से किया जा सकता है से थोड़ा अलग अवधारणा हो सकता है scalars in numpy तरह दिखता है। मुझे लगता है कि आप स्केलर मैट्रिक्स के मामले में सोच रहे हैं?