यह पायथन कोड उपयोगकर्ता द्वारा प्रदत्त आदेशों के आधार पर एक सूची पर संचालन की एक श्रृंखला करने के लिए डिज़ाइन किया गया है। यह कैसे काम करता है यह समझने के लिए आइए चरण दर चरण कोड का विश्लेषण करें:

if __name__ == '__main__':
    N = int(input())
    l = []
    while(N>0):
        cmd_l = input().split()
        if(len(cmd_l) == 3 and cmd_l[0] == "insert"):
            #insert statement
            l.insert(int(cmd_l[1]),int(cmd_l[2]))
        elif(len(cmd_l) == 2 and (cmd_l[0] == "remove" or cmd_l[0] == "append")):
            if(cmd_l[0] == "remove"):
                l.remove(int(cmd_l[1]))
            elif(cmd_l[0] == "append"):
                l.append(int(cmd_l[1]))
        elif(len(cmd_l) == 1):
            if(cmd_l[0] == "sort"):
                l.sort()
            elif(cmd_l[0] == "reverse"):
                l.reverse()
            elif(cmd_l[0] == "pop"):
                l.pop()                
            elif(cmd_l[0] == "print"):
                print(l)
        N -= 1

अगर __नाम__ == '__मुख्य__':

• यह पंक्ति जाँचती है कि क्या स्क्रिप्ट सीधे निष्पादित की जा रही है। यह सुनिश्चित करने के लिए अपनाया गया अभ्यास कि इस ब्लॉक के भीतर कोड केवल तभी निष्पादित किया जाएगा यदि फ़ाइल प्रोग्राम का प्रवेश बिंदु है।

एन = पूर्णांक(इनपुट())

• प्रोग्राम उपयोगकर्ता से एक पूर्णांक दर्ज करने की अपेक्षा करता है जो वेरिएबल एन में संग्रहीत है। यह संख्या दर्शाती है कि उपयोगकर्ता कितने ऑपरेशन करेगा।

एल = []

• संचालन निष्पादित होने पर तत्वों को संग्रहीत करने के लिए खाली सूची का उपयोग किया जाता है।

जबकि(एन>0):

• एक while लूप शुरू किया गया है जो तब तक चलता रहेगा जब तक N 0 से अधिक है। इसका मतलब यह है कि लूप N बार निष्पादित करेगा, प्रत्येक ऑपरेशन के लिए एक बार जिसे उपयोगकर्ता निष्पादित करना चाहता है।

cmd_l = इनपुट().स्प्लिट()

• लूप के भीतर प्रोग्राम उपयोगकर्ता द्वारा टेक्स्ट की एक पंक्ति दर्ज करने की प्रतीक्षा करता है, जिसे स्प्लिट() विधि का उपयोग करके स्ट्रिंग्स की सूची (cmd_l) में विभाजित किया जाता है। Cmd_l सूची का प्रत्येक तत्व निष्पादित किए जाने वाले ऑपरेशन के एक भाग का प्रतिनिधित्व करता है।

if(len(cmd_l) == 3 और cmd_l[0] == "insert"):

• यह पंक्ति जाँचती है कि क्या ऑपरेशन तीन-भाग वाला "इन्सर्ट" कमांड है (cmd_l की लंबाई 3 होनी चाहिए और पहला तत्व "इन्सर्ट" होना चाहिए)।

l.insert(int(cmd_l[1]),int(cmd_l[2]))

• यदि उपरोक्त स्थिति सत्य है, तो सूची l की सम्मिलित विधि को कॉल किया जाता है। तर्कों को स्ट्रिंग से पूर्णांक में परिवर्तित किया जाता है: cmd_l[1] वह स्थिति है जहां तत्व डाला जाएगा, और cmd_l[2] वह तत्व है जिसे डाला जाना है।

elif(len(cmd_l) == 2 और (cmd_l[0] == "हटाएं" या cmd_l[0] == "जोड़ें")):

• यह पंक्ति जांचती है कि क्या ऑपरेशन दो-भाग वाला "निकालें" या "जोड़ें" कमांड है, cmd_l की लंबाई 2 होनी चाहिए और पहला तत्व "निकालें" या "जोड़ें" होना चाहिए।

if(cmd_l[0] == "निकालें"):
l.remove(int(cmd_l[1]))
elif(cmd_l[0] == "जोड़ें"):
l.append(int(cmd_l[1]))

• कमांड (हटाएं या जोड़ें) के आधार पर, सूची एल से संबंधित विधि को कॉल किया जाता है। हटाने के लिए, cmd_l तत्व (पूर्णांक में परिवर्तित) को सूची से हटा दिया जाता है। जोड़ने के लिए, तत्व cmd_l[[1](पूर्णांक में परिवर्तित) को सूची के अंत में जोड़ा जाता है।

elif(len(cmd_l) == 1):

• जांचता है कि क्या ऑपरेशन एक एकल-भाग वाला कमांड है (cmd_l की लंबाई 1 होनी चाहिए)।

if(cmd_l[0] == "सॉर्ट"):
एल.सॉर्ट()
elif(cmd_l[0] == "रिवर्स"):
एल.रिवर्स()
elif(cmd_l[0] == "पॉप"):
एल.पॉप()
elif(cmd_l[0] == "प्रिंट"):
प्रिंट(एल)

• कमांड (सॉर्ट, रिवर्स, पॉप, या प्रिंट) के आधार पर, सूची एल से संबंधित विधि को कॉल किया जाता है। सॉर्ट सूची को क्रमबद्ध करता है, रिवर्स तत्वों के क्रम को उलट देता है, पॉप अंतिम तत्व को हटा देता है, और प्रिंट सूची को प्रिंट करता है।

एन - = 1

• लूप के अंत में, N को 1 से घटा दिया जाता है, जो दर्शाता है कि एक ऑपरेशन किया गया है। यह तब तक जारी रहता है जब तक कि N 0 न हो जाए, जब लूप समाप्त हो जाता है।