Python में एक नेस्टेड लिस्ट को सिंगल-लेवल लिस्ट में बदलने की प्रक्रिया, जिसे लिस्ट को समतल करना (Flattening a list) कहते हैं, एक सामान्य कार्य है। यह लेख इसे प्राप्त करने के विभिन्न तरीकों का पता लगाता है, उन्हें उनके समतलन की गहराई के अनुसार वर्गीकृत करता है: उथला (Shallow) और गहरा (Deep).
विषयसूची
उथला समतलन
उथला समतलन केवल नेस्टिंग के एक स्तर को हटाता है। यह आदर्श है जब आपके पास लिस्टों की एक लिस्ट होती है, लेकिन उन आंतरिक लिस्ट में आगे नेस्टेड संरचनाएँ नहीं होती हैं। दो कुशल विधियाँ मौजूद हैं:
सूची बोध (List Comprehension): यह एक संक्षिप्त और पठनीय समाधान प्रदान करता है:
nested_list = [[1, 2, 3], [4, 5], [6]]
flat_list = [item for sublist in nested_list for item in sublist]
print(flat_list) # आउटपुट: [1, 2, 3, 4, 5, 6]
itertools.chain.from_iterable: बड़ी लिस्ट के लिए, यह दृष्टिकोण इसके अनुकूलित पुनरावृत्ति के कारण बेहतर प्रदर्शन प्रदान करता है:
from itertools import chain
nested_list = [[1, 2, 3], [4, 5], [6]]
flat_list = list(chain.from_iterable(nested_list))
print(flat_list) # आउटपुट: [1, 2, 3, 4, 5, 6]
सीमाएँ: उथला समतलन उन लिस्टों को पूरी तरह से समतल करने में विफल रहता है जिनमें नेस्टेड लिस्ट नेस्टेड लिस्ट के अंदर होती हैं। उदाहरण के लिए:
nested_list = [[1, 2, [3, 4]], [5, 6]]
flat_list = [item for sublist in nested_list for item in sublist]
print(flat_list) # आउटपुट: [1, 2, [3, 4], 5, 6]
आंतरिक सूची [3, 4] नेस्टेड रहती है।
गहरा समतलन
गहरा समतलन किसी भी गहराई की नेस्टेड लिस्ट को पुनरावर्ती रूप से संभालता है। दो प्राथमिक दृष्टिकोण मौजूद हैं:
पुनरावर्ती फलन (Recursive Function): यह सुंदर समाधान नेस्टेड संरचना को पार करने के लिए पुनरावृत्ति का उपयोग करता है:
def flatten(nested_list):
flat_list = []
for item in nested_list:
if isinstance(item, list):
flat_list.extend(flatten(item))
else:
flat_list.append(item)
return flat_list
nested_list = [[1, 2, [3, 4]], [5, 6, [7, [8, 9]]]]
flat_list = flatten(nested_list)
print(flat_list) # आउटपुट: [1, 2, 3, 4, 5, 6, 7, 8, 9]
पुनरावृति दृष्टिकोण (स्टैक का उपयोग करके): पुनरावृत्ति अत्यधिक गहरे नेस्टिंग के साथ स्टैक ओवरफ्लो त्रुटियों का कारण बन सकती है। स्टैक का उपयोग करने वाला एक पुनरावृति दृष्टिकोण मजबूती प्रदान करता है:
def flatten_iterative(nested_list):
flat_list = []
stack = [nested_list]
while stack:
current = stack.pop()
if isinstance(current, list):
stack.extend(current)
else:
flat_list.append(current)
return flat_list
nested_list = [[1, 2, [3, 4]], [5, 6, [7, [8, 9]]]]
flat_list = flatten_iterative(nested_list)
print(flat_list) # आउटपुट: [1, 2, 3, 4, 5, 6, 7, 8, 9]
निष्कर्ष
उथले और गहरे समतलन के बीच चुनाव पूरी तरह से आपकी नेस्टेड लिस्ट की संरचना पर निर्भर करता है। एकल-स्तरीय नेस्टिंग के लिए उथला समतलन पर्याप्त है और संक्षिप्त, कुशल समाधान प्रदान करता है। हालाँकि, मनमाने ढंग से नेस्टेड लिस्ट के लिए, गहरा समतलन, अधिमानतः मजबूती के लिए पुनरावृति स्टैक-आधारित दृष्टिकोण का उपयोग करना, आवश्यक है।