Use Python to implement Trie

class TrieItemIterator:
def __init__(self, root, prefix=''):
self.root = root
self.stack = []
self.prefix = prefix
if self.root != None:
self.root_list = {'' : self.root}
self.stack = [(iter(self.root_list.items()), self.prefix)]

def __iter__(self):
self.stack = []
if self.root != None:
self.stack = [(iter(self.root_list.items()), self.prefix)]
return self

def __next__(self):
ret = None
while len(self.stack) > 0:
try:
p = next(self.stack[-1][0])
if p[1] != None:
if p[1][1] != None:
ret = (self.stack[-1][1] + p[0], p[1][1])
l = iter(p[1][0].items())
self.stack.append((l, self.stack[-1][1] + p[0]))
if ret != None:
return ret
except StopIteration:
self.stack.pop()
raise StopIteration

class TrieKeyIterator(TrieItemIterator):
def __next__(self):
kv = TrieItemIterator.__next__(self)
return kv[0]

class Trie:
def __init__(self):
self.root = [dict(), None]
self.size = 0

def put(self, key, value):
#assert type(key) is str
n = len(key)
i = 0
p = self.root
while i < n:
c = p[0].get(key[i])
if c == None:
c = [dict(), None]
p[0][key[i]] = c
p = c
i += 1
if p[1] == None:
if value != None:
self.size += 1
else:
if value == None:
self.size -= 1
p[1] = value

def __get(self, key):
ret = None
n = len(key)
i = 0
p = self.root
while i < n:
c = p[0].get(key[i])
if c != None:
p = c
i += 1
else:
break
if i == n:
ret = p
return ret

def get(self, key, default_value = None):
#assert type(key) is str
ret = self.__get(key)
if ret != None:
ret = ret[1]
else:
ret = default_value
return ret

def empty(self):
return self.size == 0

def keys(self):
return TrieKeyIterator(self.root)

def items(self):
return TrieItemIterator(self.root)

def longest_prefix_of(self, key):
#assert type(key) is str
ret = None
n = len(key)
n -= 1
i = 0
p = self.root
while i < n:
if p[1] != None:
ret = key[:i]
c = p[0].get(key[i])
if c != None:
p = c
i += 1
else:
break
return ret

def keys_with_prefix(self, key):
p = self.__get(key)
return TrieKeyIterator(p, key)

def __iadd__(self, other):
k, v = other
self.put(k, v)
return self

def __iter__(self):
return TrieKeyIterator(self.root)

def __setitem__(self, index, value):
self.put(index, value)

def __getitem__(self, index):
return self.get(index)

def __len__(self):
return self.size

def __bool__(self):
return self.size > 0

def __contains__(self, key):
#assert type(key) is str
return self.get(key, None) != None

def __delitem__(self, key):
#assert type(key) is str
self.put(key, None)