यह जानने का एक और तरीका है कि स्ट्रिंग में कुछ वर्ण हैं या नहीं, बूलियन रिटर्न वैल्यू (यानी True या 'गलत):

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

यदि यह केवल एक सबस्ट्रिंग खोज है तो आप string.find("substring") उपयोग कर सकते हैं।

आपको find , index , और हालांकि, जैसे कि वे खोजों को प्रतिस्थापित कर रहे find , के साथ थोड़ा सावधान रहना होगा। दूसरे शब्दों में, यह:

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

यह Found 'is' in the string. मुद्रित होगा Found 'is' in the string. इसी तरह, if "is" in s: True मूल्यांकन करेगा। यह हो सकता है कि आप जो चाहें हो या न हो।

आप ऑपरेटर का उपयोग कर सकते हैं:

if "blah" not in somestring: 
    continue

मैं देखता हूं कि पहले से ही उत्तर हैं लेकिन मैं अपने दो सेंट भी जोड़ना चाहता हूं।

पायथन में ऐसा करने के लिए कार्य हैं लेकिन सबसे सरल (और अधिकतर पसंदीदा) विधि में कीवर्ड का उपयोग करना in :

"test" in "testtext"
True

"abc" in "abcdefg"
True

"abc" in "Abc"
False

"ABC" in "abc"
False

"abc" in "def"
False

"abc" in ["abc", "def", "ghi"]
True

कुछ स्ट्रिंग विधियां भी हैं:

"xxabcxx".find("abc")
2 #returns the index of the first match

"xxabcxx".find("cde")
-1 #returns -1 if the substring 
#could not be found in the string

# and:

"xxabcxx".index("abc")
2

"xxabcxx".index("cde")
ValueError: substring not found
#raises ValueError...

प्रदर्शन के बारे में:

सामान्य रूप in एक सबस्ट्रिंग खोजने के लिए उपवास विधि है ...

index तुलना में थोड़ा तेज है

उम्मीद है कि मैं मदद कर सकता हूँ!

क्या पाइथन में स्ट्रिंग में स्ट्रिंग विधि होती है?

हां, लेकिन पायथन में एक तुलना ऑपरेटर है जिसका आपको उपयोग करना चाहिए, क्योंकि भाषा इसका उपयोग करने का इरादा रखती है, और अन्य प्रोग्रामर आपको इसका उपयोग करने की उम्मीद करेंगे। वह कीवर्ड है, जिसका उपयोग तुलना ऑपरेटर के रूप में किया जाता है:

>>> 'foo' in '**foo**'
True

विपरीत (पूरक), जो मूल प्रश्न पूछता है, इसमें not in :

>>> 'foo' not in '**foo**' # returns False
False

यह अर्थात् not 'foo' in '**foo**' जैसा not 'foo' in '**foo**' लेकिन यह पठनीयता सुधार के रूप में भाषा में अधिक पढ़ने योग्य और स्पष्ट रूप से प्रदान किया गया है।

__contains__ , find , और index का उपयोग करने से बचें

जैसा कि वादा किया गया है, यहां विधि contains है:

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

True आता है। आप सुपरस्टिंग के उदाहरण से इस फ़ंक्शन को भी कॉल कर सकते हैं:

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

लेकिन मत करो। अंडरस्कोर से शुरू होने वाले तरीके को अर्थात् निजी माना जाता है। इसका उपयोग करने का एकमात्र कारण यह है कि जब कार्यक्षमता in और विस्तार not in है (उदाहरण के लिए यदि subclassing str ):

class NoisyString(str):
    def __contains__(self, other):
        print('testing if "{0}" in "{1}"'.format(other, self))
        return super(NoisyString, self).__contains__(other)

ns = NoisyString('a string with a substring inside')

और अब:

>>> 'substring' in ns
testing if "substring" in "a string with a substring inside"
True

साथ ही, निम्न स्ट्रिंग विधियों से बचें:

>>> '**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

अन्य भाषाओं में सबस्ट्रिंग्स के लिए सीधे परीक्षण करने के लिए कोई तरीका नहीं हो सकता है, और इसलिए आपको इन प्रकार के तरीकों का उपयोग करना होगा, लेकिन पायथन के साथ, तुलनात्मक ऑपरेटर का उपयोग करना अधिक कुशल है।

प्रदर्शन तुलना

हम एक ही लक्ष्य को पूरा करने के विभिन्न तरीकों की तुलना कर सकते हैं।

import timeit

def in_(s, other):
    return other in s

def contains(s, other):
    return s.__contains__(other)

def find(s, other):
    return s.find(other) != -1

def index(s, other):
    try:
        s.index(other)
    except ValueError:
        return False
    else:
        return True



perf_dict = {
'in:True': min(timeit.repeat(lambda: in_('superstring', 'str'))),
'in:False': min(timeit.repeat(lambda: in_('superstring', 'not'))),
'__contains__:True': min(timeit.repeat(lambda: contains('superstring', 'str'))),
'__contains__:False': min(timeit.repeat(lambda: contains('superstring', 'not'))),
'find:True': min(timeit.repeat(lambda: find('superstring', 'str'))),
'find:False': min(timeit.repeat(lambda: find('superstring', 'not'))),
'index:True': min(timeit.repeat(lambda: index('superstring', 'str'))),
'index:False': min(timeit.repeat(lambda: index('superstring', 'not'))),
}

और अब हम देखते हैं कि इनका उपयोग दूसरों की तुलना में बहुत तेज़ है। बराबर ऑपरेशन करने के लिए कम समय बेहतर है:

>>> perf_dict
{'in:True': 0.16450627865128808,
 'in:False': 0.1609668098178645,
 '__contains__:True': 0.24355481654697542,
 '__contains__:False': 0.24382793854783813,
 'find:True': 0.3067379407923454,
 'find:False': 0.29860888058124146,
 'index:True': 0.29647137792585454,
 'index:False': 0.5502287584545229}

if needle in haystack: सामान्य उपयोग है, जैसा कि @ माइकल कहते हैं - यह ऑपरेटर पर निर्भर करता है, एक विधि कॉल से अधिक पठनीय और तेज़।

यदि आपको वास्तव में ऑपरेटर की बजाय एक विधि की आवश्यकता है (उदाहरण के लिए कुछ अजीब key= एक बहुत ही असाधारण प्रकार के लिए ...?), यह 'haystack'.__contains__ । लेकिन चूंकि आपका उदाहरण किसी उपयोग में उपयोग के लिए है, if मुझे लगता है कि आप वास्तव में इसका मतलब नहीं है कि आप क्या कहते हैं ;-)। यह विशेष रूप से विशेष तरीकों का उपयोग करने के लिए अच्छा फॉर्म नहीं है (न ही पठनीय, और न ही कुशल) - इसका उपयोग उन ऑपरेटरों और बिल्टिन के माध्यम से किया जाता है, जो उनके लिए प्रतिनिधि हैं।

