If you only want to know if any item of d is contained in paid[j], as you literally say:

if any(x in paid[j] for x in d): ...

If you also want to know which items of d are contained in paid[j]:

contained = [x for x in d if x in paid[j]]

contained will be an empty list if no items of d are contained in paid[j].

There are other solutions yet if what you want is yet another alternative, e.g., get the first item of d contained in paid[j] (and None if no item is so contained):

firstone = next((x for x in d if x in paid[j]), None)

BTW, since in a comment you mention sentences and words, maybe you don't necessarily want a string check (which is what all of my examples are doing), because they can't consider word boundaries -- e.g., each example will say that 'cat' is in 'obfuscate' (because, 'obfuscate' contains 'cat' as a substring). To allow checks on word boundaries, rather than simple substring checks, you might productively use regular expressions... but I suggest you open a separate question on that, if that's what you require -- all of the code snippets in this answer, depending on your exact requirements, will work equally well if you change the predicate x in paid[j] into some more sophisticated predicate such as somere.search(paid[j]) for an appropriate RE object somere. (Python 2.6 or better -- slight differences in 2.5 and earlier).

If your intention is something else again, such as getting one or all of the indices in d of the items satisfying your constrain, there are easy solutions for those different problems, too... but, if what you actually require is so far away from what you said, I'd better stop guessing and hope you clarify;-).

In your file reading part:

Use the with .. as construct

Use

with open(file, "r", encoding="UTF-8") as words_file:
    for line in words_file:

This will ensure that the file will be closed at the end.

split is more awesome than you think

>>> "abc".split(",")
["abc"]

So there is no need to check whether there is a "," in there. Note that both this and your original code will not strip the spaces after ":" and ",", if you enter for example:

foreign_word: native_word1, native_word2

So you might have to do something like this at the end:

foreign = [word.strip() for word in foreign]

You can also directly assign the read foreign_words to the class, no need for the intermediary list:

self.__foreign_words.append(foreign.split(","))
self.__native_words.append(native.split(","))

list.append() is also faster than list += other_list

From the code you posted I don't see any reason to have this in the file reading part:

x = random.randint(0, (len(self.__foreign_words) - 1))
self.__index.set(x)

Because in the second part of the code you immediately set x as well.

In your second part:

if language == "F":
    correct_word = self.__native_words[x]
elif language == "N":
    correct_word = self.__foreign_words[x]

Can be simplified to

# In the class add this member
self.dictionary = {"F": self.__native_words, "N": self.__foreign_words
...
# Then you can just use later
correct_word = self.dictionary[language][x]

Instead of putting everything in an if block to make sure there are words to process, you could do:

assert(L>0)
# or
if L==0:
    exit() # or continue if you are in a loop
# Rest of code

join is more awesome than you think

>>> ", ".join(["abc"])
'abc'

So no need to check for isinstance(words,str), just use:

self.__question.set(", ".join(correct_word))

But I would not do this, because if you leave your correct_word as a list of correct words (possibly containing only one word, which is fine), then checking for the right answer becomes what you want:

if answer in correct_words:
    # Do stuff

When checking whether the list is still not empty, it is better to set L to the new length:

L = len(self.__foreign_words)
if L > 0:
    # Do stuff

Instead of

if L - 1 > 0:
    # Do Stuff

This way you can wrap this in a while loop more easily and repeat until the user quits or has finished all words. Your current code seems to only support asking for two words in a row.

Like this, you can use a list comprehension:

mylist = ["770", "790", "1470", "1490"]
sq = "BPBA-SG790-NGTP-W-AU-BUN-3Y"

matching = [m for m in mylist if m in sq]

print(matching)

Output:

['790']

This is a job for sets

Convert your lists of lists to sets of tuples (you can't have sets of lists, as sets can only contain hashable objects, which lists, as all built-in mutable objects, are not)

a = set(map(tuple, [['abc','Hello World'],['bcd','Hello Python']]))
b = set(map(tuple, [['abc','Hello World'],['bcd','Hello World'],['abc','Python World']]))

or create them directly as sets of tuples:

a = {('abc','Hello World'),('bcd','Hello Python')}
b = {('abc','Hello World'),('bcd','Hello World'),('abc','Python World')}

You can then easily and efficiently get your differences:

print(b - a)
# {('abc', 'Python World'), ('bcd', 'Hello World')}

print(a - b)
# {('bcd', 'Hello Python')}

or even the intersection

print(a & b)
# {('abc', 'Hello World')}

or the union:

print(a | b)
# {('abc', 'Python World'), ('bcd', 'Hello World'), ('abc', 'Hello World'), ('bcd', 'Hello Python')}

s = ["this", "this", "and", "that"]
for i in xrange(1,len(s)):
    if s[i] == s[i-1]:
        print s[i]

EDIT:

Just as a side note, if you are using python 3.X use range instead of xrange

Use set intersection for this:

list(set(listA) & set(listB))

gives:

['a', 'c']

Note that since we are dealing with sets this may not preserve order:

' '.join(list(set(john.split()) & set(mary.split())))
'I and love yellow'

using join() to convert the resulting list into a string.

--

For your example/comment below, this will preserve order (inspired by comment from @DSM)

' '.join([j for j, m in zip(john.split(), mary.split()) if j==m])
'I love yellow and'

For a case where the list aren't the same length, with the result as specified in the comment below:

aa = ['a', 'b', 'c']
bb = ['c', 'b', 'd', 'a']

[a for a, b in zip(aa, bb) if a==b]
['b']