>>> ['a', 'b'].index('b')
1

If the list is already sorted, you can of course do better than linear search.

As others suggested, don't use list as a variable name. It is a type.

lists = ["22 + 13", "4500 - 2"]
for string in lists:
  signPos = None

  if "+" in string:
    signPos = string.find("+")
  elif "-" in string:
    signPos = string.find("-")
  else:
    print('Error')
    
  print(signPos)

# Output
# 3
# 5

Maybe this could be an opportunity to introduce you to some python features:

from typing import List


def rare_char(sentence: str, rare_chars: List[str]=["j", "x", "q", "z"]) -> List[str]:
    return [word for word in sentence.split() if 
            any(char in word for char in rare_chars)]


def cool_para(sentence: str) -> str:
    return f"{len(rare_char(sentence))} word(s) with rare characters"

This answer uses:

1. typing, which can be used by third party tools such as type checkers, IDEs, linters, but more importantly to make your intentions clear to other humans who might be reading your code.
2. default arguments, instead of hardcoding them inside the function. It's very important to document your functions, so that an user would not be surprised by the result (see Principle of Least Astonishment). There are of course other ways of documenting your code (see docstrings) and other ways of designing that interface (could be a class for example), but this is just to demonstrate the point.
3. List comprehensions, which can make your code more readable by making it more declarative instead of imperative. It can be hard to determine the intention behind imperative algorithms.
4. string interpolation, which in my experience is less error prone than concatenating.
5. I used the pep8 style guide to name the functions, which is the most common convention in the python world.
6. Finally, instead of printing I returned a str in the cool_para function because the code below the # DO NOT CHANGE CODE BELOW comment is printing the result of the function call.

Your biggest issue is that the for row in lists won't actually iterate through anything (you've already done a complete read of the file when you called set). I think if you get rid of that line (and look for name in row you should be doing much better.

def find_friend(filename, name):
    lists = open(filename, 'Ur')
    for row in lists:
        if name in row:
            print row
        else:
            print 'friend does not exist'

Try this:-

lst = [['a', 'e'], ['g', 'j'], ['m', 'n', 'w'], ['z']]
def search(search_char):
    result = [x for x in lst if search_char in x]
    return result
print(search('g'))

This gives a list of indices:

[i for i, x in enumerate(vec) if "you" in x]

This is called a list comprehension, and it uses the enumerate function to keep track of the indices. If you aren't familiar with these, I recommend the official python tutorial here

How about a filter?

In [191]: print('\n'.join(filter(lambda x: x[0] != 'a', ["abc", "xyz", "test"])))
xyz
test

find() returns -1 if the character is not found in the string. Anything that is not zero is equal to True. try if item.find("x") > -1.

re.findall takes a pattern (or a compiled RE) as the first arg, a string as the second arg. You're failing at both!-)

re.match returns a match object or None -- neither is acceptable as an argument to re.findall! Just pass the r'[0-1][0-9]' pattern there.

The second arg needs to be a string, not a list, so, use a loop...:

list2 = []
for astring in list1:
    list2.extend(re.findall(r'[0-1][0-9]', astring))

Assume you have a list l = ['alpha', 'bravo', 'charlie.', 'delta', 'echo'] Then you can create a list with all words containing '.' in it by doing filter like below:

l = ['alpha', 'bravo', 'charlie.', 'delta', 'echo']
list_with_dot = [x for x in l if x.find('.') != -1]

"\"" in dfTrain['name'][22] is 'McGowan, Miss. Anna "Annie"' which contains "\"

while dfTrain['name'] is a list and you dont have a "\" as element in list

Similar example as yours:

>>> nested_list_example = ["abhishek","ralesh","wr'"]
>>> "wr'" in nested_list_example
True
>>> "'" in nested_list_example
False
>>> "'" in nested_list_example[2]
True

Yes, it will freeze, once you fix enough problems to get that far: your final two lines are an infinite loop. You don't change either good or letter within the loop -- as soon as they match, you're stuck inside.

Insert print statements to trace your execution and data values.

Also, I strongly recommend that you adopt incremental programming. Your code has multiple problems; you should write just a few lines, make sure that they work, and then go on to the next small group.

Check this.

Dictionary = ["Hello", "Hi"]
Character = ['e']

def findwords(dictionary,character):
    tmp = ""
    for i in dictionary:
        #convert string to char list
        str_arr = list(i)
        for j in character:
            #if char is in char list then save it in tmp variable
            #if you want multiple values then use array instead of tmp
            if j in str_arr:
                tmp = i
    return tmp

k = findwords(Dictionary,Character)
print(k)