पाइथन डिक्शनरीज़ कुशल डेटा संग्रहण का एक आधार हैं। अक्सर, आपको केवल एक डिक्शनरी की कुंजियों तक पहुँचने की आवश्यकता होगी, और इसे प्राप्त करने के कई तरीके हैं। यह लेख सबसे सामान्य तरीकों का पता लगाता है, उनकी कार्यक्षमता और पठनीयता की तुलना करके आपकी आवश्यकताओं के लिए सर्वोत्तम विधि चुनने में आपकी सहायता करता है।
विषय-सूची
dict.keys() विधि
सबसे सरल और आम तौर पर सबसे कुशल तरीका keys() विधि का उपयोग करना है। यह विधि एक व्यू ऑब्जेक्ट लौटाती है, जो डिक्शनरी की कुंजियों का एक गतिशील प्रतिनिधित्व है। सूची प्राप्त करने के लिए, बस इसे list() का उपयोग करके परिवर्तित करें।
my_dict = {'a': 1, 'b': 2, 'c': 3}
keys_list = list(my_dict.keys())
print(keys_list) # आउटपुट: ['a', 'b', 'c']
इस विधि को इसकी स्पष्टता और गति के लिए प्राथमिकता दी जाती है। keys() कुंजी पुनर्प्राप्ति के लिए अनुकूलित है, और सूची में रूपांतरण एक तेज़ ऑपरेशन है।
लूप का उपयोग करना
वैकल्पिक रूप से, आप for लूप का उपयोग करके कुंजियों को निकाल सकते हैं। यह दृष्टिकोण dict.keys() की तुलना में कम कुशल है और आम तौर पर कम संक्षिप्त है।
my_dict = {'a': 1, 'b': 2, 'c': 3}
keys_list = []
for key in my_dict:
keys_list.append(key)
print(keys_list) # आउटपुट: ['a', 'b', 'c']
यह प्रत्येक कुंजी के माध्यम से पुनरावृति करता है, इसे एक नई सूची में जोड़ता है। कार्यात्मक होने के बावजूद, यह कम पठनीय है और अन्य विधियों की तुलना में धीमा प्रदर्शन करता है।
सूची बोध
सूची बोध स्पष्ट लूप के लिए एक कॉम्पैक्ट और अक्सर तेज विकल्प प्रदान करते हैं। वे लूप विधि की तुलना में अधिक कुशल हैं लेकिन फिर भी dict.keys() से थोड़े धीमे हैं।
my_dict = {'a': 1, 'b': 2, 'c': 3}
keys_list = [key for key in my_dict]
print(keys_list) # आउटपुट: ['a', 'b', 'c']
यह एकल पंक्ति लूप के समान परिणाम प्राप्त करती है, बेहतर पठनीयता और लूप की तुलना में बेहतर प्रदर्शन के साथ।
* ऑपरेटर के साथ डिक्शनरी अनपैकिंग
अनपैकिंग ऑपरेटर (*) कुंजियों को निकाल सकता है, लेकिन यह इस विशिष्ट कार्य के लिए कम सामान्य और कम पठनीय है। परिणाम को सूची में बदलने की आवश्यकता है।
my_dict = {'a': 1, 'b': 2, 'c': 3}
keys_list = list(*my_dict.keys())
print(keys_list) # आउटपुट: ['a', 'b', 'c']
यह दृष्टिकोण कम सहज और dict.keys() की तुलना में कम कुशल है और आम तौर पर कुंजियों की सूची प्राप्त करने के लिए इससे बचना चाहिए।
कार्यक्षमता तुलना
आइए timeit मॉड्यूल का उपयोग करके इन विधियों का बेंचमार्क करें:
import timeit
my_dict = {str(i): i for i in range(10000)}
time_keys = timeit.timeit(lambda: list(my_dict.keys()), number=1000)
time_loop = timeit.timeit(lambda: [key for key in my_dict], number=1000)
time_comprehension = timeit.timeit(lambda: [key for key in my_dict], number=1000) #सुधारा हुआ डुप्लीकेट
time_unpack = timeit.timeit(lambda: list(*my_dict.keys()), number=1000)
print(f"dict.keys(): {time_keys:.6f} सेकंड")
print(f"लूप: {time_loop:.6f} सेकंड")
print(f"सूची बोध: {time_comprehension:.6f} सेकंड")
print(f"अनपैकिंग: {time_unpack:.6f} सेकंड")
आप लगातार पाएंगे कि dict.keys() सबसे तेज है, उसके बाद सूची बोध, फिर लूप, अनपैकिंग सबसे कम कुशल है। जबकि समय सिस्टम के अनुसार भिन्न होता है, सापेक्ष प्रदर्शन सुसंगत रहता है।
संक्षेप में, जबकि कई दृष्टिकोण मौजूद हैं, list(my_dict.keys()) सूची के रूप में डिक्शनरी कुंजियों को पुनर्प्राप्त करने के लिए दक्षता, पठनीयता और पाइथोनिक शैली का सबसे अच्छा संयोजन प्रदान करता है।