Ar „Python“ turi „yra“ pagrindo metodą?

string.contains arba string.indexof .

Noriu padaryti:

 if not somestring.contains("blah"): continue 
3355
09 авг. nustatė Blankman 09 rug. 2010-08-09 05:52 '10, 5:52 val. 2010-08-09 05:52
@ 19 atsakymų

Galite naudoti operatorių:

 if "blah" not in somestring: continue 
5043
09 авг. atsakymas, kurį pateikė Michael Mrozek 2010-08-09 05:56 '10, 5:56, 2010-08-09 05:56

Jei tai yra tiesiog paieškos eilutė, galite naudoti string.find("substring") .

Turite būti šiek tiek atsargūs find , index ir įsirašydami, nors jie yra vykdomi su antraštėmis. Kitaip tariant, tai yra:

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

Jis bus spausdinamas Found 'is' in the string. Panašiai, if "is" in s: bus vertinama True . Tai gali būti ar ne, ko norite.

525
09 авг. atsakymą pateikė eldarerathis 09 rug . 2010-08-09 05:55 '10, 5:55, 2010-08-09 05:55

if needle in haystack: - tai yra normalus naudojimas, kaip sako @Michael - jis priklauso nuo operatoriaus, kuris yra lengviau skaitomas ir greitesnis nei skambinant šiuo metodu.

Jei jums tikrai reikia metodo, o ne operatoriaus (pvz., Tam tikro keistojo key= labai savotiško pobūdžio ...?), Tai bus 'haystack'.__contains__ . Bet kadangi jūsų pavyzdys skirtas naudoti, if manau, kad jūs tikrai nesuprantate, ką sakote ;-). Tai nėra gera forma (nei įskaitoma, nei veiksminga) tiesiogiai naudoti specialius metodus - jie skirti naudoti vietoj operatorių ir jiems pavestų funkcijų.

143
09 авг. Alex Martelli atsakymas, rugpjūčio 9 d. 2010-08-09 06:19 '10, 6:19 val. 2010-08-09 06:19

Iš esmės, norite surasti eilutę Python eilutėje. Yra du būdai, kaip ieškoti eilutės Python eilutėje.

1 metodas: operatoriuje

Galite patikrinti „Python in operatorių, kad patikrintumėte pagrindą. Tai gana paprasta ir intuityvi. Jis grįš True jei eilutė bus nustatyta eilutėje, kitaip False .

 >>> "King" in "King landing" True >>> "Jon Snow" in "King landing" False 

2 metodas: str.find() metodas

Antrasis būdas yra naudoti str.find() . Čia vadiname .find() metodą, skirtą .find() , kurioje turi būti rasta. Mes perduodame pagrindą į paieškos () metodą ir patikriname jo grąžos vertę. Jei jos vertė skiriasi nuo -1, eilutė buvo nustatyta eilutėje, kitaip ne. Grąžinimo reikšmė yra rodyklė, kurioje yra rėmelis.

 >>> some_string = "valar morghulis" >>> some_string.find("morghulis") 6 >>> some_string.find("dohaeris") -1 

Norėčiau rekomenduoti naudoti pirmąjį metodą, nes jis yra daugiau „Pythonic“ ir intuityvus.

130
26 мая '15 в 20:46 2015-05-26 20:46 atsakymą pateikė Rahul Gupta gegužės 26 d., 15 val. 20:46 2015-05-26 20:46

Ar yra „Python“ eilutė, kurioje yra antraštės metodas?

Taip, bet Python turi palyginimo operatorių, kurį turėtumėte naudoti, nes kalba ketina ją naudoti, o kiti programuotojai tikisi, kad jį naudosite. Tai raktinis žodis, kuris naudojamas kaip palyginimo operatorius:

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

Priešingai (papildomai), kad pradinis klausimas užduodamas, not in :

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

Tai yra semantiškai tas pats, kas not 'foo' in '**foo**' , tačiau jis yra daug aiškesnis ir aiškiai numatytas kalboje, kaip gerinamumo.

Nenaudokite __contains__ , find ir index

Kaip buvo žadėta, čia contains metodas:

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

grįžta True . Šią funkciją galite skambinti ir iš superline pavyzdžio:

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

Bet ne. Metodai, prasidedantys pabraukimu, yra laikomi semantiniu būdu privačiais. Vienintelė priežastis - išplėsti įvestį in o not in funkcijose (pvz., Kai pogrupis):

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

ir dabar:

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

