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)