अजगर में संख्यात्मक प्रकार की पहचान कैसे करें?

Question 1

यदि कोई वस्तु एक सुन्न प्रकार की है तो कोई कैसे निश्चित रूप से निर्धारित कर सकता है?

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

Question 2

typeप्रकार प्राप्त करने के लिए अंतर्निहित फ़ंक्शन का उपयोग करें , फिर आप __module__संपत्ति का उपयोग यह पता लगाने के लिए कर सकते हैं कि यह कहां परिभाषित किया गया था:

>>> import numpy as np
a = np.array([1, 2, 3])
>>> type(a)
<type 'numpy.ndarray'>
>>> type(a).__module__
'numpy'
>>> type(a).__module__ == np.__name__
True

Question 3

जो समाधान मैं लेकर आया हूं वह है:

isinstance(y, (np.ndarray, np.generic) )

हालाँकि, यह 100% स्पष्ट नहीं है कि सभी प्रकार के खट्टे प्रकारों की गारंटी दी जाती है np.ndarrayया np.generic, और यह संभवतः संस्करण मजबूत नहीं है।

Question 4

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

##################
# important part!
##################

import numpy as np

####################
# toy array for demo
####################

arr = np.asarray(range(1,100,2))

########################
# The instance check
######################## 

isinstance(arr,np.ndarray)

Question 5

यह वास्तव में आप क्या देख रहे हैं पर निर्भर करता है।

यदि आप परीक्षण करना चाहते हैं कि क्या वास्तव में एक अनुक्रम एक है ndarray, एक isinstance(..., np.ndarray)शायद सबसे आसान है। सुनिश्चित करें कि आप पृष्ठभूमि में सुन्न नहीं हैं क्योंकि मॉड्यूल अलग हो सकता है, लेकिन अन्यथा, आपको ठीक होना चाहिए। MaskedArrays, matrix, recarrayके सभी उपवर्गों हैं ndarray, तो आप सेट किया जाना चाहिए।
यदि आप परीक्षण करना चाहते हैं कि क्या एक अदिश एक अदिश अदिश राशि है, तो चीजें थोड़ी अधिक जटिल हो जाती हैं। आप देख सकते हैं कि इसमें shapeएक dtypeविशेषता है या नहीं। आप इसकी तुलना dtypeमूल dtypes से कर सकते हैं, जिसकी सूची आप पा सकते हैं np.core.numerictypes.genericTypeRank। ध्यान दें कि इस सूची के तत्व स्ट्रिंग हैं, इसलिए आपको एक करना होगा tested.dtype is np.dtype(an_element_of_the_list)...

Question 6

प्रकार प्राप्त करने के लिए, अंतर्निहित typeफ़ंक्शन का उपयोग करें । inऑपरेटर के साथ , आप यह जांच कर सकते हैं कि क्या टाइप में एक खसरा प्रकार है या नहीं, अगर यह स्ट्रिंग है numpy;

In [1]: import numpy as np

In [2]: a = np.array([1, 2, 3])

In [3]: type(a)
Out[3]: <type 'numpy.ndarray'>

In [4]: 'numpy' in str(type(a))
Out[4]: True

(यह उदाहरण आईपीथॉन में चलाया गया था , वैसे भी। इंटरैक्टिव उपयोग और त्वरित परीक्षणों के लिए बहुत आसान है।)

Question 7

ध्यान दें कि type(numpy.ndarray)एक typeही है और बूलियन और स्केलर प्रकारों के लिए बाहर देखो। अगर यह सहज या आसान नहीं है, तो निराश मत हो, यह पहली बार में दर्द है।

इसे भी देखें: - https://docs.scipy.org/doc/numpy-1.15.1/reference/arrays.dtypes.html - https://github.com/machinalis/mypy-data/tree/master/numpy- mypy

>>> import numpy as np
>>> np.ndarray
<class 'numpy.ndarray'>
>>> type(np.ndarray)
<class 'type'>
>>> a = np.linspace(1,25)
>>> type(a)
<class 'numpy.ndarray'>
>>> type(a) == type(np.ndarray)
False
>>> type(a) == np.ndarray
True
>>> isinstance(a, np.ndarray)
True

बुलियन के साथ मज़ा:

>>> b = a.astype('int32') == 11
>>> b[0]
False
>>> isinstance(b[0], bool)
False
>>> isinstance(b[0], np.bool)
False
>>> isinstance(b[0], np.bool_)
True
>>> isinstance(b[0], np.bool8)
True
>>> b[0].dtype == np.bool
True
>>> b[0].dtype == bool  # python equivalent
True

स्केलर प्रकारों के साथ अधिक मज़ा, देखें: - https://docs.scipy.org/doc/numpy-1.15.1/reference/arrays.scalars.html#arrays-scalars-built-in

>>> x = np.array([1,], dtype=np.uint64)
>>> x[0].dtype
dtype('uint64')
>>> isinstance(x[0], np.uint64)
True
>>> isinstance(x[0], np.integer)
True  # generic integer
>>> isinstance(x[0], int)
False  # but not a python int in this case

# Try matching the `kind` strings, e.g.
>>> np.dtype('bool').kind                                                                                           
'b'
>>> np.dtype('int64').kind                                                                                          
'i'
>>> np.dtype('float').kind                                                                                          
'f'
>>> np.dtype('half').kind                                                                                           
'f'

# But be weary of matching dtypes
>>> np.integer
<class 'numpy.integer'>
>>> np.dtype(np.integer)
dtype('int64')
>>> x[0].dtype == np.dtype(np.integer)
False

# Down these paths there be dragons:

# the .dtype attribute returns a kind of dtype, not a specific dtype
>>> isinstance(x[0].dtype, np.dtype)
True
>>> isinstance(x[0].dtype, np.uint64)
False  
>>> isinstance(x[0].dtype, np.dtype(np.uint64))
Traceback (most recent call last):
  File "<console>", line 1, in <module>
TypeError: isinstance() arg 2 must be a type or tuple of types
# yea, don't go there
>>> isinstance(x[0].dtype, np.int_)
False  # again, confusing the .dtype with a specific dtype


# Inequalities can be tricky, although they might
# work sometimes, try to avoid these idioms:

>>> x[0].dtype <= np.dtype(np.uint64)
True
>>> x[0].dtype <= np.dtype(np.float)
True
>>> x[0].dtype <= np.dtype(np.half)
False  # just when things were going well
>>> x[0].dtype <= np.dtype(np.float16)
False  # oh boy
>>> x[0].dtype == np.int
False  # ya, no luck here either
>>> x[0].dtype == np.int_
False  # or here
>>> x[0].dtype == np.uint64
True  # have to end on a good note!