आपका जवाब यहां दिया गया है:

if "insert_char_or_string_here" in "insert_string_to_search_here":
    #DOSTUFF

यह जांचने के लिए कि क्या यह गलत है:

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

या:

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

पायथन स्ट्रिंग्स और सूचियों में

यहां कुछ उपयोगी उदाहरण दिए गए हैं जो विधि in संबंधित स्वयं के लिए बोलते हैं:

"foo" in "foobar"
True

"foo" in "Foobar"
False

"foo" in "Foobar".lower()
True

"foo".capitalize() in "Foobar"
True

"foo" in ["bar", "foo", "foobar"]
True

"foo" in ["fo", "o", "foobar"]
False

चेतावनी। सूचियां पुनरावृत्त हैं, और विधि केवल तारों पर ही नहीं, बल्कि तारों पर कार्य करती है।

यदि आप किसी अन्य शब्द के भीतर निहित एक सबस्ट्रिंग के बजाय पूरे शब्दों के लिए केस-असंवेदनशील खोज की तलाश में हैं:

import string

s = 'This is my text example'
if 'is' not in (word.lower() 
    for split_char in string.punctuation + string.whitespace 
    for word in s.split(split_char)):
    # do something

यदि आप "blah" in somestring लेकिन यह एक समारोह कॉल होना चाहते हैं, तो आप शायद यह कर सकते हैं

import operator

if not operator.contains(somestring, "blah"):
    continue

पाइथन में सभी ऑपरेटरों को ऑपरेटर मॉड्यूल में कम या ज्यादा पाया जा सकता in ।

तो स्पष्ट रूप से वेक्टर-वार तुलना के लिए कुछ भी समान नहीं है। ऐसा करने के लिए एक स्पष्ट पायथन तरीका होगा:

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

सबस्ट्र () सामान्य रूप से (यानी PHP, पर्ल) इस तरह से काम करता है:

s = Substr(s, beginning, LENGTH)

तो पैरामीटर शुरू हो रहे हैं और LENGTH

लेकिन पायथन का व्यवहार अलग है, यह शुरुआत की उम्मीद है और एक अंत (!) के बाद। शुरुआती लोगों द्वारा स्पॉट करना मुश्किल है। तो Substr (एस, शुरुआत, LENGTH) के लिए सही प्रतिस्थापन है

s = s[ beginning : beginning + LENGTH]