NumPy 1.14 - Data type objects (dtype)

डेटा प्रकार ऑब्जेक्ट (dtype)




numpy

डेटा प्रकार ऑब्जेक्ट (dtype)

एक डेटा प्रकार ऑब्जेक्ट ( numpy.dtype क्लास का एक उदाहरण) वर्णन करता है कि किसी सरणी आइटम के अनुरूप मेमोरी के निश्चित-आकार के ब्लॉक में बाइट्स की व्याख्या कैसे की जानी चाहिए। यह डेटा के निम्नलिखित पहलुओं का वर्णन करता है:

  1. डेटा का प्रकार (पूर्णांक, फ्लोट, पायथन ऑब्जेक्ट, आदि)
  2. डेटा का आकार ( उदाहरण के लिए कितने बाइट्स पूर्णांक है)
  3. डेटा का बाइट क्रम ( छोटा-एंडियन या बड़ा-एंडियन )
  4. यदि डेटा प्रकार संरचित है , तो अन्य डेटा प्रकारों का एक समुच्चय, ( जैसे , एक पूर्णांक और फ्लोट से मिलकर एक सरणी आइटम का वर्णन करना),
    1. संरचना के " फ़ील्ड " के नाम क्या हैं, जिसके द्वारा उन्हें accessed किया accessed सकता accessed ,
    2. प्रत्येक फ़ील्ड का डेटा-प्रकार क्या है, और
    3. मेमोरी का कौन सा भाग प्रत्येक क्षेत्र को ब्लॉक करता है।
  5. यदि डेटा प्रकार एक उप-सरणी है, तो इसका आकार और डेटा प्रकार क्या है।

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

ध्यान दें कि स्केलर प्रकार numpy.dtype ऑब्जेक्ट नहीं हैं, भले ही वे एक के स्थान पर उपयोग किए जा सकते हैं जब भी कोई डेटा प्रकार विनिर्देश NumPy में आवश्यक हो।

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

अंत में, एक डेटा प्रकार उन वस्तुओं का वर्णन कर सकता है जो स्वयं किसी अन्य डेटा प्रकार की वस्तुओं के सरणियाँ हैं। हालांकि, इन उप-सरणियों को एक निश्चित आकार का होना चाहिए।

यदि एक उप-सरणी का वर्णन करने वाले डेटा-प्रकार का उपयोग करके एक सरणी बनाई जाती है, तो सरणी बनाते समय उप-सरणी के आयाम को सरणी के आकार से जोड़ दिया जाता है। एक संरचित प्रकार के क्षेत्र में उप-सरणियाँ अलग तरह से व्यवहार करती हैं, accessed देखें।

उप-सरणियों में हमेशा सी-सन्निहित स्मृति लेआउट होता है।

उदाहरण

32-बिट बड़े-एंडियन पूर्णांक वाले एक साधारण डेटा प्रकार: ( निर्माण पर विवरण के लिए डेटा प्रकार निर्दिष्ट करना और बनाना )

>>> dt = np.dtype('>i4')
>>> dt.byteorder
'>'
>>> dt.itemsize
4
>>> dt.name
'int32'
>>> dt.type is np.int32
True

इसी सरणी स्केलर प्रकार int32

उदाहरण

एक संरचित डेटा प्रकार जिसमें 16-वर्ण स्ट्रिंग (फ़ील्ड 'नाम') और दो 64-बिट फ़्लोटिंग-पॉइंट नंबर (फ़ील्ड में 'ग्रेड') का उप-सरणी है:

>>> dt = np.dtype([('name', np.unicode_, 16), ('grades', np.float64, (2,))])
>>> dt['name']
dtype('|U16')
>>> dt['grades']
dtype(('float64',(2,)))

इस डेटा प्रकार के एक सरणी के आइटम एक सरणी स्केलर प्रकार में लिपटे होते हैं जिसमें दो फ़ील्ड भी होते हैं:

>>> x = np.array([('Sarah', (8.0, 7.0)), ('John', (6.0, 7.0))], dtype=dt)
>>> x[1]
('John', [6.0, 7.0])
>>> x[1]['grades']
array([ 6.,  7.])
>>> type(x[1])
<type 'numpy.void'>
>>> type(x[1]['grades'])
<type 'numpy.ndarray'>