Taip pat venkite šių eilutės metodų:

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

Kitos kalbos neturi metodų, skirtų tiesiogiai testuoti antraštes, todėl turėsite naudoti tokius metodus, tačiau su Python yra daug efektyviau naudoti palyginimo operatorių.

Veiklos palyginimas

Galime palyginti skirtingus būdus, kaip pasiekti tą patį tikslą.

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

Ir dabar matome, kad naudojimasis in daug greičiau nei kiti. Mažiau laiko atlikti lygiavertę operaciją yra geriau:

 >>> 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} 
116
26 нояб. atsakymą pateikė Aaron Hall lapkričio 26 d. 2014-11-26 01:33 '14 ne 1:33 2014-11-26 01:33

Ne, nėra jokios string.contains(str) metodą, tačiau operatoriuje yra:

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

Čia yra sudėtingesnis darbo pavyzdys:

 # 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 ] 
68
30 сент. Atsakymą pateikė Bohdan rugsėjo 30 d 2013-09-30 21:59 '13, 9:59 pm 2013-09-30 21:59

Python eilutėse ir sąrašuose

Štai keletas naudingų pavyzdžių, kurie patys kalba apie metodą:

 "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 

Įspėjimas Sąrašai pateikiami, o metodas veikia iteraciją, o ne tik stygas.

36
28 апр. Atsakyti firelynx 28 bal . 2017-04-28 21:52 '17 at 9:52 pm 2017-04-28 21:52

Taigi, atrodo, kad vektoriaus palyginimui nėra nieko panašaus. Akivaizdu, kad Python galėtų tai padaryti:

 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 
26
17 июля '15 в 16:19 2015-07-17 16:19 atsakymas pateikiamas Ufosui liepos 17 d., 15 val. 16:19 2015-07-17 16:19

