पायथन इंट और लंबे का प्रबंधन कैसे करता है?

118

क्या किसी को पता है कि पायथन आंतरिक रूप से इंट और लंबे प्रकारों का प्रबंधन कैसे करता है?

क्या यह गतिशील रूप से सही प्रकार का चयन करता है?
इंट के लिए सीमा क्या है?
मैं पायथन 2.6 का उपयोग कर रहा हूं, पिछले संस्करणों के साथ अलग है?

मुझे नीचे दिए गए कोड को कैसे समझना चाहिए?

>>> print type(65535)
<type 'int'>
>>> print type(65536*65536)
<type 'long'>

अपडेट करें:

>>> print type(0x7fffffff)
<type 'int'>
>>> print type(0x80000000)
<type 'long'>

python integer

— ल्यूक
स्रोत

क्या वे सिर्फ CPython में फ्लाई अंडरनेट पर stdc प्रकारों का नक्शा बनाते हैं?

— इलियन बेल

हाँ, मुझे लगता है कि वे करते हैं। मुझे यह भी संदेह है कि सब कुछ ढेर पर आवंटित किया गया है, इसलिए जब किसी संख्या को अधिक सटीकता की आवश्यकता होती है तो वे reallocइसे ठीक करते हैं। लेकिन मुझे यकीन नहीं है, इसलिए मैं किसी और को जवाब छोड़ दूंगा।

— 21

2

आप अजगर को लंबे समय तक चर का उपयोग करने के लिए मजबूर कर सकते हैंvar = 666L

— Qba

8

@ इग्नासियो: गलत एक सीपीथॉन intएक सी है long(डिफ़ॉल्ट रूप से हस्ताक्षरित है) ... देखें <CPython 2.X source>/Include/intobject.h: टाइपिडिफ संरचना {PyObject_HEAD लंबे ob_ival; } PyIntObject; किसी भी मामले में पायथन 2.x intनकारात्मक संख्या की अनुमति देता है; C unsignedकेवल सामना नहीं करेगा।

— जॉन माकिन

PEP 237 चर्चा करता है कि कैसे हूड पायथन के तहत यह सब एक समान प्रतीत होता है।

— Carel

124

intऔर कुछ संस्करणोंlong में "एकीकृत" थे । इससे पहले गणित ऑप्स के माध्यम से एक इंट को ओवरफ्लो करना संभव था।

3.x ने इसे लंबे समय तक पूरी तरह से खत्म कर दिया है और केवल इंट में है।

पायथन 2 : sys.maxintअधिकतम मूल्य में एक पायथन इंट पकड़ सकता है।
- 64-बिट पायथन 2.7 पर, आकार 24 बाइट्स है। के साथ जाँच करें sys.getsizeof()।
पायथन 3 : sys.maxsizeबाइट्स में अधिकतम आकार होता है एक पायथन इंट हो सकता है।
- यह 32 बिट्स में गीगाबाइट और 64 बिट्स में एक्साबाइट होगा।
- इतने बड़े int का मान 8 की शक्ति के समान होगा sys.maxsize।

— इग्नासियो वाज़केज़-अब्राम्स
स्रोत

30

लेकिन Python3 इस प्रकार को 'int' कहता है, भले ही यह 2.x के 'long' की तरह अधिक व्यवहार करता है।

3

टेड द्वारा टिप्पणी: जैसा कि नीचे उल्लेख किया गया है कि अधिकतम करने के लिए int से कुछ कास्टिंग करना अभी भी एक लंबा परिणाम होगा >>> प्रकार (int (sys.maxint + 1)) <प्रकार 'लंबी'>

— स्टुअर्टएलसी

2

sys.maxint आपको सबसे बड़ा 64 बिट पूर्णांक (मेरी 64 बिट मशीन पर) देगा एक लोंग इतना बड़ा हो सकता है कि 64 बिट्स, बस "sys.maxint << 1000000"

— आज़माएं

4

Python3 में यह sys.maxsize है

— pylover

3