डेटा प्रकार निर्दिष्ट करना और बनाना

जब भी एक NumPy फ़ंक्शन या विधि में डेटा-प्रकार की आवश्यकता होती है, तो एक numpy.dtype ऑब्जेक्ट या कुछ जिसे किसी में परिवर्तित किया जा सकता है, आपूर्ति की जा सकती है। इस तरह के रूपांतरण numpy.dtype कंस्ट्रक्टर द्वारा किए जाते हैं:

numpy.dtype (obj [, align, copy]) डेटा टाइप ऑब्जेक्ट बनाएं।

डेटा-टाइप ऑब्जेक्ट में क्या परिवर्तित किया जा सकता है, नीचे वर्णित है:

numpy.dtype ऑब्जेक्ट

के रूप में उपयोग किया जाता है।

None

डिफ़ॉल्ट डेटा प्रकार: float_

ऐरे-स्केलर प्रकार

24 बिल्ट-इन सरणी स्केलर टाइप ऑब्जेक्ट्स सभी संबंधित डेटा-टाइप ऑब्जेक्ट में कनवर्ट होते हैं। यह उनके उप-वर्गों के लिए भी सही है।

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

उदाहरण

>>> dt = np.dtype(np.int32)      # 32-bit integer
>>> dt = np.dtype(np.complex128) # 128-bit complex floating-point number

सामान्य प्रकार

सामान्य श्रेणीबद्ध प्रकार की वस्तुएं संघों के अनुसार संबंधित प्रकार की वस्तुओं में परिवर्तित होती हैं:

number , inexact , floating float
complexfloating cfloat
integer , signedinteger int_
unsignedinteger uint
character string
generic , flexible void

अंतर्निहित पायथन प्रकार

जब एक numpy.dtype ऑब्जेक्ट उत्पन्न करने के लिए उपयोग किया जाता है तो कई अजगर प्रकार एक संबंधित सरणी स्केलर के बराबर होते हैं:

int int_
bool bool_
float float_
complex cfloat
bytes bytes_
str bytes_ (पायथन 2) या unicode_ (पायथन 3)
unicode unicode_
buffer void
(बाकी सब) object_

ध्यान दें कि स्ट्रिंग पायथन संस्करण के आधार पर या तो शून्य समाप्त बाइट्स या यूनिकोड स्ट्रिंग्स को संदर्भित करता है। Python 2 और 3 np.unicode_ दोनों को लक्षित करने वाले कोड में स्ट्रिंग के लिए dtype के रूप में उपयोग किया जाना चाहिए। स्ट्रिंग प्रकार पर ध्यान दें देखें।

उदाहरण

>>> dt = np.dtype(float)   # Python-compatible floating-point number
>>> dt = np.dtype(int)     # Python-compatible integer
>>> dt = np.dtype(object)  # Python object

प्रकार .dtype साथ

dtype विशेषता के साथ किसी भी प्रकार की वस्तु: विशेषता को सीधे एक्सेस और उपयोग किया जाएगा। विशेषता को ऐसी चीज़ को वापस करना होगा जो एक dtype ऑब्जेक्ट में कन्वर्टिबल है।

कई प्रकार के तारों को परिवर्तित किया जा सकता है। बाइट ऑर्डर को निर्दिष्ट करने के लिए मान्यता प्राप्त तारों को '>' ( बड़े-एंडियन ), '<' ( छोटे-एंडियन ), या '=' (हार्डवेयर-मूल, डिफ़ॉल्ट) के साथ जोड़ा जा सकता है।

एक वर्ण का तार

प्रत्येक अंतर्निहित डेटा-प्रकार में एक वर्ण कोड (अद्यतन न्यूमेरिक टाइपकोड) होता है, जो विशिष्ट रूप से इसकी पहचान करता है।

उदाहरण

>>> dt = np.dtype('b')  # byte, native byte order
>>> dt = np.dtype('>H') # big-endian unsigned short
>>> dt = np.dtype('<f') # little-endian single-precision float
>>> dt = np.dtype('d')  # double-precision floating-point number

ऐरे-प्रोटोकॉल प्रकार के तार ( ऐरे इंटरफ़ेस देखें)

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

