sparse vector dot product
Valid. But your code is messy. You are taking one step away from the original traditional problem, and that actually becomes a problem form your code. 

Your actually better off with the one dimensional arrays then the two dimensional tuples. Tuples may be the wrong data type to use for your problem to resolve itself nicely. 



Styling notes:
This:

def dot_product(v1, v2):
    ...


suggest to me that v1 and v2 are vectors, not a list of vectors, but by changing to:

def dot_product1(v1: [()], v2: [()]):
    ...


the obscurity magically disappears. 

This method of commenting your code is called annotations and is commonly used in python, I like them a lot. 



The 

    ...
    return result
if __name__ == "__main__":
    ...


could be more readable if: 

    ...
    return result


if __name__ == "__main__":
    ...




An analogue solution which will scale better is

def get_pointers(v: tuple):
    return {key: value for key, value in enumerate(v) if value}


def sparse_vector_dot(a: dict, b: dict):
    result = 0
    for key, value in a.items():
        if key in b:
            result += b[key] * value
    return result


def main():
    a = (2, 4, 0, 0, 0, 6)
    b = (0, 3, 4, 0, 0, 7)
    a, b = get_pointers(a), get_pointers(b)
    print(sparse_vector_dot(a, b))


and the function sparse_vector_dot could be written as:

def sparse_vector_dot_oneliner(a: dict, b: dict):
    return sum(b[key]*value for key, value in a.items() if key in b)


It will scale better since we are never checking what we don't have to check, the only thing we have to check is if there is a corresponding index in the other list (now dict).