Do both strings have the same lenght? otherwise you should consider using something like:

while count < min(len(seqA), len(seqB)):

OK, let's take this one step at a time. First, I would read file B into a structure that's well suited for fast lookup since we're going to be doing that quite often:

chars = {}
with open("B") as lookupfile:
    for number,line in enumerate(lookupfile):
        chars[line.strip()] = number

Now we have a dictionary chars that contains letters as keys and their row number as values:

>>> chars
{'t': 1, 'a': 4, 'i': 3, 'h': 0, 's': 2}

Now we can iterate over the first file. The standard Python iterator for files consumes one line per iteration, not one character, so it's probably best to simply read the entire file into a string and then iterate over that (because for strings, iteration is character-by-character):

with open("A") as textfile:
    text = textfile.read()

Now we iterate over the string and print matching values:

for char in text:
    if char in chars:
        print("Character {0} found in row {1}".format(char, chars[char]))

If you don't like accessing the dictionary twice, you can also use

for char in text:
    found = chars.get(char):    # returns None if char isn't a key in chars
    if found:
        print("Character {0} found in row {1}".format(char, found))

or, using exceptions:

for char in text:
    try:
        print("Character {0} found in row {1}".format(char, chars[char]))
    except KeyError:
        pass

You never reset x inside the outer loop. As a result it'll always be equal or greater to len(stringscompare) after the first iteration of the outer loop.

Set it to 0 in the outer loop:

v = 0
while v < len(strings) and stop == False:
    x = 0
    while x < len(stringscompare) and stop == False:

Other observations:

Don't use stop == False where not stop will do.

You could just use a for loop, then break out twice:

for s in strings:
    for sc in stringscompare:
        if re.search(s, sc):
            same.append(dict)
            break
    else:
        continue
    # only reached if the inner loop broke out
    break

or use any() with a generator expression to find the first match:

 if any(re.search(s, sc) for s in strings for sc in stringscompare):
     same.append(dict)

This statement

x != 'Y' or x != 'N'

is always True, because everything in the world is not "Y" or not "N".

Change it to:

x != 'Y' and x != 'N'

Your while loop compares each character with the last, a, stopping when it finds a character that isn't equal or higher than a. Your code stops at the space because the latter's position in the ASCII table is 32:

>>> ' ' < 'a'
True
>>> ord(' ')
32
>>> ord('a')
97

You probably wanted to create a loop comparing num_index to num_length instead:

while num_index <= num_length:

If you wanted to loop through all characters in a string, just use a for loop:

for character in myString:
    print(character)

You can use the enumerate() function to add an index:

for index, character in enumerate(myString):
    print(index, character, sep=': ')
    print(myString[:index])

Try and instead of or. Alternatively, you might find the following more readable:

while direction not in ('encode', 'encrypt', 'decrypt', 'decode'):

You are resetting count to 0 each iteration of the loop. The loop therefore compares the first elements over and over and over and over again. To fix that problem, just move the count = 0 assignment outside of the loop, like this:

# ...
b = input('Please enter the second string to compare: ')

count = 0
while True:
    if a[count] != b[count]:
# ...

When you have done that, you will realise that you have a second problem – the program crashes when you have reached the end of one of the strings. You might want to handle this case too.

If you have a condition of number != '1' or number != '2', one of those conditions will always be true, so it'll never break out of the loop. Try while number not in ('1', '2', '3') instead.

You don't need nested loop in this case, thanks to the in operator:

for c in local:
    if c in valChar:
        performvalidaction(c)
    else:
        denoteasinvalid(c)

What identifier to use (c, ch, or anything else) is pretty indifferent, I tend to use single-character identifiers for loop variables, but there's no rule saying that you must.

If you did have to use two nested loops, you'd just use different loop variables for the two loops.

In fact you don't even need one loop here (you could instead work e.g with Python's sets, for example) -- much less two -- but I guess using one loop is OK if it's clearer for you.

You have your logic inverted. Use and instead:

while choice != 'y' and choice != 'Y' and choice != 'N' and choice != 'n':

By using or, typing in Y means choice != 'y' is true, so the other or options no longer matter. or means one of the options must be true, and for any given value of choice, there is always at least one of your != tests that is going to be true.

You could save yourself some typing work by using choice.lower() and test only against y and n, and then use membership testing:

while choice.lower() not in {'n', 'y'}:

For all built-in Python objects (like strings, lists, dicts, functions, etc.), if x is y, then x==y is also True.

Not always. NaN is a counterexample. But usually, identity (is) implies equality (==). The converse is not true: Two distinct objects can have the same value.

Also, is it generally considered better to just use '==' by default, even when comparing int or Boolean values?

You use == when comparing values and is when comparing identities.

When comparing ints (or immutable types in general), you pretty much always want the former. There's an optimization that allows small integers to be compared with is, but don't rely on it.

For boolean values, you shouldn't be doing comparisons at all. Instead of:

if x == True:
    # do something

write:

if x:
    # do something

For comparing against None, is None is preferred over == None.

I've always liked to use 'is' because I find it more aesthetically pleasing and pythonic (which is how I fell into this trap...), but I wonder if it's intended to just be reserved for when you care about finding two objects with the same id.

Yes, that's exactly what it's for.