Does Python have a string contains substring method?

If it's just a substring search you can use string.find("substring")

You do have to be a little careful with find, index, and in though, as they are substring searches. In other words, this:

s = "This be a string"
if s.find("is") == -1:
    print "No 'is' here!"
else:
    print "Found 'is' in the string."

Would print Found 'is' in the string. Similarly, if "is" in s: would evaluate to True. This may or may not be what you want.

if needle in haystack: is the normal use, as @Michael says -- it relies on the in operator, more readable and faster than a method call.

If you truly need a method instead of an operator (e.g. to do some weird key= for a very peculiar sort...?), that would be 'haystack'.__contains__. But since your example is for use in an if, I guess you don't really mean what you say;-). It's not good form (nor readable, nor efficient) to use special methods directly -- they're meant to be used, instead, through the operators and builtins that delegate to them.

Not there is no string.contains(str) method but there is in operator:

if substring in someString:
    print "It's there!!!"

Here is more complex working example:

# print all files with dot in home directory
import commands
(st, output) = commands.getstatusoutput('ls -a ~')
print [f for f in output.split('\n') if '.' in f ]

"Does Python have a string contains method?"

Yes, in fact it does, but using it directly is considered rather unPythonic usage (see below if you're still curious). Python has a keyword that you should use instead, because the language intends its usage, and most other programmers you work with will expect you to use it. That keyword is in, which is used as a comparison operator:

'foo' in '**foo**'

The complement, which the original question asks for, is not in:

'foo' not in '**foo**'

This is semantically the same as not 'foo' in '**foo**' but it's much more readable and explicitly provided for in the language as a readability improvement.

Avoid using the below

As promised, here's the contains method:

str.__contains__('**foo**', 'foo')

returns True. You could also call this function from the instance of the superstring:

'**foo**'.__contains__('foo')

But don't, if other Python writers work with you, they will find this quite unnatural and difficult to read. In fact, most usages of methods or other names that begin with underscores is generally discouraged.

Also, avoid the following string methods:

>>> '**foo**'.index('foo')
2
>>> '**foo**'.find('foo')
2

>>> '**oo**'.find('foo')
-1
>>> '**oo**'.index('foo')

Traceback (most recent call last):
  File "<pyshell#40>", line 1, in <module>
    '**oo**'.index('foo')
ValueError: substring not found

Other languages may have no methods to directly test for substrings, and so you would have to use these types of methods, but with Python, it is more semantically sound to use the in comparison operator.

Basically, you want to find a substring in a string in python. There are 2 ways to search for a substring in a string in python.

Method 1: in operator
You can use the python's in operator to check for a substring. Its quite simple and intuitive. It will return True if the substring was found in the string else False.

>>> "King" in "King's landing"
True

>>> "Jon Snow" in "King's landing"
False

Method 2: str.find() method
Second method is to use the str.find() method. Here, we call the .find() method on the string in which substring is to found. We pass the substring to the find() method and check its return value. If its value is other than -1, substring was found in the string otherwise not. The value returned is the index where substring was found.

>>> some_string = "valar morghulis"

>>> some_string.find("morghulis")
6

>>> some_string.find("dohaeris")
-1

I would recommend you to use the first method as it is more pythonic and intuitive.

Another way to find whether string contains few characters or not with the Boolean return value (i.e. True or `False)

str1 = "This be a string"
find_this = "tr"
if find_this in str1:
    print find_this, " is been found in ", str1
else:
    print find_this, " is not found in ", str1

Here is your answer:

if "insert_char_or_string_here" in "insert_string_to_search_here":
    //DOSTUFF

For checking if it is false:

if not "insert_char_or_string_here" in "insert_string_to_search_here":
    //DOSTUFF

OR:

if "insert_char_or_string_here" not in "insert_string_to_search_here":
    //DOSTUFF

So apparently there is nothing similar for vector-wise comparison. An obvious Python way to do so would be:

names = ['bob', 'john', 'mike']
any([st in 'bob and john' for st in names]) 
>> True

any([st in 'mary and jane' for st in names]) 
>> False