python - इनपुट() फ़ंक्शन में इनपुट कितना बड़ा हो सकता है?




string python-3.x (2)

बेशक वहाँ है, यह असीमित * नहीं हो सकता है। प्रलेखन से मुख्य वाक्य जो मुझे विश्वास है कि हाइलाइट करने की आवश्यकता है:

[...] फ़ंक्शन तब इनपुट से एक पंक्ति पढ़ता है, इसे एक स्ट्रिंग में परिवर्तित करता है (एक पिछली नई रेखा को अलग करना) [...]

(जोर मेरा)

चूंकि यह आपके द्वारा पाइथन str ऑब्जेक्ट में प्रदान किए गए इनपुट को परिवर्तित करता है, यह अनिवार्य रूप से अनुवाद करता है: "इसका आकार सबसे बड़ा स्ट्रिंग पाइथन बना सकता है या उससे कम होना चाहिए"।

इसका कारण यह नहीं है कि कोई स्पष्ट आकार क्यों नहीं दिया गया है क्योंकि यह एक कार्यान्वयन विस्तार है। पाइथन के अन्य सभी कार्यान्वयन के लिए अधिकतम आकार लागू करने से ज्यादा समझ नहीं आएगी।

* सीपीथॉन में, कम से कम, स्ट्रिंग का सबसे बड़ा आकार इस बात से घिरा हुआ है कि इसकी अनुक्रमणिका कितनी बड़ी है ( पीईपी 353 देखें)। यही है, जब आप कोशिश करते हैं और अनुक्रमित करते हैं तो ब्रैकेट [] में कितनी बड़ी अनुमति होती है:

>>> s = ''
>>> s[2 ** 63]

IndexErrorTraceback (most recent call last)
<ipython-input-10-75e9ac36da20> in <module>()
----> 1 s[2 ** 63]

IndexError: cannot fit 'int' into an index-sized integer

(पिछली बार 2 ** 63 - 1 साथ प्रयास करें, यह सकारात्मक स्वीकार्य सीमा है, -2 ** 63 नकारात्मक सीमा है।)

सूचकांक के लिए, यह पाइथन संख्या नहीं है जो आंतरिक रूप से उपयोग की जाती है; इसके बजाए, यह एक Py_ssize_t जो क्रमश: 32/64 बिट मशीनों पर हस्ताक्षरित 32/64 बिट int है। तो, यह कैसा लगता है उससे मुश्किल सीमा है।

(जैसा कि त्रुटि संदेश बताता है, int और intex-sizeized पूर्णांक दो अलग - अलग चीजें हैं)

ऐसा लगता है कि input() स्पष्ट रूप से जांचता है कि क्या इनपुट इनपुट PY_SSIZE_T_MAX ( PY_SSIZE_T_MAX का अधिकतम आकार) से पहले कनवर्ट करने से पहले है:

if (len > PY_SSIZE_T_MAX) {
    PyErr_SetString(PyExc_OverflowError,
                    "input: input too long");
    result = NULL;
}

फिर यह इनपुट को PyUnicode_Decode साथ एक पायथन str परिवर्तित करता है।

इसे आपके लिए परिप्रेक्ष्य में रखने के लिए; यदि औसत पुस्तक 500.000 वर्ण लंबी है और पुस्तकों की कुल संख्या का estimation लगभग 130 मिलियन है, तो आप सैद्धांतिक रूप से आसपास input कर सकते हैं:

>>> ((2 ** 63) - 1) // 500000 * 130000000
141898

उन पात्रों के समय; यह शायद आपको कुछ समय लगेगा, हालांकि :-) (और आप पहले उपलब्ध स्मृति से सीमित होंगे!)

input() फ़ंक्शन में इनपुट कितना बड़ा हो सकता है?

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

input फ़ंक्शन के लिए documentation इस बारे में कुछ भी उल्लेख नहीं करता है:

यदि prompt तर्क मौजूद है, तो यह पिछली नई लाइन के बिना मानक आउटपुट पर लिखा गया है। फ़ंक्शन तब इनपुट से एक पंक्ति पढ़ता है, इसे एक स्ट्रिंग में परिवर्तित करता है (एक पिछली न्यूलाइन को अलग करना), और उसे वापस कर देता है। जब EOFError पढ़ा जाता है, तो EOFError उठाया जाता है।

तो, मुझे लगता है कि कोई सीमा नहीं है? क्या कोई जानता है कि क्या है और, यदि हां, तो यह कितना है?


हम उत्तर को प्रयोगात्मक रूप से काफी आसानी से पा सकते हैं। दो फाइलें बनाएं:

make_lines.py :

num_lines = 34

if __name__ == '__main__':
    for i in range(num_lines):
        print('a' * (2 ** i))

read_input.py :

from make_lines import num_lines

for i in range(num_lines):
    print(len(input()))

फिर लिनक्स या ओएसएक्स में यह आदेश चलाएं (मुझे विंडोज़ समकक्ष नहीं पता):

python make_lines.py | python3 read_input.py

मेरे कंप्यूटर पर यह खत्म करने का प्रबंधन करता है लेकिन अंत तक संघर्ष करता है, जिससे अन्य प्रक्रियाओं में काफी कमी आती है। आखिरी चीज जो प्रिंट करती है वह 8589934592 9 2 है, यानी 8 8589934592 । समय और मेमोरी सीमाओं के संदर्भ में स्वीकार्य होने की आपकी परिभाषा के अनुसार आप अपने लिए मूल्य का पता लगा सकते हैं।







python-internals