तिथियों वाली dictionary को फ्लैटन कर (label, date) सूची सॉर्ट करें

Python में तिथियों की सूचियों वाली dictionary को एक ही (label, date) सूची में फ्लैटन कर chronological क्रम में सॉर्ट करने का सरल तरीका, कोड उदाहरण और व्याख्या.

जब किसी मैपिंग में अलग-अलग कुंजियों के तहत तिथियाँ रखी होती हैं, तो अक्सर सभी कुंजियों के पार एक ही कालानुक्रमिक क्रम की जरूरत पड़ती है। कार्य यह है कि ऐसे शब्दकोश (dictionary) को समतल (flatten) किया जाए जो लेबल्स को तारीख़ ऑब्जेक्ट्स की सूचियों से मैप करता है, और (label, date) युग्मों की एक क्रमबद्ध सूची निकाली जाए—पहले तारीख़ के अनुसार, फिर लेबल के अनुसार। नीचे इस परिदृश्य का एक लघु, पुनरुत्पाद्य सेटअप और उसे हल करने का मजबूत तरीका दिया गया है।

समस्या की रूपरेखा

डेटा माह/दिन घटकों के रूप में आता है, जिन्हें जोड़कर date ऑब्जेक्ट बनाए जाते हैं और लेबल के आधार पर समूहित किया जाता है। लक्ष्य एक एकल, क्रमित युग्मों की सूची पाना है।

from datetime import datetime, date
mon_x = [8, 9, 10]
day_x = [13, 12, 15]
mon_y = [8, 9, 10]
day_y = [13, 11, 13]
dates_x = []
for mm, dd in zip(mon_x, day_x):
    dates_x.append(datetime(2025, mm, dd).date())
dates_y = []
for mm, dd in zip(mon_y, day_y):
    dates_y.append(datetime(2025, mm, dd).date())
label_to_dates = {"A": dates_x, "B": dates_y}
print("original:")
print(label_to_dates)
expected_sorted = [
    ("A", date(2025, 8, 13)),
    ("B", date(2025, 8, 13)),
    ("B", date(2025, 9, 11)),
    ("A", date(2025, 9, 12)),
    ("B", date(2025, 10, 13)),
    ("A", date(2025, 10, 15)),
]
print("sorted:")
print(expected_sorted)

मुद्दा क्या है और ऐसा क्यों होता है

डेटा संरचना एक डिक्शनरी है, जिसकी मान (values) तिथियों की सूचियाँ हैं। इन सूचियों को अलग-अलग सॉर्ट करने से सभी लेबल्स पर फैला एक समन्वित टाइमलाइन नहीं बनती। व्यवहारिक तरीका यह है कि संरचना को (label, date) युग्मों की एक ही सूची में समतल करें, और फिर उसे ऐसी कुंजी से सॉर्ट करें जो कालानुक्रमिक क्रम का पालन करे और समान तारीख़ होने पर लेबल से टाई तोड़े। इससे समस्या दो छोटे, स्पष्ट चरणों में बदल जाती है: पहले युग्म बनाएँ, फिर उन्हें सॉर्ट करें।

समाधान: पहले फ्लैटन, फिर संयुक्त कुंजी से सॉर्ट

नीचे दिया फ़ंक्शन एक ही पास में सभी युग्म समेटता है और सूची को पहले तारीख़ तथा फिर लेबल के आधार पर सॉर्ट करके लौटाता है। कार्यान्वयन सीधा और स्पष्ट रखा गया है।

from datetime import datetime, date
def arrange_pairs(mapping: dict[str, list[date]]) -> list[tuple[str, date]]:
    pairs: list[tuple[str, date]] = []
    for lbl, seq in mapping.items():
        for dt in seq:
            pairs.append((lbl, dt))
    return sorted(pairs, key=lambda it: (it[1], it[0]))
mon_x = [8, 9, 10]
day_x = [13, 12, 15]
mon_y = [8, 9, 10]
day_y = [13, 11, 13]
dates_x: list[date] = []
for mm, dd in zip(mon_x, day_x):
    dates_x.append(datetime(2025, mm, dd).date())
dates_y: list[date] = []
for mm, dd in zip(mon_y, day_y):
    dates_y.append(datetime(2025, mm, dd).date())
label_to_dates = {"A": dates_x, "B": dates_y}
print(label_to_dates)
print(arrange_pairs(label_to_dates))

यह key lambda ट्यूपल के दूसरे अवयव (तारीख़) के अनुसार सॉर्ट करती है और बराबर तारीख़ पर निर्धारक क्रम के लिए लेबल को द्वितीयक कुंजी बनाती है।

यदि आप संक्षिप्त अभिव्यक्ति पसंद करते हैं, तो यही विचार एक जनरेटर पर एक ही sorted कॉल में लिखा जा सकता है, जो सीधे युग्म उत्पन्न करता है।

result = sorted(
    ((k, d) for k, vals in label_to_dates.items() for d in vals),
    key=lambda t: (t[1], t[0])
)

यह क्यों मायने रखता है

समूहित टाइम सीरीज़ पर कालानुक्रमिक दृश्य हर जगह मिलते हैं: लॉग्स, मेट्रिक्स, ईवेंट्स, या ETL इनपुट्स। रूपांतरण को स्पष्ट रखना—पहले युग्मों में फ्लैटन करना, फिर सॉर्ट करना—सूक्ष्म गलतियों से बचाता है और पाइपलाइन को पठनीय बनाए रखता है। यह समग्र प्रवाह को बरकरार रखते हुए टाई-ब्रेकर जोड़ना या समायोजित करना भी आसान बना देता है।

मुख्य बातें

सबसे पहले (label, date) युग्मों का एक एकल अनुक्रम बनाइए, फिर ऐसी संयुक्त कुंजी से सॉर्ट कीजिए जो तारीख़ को प्राथमिकता दे। यह तरीका अभिप्रेत उद्देश्य को बिल्कुल साफ रखता है और परिणाम स्थिर रहता है। यदि हर लेबल के भीतर की सूचियाँ पहले से क्रम में हों, तब भी लेबल्स के आर-पार मर्ज और सॉर्ट की आवश्यकता खत्म नहीं होती; एकीकृत सूची वैश्विक टाइमलाइन स्थापित करने के लिए फिर भी ज़रूरी है।