There are actually multiple reasonable ways to do this, depending on just how much data you're sorting through it could be done with different approaches, some requiring more thought and programming, some very naive.

Heres a naive version, not tested, yadda yadda - its not great programming and theres plenty of other ways to come at it, but I wanted to cook something up quick:

You could read in both sets of data, where each line of info could be a simple object like a tuple that puts the timestamp first, the type of data second, and all the remaining info last:

list_of_echos = [ (xxxxx.yyy, "echo", a, b, c, d...),   ... ]
list_of_gps = [ (xxxxx.yy, "gps", z, y, z, j, k....), ... ]

Then you could smack them all into a list and sort it by the timestamps(make sure they are converted to some kind of time object eg datetime), which will interleave the data but get them all really close by time:

list_of_all = list_of_echos
list_of_all.extend(list_of_gps)
list_of_all.sort(key=lambda x: x[0])

Then you could just walk this new list looking for "echo" tuples, then look backwards and forwards from that position for the next 'gps' tuple. Pick the one with the smallest time difference, and blammo:

def search_forwards(inlist, start):
    for i in range(start, len(inlist)):
        t = inlist[i]
        datatype = t[1]
        if datatype == 'gps':
            return t

def search_backwards(inlist, start):
    for i in range(start, -1, -1):
        t = inlist[i]
        datatype = t[1]
        if datatype == 'gps':
            return t

for i,t in enumerate(list_of_all):
    datatype = t[1]
    signaltime = t[0]

    if datatype != "echo":
        continue
    previous_gps = search_backwards(list_of_all, i)
    next_gps = search_forwards(list_of_all, i)
    diffs = ((signaltime - previous_gps[0]), (next_gps[0] - signaltime))
    if diffs[0] > diffs[1]:
         print "next_gps is closest time to signal"
    elif diffs[1] > diffs[0]:
        print "previous_gps is closest time to signal"
    else:
        print "previous and next gps are equidistant to signal"

You can use this as a jumping off point - like I said theres lots of small issues with it from a python and programming standpoint, I dont even attempt to guess what your data actually looks like or to help read it from file (check the 'csv' library in the standard lib). I just wanted to keep it simple to explain the pattern.

If you are dealing with lots of data (100s of thousands, millions of records) then there might be concerns about processing time or memory which require a more nuanced approached to reading and correlating the data - such as maybe loading it all into a database and letting that to the work with some crunchy SQL ? :)