Prüfen, ob eine Zeichenfolge mit XXXX beginnt

Ich würde gerne wissen, wie man überprüft, ob eine Zeichenfolge in Python mit “Hallo” beginnt.

In Bash mache ich normalerweise:

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

Wie erreiche ich dasselbe in Python?

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

Mehr Infos zu startswith.

RanRag hat es bereits für Ihre spezifische Frage beantwortet.

Aber allgemeiner, was Sie mit tun

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

ist ein regulärer Ausdruck Spiel. Um dasselbe in Python zu tun, würden Sie Folgendes tun:

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

Offensichtlich ist in diesem Fall somestring.startswith('hello') ist besser.

Falls Sie übereinstimmen möchten mehrere Wörter zu Ihrem Zauberwort hinzufügen, können Sie die passenden Wörter als Tupel übergeben:

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

startswith nimmt einen String oder ein Tupel von Strings.

Kann man auch so machen..

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

Ich habe ein kleines Experiment gemacht, um zu sehen, welche dieser Methoden

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

sind am effizientesten, um zurückzugeben, ob eine bestimmte Zeichenfolge mit einer anderen Zeichenfolge beginnt.

Hier ist das Ergebnis eines der vielen Testläufe, die ich durchgeführt habe, wobei jede Liste so geordnet ist, dass sie die kürzeste benötigte Zeit anzeigt (in Sekunden) um 5 Millionen von jedem der oben genannten Ausdrücke während jeder Iteration von zu analysieren 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 am effizientesten herauskommen, da die Rückgabe, ob eine Zeichenfolge mit der angegebenen Zeichenfolge beginnt, ihr Hauptzweck ist.

Was mich wundert ist, dass das scheinbar unpraktisch ist string.rpartition('hello')[0] == '' Methode findet immer einen Weg, zuerst aufgelistet zu werden, vor dem string.startswith('hello') Methode hin und wieder. Die Ergebnisse zeigen, dass mit str.partition zu bestimmen, ob eine Zeichenfolge mit einer anderen Zeichenfolge beginnt, ist effizienter als die Verwendung beider rfind und rindex.

Eine andere Sache, die mir aufgefallen ist, ist das string.rfind('hello') == 0 und string.rindex('hello') == 0 Haben Sie einen guten Kampf im Gange, jeder steigt vom vierten auf den dritten Platz auf und fällt vom dritten auf den vierten Platz ab, was Sinn macht, da ihre Hauptzwecke dieselben 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())])