'?' बूलियन
'b' (हस्ताक्षर किए हुए) बाइट
'B' अहस्ताक्षरित बाइट
'i' (हस्ताक्षरित) पूर्णांक
'u' अहस्ताक्षरित पूर्णांक
'f' तैरनेवाला स्थल
'c' जटिल-अस्थायी बिंदु
'm' timedelta
'M' दिनांक समय
'O' (पायथन) ऑब्जेक्ट्स
'S' , 'a' शून्य-समाप्त बाइट्स (अनुशंसित नहीं)
'U' यूनिकोड स्ट्रिंग
'V' कच्चा डेटा ( void )

उदाहरण

>>> dt = np.dtype('i4')   # 32-bit signed integer
>>> dt = np.dtype('f8')   # 64-bit floating-point number
>>> dt = np.dtype('c16')  # 128-bit complex floating-point number
>>> dt = np.dtype('a25')  # 25-length zero-terminated bytes
>>> dt = np.dtype('U25')  # 25-character string

स्ट्रिंग प्रकारों पर ध्यान दें

अजगर 2 S के साथ पिछड़े संगतता के लिए और a टाइपस्ट्रीम शून्य-शून्य बाइट्स रहता है और np.string_ लिए मैप करना जारी np.bytes_ । पायथन 3 में वास्तविक तारों का उपयोग करने के लिए U या np.unicode_ उपयोग करें। हस्ताक्षरित बाइट्स के लिए जिन्हें शून्य-समाप्ति की आवश्यकता नहीं है b या i1 का उपयोग किया जा सकता है।

अल्पविराम से अलग क्षेत्रों के साथ स्ट्रिंग

संरचित डेटा प्रकार के प्रारूप को निर्दिष्ट करने के लिए एक शॉर्ट-हैंड नोटेशन बुनियादी प्रारूपों का एक अल्पविराम से अलग स्ट्रिंग है।

इस संदर्भ में एक बुनियादी प्रारूप एक वैकल्पिक आकार निर्दिष्ट है, जिसके बाद एक सरणी-प्रोटोकॉल प्रकार स्ट्रिंग है। यदि एक से अधिक आयाम हैं, तो आकार पर कोष्ठक की आवश्यकता होती है। NumPy प्रारूप में एक संशोधन की अनुमति देता है जिसमें किसी भी स्ट्रिंग को विशिष्ट प्रकार से पहचाना जा सकता है जिसका उपयोग किसी क्षेत्र में डेटा-प्रकार को निर्दिष्ट करने के लिए किया जा सकता है। जनरेट किए गए डेटा-टाइप फ़ील्ड को 'f0' , 'f1' , ..., 'f<N-1>' जहां N (> 1) स्ट्रिंग में अल्पविराम से अलग किए गए मूल स्वरूपों की संख्या है। यदि वैकल्पिक आकार निर्दिष्ट किया जाता है, तो संबंधित फ़ील्ड के लिए डेटा-प्रकार एक उप-सरणी का वर्णन करता है।

उदाहरण

  • फ़ील्ड जिसका नाम f0 जिसमें 32-बिट पूर्णांक है
  • फ़ील्ड जिसका नाम f1 जिसमें 2-x 3 उप-सरणी 64-बिट फ़्लोटिंग-पॉइंट संख्या है
  • f2 नामक फ़ील्ड जिसमें 32-बिट फ़्लोटिंग-पॉइंट संख्या होती है
>>> dt = np.dtype("i4, (2,3)f8, f4")
  • f0 नामक फ़ील्ड जिसमें 3-वर्ण स्ट्रिंग है
  • f1 नाम का फ़ील्ड जिसमें आकार का उप-सरणी है (3), जिसमें 64-बिट अहस्ताक्षरित पूर्णांक हैं
  • f2 नामक फ़ील्ड में 3 x 4 उप-सरणी होती है जिसमें 10-वर्ण स्ट्रिंग्स होते हैं
>>> dt = np.dtype("a3, 3u8, (3,4)a10")

तार टाइप करें

numpy.sctypeDict .keys () में कोई भी स्ट्रिंग:

उदाहरण

>>> dt = np.dtype('uint32')   # 32-bit unsigned integer
>>> dt = np.dtype('Float64')  # 64-bit floating-point number

