@Dimitris's answer showed that s.find() and s.index() perform equally well if the substring is found.

But as @augustomen pointed out, if the substring is not found then s.index() will be significantly slower due to the exception handling. We can test this with the following code snippets.

Note that I'm using a different machine to @Dimitris so my timings cannot be compared with his.

$ python3 -m timeit -s "s = 'a' * 1000" "s.find('b')"
5000000 loops, best of 5: 87.3 nsec per loop

$ python3 -m timeit -s "s = 'a' * 1000" "try: s.index('b')" "except ValueError: pass"
1000000 loops, best of 5: 242 nsec per loop

It's clear that s.find() is the winner when the substring is not found, but is that just because we didn't include a try/except block for it?

Let's try adding a try/except block to s.find() (even though we know it won't be triggered).

$ python3 -m timeit -s "s = 'a' * 1000" "try: s.find('b')" "except ValueError: pass"
5000000 loops, best of 5: 89.1 nsec per loop

We see here that the mere presence of a try/except block barely alters the time at all. It's only when the exception is actually triggered that we incur a meaningful hit to performance.

The moral of the story is to use s.find() if there's a reasonable chance that the substring won't be found.

If you're sure that the substring will almost always be found then you can use either s.find() or s.index(). You might prefer s.index() in that case, because the try/except syntax signals to other developers that you are handling an edge case that you don't expect will occur very often.

find() will return the index of the first match. But rfind will give you the last occurence of the pattern. It will be clear if you try to match repeated match case.

       >>> string='hey! how are you harish'
       >>>string.find('h')
       >>>0                #it matched for first 'h' in the string
       >>> string.rfind('h')    
           22             #it matched for the last 'h' in the string

Also find is only available for strings where as index is available for lists, tuples and strings

>>> somelist
['Ok', "let's", 'try', 'this', 'out']
>>> type(somelist)
<class 'list'>

>>> somelist.index("try")
2

>>> somelist.find("try")
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'list' object has no attribute 'find'

>>> sometuple
('Ok', "let's", 'try', 'this', 'out')
>>> type(sometuple)
<class 'tuple'>

>>> sometuple.index("try")
2

>>> sometuple.find("try")
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'tuple' object has no attribute 'find'

>>> somelist2
"Ok let's try this"
>>> type(somelist2)
<class 'str'>

>>> somelist2.index("try")
9
>>> somelist2.find("try")
9

>>> somelist2.find("t")
5
>>> somelist2.index("t")
5