Python：懶惰字符串解碼

Question

我正在編寫解析器，並且有大量文本需要解碼，但大多數用戶只關心所有數據的幾個字段。所以我只想在用戶實際使用某些數據時進行解碼。這是做這件事的好方法嗎？

class LazyString(str): 
    def __init__(self, v) : 
     self.value = v 
    def __str__(self) : 
     r = "" 
     s = self.value 
     for i in xrange(0, len(s), 2) : 
      r += chr(int(s[i:i+2], 16)) 
     return r 

def p_buffer(p): 
    """buffer : HASH chars""" 
    p[0] = LazyString(p[2]) 

這是我唯一需要重寫的方法嗎？

Answer 1

我不知道如何實現一個字符串子類在這裏很有好處。在我看來，如果你正在處理一個包含PB級數據的數據流，每當你創建了一個你不需要的對象時，你就已經失去了遊戲。您的首要任務應該是儘可能多地忽略儘可能多的輸入。

你當然可以建立一個字符串類是這樣做：

class mystr(str): 
    def __init__(self, value): 
     self.value = value 
     self._decoded = None 
    @property 
    def decoded(self): 
     if self._decoded == None: 
      self._decoded = self.value.decode("hex") 
      return self._decoded 
    def __repr__(self): 
     return self.decoded 
    def __len__(self): 
     return len(self.decoded) 
    def __getitem__(self, i): 
     return self.decoded.__getitem__(i) 
    def __getslice__(self, i, j): 
     return self.decoded.__getslice__(i, j) 

等。關於這樣一個奇怪的事情是，如果你繼承str，每一個你沒有明確的實現方法將在則傳遞給構造函數的值稱爲：

>>> s = mystr('a0a1a2') 
>>> s 
 ¡¢ 
>>> len(s) 
3 
>>> s.capitalize() 
'A0a1a2' 

Answer 2

我在代碼中看不到任何一種惰性評估。您使用xrange的事實僅意味着將按需生成從0到len(s)的整數列表。無論如何，整個字符串r將在字符串轉換期間被解碼。

在Python中實現惰性序列的最佳方式是使用generators。你可以嘗試這樣的事：

def lazy(v): 
    for i in xrange(0, len(v), 2): 
     yield int(v[i:i+2], 16) 

list(lazy("0a0a0f")) 
Out: [10, 10, 15] 

Answer 3

你在做什麼是建立在已經：

s = "i am a string!".encode('hex') 
# what you do 
r = "" 
for i in xrange(0, len(s), 2) : 
    r += chr(int(s[i:i+2], 16)) 
# but decoding is builtin 
print r==s.decode('hex') # => True 

正如你可以看到你的整個解碼s.decode('hex')。

但「懶惰」的解碼聽起來像是對我不成熟的優化。你需要千兆字節的數據才能注意到它。嘗試分析，.decode比舊代碼快50倍。

也許你想的財產以後這樣的：

class DB(object): # dunno what data it is ;) 
    def __init__(self, data): 
     self.data = data 
     self.decoded = {} # maybe cache if the field data is long 
    def __getitem__(self, name): 
     try: 
      return self.decoded[name] 
     except KeyError: 
      # this copies the fields data 
      self.decoded[name] = ret = self.data[ self._get_field_slice(name) ].decode('hex') 
      return ret 
    def _get_field_slice(self, name): 
     # find out what part to decode, return the index in the data 
     return slice(...) 

db = DB(encoded_data)  
print db["some_field"] # find out where the field is, get its data and decode it 

Answer 4

你需要重寫的方法真的取決於如何計劃使用您新的字符串類型。

但是你基於str的類型對我來說看起來有點可疑，你看看str的實現來檢查它是否有value屬性，你在__init__()中設置？執行dir(str)並不表示在str上有任何此類屬性。這是正常的str方法將不會在您的數據上運行的情況下，我懷疑這是否是你想要的效果，否則子分類的優點是什麼。

無論如何，子類別基礎數據類型有點奇怪，除非您有非常特殊的要求。對於懶惰的評估，你希望你可能更好地創建包含字符串而不是子類str的類，並編寫客戶端代碼來處理該類。然後，您可以通過多種方式自由添加所需的即時評估：在此演示文稿中可找到使用描述符協議的示例：Python's Object Model（搜索「class Jit（object）」以訪問相關部分）

Answer 5

的問題是不完整的，因爲答案將取決於你使用的編碼細節。假設你將一個字符串列表編碼爲pascal字符串（即以字符串長度作爲固定長度整數編碼的前綴），並且假設你想從列表中讀取第100個字符串，你可以seek（）forward對於前99個字符串中的每一個並且根本不讀取它們的內容。如果字符串很大，這會帶來一些性能提升。

如果OTOH，你編碼字符串作爲串接0終結stirngs的列表，你會閱讀所有字節，直到第100 0

此外，你談到一些「場」，但你例子看起來完全不同。