(flexible_dtype, itemsize)

पहला तर्क एक ऑब्जेक्ट होना चाहिए जो शून्य-आकार के लचीले डेटा-प्रकार ऑब्जेक्ट में बदल जाता है, दूसरा तर्क वांछित आकार प्रदान करने वाला पूर्णांक है।

उदाहरण

>>> dt = np.dtype((np.void, 10))  # 10-byte wide data block
>>> dt = np.dtype(('U', 10))   # 10-character unicode string

(fixed_dtype, shape)

पहला तर्क किसी भी ऑब्जेक्ट को एक निश्चित आकार के डेटा-प्रकार ऑब्जेक्ट में परिवर्तित किया जा सकता है। दूसरा तर्क इस प्रकार का वांछित आकार है। यदि आकृति पैरामीटर 1 है, तो डेटा-टाइप ऑब्जेक्ट निश्चित dtype के बराबर है। यदि आकार एक टपल है, तो नया dtype दिए गए आकार के उप-सरणी को परिभाषित करता है।

उदाहरण

>>> dt = np.dtype((np.int32, (2,2)))          # 2 x 2 integer sub-array
>>> dt = np.dtype(('U10', 1))                 # 10-character string
>>> dt = np.dtype(('i4, (2,3)f8, f4', (2,3))) # 2 x 3 structured sub-array

[(field_name, field_dtype, field_shape), ...]

obj उन फ़ील्ड्स की एक सूची होनी चाहिए जहाँ प्रत्येक फ़ील्ड को लंबाई 2 या 3 के tuple द्वारा वर्णित किया गया है। ( __array_interface__ विशेषता में descr आइटम के __array_interface__ है।)

पहला तत्व, field_name , फ़ील्ड नाम है (यदि यह '' तो एक मानक फ़ील्ड नाम, 'f#' , असाइन किया गया है)। फ़ील्ड नाम तार का 2-टुपल भी हो सकता है जहां पहला स्ट्रिंग या तो एक "शीर्षक" है (जो किसी भी स्ट्रिंग या यूनिकोड स्ट्रिंग हो सकता है) या फ़ील्ड के लिए मेटा-डेटा जो कोई भी वस्तु हो सकती है, और दूसरा स्ट्रिंग है "नाम" जो एक मान्य पायथन पहचानकर्ता होना चाहिए।

दूसरा तत्व, field_dtype , कुछ भी हो सकता है जिसे डेटा-प्रकार के रूप में व्याख्या किया जा सकता है।

वैकल्पिक तीसरा तत्व field_shape में आकृति होती है यदि यह फ़ील्ड दूसरे तत्व में डेटा-प्रकार की एक सरणी का प्रतिनिधित्व करती है। ध्यान दें कि 1 के बराबर तीसरे तर्क के साथ 3-ट्यूपल 2-ट्यूपल के बराबर है।

यह शैली numpy.dtype कंस्ट्रक्टर में संरेखित नहीं करती है क्योंकि यह माना जाता है कि सभी की मेमोरी सरणी विवरण के अनुसार है।

उदाहरण

big (बड़े-एंडियन 32-बिट पूर्णांक) और little (छोटे-एंडियन 32-बिट पूर्णांक) फ़ील्ड के साथ डेटा-प्रकार:

>>> dt = np.dtype([('big', '>i4'), ('little', '<i4')])

R , G , B , A , प्रत्येक 8-बिट पूर्णांक वाले फ़ील्ड के साथ डेटा-प्रकार:

>>> dt = np.dtype([('R','u1'), ('G','u1'), ('B','u1'), ('A','u1')])

{'names': ..., 'formats': ..., 'offsets': ..., 'titles': ..., 'itemsize': ...}

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

जब वैकल्पिक कुंजी ऑफ़सेट और शीर्षक प्रदान किए जाते हैं, तो उनके मानों को प्रत्येक के नाम और प्रारूप सूची के समान लंबाई की सूची होनी चाहिए। ऑफ़सेट्स मान प्रत्येक फ़ील्ड के लिए बाइट ऑफ़सेट्स (पूर्णांक) की एक सूची है, जबकि शीर्षकों का मान प्रत्येक फ़ील्ड के शीर्षकों की सूची है (यदि कोई शीर्षक उस फ़ील्ड के लिए वांछित नहीं है, तो इसका उपयोग किया जा सकता है)। शीर्षक किसी भी string या unicode ऑब्जेक्ट हो सकते हैं और शीर्षक द्वारा बंद किए गए फ़ील्ड शब्दकोश में एक और प्रविष्टि जोड़ देंगे और उसी फ़ील्ड टपल को संदर्भित करेंगे जिसमें शीर्षक को अतिरिक्त टपल सदस्य के रूप में शामिल किया जाएगा।

