Prüfen, ob eine Zeichenkette mit XXXX beginnt

Question

Ich würde gerne wissen, wie man in Python prüfen kann, ob eine Zeichenkette mit "Hallo" beginnt.

In Bash tue ich das normalerweise:

if [[ "$string" =~ ^hello ]]; then
 do something here
fi

Wie kann ich dasselbe in Python erreichen?

Answer 1

aString = "hello world"
aString.startswith("hello")

Mehr Informationen über startswith .

Answer 2

RanRag hat bereits geantwortet es für Ihre spezielle Frage.

Generell gilt jedoch, dass das, was Sie mit

if [[ "$string" =~ ^hello ]]

ist eine regex Spiel. Um das gleiche in Python zu tun, würden Sie tun:

import re
if re.match(r'^hello', somestring):
    # do stuff

In diesem Fall ist es offensichtlich, somestring.startswith('hello') ist besser.

Answer 3

Falls Sie eine Übereinstimmung wünschen multiple Wörter mit dem Zauberwort zu vergleichen, können Sie die zu übereinstimmenden Wörter als Tupel übergeben:

>>> magicWord = 'zzzTest'
>>> magicWord.startswith(('zzz', 'yyy', 'rrr'))
True

startswith nimmt eine Zeichenkette oder ein Tupel von Zeichenketten.

Answer 4

Kann auch so gemacht werden..

regex=re.compile('^hello')

## THIS WAY YOU CAN CHECK FOR MULTIPLE STRINGS
## LIKE
## regex=re.compile('^hello|^john|^world')

if re.match(regex, somestring):
    print("Yes")

Answer 5

Ich habe ein kleines Experiment durchgeführt, um herauszufinden, welche der folgenden Methoden

• string.startswith('hello')
• string.rfind('hello') == 0
• string.rpartition('hello')[0] == ''
• string.rindex('hello') == 0

sind am effizientesten, um festzustellen, ob eine bestimmte Zeichenfolge mit einer anderen Zeichenfolge beginnt.

Hier ist das Ergebnis eines der vielen Testläufe, die ich gemacht habe, wobei jede Liste so geordnet ist, dass sie die geringste Zeit benötigt (in Sekunden) bei jeder Iteration des Programms 5 Millionen der oben genannten Ausdrücke zu parsen while Schleife, die ich verwendet habe:

['startswith: 1.37', 'rpartition: 1.38', 'rfind: 1.62', 'rindex: 1.62']
['startswith: 1.28', 'rpartition: 1.44', 'rindex: 1.67', 'rfind: 1.68']
['startswith: 1.29', 'rpartition: 1.42', 'rindex: 1.63', 'rfind: 1.64']
['startswith: 1.28', 'rpartition: 1.43', 'rindex: 1.61', 'rfind: 1.62']
['rpartition: 1.48', 'startswith: 1.48', 'rfind: 1.62', 'rindex: 1.67']
['startswith: 1.34', 'rpartition: 1.43', 'rfind: 1.64', 'rindex: 1.64']
['startswith: 1.36', 'rpartition: 1.44', 'rindex: 1.61', 'rfind: 1.63']
['startswith: 1.29', 'rpartition: 1.37', 'rindex: 1.64', 'rfind: 1.67']
['startswith: 1.34', 'rpartition: 1.44', 'rfind: 1.66', 'rindex: 1.68']
['startswith: 1.44', 'rpartition: 1.41', 'rindex: 1.61', 'rfind: 2.24']
['startswith: 1.34', 'rpartition: 1.45', 'rindex: 1.62', 'rfind: 1.67']
['startswith: 1.34', 'rpartition: 1.38', 'rindex: 1.67', 'rfind: 1.74']
['rpartition: 1.37', 'startswith: 1.38', 'rfind: 1.61', 'rindex: 1.64']
['startswith: 1.32', 'rpartition: 1.39', 'rfind: 1.64', 'rindex: 1.61']
['rpartition: 1.35', 'startswith: 1.36', 'rfind: 1.63', 'rindex: 1.67']
['startswith: 1.29', 'rpartition: 1.36', 'rfind: 1.65', 'rindex: 1.84']
['startswith: 1.41', 'rpartition: 1.44', 'rfind: 1.63', 'rindex: 1.71']
['startswith: 1.34', 'rpartition: 1.46', 'rindex: 1.66', 'rfind: 1.74']
['startswith: 1.32', 'rpartition: 1.46', 'rfind: 1.64', 'rindex: 1.74']
['startswith: 1.38', 'rpartition: 1.48', 'rfind: 1.68', 'rindex: 1.68']
['startswith: 1.35', 'rpartition: 1.42', 'rfind: 1.63', 'rindex: 1.68']
['startswith: 1.32', 'rpartition: 1.46', 'rfind: 1.65', 'rindex: 1.75']
['startswith: 1.37', 'rpartition: 1.46', 'rfind: 1.74', 'rindex: 1.75']
['startswith: 1.31', 'rpartition: 1.48', 'rfind: 1.67', 'rindex: 1.74']
['startswith: 1.44', 'rpartition: 1.46', 'rindex: 1.69', 'rfind: 1.74']
['startswith: 1.44', 'rpartition: 1.42', 'rfind: 1.65', 'rindex: 1.65']
['startswith: 1.36', 'rpartition: 1.44', 'rfind: 1.64', 'rindex: 1.74']
['startswith: 1.34', 'rpartition: 1.46', 'rfind: 1.61', 'rindex: 1.74']
['startswith: 1.35', 'rpartition: 1.56', 'rfind: 1.68', 'rindex: 1.69']
['startswith: 1.32', 'rpartition: 1.48', 'rindex: 1.64', 'rfind: 1.65']
['startswith: 1.28', 'rpartition: 1.43', 'rfind: 1.59', 'rindex: 1.66']

Ich glaube, dass es von Anfang an ziemlich offensichtlich ist, dass die startswith Methode wäre die effizienteste, da die Rückgabe, ob eine Zeichenfolge mit der angegebenen Zeichenfolge beginnt, ihr Hauptzweck ist.

Was mich überrascht, ist, dass die scheinbar unpraktischen string.rpartition('hello')[0] == '' Methode findet immer einen Weg, um als erstes aufgeführt zu werden, vor der string.startswith('hello') Methode, ab und zu. Die Ergebnisse zeigen, dass die Verwendung str.partition um festzustellen, ob eine Zeichenkette mit einer anderen Zeichenkette beginnt, ist effizienter als die Verwendung beider rfind y rindex .

Eine weitere Beobachtung, die ich gemacht habe, ist, dass string.rfind('hello') == 0 y string.rindex('hello') == 0 liefern sich einen spannenden Kampf, bei dem sie jeweils vom vierten auf den dritten Platz aufsteigen und vom dritten auf den vierten Platz zurückfallen, was sinnvoll ist, da ihre Hauptziele die gleichen sind.

Hier ist der Code:

from time import perf_counter

string = 'hello world'
places = dict()

while True:
    start = perf_counter()
    for _ in range(5000000):
        string.startswith('hello')
    end = perf_counter()
    places['startswith'] = round(end - start, 2)

    start = perf_counter()
    for _ in range(5000000):
        string.rfind('hello') == 0
    end = perf_counter()
    places['rfind'] = round(end - start, 2)

    start = perf_counter()
    for _ in range(5000000):
        string.rpartition('hello')[0] == ''
    end = perf_counter()
    places['rpartition'] = round(end - start, 2)

    start = perf_counter()
    for _ in range(5000000):
        string.rindex('hello') == 0
    end = perf_counter()
    places['rindex'] = round(end - start, 2)

    print([f'{b}: {str(a).ljust(4, "4")}' for a, b in sorted(i[::-1] for i in places.items())])