Not the most efficient one, but by far the most obvious way to do it is:

>>> a = [1, 2, 3, 4, 5]
>>> b = [9, 8, 7, 6, 5]
>>> set(a) & set(b)
{5}

if order is significant you can do it with list comprehensions like this:

>>> [i for i, j in zip(a, b) if i == j]
[5]

(only works for equal-sized lists, which order-significance implies).

Personally, I think dicts would suit your solution better, as you can access them via their keys (e.g. dict['km_driven']) which is less confusing than integer indices in a list.

This code works using lists:

# list1 = ('Name', 'Kilometers Driven')
list1 = [('Joe Doe', 500),('Jane Doe', 200)]

# list2 = ('Id','Name','Kilometers Walked','Total Events', optional='Kilometers Driven')
list2 = [(2,'Joe Doe',20,2),(3,'Frank Kelly',32,4)]

# Iterate through items of list1
for item1 in list1:
    # Iterate through items of list2
    for i in range(len(list2)):
        # Match 'Name' field in list1 to 'Name' field in list2
        if item1[0] == list2[i][1]:
            # Add 'Kilometers Driven' to that list2 item
            list2[i] = list2[i] + (item1[1], )

print(list2[0])     

Output:

(2, 'Joe Doe', 20, 2, 500)

I might do something like:

set1 = set((x.id,x.name,...) for x in list1)
difference = [ x for x in list2 if (x.id,x.name,...) not in set1 ]

where ... is additional (hashable) attibutes of the instance -- You need to include enough of them to make it unique.

This takes your O(N*M) algorithm and turns it into an O(max(N,M)) algorithm.

The problem with this is that, for each element in list A, you're checking all of the elements in list B. So, if the lengths of your lists are N and M, that's N*M comparisons.

If you make a set of the usernames from list B, then you can just use the in operator on it—which is not only simpler, it's instantaneous, instead of having to check all of the values one by one. So, you only need N lookups instead of N*M.

So:

b_names = {record.username for record in List_B}
for record_a in List_A:
    if record_a.username in b_names:
        print "Duplicate username: {0}".format(record_a.username)

Or, even simpler, use set intersection:

a_names = {record.username for record in List_A}
b_names = {record.username for record in List_B}
for name in a_names & b_names:
    print "Duplicate username: {0}".format(name)

And really, you don't need both of them to be sets, you can make one a set and the other just an iterator, using a generator expression:

a_names = {record.username for record in List_A}
b_names = (record.username for record in List_B)
for name in a_names.intersection(b_names):
    print "Duplicate username: {0}".format(name)

One of these may be a little faster than the others, but they'll all be in the same ballpark—and, more importantly, they're all linear instead of quadratic. So, I'd suggest using whichever one makes the most sense to you.

If you just need to know whether there are duplicates rather than get a list of them, or just need to get one of the duplicates arbitrarily rather than all of them, you can speed it up by "short-circuiting" early—e.g., adding a break after the print in the first one, or using isdisjoint instead of intersection in the last one.

Mmm, like this?

if list1 == list2: # compare lists for equality
    doStuff()      # if lists are equal, do stuff after that   

Of course, you need to clarify what do you mean by "if lists values match". The above will check to see if both lists have the same elements, in the same position - that is, if they're equal.

EDIT:

The question is not clear, let's see some possible interpretations. To check if all elements in list1 are also in list2 do this:

if all(x in list2 for x in list1):
    doStuff()

Or to do something with each element in list1 that also belongs in list2, do this:

for e in set(list1) & set(list2):
    doStuff(e)