आइटम कुंजी कुंजी सेट करने के लिए dtype के कुल आकार की अनुमति देता है, और एक पूर्णांक बड़ा होना चाहिए ताकि सभी फ़ील्ड dtype के भीतर हों। यदि dtype का निर्माण किया जा रहा है, तो संरेखित किया जाना चाहिए, संरेखित संरेखण द्वारा आइटम भी विभाज्य होना चाहिए।

उदाहरण

फ़ील्ड r , g , b , a साथ डेटा प्रकार, प्रत्येक एक 8-बिट अहस्ताक्षरित पूर्णांक:

>>> dt = np.dtype({'names': ['r','g','b','a'],
...                'formats': [uint8, uint8, uint8, uint8]})

डेटा प्रकार फ़ील्ड्स के साथ r और b (दिए गए शीर्षकों के साथ), दोनों 8-बिट अहस्ताक्षरित पूर्णांक, फ़ील्ड की शुरुआत से बाइट स्थिति 0 पर पहला और स्थिति 2 पर दूसरा:

>>> dt = np.dtype({'names': ['r','b'], 'formats': ['u1', 'u1'],
...                'offsets': [0, 2],
...                'titles': ['Red pixel', 'Blue pixel']})

{'field1': ..., 'field2': ..., ...}

यह उपयोग हतोत्साहित किया जाता है, क्योंकि यह अन्य तानाशाही-आधारित निर्माण विधि से अस्पष्ट है। यदि आपके पास एक फ़ील्ड है जिसका नाम 'नाम' है और एक फ़ील्ड जिसे 'फ़ॉर्मेट' कहा जाता है, तो एक संघर्ष होगा।

यह शैली डेटा-प्रकार ऑब्जेक्ट के fields विशेषता में गुजरने की अनुमति देती है।

obj में स्ट्रिंग या यूनिकोड कुंजियाँ होनी चाहिए जो (data-type, offset) या (data-type, offset, title) वूपल्स को संदर्भित करती हैं।

उदाहरण

डेटा प्रकार जिसमें फ़ील्ड col1 (बाइट स्थिति में 10-वर्ण स्ट्रिंग), col2 (बाइट स्थिति 10 पर 32-बिट फ़्लोट), और col3 (बाइट स्थिति 14 में पूर्णांक):

>>> dt = np.dtype({'col1': ('U10', 0), 'col2': (float32, 10),
    'col3': (int, 14)})

(base_dtype, new_dtype)

NumPy 1.7 और बाद में, यह फ़ॉर्म base_dtype को संरचित dtype के रूप में व्याख्या करने की अनुमति देता है। इस dtype के साथ बनाई गई सारणियों में अंतर्निहित dtype base_dtype होगा, लेकिन इसमें base_dtype से लिए गए फ़ील्ड और फ़्लैग new_dtype । यह कस्टम संरचित dtypes बनाने के लिए उपयोगी है, जैसा कि रिकॉर्ड सरणियों में किया जाता है।

यह फ़ॉर्म ओवरलैपिंग फ़ील्ड्स के साथ संरचनात्मक dtypes को निर्दिष्ट करने के लिए भी संभव बनाता है, सी में 'संघ' प्रकार की तरह कार्य करना। यह उपयोग हतोत्साहित किया जाता है, हालांकि, और संघ तंत्र को प्राथमिकता दी जाती है।

दोनों तर्कों को एक ही कुल आकार के साथ डेटा-टाइप ऑब्जेक्ट के लिए परिवर्तनीय होना चाहिए। .. उपदेश :: उदाहरण

32-बिट पूर्णांक, जिनके पहले दो बाइट्स को क्षेत्र real माध्यम से एक पूर्णांक के रूप में व्याख्या की जाती है, और निम्नलिखित दो बाइट्स क्षेत्र imag माध्यम से।

