इस अभ्यास को देखते हुए: (codewars.com से)

एक फ़ंक्शन बनाएं जो किसी संख्या के प्रत्येक अंक का वर्ग लौटाता है।

उदाहरण के लिए, फ़ंक्शन में प्रवेश करते समय संख्या 702 वापस आना चाहिए 4904, क्योंकि 7 का वर्ग 49 है, 0 का वर्ग 0 और 2 का वर्ग 4 है। यदि फ़ंक्शन को शून्य प्राप्त होता है तो उसे 0 लौटना होगा।

इस अभ्यास की अंतर्निहित चुनौती एक पूर्णांक अंक को अंक दर अंक पार करना और एक परिणाम को दूसरे पूर्णांक के रूप में लौटाना है।

प्रोग्रामिंग में हर चीज़ की तरह, इस अभ्यास को कई तरीकों से हल करना संभव है। सबसे पहले, आइए इसे पायथन में संख्या हेरफेर गुणों का उपयोग करके हल करें, फिर मैं एक और अधिक उन्नत तरीका बताऊंगा?

def square_digits(num):
    if num == 0:
        return 0
    result = ""
    while num > 0:
        num_sqr = (num % 10) ** 2 
        num = num // 10
        result = str(num_sqr)   result 
    return int(result)

इस कोड में, हम पहले मूल्यांकन करते हैं कि 0 वापस करने के लिए 0 प्राप्त हुआ है या नहीं, जैसा कि कथन में दर्शाया गया है। फिर, हम वेरिएबल परिणाम को एक खाली स्ट्रिंग के रूप में आरंभ करते हैं, शर्त संख्या > 0 के साथ एक while लूप बनाते हैं। हम वेरिएबल num_sqr को परिभाषित करते हैं, जो प्राप्त प्रत्येक अंक का वर्ग है। संख्या % 10 से हम प्राप्त संख्या का अंतिम अंक प्राप्त करते हैं और फिर इसे **2 से वर्गित करते हैं।

• किसी संख्या का अंतिम अंक निकालने के लिए संख्या% 10 का उपयोग करना एक सामान्य तरीका है।

• अभिव्यक्ति num = num // 10 प्रत्येक अंक के माध्यम से आगे बढ़ते हुए, संख्या के अंतिम अंक को हटा देता है।

इसे हल करने का दूसरा तरीका यह है कि संख्या को एक स्ट्रिंग में परिवर्तित किया जाए और इस स्ट्रिंग के माध्यम से लूप के साथ लूप किया जाए:

def square_digits(num):
    result = ""
    for digit in str(num):
        result  = str(int(digit)**2)
    return int(result)

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

• एक लूप के भीतर तारों को जोड़ना बहुत बड़ी संख्या के लिए कम प्रदर्शन कुशल हो सकता है, लेकिन अधिकांश उपयोग के मामलों के लिए पूरी तरह से स्वीकार्य है।

*एक अधिक उन्नत और "सुंदर" तरीका * जेनरेटर अंडरस्टैंडिंग और .join motodo का उपयोग कर रहा है। मैं सबसे पहले आपके सामने कोड प्रस्तुत करता हूं और हम इन शर्तों को समझाते हुए इसे तोड़ देंगे।

def square_digits(num):
    return int(''.join(str(int(digit)**2) for digit in str(num)))

यदि आप अवधारणाओं को नहीं जानते हैं तो यह पहला कोड बहुत पठनीय नहीं है
जो इसे बनाता है।

str(num) में अंक के लिए अभिव्यक्ति str(int(digit)**2) एक _जनरेटर _(जनरेटर अभिव्यक्ति) है जो संख्या संख्या के स्ट्रिंग प्रतिनिधित्व में प्रत्येक अंक पर पुनरावृत्त होता है।
प्रत्येक अंक के लिए, यह इसे एक पूर्णांक (int(अंक)) में परिवर्तित करता है, इसका वर्ग (**2) करता है, और फिर इसे वापस एक स्ट्रिंग (str(...)) में परिवर्तित करता है। फिर, ''.join(...) के साथ, आप एक अनुक्रम लेते हैं (इस मामले में, जनरेटर) और सभी तत्वों को एक स्ट्रिंग में जोड़ते हैं। यहां, सभी वर्ग अंकों को बिना किसी विभाजक के एक स्ट्रिंग में संयोजित किया गया है (क्योंकि एकल उद्धरण चिह्नों के बीच की स्ट्रिंग खाली है '')।

जैसा कि हम देखते हैं, किसी अभ्यास को हल करने के विभिन्न तरीके किसी भाषा में ज्ञान के स्तर को प्रदर्शित करते हैं। यदि सभी समाधान परीक्षण में उत्तीर्ण होते हैं तो वे सही होते हैं, लेकिन कुछ अन्य की तुलना में अधिक कुशल और पठनीय होते हैं। दृष्टिकोण का चुनाव संदर्भ पर निर्भर करता है और प्रत्येक मामले में क्या प्राथमिकता दी जाती है:

• पठनीयता: यह महत्वपूर्ण है जब अन्य डेवलपर्स आपके कोड को पढ़ेंगे और बनाए रखेंगे। स्पष्ट, समझने में आसान कोड त्रुटियों की संभावना को कम करता है और इसे बनाए रखना आसान बनाता है। ?

• दक्षता: बड़ी मात्रा में डेटा के साथ या उन अनुप्रयोगों में काम करते समय मायने रखता है जहां प्रदर्शन महत्वपूर्ण है। अधिक अनुकूलित कोड गति और संसाधन खपत में बड़ा अंतर ला सकता है। ?

• सादगी: ऐसे मामलों के लिए जहां प्राथमिकता समस्या को जल्दी और सीधे हल करना है, जैसे प्रोटोटाइप या उपदेशात्मक अभ्यास में। सरलता अक्सर कोड डिबगिंग और परीक्षण को आसान बना देती है। ?

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