sys.maxsize का पूर्णांकों से कोई संबंध नहीं है। पायथन 3 का sys.maxint हटा दिया गया था क्योंकि पूर्णांक के लिए कोई अधिकतम आकार नहीं है (Python 3's int, Python 2 के समान है long)।

— 20

19

इस पीईपी को मदद करनी चाहिए।

लब्बोलुआब यह है कि आपको वास्तव में अजगर संस्करणों> 2.4 में इसके बारे में चिंता नहीं करनी चाहिए

— mluebke
स्रोत

15

आपको इसके बारे में चिंता करने की ज़रूरत है यदि आपको सी में एक इंट फ़ंक्शन को कुछ के साथ कॉल करना है जो इंट (यानी एक लंबा) में फिट नहीं होगा। लंबे समय तक कास्टिंग की कोई राशि-> int मदद नहीं करेगा। अभी हाल ही में मेरे पास आया।

— मैके

1

@ मैके: इस टिप्पणी ने मुझे बचा लिया, मैंने मान लिया कि इंट ट्रिक करेगा, और सोच रहा था कि मुझे अभी भी जेथोन अपवाद क्यों मिल रहा है।

— टेड

@ मैके बिल्कुल सच। वर्तमान में मैं जिस कंपनी में काम करता हूं उसमें हमारे पास पायथन में लिखा एक सिम्युलेटर है जो टिंकर प्रविष्टियों के माध्यम से उपयोगकर्ता इनपुट लेता है और एक ग्राहक को टीसीपी / आईपी के माध्यम से डाले गए मानों (सी / सी ++ में लिखा हुआ) भेजता है जो एक एम्बेडेड सिस्टम की नकल करता है। कल्पना कीजिए कि जब आप अपने पायथन-आधारित प्रवेश में 100000000000000000000000

— डालते हैं

@ मैके अच्छी तरह से अगर आप वास्तव में पीईपी को पढ़ने के लिए परेशान हैं, तो यह स्पष्ट रूप से कहता है: सी एपीआई अपरिवर्तित रहता है; सी कोड को अभी भी शॉर्ट और लॉन्ग इनट्स के बीच अंतर के बारे में पता होना चाहिए। (Python 3.0 C API शायद पूरी तरह से असंगत होगा।) PyArg_Parse * () API पहले से ही लंबे इन्टस को स्वीकार करते हैं, जब तक कि वे C ints या longs द्वारा प्रतिनिधित्व करने योग्य सीमा के भीतर हैं, इसलिए C int या लंबे तर्क को लेने वाले कार्य जीते गए। ' टी को पाइथन लॉन्ग से निपटने के बारे में चिंता करनी होगी।

— काउबर्ट

4

मेरी मशीन पर:

>>> print type(1<<30)
<type 'int'>
>>> print type(1<<31)
<type 'long'>
>>> print type(0x7FFFFFFF)
<type 'int'>
>>> print type(0x7FFFFFFF+1)
<type 'long'>

पायथन का उपयोग करता है ints (32 बिट हस्ताक्षरित पूर्णांक, मुझे नहीं पता कि वे हुड के नीचे सी ints हैं या नहीं) उन मानों के लिए जो 32 बिट में फिट होते हैं, लेकिन स्वचालित रूप से लंबे समय तक स्विच करते हैं (मनमाने ढंग से बड़ी संख्या में बिट्स - यानी कि कुछ भी)। बड़ा। मैं अनुमान लगा रहा हूँ कि यह गति छोटे मूल्यों के लिए है, जबकि किसी भी अतिवृद्धि से बचने के लिए एक सहज संक्रमण के साथ bignums।

— MAK
स्रोत

4

दिलचस्प। मेरे 64-बिट (i7 Ubuntu) बॉक्स पर:

>>> print type(0x7FFFFFFF)
<type 'int'>
>>> print type(0x7FFFFFFF+1)
<type 'int'>

लगता है कि यह एक बड़ी मशीन पर 64 बिट्स तक कदम रखता है।

— ग्रिंगो सुवे
स्रोत

2

मशीन के लिए पायथन बड़े पूर्णांक प्रकार का उपयोग करता है। एसओ आमतौर पर 32-बिट मशीनों पर इंट का 32 बिट आकार होगा, जबकि 64 बिट मशीनों पर इसका 64 बिट आकार होगा। लेकिन 64-बिट पूर्णांक को परिभाषित करने वाले 32-बिट आर्किटेक्चर हो सकते हैं, उस स्थिति में अजगर 64-बिट पूर्णांक का उपयोग करेगा।

— बाकुरि

4

पायथन 2.7.9 ऑटो संख्या को बढ़ावा देता है। ऐसे मामले के लिए जहां कोई int () या लॉन्ग () का उपयोग करने के लिए अनिश्चित है।

>>> a = int("123")
>>> type(a)
<type 'int'>
>>> a = int("111111111111111111111111111111111111111111111111111")
>>> type(a)
<type 'long'>

— NVD
स्रोत

4

पायथन 2 स्वचालित रूप से मूल्य के आकार के आधार पर प्रकार सेट करेगा। अधिकतम मूल्यों का एक गाइड नीचे पाया जा सकता है।

पायथन 2 में डिफ़ॉल्ट इंट का अधिकतम मूल्य 65535 है, इससे ऊपर कुछ भी लंबा होगा

उदाहरण के लिए:

>> print type(65535)
<type 'int'>
>>> print type(65536*65536)
<type 'long'>

पायथन 3 में लंबे डेटाटाइप को हटा दिया गया है और सभी पूर्णांक मानों को इंट क्लास द्वारा नियंत्रित किया जाता है। Int का डिफ़ॉल्ट आकार आपके CPU आर्किटेक्चर पर निर्भर करेगा।

उदाहरण के लिए:

32 बिट सिस्टम पूर्णांक के लिए डिफ़ॉल्ट डेटाटाइप 'Int32' होगा
64 बिट सिस्टम पूर्णांक के लिए डिफ़ॉल्ट डेटाटाइप 'Int64' होगा

प्रत्येक प्रकार का न्यूनतम / अधिकतम मान नीचे पाया जा सकता है:

Int8: [-128,127]
Int16: [-32768,32767]
Int32: [-2147483648,2147483647]
Int64: [-922337203685474780808,9223372036854775807]
Int128: [-1701411834604692317316873037158841057282817171183460469231731687303715884105727]
UInt8: [0,255]
UInt16: [0,65535]
UInt32: [0,4294967295]
UInt64: [0,18446744073709551615]
UInt128: [0,340282366920938463463374607431768211455]

यदि आपके इंट का आकार ऊपर उल्लिखित सीमा से अधिक है, तो अजगर स्वचालित रूप से इसे बदल देगा और मिनट / अधिकतम मूल्यों में इस वृद्धि को संभालने के लिए अधिक मेमोरी आवंटित करेगा। जहां पायथन 2 में, यह 'लॉन्ग' में परिवर्तित होता है, अब यह सिर्फ इंट के अगले आकार में परिवर्तित होता है।

उदाहरण: यदि आप 32 बिट ऑपरेटिंग सिस्टम का उपयोग कर रहे हैं, तो एक Int का अधिकतम मान डिफ़ॉल्ट रूप से 2147483647 होगा। यदि 2147483648 या अधिक का मान असाइन किया गया है, तो प्रकार बदलकर Int64 कर दिया जाएगा।

इंट के आकार की जांच करने के लिए अलग-अलग तरीके हैं और यह मेमोरी एलोकेशन है। नोट: पायथन 3 में, अंतर्निहित प्रकार () विधि का उपयोग करके हमेशा <class 'int'>कोई फर्क नहीं पड़ता कि आप किस आकार का उपयोग कर रहे हैं।

— जेम्स लेन
स्रोत

1

अजगर 3.x से, एकीकृत पूर्णांक के काम पुराने संस्करणों की तुलना में अधिक होशियार हैं। मेरे (i7 Ubuntu) बॉक्स पर मुझे निम्नलिखित मिला,

>>> type(math.factorial(30))
<class 'int'>

कार्यान्वयन के विवरण के लिए Include/longintrepr.h, Objects/longobject.c and Modules/mathmodule.cफाइलें देखें । अंतिम फ़ाइल एक गतिशील मॉड्यूल है (एक फ़ाइल में संकलित)। कोड का पालन करने के लिए अच्छी तरह से टिप्पणी की गई है।

— Venki
स्रोत

1

बस उन सभी उत्तरों को जारी रखने के लिए जो यहां दिए गए थे, विशेष रूप से @ जेम्स लैंस

पूर्णांक प्रकार का आकार इस सूत्र द्वारा व्यक्त किया जा सकता है:

कुल सीमा = (2 ^ बिट सिस्टम)

निचली सीमा = - (2 ^ बिट सिस्टम) * 0.5 ऊपरी सीमा = ((2 ^ बिट सिस्टम) * 0.5) - 1

— नादेर बेलाल
स्रोत

0

यह उनका प्रबंधन करता है क्योंकि intऔर longवर्ग की परिभाषाएँ हैं। उनके पास +, -, *, /, आदि के लिए उपयुक्त विधियाँ हैं, जो उपयुक्त वर्ग के परिणामों का उत्पादन करेंगी।

उदाहरण के लिए

>>> a=1<<30
>>> type(a)
<type 'int'>
>>> b=a*2
>>> type(b)
<type 'long'>

इस मामले में, कक्षा intमें एक __mul__विधि है (जो कि * लागू करता है) जो longआवश्यक होने पर एक परिणाम बनाता है ।

— S.Lott
स्रोत