Kitas būdas sužinoti, ar eilutėje yra keletas simbolių, ar ne, su grąžos reikšme Boole (ty True arba `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 
20
28 июля '11 в 15:32 2011-07-28 15:32 atsakymą pateikė Harish Reddy, liepos 28 d., 11 d., 15:32 2011-07-28 15:32

Jei esate patenkintas "blah" in somestring bet norite, kad tai būtų funkcijų skambutis, galite tai padaryti

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

Visi „Python“ operatoriai gali būti daugiau ar mažiau rasti operatoriaus modulyje, įskaitant.

14
28 марта '18 в 12:59 2018-03-28 12:59 atsakymą pateikė Jeffrey04 kovo 28 d. 18 val. 12:59 val. 2018-03-28 12:59

Yra du paprasti būdai tai padaryti „Python“:

Pythonic Path: „Python“ naudojimas „Raktinių žodžių“

Įtraukia du "argumentus", vieną kairėje (antraštėje) ir vieną dešinėje, ir grąžina True jei kairysis argumentas yra teisių argumente, o jei ne, jis grąžina False .

 example_string = "This is an example string" substring = "example" print(substring in example_string) 

Išvada:

 True 

Ne Pitonio metodas: naudojant Python str.find:

find metodas grąžina eilutės poziciją eilutėje arba -1, jei jis nerastas. Bet tiesiog patikrinkite, ar pozicija yra -1.

 if example_string.find(substring) != -1: print('Substring found!') else: print('Substring not found!') 

Išvada:

 Substring found! 
12
20 нояб. atsakymą pateikė Inconnu lapkričio 20 d 2016-11-20 21:58 '16 at 21:58 2016-11-20 21:58

Čia yra jūsų atsakymas:

 if "insert_char_or_string_here" in "insert_string_to_search_here": #DOSTUFF 

Jei norite patikrinti, ar tai neteisinga:

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

ARBA:

 if "insert_char_or_string_here" not in "insert_string_to_search_here": #DOSTUFF 
11
26 мая '15 в 1:50 2015-05-26 01:50 atsakymą pateikė „ ytpillai“ gegužės 26 d., 15 d., 1:50 val. 2015-05-26 01:50

Matau, kad jau yra atsakymų, bet aš taip pat noriu pridėti savo du centus.

„Python“ turi funkcijų, tačiau paprasčiausias (ir labiausiai pageidaujamas) būdas yra naudoti raktinį žodį:

 "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 

Taip pat yra keletas eilutės metodų:

 "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... 

Apie našumą:

Apskritai, greičiausias būdas rasti tekstą ...

find šiek tiek greičiau nei index .

10
16 июня '18 в 15:02 2018-06-16 15:02 atsakymą pateikė Fipsi birželio 18 d. 15:02 2018-06-16 15:02

Jei ieškote nejautrių žodžių paieškos, o ne kito žodžio pavadinimo:

 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 
10
13 янв. Atsakymą pateikė Jamie Bull 13 sausis 2018-01-13 18:32 '18, 18:32 pm 2018-01-13 18:32

Yra keturi paprasčiausi būdai, kaip sužinoti, kas yra antraštė ir kur prasideda antraštė.

Pirma per „Python in operatoriuje:

 someString = "Polly is drinking Coca-Cola." "Coca-Cola" in someString # Result: True "Pepsi" in someString # Result: False 

Antrasis būdas yra naudoti styginių find() metodą.

Skirtingai nuo operatoriaus, kuris vertinamas kaip loginė vertė, find metodas grąžina sveikąjį skaičių . Šis sveikasis skaičius yra padėties pradžios indeksas, jei ši antraštė egzistuoja, kitaip -1 . Štai kaip jis veikia:

 someString = "Polly is drinking Coca-Cola." someString.find("is") # Result: 6 someString.find("Pepsi") # Result: -1 someString.find("Polly") # Result: 0 

Taip pat galite nurodyti pradžios ir pabaigos indeksus, kad apribotumėte paiešką. Pavyzdžiui:

 someString = "Polly is drinking Coca-Cola." someString.find("is", 5, 10) # Result: 6 someString.find("Polly", 15, 20) # Result: -1 

Trečiajame. Ir, žinoma, galite naudoti, if...is not pareiškimas (jis veikia 2.7 ir 3.6 Python):

 someString = "Polly is drinking Coca-Cola." substring = "drinking" if someString.find(substring) is not -1: print("Cool! Python found the desired substring!") else: print("Python didn't find the desired substring!") # Result: "Cool! Python found the desired substring!" 

Keturi. Naudokite index() metodą. Tai beveik toks pat kaip ir find() metodas.

 someString = "Polly is drinking Coca-Cola." x = someString.index("drinking") print(x) # Result: 9 

Tikiuosi, kad tai padės.

6
25 дек. ARGeo atsakymas . 2018-12-25 18:35 '18, 18:35 pm 2018-12-25 18:35

Kaip jau minėta, naudodami operatorių galite naudoti:

 >>> to_search_in = "String to search in" >>> to_search = "search" >>> print(to_search in to_search_in) True >>> print(to_search_in.find(to_search)) 10 

Taip pat galite naudoti įprastas išraiškas, kad gautumėte įrašus:

 >>> import re >>> print(re.findall(r'( |t)', to_search_in)) # searches for t or space ['t', ' ', 't', ' ', ' '] 
1
23 нояб. Atsakymas pateikiamas Muskovets 23 lapkričio. 2018-11-23 10:15 '18, 10:15 am 2018-11-23 10:15

Skaičiuojant eilutes eilutėje

 a = "Hello, what your name?" if a.count("what's"): print("Found") else: print("Not found") 
0
02 дек. Atsakyti RAMunna 02 Dec 2017-12-02 23:12 '17 at 11:12 2017-12-02 23:12

Yra daug atsakymų.

Tačiau, naudojant count gali būti patogu.

pavyzdys:

 strblah = 'I have blah in me' if strblah.count('blah') > 0: print('Yes: substring found') 
0
23 янв. Atsakymą pateikė „ Naidu “ sausio 23 d. 2019-01-23 22:58 '19, 22:58 pm 2019-01-23 22:58

Galite naudoti kelis metodus:

  1. if x in y:
  2. y.count()
  3. y.find()

1 yra loginė išraiška, tai reiškia, kad ji grąžins arba klaidingą būseną, priklausomai nuo to, ar būklė yra teisinga, ar ne.

Pavyzdžiui:

 string = "Hello world" if "Hello" in string: >>True if "Python" in string: >>False 

2 sugrąžina eilutės reikšmės eilutėje skaičių.

Pavyzdžiui:

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

3 sugrąžina pradinių padėčių indekso reikšmę. Tai taip pat sugrįš -1, jei nepavyksta rasti antraštės.

Pavyzdžiui:

 string.find("Hello") >>0 string.find("foo") >>-1 
0
06 февр. Atsakymą pateikė Brandon Bailey 06 vasaris. 2019-02-06 14:06 '19, 14:06 pm 2019-02-06 14:06

Kiti klausimai apie „ žymių arba „ Užduoti klausimą“