Rough lookup benchmark

lookup_bench.py

#!/usr/bin/env python

test_int_list = [0,1,2,3,4,4,3,2,1,0]*10
test_str_list = ['a', 'ab', 'abc', 'abcd', 'efgh', 'efgh', 'abcd', 'abc', 'ab', 'a']*10

def lookup_if_int(cond, arg):
    val = None
    if cond == 0:
        val = arg+1
    elif cond == 1:
        val = arg+2
    elif cond == 2:
        val = arg+4
    elif cond == 3:
        val = arg+8
    elif cond == 4:
        val = arg+16
    return val

def test_if_int():
    for i in range(len(test_int_list)):
        val = lookup_if_int(test_int_list[i], i)

def lookup_if_return_int(cond, arg):
    if cond == 0:
        return arg+1
    elif cond == 1:
        return arg+2
    elif cond == 2:
        return arg+4
    elif cond == 3:
        return arg+8
    elif cond == 4:
        return arg+16
    return None

def test_if_return_int():
    for i in range(len(test_int_list)):
        val = lookup_if_return_int(test_int_list[i], i)

lookup_list_int = [
    lambda arg : arg + 1,
    lambda arg : arg + 2,
    lambda arg : arg + 4,
    lambda arg : arg + 8,
    lambda arg : arg + 16,
]

def test_list_int():
    for i in range(len(test_int_list)):
        val = lookup_list_int[test_int_list[i]](i)

lookup_dict_int = {
    0: lambda arg : arg + 1,
    1: lambda arg : arg + 2,
    2: lambda arg : arg + 4,
    3: lambda arg : arg + 8,
    4: lambda arg : arg + 16,
}

def test_dict_int():
    for i in range(len(test_int_list)):
        val = lookup_dict_int[test_int_list[i]](i)

def lookup_if_str(cond, arg):
    val = None
    if cond == 'a':
        val = arg+1
    elif cond == 'ab':
        val = arg+2
    elif cond == 'abc':
        val = arg+4
    elif cond == 'abcd':
        val = arg+8
    elif cond == 'efgh':
        val = arg+16
    return val

def test_if_str():
    for i in range(len(test_int_list)):
        val = lookup_if_str(test_str_list[i], i)

def lookup_if_return_str(cond, arg):
    if cond == 'a':
        return arg+1
    elif cond == 'ab':
        return arg+2
    elif cond == 'abc':
        return arg+4
    elif cond == 'abcd':
        return arg+8
    elif cond == 'efgh':
        return arg+16
    return None

def test_if_return_str():
    for i in range(len(test_int_list)):
        val = lookup_if_return_str(test_str_list[i], i)

lookup_dict_str = {
    'a':    lambda arg : arg + 1,
    'ab':   lambda arg : arg + 2,
    'abc':  lambda arg : arg + 4,
    'abcd': lambda arg : arg + 8,
    'efgh': lambda arg : arg + 16,
}

def test_dict_str():
    for i in range(len(test_str_list)):
        val = lookup_dict_str[test_str_list[i]](i)


if __name__ == '__main__':
    import timeit
    print("test_if_int: %f" % timeit.timeit("test_if_int()", setup="from __main__ import lookup_if_int, test_int_list, test_if_int"))
    print("test_if_return_int: %f" % timeit.timeit("test_if_return_int()", setup="from __main__ import lookup_if_return_int, test_int_list, test_if_return_int"))
    print("test_list_int: %f" % timeit.timeit("test_list_int()", setup="from __main__ import lookup_list_int, test_int_list, test_list_int"))
    print("test_dict_int: %f" % timeit.timeit("test_dict_int()", setup="from __main__ import lookup_dict_int, test_int_list, test_dict_int"))
    print("test_if_str: %f" % timeit.timeit("test_if_str()", setup="from __main__ import lookup_if_str, test_str_list, test_if_str"))
    print("test_if_return_str: %f" % timeit.timeit("test_if_return_str()", setup="from __main__ import lookup_if_return_str, test_str_list, test_if_return_str"))
    print("test_dict_str: %f" % timeit.timeit("test_dict_str()", setup="from __main__ import lookup_dict_str, test_str_list, test_dict_str"))