पायथन

Question

में टुपल की सूची में उच्चतम 6 नाम लौटाना कृपया मुझे नीचे दिए गए tuple की सूची से उच्चतम संबंधित पूर्णांक वाले पहले 6 नाम (केवल नाम) वापस करना चाहते हैं। मैं सभी नामों को उच्चतम (एसएमएस) से सबसे कम (बॉस) में वापस करने में सक्षम हूं।

[('sms', 10), ('bush', 9), ('michaels', 7), ('operations', 6), ('research', 5), ('code', 4), ('short', 3), ('ukandu', 2), ('technical', 1), ('apeh', 1), ('boss', 1)] 

धन्यवाद।

Answer 1

डेटा पहले से ही बस पहले छह tuples बंद स्लाइस और फिर नाम पाने के अनुसार क्रमबद्ध किया गया है:

first_six = data[0:6] # or data[:6] 
only_names = [entry[0] for entry in first_six] 

सूची समझ को unrolled जा सकता है:

only_names = [] 
for entry in first_six: 
    only_names.append(entry[0]) 

तो सूची है पहले ही सॉर्ट नहीं किया गया है आप स्कोर द्वारा क्रमबद्ध करने के लिए sort विधि (या sorted अंतर्निर्मित) के key कीवर्ड तर्क का उपयोग कर सकते हैं:

data.sort(key=lambda entry: entry[1], reverse=True) 

lambda एक गुमनाम समारोह है - बराबर है:

def get_score(entry): 
    return entry[1] 

data.sort(key=get_score, reverse=True) 

Answer 2

data=[('sms', 10), ('bush', 9), ('michaels', 7), ('operations', 6), ('research', 5), ('code', 4), ('short', 3), ('ukandu', 2), ('technical', 1), ('apeh', 1), ('boss', 1)] 
return [x[0] for x in sorted(data, key=lambda x: x[1], reverse=True)[0:6]] 

निम्नलिखित में से कौन करता है:

• sorted रिटर्न डेटा key समारोह का प्रयोग कर। चूंकि मानक सॉर्टिंग ऑर्डर आरोही से है, reverse=True इसे अवरोही करता है;
• lambda x: x[1] अज्ञात फ़ंक्शन है जो तर्क के दूसरे तत्व (इस मामले में एक टुपल का) देता है; itemgetter(1) ऐसा करने का अच्छा तरीका है, लेकिन अतिरिक्त आयात की आवश्यकता है;
• [0:6] सूची के पहले 6 तत्व स्लाइस;
• [x[0] for x in ... ] प्रत्येक उत्तीर्ण ट्यूपल के पहले तत्वों की एक सूची बनाता है;

  import heapq 
  from operator import itemgetter 
  largest_names = [x[0] for x in heapq.nlargest(6,your_list,key=itemgetter(1))] 
  

  यह छँटाई के रूप में यह केवल सबसे बड़ी तत्वों लेता है और बाकी को छोड़ देता है और अधिक से अधिक कुशल हो जाएगा:

Answer 3

heapq.nlargest तुम यहाँ क्या चाहते है। बेशक, यह स्लाइसिंग से कम कुशल है यदि सूची अन्य कारणों से पूर्व-क्रमबद्ध है।

जटिलता:

• heapq: हे (एन)
• छँटाई: हे (NlogN)
• टुकड़ा करने की क्रिया (केवल यदि पूर्व क्रमबद्ध): हे (6)

स्पष्टीकरण :

heapq.nlargest(6,your_list,key=itemgetter(1)) 

यह लाइन (नाम, मूल्य) tu की एक सूची देता है ples, लेकिन केवल 6 सबसे बड़ी - तुलना दूसरे (इंडेक्स = 1 ->key=itemgetter(1)) तत्व द्वारा tuple में किया जाता है।

शेष पंक्ति 6 ​​सबसे बड़े नाम, मूल्य tuples पर एक सूची-समझ है जो केवल tuple का नाम भाग लेती है और इसे एक सूची में संग्रहीत करती है।

---

यह है कि आप एक collections.Counter के रूप में यह डेटा भी संग्रहीत कर सकती है आपकी रुचि का हो सकता है।

d = collections.Counter(dict(your_list)) 
biggest = [x[0] for x in d.most_common(6)] 

यह शायद सिर्फ इस गणना करने के लिए (कि क्या heapq सब के बाद ;-) के लिए है परिवर्तित करने के लायक नहीं है, लेकिन यह डेटा के साथ काम करने के लिए आसान बनाने के लिए परिवर्तित करने के लायक हो सकता है।