Linear Search Table in Python and Ruby

LinTable.py

from collections.abc import Mapping, MutableMapping

class Table(MutableMapping):
    def __init__(self):
        self.__table = []      # the internal table as a list of key-value pairs

    def __len__(self):
        return len(self.__table)

    def __str__(self):
        result = "{\n"
        for kv in self.__table:
            result += "\t" + str(kv[0]) + ": " + str(kv[1]) + ",\n"
        result += "}"
        return result

    def __lin_search(self, key):
        for ix in range(len(self.__table)):
            if self.__table[ix][0] == key:
                return ix
        return -1
    
    def __search(self, key):
        return self.__lin_search(key)

    def __contains(self, key):
        return self.__search(key) != -1
    
    def __getitem__(self, key):
        for kv in self.__table:
            if kv[0] == key:
                return kv[1]
        return self.__missing__(kv[0])

    def get(self, key, defaultvalue=None):
        for kv in self.__table:
            if kv[0] == key:
                return kv[1]
        return defaultvalue

    def __setitem__(self, key, value):
        for kv in self.__table:
            if kv[0] == key:
                kv[1] = value
                return
        self.__table.append((key, value))

    def __delitem__(self, key):
        ix = self.__search(key)
        if ix in range(len(self.__table)):
            del self.__table[ix]

    def __iter__(self):
        return self.keys()
    
    def keys(self):
        for kv in self.__table:
            yield kv[0]
    
    def values(self):
        for kv in self.__table:
            yield kv[1]
    
    def items(self):
        for kv in self.__table:
            yield kv

def main():
    unitTest()
    table = Table()
    table["Japan"] = "Tokyo"
    table["England"] = "London"
    print(table)
    del table["Japan"]
    print(table)

def unitTest():
    table = Table()
    return table

if __name__ == "__main__":
    main()
    unitTest()