මම පයිතන්හි ක්‍රමයක් string.containsහෝ string.indexofක්‍රමයක් සොයමි .

මට කරන්න ඕනි:

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

ඔබට inක්රියාකරු භාවිතා කළ හැකිය :

if "blah" not in somestring: 
    continue

එය උපස්ථර සෙවුමක් නම් ඔබට භාවිතා කළ හැකිය string.find("substring").

ඔබ සමඟ ටිකක් පරිස්සම් විය යුතු නැහැ find, indexසහ inඔවුන් සෝදිසි substring ඇත ලෙස, නමුත්. වෙනත් වචන වලින් කිවහොත්, මෙය:

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., ඒ වගේම if "is" in s:කිරීමට ඇගයීමට ඇත True. මෙය ඔබට අවශ්‍ය දේ හෝ නොවිය හැකිය.

පයිතන්හි නූලක් උපස්ථර ක්‍රමයක් තිබේද?

ඔව්, නමුත් පයිතන් සතුව ඔබ ඒ වෙනුවට භාවිතා කළ යුතු සංසන්දනාත්මක ක්‍රියාකරුවෙකු ඇත, මන්ද භාෂාව එහි භාවිතය අදහස් කරන අතර අනෙක් ක්‍රමලේඛකයින් ඔබ එය භාවිතා කරනු ඇතැයි අපේක්ෂා කරයි. එම මූල පදය inසංසන්දනාත්මක ක්‍රියාකරුවෙකු ලෙස භාවිතා කරයි:

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

මුල් ප්‍රශ්නය අසන ප්‍රතිවිරුද්ධ (අනුපූරකය) not in:

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

මෙය අර්ථාන්විතව සමාන වන not 'foo' in '**foo**'නමුත් එය කියවිය හැකි වැඩිදියුණු කිරීමක් ලෙස භාෂාවට වඩා කියවිය හැකි සහ පැහැදිලිවම සපයා ඇත.

භාවිතා කිරීමෙන් වැළකෙන __contains__, findසහindex

පොරොන්දු වූ පරිදි, මෙන්න containsක්‍රමය:

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

ප්‍රතිලාභ True. ඔබට මෙම ශ්‍රිතය සුපිරි නූලෙන් හැඳින්විය හැක:

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

නමුත් එපා. යටි ඉරි වලින් ආරම්භ වන ක්‍රම අර්ථකථන වශයෙන් පුද්ගලික ලෙස සැලකේ. මෙය භාවිතා කිරීමට ඇති එකම හේතුව වන්නේ ක්‍රියාකාරීත්වය දීර් ing කිරීමේදී inසහ not in(උදා: උප පංති නම් 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

වෙනත් භාෂාවන්ට උපස්ථර සඳහා කෙලින්ම පරීක්ෂා කිරීමට ක්‍රමවේදයන් නොමැති විය හැක, එබැවින් ඔබට මෙම ක්‍රම භාවිතා කිරීමට සිදුවනු ඇත, නමුත් පයිතන් සමඟ inසැසඳීමේ ක්‍රියාකරු භාවිතා කිරීම වඩා කාර්යක්ෂම වේ.

කාර්ය සාධන සැසඳීම්

එකම ඉලක්කය සපුරා ගැනීමේ විවිධ ක්‍රම අපට සැසඳිය හැකිය.

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'))),
}

දැන් අපට පෙනෙන්නේ භාවිතා කිරීම inඅනෙක් ඒවාට වඩා වේගවත් බවයි. සමාන මෙහෙයුමක් කිරීමට අඩු කාලයක් ගැනීම වඩා හොඳය:

>>> 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:use මයිකල් පවසන පරිදි සාමාන්‍ය භාවිතය වේ - එය inක්‍රියාකරු මත රඳා පවතී , ක්‍රම ඇමතුමකට වඩා කියවිය හැකි සහ වේගවත් වේ.

ඔබට සැබවින්ම ක්‍රියාකරුවෙකු වෙනුවට ක්‍රමවේදයක් අවශ්‍ය නම් (උදා: key=ඉතා සුවිශේෂී වර්ගයක් සඳහා අමුතු දෙයක් කිරීමට ...?), එය එසේ වනු ඇත 'haystack'.__contains__. නමුත් ඔබේ උදාහරණය භාවිතා කිරීම සඳහා වන බැවින් if, ඔබ කියන දේ ඔබ සැබවින්ම අදහස් නොකරන බව මම අනුමාන කරමි ;-). විශේෂ ක්‍රම කෙලින්ම භාවිතා කිරීම හොඳ ආකාරයක් නොවේ (කියවිය හැකි හෝ කාර්යක්ෂම නොවේ) - ඒවා භාවිතා කිරීමට අදහස් කරන්නේ, ඒ වෙනුවට, ඔවුන් වෙත පැවරෙන ක්‍රියාකරුවන් සහ බිල්ඩින් හරහා ය.

in පයිතන් නූල් සහ ලැයිස්තු

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

["foo" in a for a in ["fo", "o", "foobar"]]
[False, False, True]

අවවාදය. ලැයිස්තු පුනරාවර්තන වන අතර, inක්‍රමවේදය ක්‍රියා කරන්නේ නූල් මත පමණක් නොව, පුනරාවර්තන මත ය.

ඔබ සතුටු වන "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

ඔබට භාවිතා කළ හැකිය y.count().

එමඟින් නූලක් තුළ උප නූලක් දිස්වන වාර ගණනෙහි පූර්ණ සංඛ්‍යා අගය ලබා දෙනු ඇත.

උදාහරණයක් වශයෙන්:

string.count("bah") >> 0
string.count("Hello") >> 1

මෙන්න ඔබේ පිළිතුර:

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

සිදුවීම් ලබා ගැනීම සඳහා ඔබට සාමාන්‍ය ප්‍රකාශන භාවිතා කළ හැකිය:

>>> import re
>>> print(re.findall(r'( |t)', to_search_in)) # searches for t or space
['t', ' ', 't', ' ', ' ']