How good is startswith?

Question

Is

text.startswith('a')

better than

text[0]=='a'

?

Knowing text is not empty and we are only interested in the first character of it.

Answer 1

text[0] fails if text is an empty string:

IronPython 2.6 Alpha (2.6.0.1) on .NET 4.0.20506.1
Type "help", "copyright", "credits" or "license" for more information.
>>> text = ""
>>> print(text.startswith("a"))
False
>>> print(text[0]=='a')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
IndexError: index out of range: 0

EDIT: You say you "know" that text is not empty... how confident are you of that, and what would you want to happen if it is empty in reality? If a failure is appropriate (e.g. it means a bug in your code) that would encourage the use of text[0]=='a'.

Other questions:

• How concerned are you about the performance of this? If this is performance critical, then benchmark it on your particular Python runtime. I wouldn't be entirely surprised to find that (say) one form was faster on IronPython and a different one faster on CPython.

• Which do you (and your team) find more readable?

Answer 2

Personally I would say startswith is more readable.

Also, from Python 2.5 startwith can take a tuple of prefixes to look for:

>>> "hello world".startswith(("hello","goodbye"))
True

Answer 3

Instead of asking you can just write a quick test and see which one's faster.
And then let us know.
Ofcourse you'll have to add to text[0] the check that the string isn't empty.

Answer 4

Yes: it’s easier to use and easier to read. When you are testing for more than one letter, when using slicing, you’ll have to know how long the target text is:

haystack = 'Hello, World!'
needle = 'Hello'

# The easy way
result = haystack.startswith(needle)

# The slightly harder way
result = haystack[:len(needle)] == needle

Edit: The question seems to have changed. It now says, “knowing text is not empty and we are only interested in the first character of it.” That turns it into a fairly meaningless hypothetical situation.

I suspect the questioner is trying to “optimize” his/her code for execution speed. If that is the case, my answer is: don’t. Use whichever form is more readable and, therefore, more maintainable when you have to come back and work on it a year from now. Only optimize if profiling shows that line of code to be the bottleneck. This is not some O(n²) algorithm. It’s a string comparison.

Answer 5

The stock phrase for the questiom is: "Premature optimization is the root of all evil".

Answer 6

text[0]=='a' is good considering performance. Also you need to add validation when you use this.

Answer 7

text[0] can fail but the equivalent text[:1] is safe if the string is empty.

If you want to compare more than one characters, I believe .startswith() is better.

Answer 8

I'd agree with the others that startswith is more readable, and you should use that. That said, if performance is a big issue for such a special case, benchmark it:

$ python -m timeit -s 'text="foo"' 'text.startswith("a")'
1000000 loops, best of 3: 0.537 usec per loop

$ python -m timeit -s 'text="foo"' 'text[0]=="a"'
1000000 loops, best of 3: 0.22 usec per loop

So text[0] is amost 2.5 times as fast - but it's a pretty quick operation; you'd save ~0.3 microseconds per compare depending on the system. Unless you're doing millions of comparisons in a time critical situation though, I'd still go with the more readable startswith.

Answer 9

PEP 8 explicitly tells to use startswith, because of readability:

- Use ''.startswith() and ''.endswith() instead of string

slicing to check for prefixes or suffixes.

  startswith() and endswith() are cleaner and less error prone.  For
  example:

    Yes: if foo.startswith('bar'):

    No:  if foo[:3] == 'bar':