लंबाई से और मूल्य

Question

द्वारा सूचियों की एक सूची छंटाई मैं सूचियों की एक सूची है संदर्भ सूची:

>>> confrom = {'3':3, '4':4, '5':5, '6':6, '7':7, '8':8, '9':9, \ 
... '0':10, 'J':11, 'Q':12, 'K':13, 'A':14, '2':15} 

मैं एक कार्ड खेल है जहाँ अधिकतम मूल्य 2. है सूची की लंबाई से क्रमबद्ध करने के लिए खेल रहा हूँ के रूप में, मैं करता हूँ:

>>> a = sorted(a, key = lambda x: len(x)) 
>>> a 
... [['3D'], ['4C'], ['4D'], ['2C'], ['5D'], ['JC'], ['JS'], ['4C', '4D'], ['JC', 'JS'], ['3D', '4D', '5D']] 

मैं टी की जरूरत है ओ भी अपने शब्दकोश मूल्य के लिए तो मेरे जिसके परिणामस्वरूप सूची होगा अनुसार क्रमित:

>>> [['3D'], ['4C'], ['4D'], ['5D'], ['JC'], ['JS'], ['2C'], ['4C', '4D'], ['JC', 'JS'], ['3D', '4D', '5D']] 

वर्तमान में यह काफी सरल कार्यान्वयन है, लेकिन मैं एक और अधिक जटिल तरीके से सुलझाने के लिए सक्षम होना चाहते हैं।

Answer 1

इस प्रयास करें:

sorted(a, key = lambda x: (len(x), [confrom[card[0]] for card in x])) 

ideone

Answer 2

यह जब एक वर्ग के लिए पायथन में एक आधार डेटा संरचना से संक्रमण के लिए की एक बहुत अच्छा उदाहरण हो सकता है।

पर विचार करें:

values = ('2', '3', '4', '5', '6', '7', '8', '9', '10', 'J', 'Q', 'K', 'A') 
suits = ('H', 'C', 'D', 'S') 
sRep = {'H':'Hearts', 'C':'Clubs', 'D':'Diamonds', 'S':'Spades'} 
ranks = {'2':15, '3':3, '4':4,'5':5,'6':6,'7':7,'8':8, 
     '9':9, '0':10, '0':10, 'J':11, 'Q':12, 'K':13, 'A':14 } 

class Card: 
    def __init__(self, value, suit): 
     value=str(value) 
     self.value, self.suit = value.upper(), suit.upper() 
     self.rSuit = sRep[suit.upper()] 
     self.rank = ranks[value.upper()] 

    def __repr__(self): 
     return "%s of %s" % (self.value, self.rSuit) 

    def __cmp__(self,other): 
     if self.rank > other.rank: return 1 
     if self.rank < other.rank: return -1  
     if self.value > other.value: return 1 
     if self.value < other.value: return -1 
     if self.rSuit > other.rSuit: return 1 
     if self.rSuit < other.rSuit: return -1 
     return 0 

कुछ कार्ड बाहर का प्रयास करें:

c1=Card(2,'s')  
c2=Card(4,'d') 

if c1>c2: 
    print "A", c1, "beats a", c2 
elif c2>c1:  
    print "A", c2, "beats a", c1 
else: 
    print "Same..."  

यह प्रिंट:

A 2 of Spades beats a 4 of Diamonds 

जब से हम कक्षा में एक सॉर्ट क्रम में परिभाषित किया गया है, जटिल सॉर्टिंग आसान है और विभिन्न खेलों के आधार पर रैंकिंग आसान है। एक उदाहरण के रूप

आपका कार्ड सूची:

a = [['3D'], ['3D', '4D', '5D'], ['4C'], ['2C'],['4C', '4D'], ['4D'], ['5D'], ['JC'], ['JC', 'JS'], ['JS']] 

print sorted([Card(c[0],c[1]) for e in a for c in e]) 

प्रिंटों:

[3 of Diamonds, 3 of Diamonds, 4 of Clubs, 4 of Clubs, 4 of Diamonds, 
4 of Diamonds, 4 of Diamonds, 5 of Diamonds, 5 of Diamonds, J of Clubs, 
J of Clubs, J of Spades, J of Spades, 2 of Clubs] 

थोड़ा और काम के साथ

, तो आप हाथ परिभाषित कर सकते हैं और क्या हाथ एक और हाथ धड़कता है।

आप क्लासिक अजगर किताब कैसे एक कंप्यूटर वैज्ञानिक की तरह लगता है कि करने के लिए इस उदाहरण के बारे में अधिक पढ़ सकते हैं: यही कारण है कि अगर सभी सूचियों लंबाई 1 से थे काम करेगा अजगर HERE