पायथन में पुन: ऑर्डर सूची यह सुनिश्चित करने के लिए कि यह चेक मानों के साथ शुरू होता है

Question

मैं 256 हर्ट्ज की नमूना दर पर 17 मानों (1byte प्रत्येक) की एक सूची को पॉप्युलेट करने के लिए पीसियल का उपयोग कर धारावाहिक डेटा में पढ़ रहा हूं।

बाइट्स मैं आखिरकार उपयोग करना चाहता हूं सूची में 5 वीं से 8 वीं है। कोई बाइट प्रदान नहीं किया जाता है, धारा के पहले दो मान हमेशा एक ही होते हैं ('165', '9 0')। हालांकि मुझे कुछ गिराए गए मूल्य मिल रहे हैं, और मेरी सूची मान स्थानांतरित हो रहे हैं, इसलिए जब मैं 5 वीं -8 वीं बाइट्स पढ़ता हूं, तो वे सही मान नहीं होते हैं।

मैंने यह सुनिश्चित करके आंशिक रूप से इसे जोड़ दिया है कि वांछित सीमेंट पर कब्जा करने से पहले, पहले कुछ मूल्यों को उनके खिलाफ क्या किया जाना चाहिए (यानी अगर मेरी सूची [0] == 165 & ....)।
यह कच्चा है लेकिन ठीक है क्योंकि सूची में एक दूसरे के समीप आने वाले इन दो मूल्यों की संभावना कम है। समस्या यह है कि बाइट्स शिफ्ट के रूप में इसका मतलब है, मैं मूल्यों का भार खो रहा हूं, जब तक कि यह अंततः रीयलिन न हो जाए।

मेरा प्रश्न है: क्या कोड मैं करने के लिए उपयोग कर सकते हैं:

क) एक बार यह पाया गया है कि यह अब 165,90 साथ शुरू होता है फिर से संगठित करना करने के लिए सूची बाध्य करें। (Elif ....)।

बी) सूची में '165' & '9 0' (एक दूसरे के बगल में) हैं और उन मूल्यों को निकालें जिन्हें मैं अपनी स्थिति के संबंध में चाहता हूं (अगला लेकिन एक, आगे)।

अग्रिम

S_S

धन्यवाद बस है कि मैं

mylist.append(mylist.pop(0)) 

कई बार इस्तेमाल कर सकते हैं, जब तक वे सही जगह में हैं संबंधित Q के देखा। क्या कोई बेहतर तरीका है कि कोई भी सुझाव दे सकता है? , उपयोगी = [3,5,151,99]

तब:

Answer 1

मामले में मैं तुम्हें अच्छी तरह से समझ, मान लीजिए कि आप इस तरह की एक सूची है:

l = [67, 126, 165, 90, 11, 1, 3, 5, 151, 99, 23] 

आप प्राप्त करना चाहते हैं आप कर सकते हैं:

# obtain places where 165 is followed by 90 
match = [x for x in xrange(len(l)-1) if l[x]==165 and l[x+1]==90] 
# obtain range of useful values 
useful = l[match[0]+4:match[0]+8] 

अगर आपको आपकी समस्या को गलत समझा जाता है तो आपको संख्याओं को ट्विक करना पड़ सकता है। आशा है कि यह मदद करता है,

मैनुअल

Answer 2

अगर मैं आपकी समस्या को सही समझते हैं, आप डेटा है लगातार आ रहा है 17-बाइट मात्रा में। मान लिया जाये कि यह सही है, कैसे कुछ इस तरह के बारे में:

while True:  
    mylist.extend(get_more_data()) 

    # If we're misaligned, skip bytes until we're aligned again 
    while mylist and mylist[0] != 165 or mylist[1] != 90: 
     mylist.pop(0) 

    # If we've skip bytes, we might not have enough data, so get more 
    if len(mylist) < 17: 
     continue 

    # Process one chunk of data and remove it from the list 
    process_data(mylist[:17]) 
    del mylist[:17] 

Answer 3

मैं हैडर मूल्यों के रूप में 165 और 90 का प्रयोग करेंगे, हमेशा एक मैच के लिए भेजे बाइट की जाँच। यह समाधान अपने आप स्वत: समन्वयित हो जाता है खुद को और यह उतना ही आसान है के रूप में:

def get_message(): 
    while True: #Some timeout functionality is useful here ;-) 
     message = [] 
     byte = xxx.get_byte() 
     if byte == 165: 
      byte = xxx.get_byte() 
      if byte == 90: 
      xxx.get_byte() #drop it 
      xxx.get_byte() #drop it 
      message[0] = xxx.get_byte() 
      message[1] = xxx.get_byte() 
      message[2] = xxx.get_byte() 
      message[3] = xxx.get_byte() 
      #Break out of loop. We have a message! 
      return message 

यदि आपके दोनों पक्षों को डिजाइन करने, तुम सच में चेकसम किसी तरह डालूँ। यदि आप बस कुछ हैकिंग करते हैं, तो चेकसम के लिए बाइट्स देखें। यह शायद पहले से ही है।