This is documented under Structural Pattern Matching

Like unpacking assignments, tuple and list patterns have exactly the same meaning and actually match arbitrary sequences. Technically, the subject must be a sequence. Therefore, an important exception is that patterns don’t match iterators. Also, to prevent a common mistake, sequence patterns don’t match strings.

and in PEP 635 -- Structural Pattern Matching: Motivation and Rationale

As in iterable unpacking, we do not distinguish between 'tuple' and 'list' notation. [a, b, c], (a, b, c) and a, b, c are all equivalent. While this means we have a redundant notation and checking specifically for lists or tuples requires more effort (e.g. case list([a, b, c])), we mimic iterable unpacking as much as possible.

You can use sets and intersection:

loc3 = set(loc1).intersection(loc2)

This gives you a set which is unordered and won't contain duplicates (and enforces that the items are hashable). If that's a problem, see the other answer by Phil Frost. However, this should be significantly more efficient where order and duplicates are unnecessary.

A order preserving solution which can contain duplicates, but requires hashability of the items (in loc2) is as follows:

sloc2 = set(loc2)
loc3 = [ item for item in loc1 if item in sloc2 ]  #still O(m)

In python, a set is simply a hash table. Checking to see if an item is contained in that set is an (approximately) O(1) operation because the position of the item is found via hashing.

a good way to do this is to have a function that will extract the information you need from the tuple list i.e.

def get_address_info(address_data):
    address_number = None
    street_name_pre_directional = None
    street_name_post_directional = None

    for value, property_name in address_data:
        if property_name == "AddressNumber":
            address_number = value
        elif property_name == "StreetNamePreDirectional":
            street_name_pre_directional = value
        elif property_name == "StreetNamePostDirectional":
            street_name_post_directional = value

    return address_number, street_name_pre_directional, street_name_post_directional

that way you dont have to compare the items with each another, and the maintenance is easier now you can get the necessary data and compare them directly and determine whether some information is missing by checking whether None is present in the info

add1_info = get_address_info(add1)
add2_info = get_address_info(add2)
if add1_info  == add2_info and None not in add1_info and None not in add2_info :
    #do something...

Use list.index:

>>> TupList = [('ABC D','235'),('EFG H','462')]
>>> TupList.index((u'EFG H',u'462'))
1

You didn't make the RegEx ungreedy. The solution is re.findall(r'\((.*?,.*?)\)',s).

You were close, after iterating the inner loop, you should check whether the item from the outer loop is actually equal to the tup[1] (each tup represent (0, 'a') or (1, 'b') for example).

if they equal, just append the first element in tup (tup[0]) to the result list.

lst = ['a', 'a', 'b']

catlist = [(0, 'a'), (1, 'b')]

catindexes = []
for item in lst:
    for tup in catlist:
        if item == tup[1]:
            catindexes.append(tup[0])
print (catindexes)

You also can use list comprehension:

catindexes = [tup[0] for item in lst for tup in catlist if tup[1] == item]