>>> dt = np.dtype((np.int32,{'real':(np.int16, 0),'imag':(np.int16, 2)})

32-बिट पूर्णांक, जो आकार के उप-सरणी (4,) मिलकर बना होता है (4,) जिसमें 8-बिट पूर्णांक होते हैं:

>>> dt = np.dtype((np.int32, (np.int8, 4)))

32-बिट पूर्णांक, जिसमें फ़ील्ड r , g , b , जो पूर्णांक में 4 बाइट्स की व्याख्या चार अनिर्धारित पूर्णांक के रूप में करता है:

>>> dt = np.dtype(('i4', [('r','u1'),('g','u1'),('b','u1'),('a','u1')]))

dtype

NumPy डेटा प्रकार विवरण numpy.dtype वर्ग के उदाहरण हैं।

गुण

डेटा का प्रकार निम्नलिखित numpy.dtype विशेषताओं द्वारा वर्णित है:

dtype.type इस डेटा प्रकार के एक स्केलर को तुरंत टाइप करने के लिए जिस प्रकार की वस्तु का उपयोग किया जाता है।
dtype.kind एक चरित्र कोड ('biufcmMOSUV') सामान्य प्रकार के डेटा की पहचान करता है।
dtype.char 21 अलग-अलग अंतर्निहित प्रकारों में से प्रत्येक के लिए एक अद्वितीय वर्ण कोड।
dtype.num 21 अलग-अलग प्रकारों में से प्रत्येक के लिए एक अद्वितीय संख्या।
dtype.str इस डेटा-प्रकार ऑब्जेक्ट का सरणी-प्रोटोकॉल टाइपस्ट्रिंग।

डेटा का आकार बदले में इसके द्वारा वर्णित है:

dtype.name इस डेटा-प्रकार के लिए एक बिट-चौड़ाई नाम।
dtype.itemsize इस डेटा-प्रकार ऑब्जेक्ट का तत्व आकार।

इस डेटा की समाप्ति:

dtype.byteorder इस डेटा-प्रकार ऑब्जेक्ट के बाइट-ऑर्डर को इंगित करने वाला एक चरित्र।

संरचित डेटा प्रकार में उप-डेटा-प्रकार के बारे में जानकारी:

fields इस डेटा प्रकार, या None लिए नामित फ़ील्ड के शब्दकोश।
dtype.names क्षेत्र के नाम की क्रमबद्ध सूची, या None भी क्षेत्र न होने पर।

उप-सरणियों का वर्णन करने वाले डेटा प्रकारों के लिए:

dtype.subdtype Tuple (item_dtype, shape) यदि यह numpy.dtype उप-सरणी का वर्णन करता है, और कोई नहीं तो।
dtype.shape यदि यह डेटा प्रकार उप-सरणी का वर्णन करता है, और ()

अतिरिक्त जानकारी प्रदान करने वाले गुण:

dtype.hasobject बूलियन यह इंगित करता है कि क्या इस dtype में किसी भी फ़ील्ड या उप-dypypes में कोई संदर्भ-गणना की गई ऑब्जेक्ट्स हैं।
dtype.flags इस डेटा प्रकार की व्याख्या कैसे की जाए, इसका वर्णन करने वाले बिट-फ्लैग।
dtype.isbuiltin पूर्णांक यह दर्शाता है कि यह dtype अंतर्निहित dtypes से कैसे संबंधित है।
dtype.isnative बूलियन यह दर्शाता है कि क्या इस dtype का बाइट ऑर्डर प्लेटफॉर्म का मूल है।
dtype.descr PEP3118 डेटा-प्रकार का इंटरफ़ेस विवरण।
dtype.alignment संकलक के अनुसार इस डेटा-प्रकार के आवश्यक संरेखण (बाइट्स)।

तरीके

बाइट क्रम को बदलने के लिए डेटा प्रकार निम्नलिखित विधि है:

dtype.newbyteorder ([new_order]) एक अलग बाइट क्रम के साथ एक नया dtype लौटाएं।

निम्नलिखित तरीके अचार प्रोटोकॉल को लागू करते हैं:

dtype.__reduce__
dtype.__setstate__