इंटरएक्टिव Python कैलकुलेटर में आउटपुट क्यों गायब होता है: return बनाम print और अन्य आम गलतियाँ

जानें क्यों आपका Python कैलकुलेटर परिणाम दिखाए बिना रीस्टार्ट होता है: return बनाम print की गलती, ऑपरेशन वैलिडेशन और नियंत्रण प्रवाह के स्पष्ट समाधान.

इंटरएक्टिव Python कैलकुलेटर बार‑बार रीस्टार्ट हो रहा है और परिणाम नहीं दिखता: वजह क्या है और कैसे ठीक करें

छोटा‑सा इंटरएक्टिव कैलकुलेटर बनाना Python के I/O और नियंत्रण प्रवाह सीखने का बढ़िया तरीका है। लेकिन अक्सर लोग यह मान लेते हैं कि कोई फ़ंक्शन सिर्फ़ मान लौटाते ही नतीजा दिखा देगा। अगर आपका प्रोग्राम सारे इनपुट लेता है और अंतिम उत्तर दिखाए बिना फिर से शुरू हो जाता है, तो सबसे संभावित कारण यह है कि आप परिणाम को प्रिंट करने की बजाय return कर रहे हैं। साथ ही, कुछ नियंत्रण‑प्रवाह और फ़ॉर्मैटिंग से जुड़ी बातें भी हैं जो अपेक्षित व्यवहार को छिपा सकती हैं।

समस्या वाला उदाहरण

नीचे दिया गया कोड यही दिक्कत दिखाता है। यह दो संख्याएँ और एक ऑपरेशन पढ़ता है, उन्हें ऊर्ध्वाधर रूप में फ़ॉर्मैट करता है, और फिर कंसोल पर कुछ दिखने से पहले ही समय से पहले बाहर निकल जाता है।

def calc_runner():
    while True:
        try:
            lhs = float(input('Add 1st number: '))
            rhs = float(input('Add 2nd number: '))
        except ValueError:
            print('Invalid input. Please enter a number')
            continue
        ops_set = set(['+', '-', '/', '*'])
        try:
            op_choice = input('Please choose operation from [+, -, *, /]: ')
        except op_choice not in ops_set:
            print(f'Function must contain mathetmatical operation values only')
            continue
        header_line = ""
        op_line = ""
        dash_line = ""
        out_line = ""
        if op_choice == '+':
            result_val = lhs + rhs
        elif op_choice == '-':
            result_val = lhs - rhs
        elif op_choice == '*':
            result_val = lhs * rhs
        elif op_choice == '/':
            if rhs == 0:
                print(f'Division by 0 not possible')
                continue
            else:
                result_val = lhs / rhs
        s_lhs = str(lhs)
        s_rhs = str(rhs)
        s_out = str(result_val)
        col_width = max(len(s_lhs), len(s_rhs)) + 2
        top_line = s_lhs.rjust(col_width)
        bottom_line = op_choice + s_rhs.rjust(col_width - 1)
        sep_line = '-' * col_width
        res_line = s_out.rjust(col_width)
        header_line += top_line
        op_line += bottom_line
        dash_line += sep_line
        out_line += res_line
        display_block = f'{header_line}\n{op_line}\n{dash_line}\n{out_line}'
        return display_block
        exit_choice = input('Quit Program? Y/N: ')
        if exit_choice == 'Y' or exit_choice == 'y':
            break
calc_runner()

प्रोग्राम परिणाम क्यों नहीं दिखाता

मुख्य वजह अंतिम आउटपुट के लिए print की जगह return का इस्तेमाल करना है। return कथन मान को कॉलर को लौटा देता है और फ़ंक्शन तुरंत समाप्त हो जाता है; यह टर्मिनल पर कुछ नहीं दिखाता। क्योंकि फ़ंक्शन return तक पहुँचते ही निकल जाता है, न तो कुछ प्रिंट होता है और न ही exit का प्रॉम्प्ट दिखता है—return के बाद का कोड चलता ही नहीं।

ऑपरेशन जाँच में दूसरी तर्कगत गलती भी है। जहाँ सामान्य शर्त की ज़रूरत है, वहाँ except ब्लॉक लगा है। except तभी चलता है जब कोई अपवाद उठे; किसी मान का सेट में सदस्‍य न होना अपवाद नहीं है। अनुमति प्राप्त चिन्हों के साथ इनपुट को जाँचने के लिए if का उपयोग करें और इनपुट अमान्य हो तो लूप को continue से फिर शुरू करें।

कई फ़ॉर्मैटिंग वेरिएबल्स पर अनावश्यक रूप से += किया गया है, जबकि वे किसी संचय के लिए इस्तेमाल ही नहीं हो रहे। इससे मंशा धुंधली पड़ती है और कोड शोरभरा लगता है। एक बार फ़ॉर्मैट किए हुए स्ट्रिंग्स निकालें और सीधे उन्हीं का उपयोग करें—यह अधिक साफ़ है।

शून्य से भाग देने की जाँच के बाद नियंत्रण प्रवाह में एक छोटी समस्या और है। एक बार continue चल गया तो उस शाखा के बाद का कोड चलना ही नहीं है, इसलिए वहाँ else अनावश्यक है।

आख़िर में, quit प्रॉम्प्ट में दो केस अलग‑अलग तुलना किए गए हैं। इनपुट को lower() से सामान्य रूप में लाने से शर्त सरल हो जाती है, व्यवहार बदले बिना।

समाधान और सुधरा हुआ संस्करण

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

def calc_runner():
    while True:
        try:
            lhs = float(input('Add 1st number: '))
            rhs = float(input('Add 2nd number: '))
        except ValueError:
            print('Invalid input. Please enter a number')
            continue
        ops_set = {'+', '-', '/', '*'}
        op_choice = input('Please choose operation from [+, -, *, /]: ')
        if op_choice not in ops_set:
            print(f'Function must contain mathematical operation values only')
            continue
        if op_choice == '+':
            result_val = lhs + rhs
        elif op_choice == '-':
            result_val = lhs - rhs
        elif op_choice == '*':
            result_val = lhs * rhs
        elif op_choice == '/':
            if rhs == 0:
                print(f'Division by 0 not possible')
                continue
            result_val = lhs / rhs
        s_lhs = str(lhs)
        s_rhs = str(rhs)
        s_out = str(result_val)
        col_width = max(len(s_lhs), len(s_rhs)) + 2
        top_line = s_lhs.rjust(col_width)
        bottom_line = op_choice + s_rhs.rjust(col_width - 1)
        sep_line = '-' * col_width
        res_line = s_out.rjust(col_width)
        display_block = f'{top_line}\n{bottom_line}\n{sep_line}\n{res_line}'
        print(display_block)
        exit_choice = input('Quit Program? Y/N: ')
        if exit_choice.lower() == 'y':
            break
calc_runner()

यह जानना क्यों ज़रूरी है

डेटा लौटाने और stdout पर प्रिंट करने के अंतर को समझना Python में बुनियादी बात है। यही तय करता है कि आप फ़ंक्शनों को कैसे रचते हैं, उन्हें कैसे परखते हैं, और CLI टूल्स में नतीजे कैसे दिखाते हैं। स्पष्ट इनपुट वैलिडेशन नियंत्रण प्रवाह को उलझने नहीं देता, जबकि सीधा‑सादा स्ट्रिंग फ़ॉर्मैटिंग और सरल शाखाएँ कोड को पढ़ने, डिबग करने और बढ़ाने में सहूलियत देती हैं। यूज़र इनपुट को सामान्य रूप देने जैसे छोटे सुधार दोहराव और महीन बग्स घटाते हैं।

मुख्य बातें और व्यावहारिक सलाह

टर्मिनल सत्र में यदि आपको कुछ दिखाना है, तो वहीं print करें जहाँ यूज़र को प्रतिक्रिया की उम्मीद हो। return का इस्तेमाल फ़ंक्शनों के बीच मान पास करने के लिए रखें। यूज़र इनपुट की जाँच सामान्य शर्तों से करें, exception हैंडलर्स से नहीं—सिवाय तब, जब आप सचमुच किसी त्रुटि (जैसे float कन्वर्ज़न से आने वाला ValueError) को पकड़ रहे हों। फालतू वेरिएबल्स और continue के बाद अनावश्यक else से बचें। लूप से बाहर निकलने का लॉजिक भरोसेमंद रहे, इसके लिए तुलना से पहले यूज़र का उत्तर सामान्य रूप (जैसे lower()) में ले आएँ।