How to Check if String Starts With a Number or Letter in Python

When processing strings in Python, you often need to validate their format or content, such as determining if a string begins with a numeric digit or an alphabetic character. This is common in tasks like parsing identifiers, validating user input, or cleaning data.

This guide demonstrates reliable methods in Python to check if a string starts with a number or a letter, using string methods and regular expressions.

The Basics: Checking the First Character

The fundamental approach to determine what a string starts with is to examine its very first character. In Python, strings are sequence types, and you can access individual characters using zero-based indexing. The first character is at index 0.

my_string = "Python3"
first_char = my_string[0]
print(f"The first character of '{my_string}' is: '{first_char}'") # Output: The first character of 'Python3' is: 'P'

Handling Empty Strings

Attempting to access my_string[0] on an empty string ("") will raise an IndexError. Therefore, you must always ensure the string is not empty before trying to access its first character.

Common ways to handle empty strings:

• Boolean and: Check if the string is truthy (non-empty) before accessing the index.

  my_str = ""
  if my_str and my_str[0].isdigit(): # The second part is skipped if my_str is empty
      print("Starts with digit")
  else:
      print("Does not start with digit or is empty")

  Output:

  Does not start with digit or is empty

• Slicing: Use slicing [:1]. If the string is empty, my_str[:1] results in an empty string "", on which methods like .isdigit() or .isalpha() safely return False.

  my_str = ""
  first_char_slice = my_str[:1] # Results in "" for an empty string
  print(f"Slice result: '{first_char_slice}'")
  if first_char_slice.isdigit():
      print("Starts with digit")
  else:
      print("Does not start with digit or is empty")

  Output:

  Slice result: ''
  Does not start with digit or is empty

note

Slicing is often considered slightly more robust or Pythonic for this specific check.

Checking if a String Starts with a Number

Using Indexing and str.isdigit()

Access the first character (safely) and use the str.isdigit() method. isdigit() returns True if the character is a digit (0-9), False otherwise.

def starts_with_digit_index(input_str):
  """Checks if string starts with a digit using indexing and isdigit()."""
  # Slicing handles empty strings safely
  first_char = input_str[:1]
  return first_char.isdigit()

# Example Usage
string1 = "123 Main St"
string2 = "Address 123"
string3 = ""
string4 = "+123" # '+' is not a digit

print(f"'{string1}': Starts with digit? {starts_with_digit_index(string1)}") # True
print(f"'{string2}': Starts with digit? {starts_with_digit_index(string2)}") # False
print(f"'{string3}': Starts with digit? {starts_with_digit_index(string3)}") # False
print(f"'{string4}': Starts with digit? {starts_with_digit_index(string4)}") # False

• isdigit() only recognizes characters defined as digits in Unicode, which primarily includes 0-9. It returns False for decimals (.), signs (-, +), or non-numeric characters.

Using Regular Expressions (re.match())

Regular expressions provide a flexible way to match patterns. re.match() attempts to match a pattern only at the beginning of the string.

import re # Required import

def starts_with_digit_regex(input_str):
  """Checks if string starts with a digit using re.match()."""
  # \d matches any Unicode digit character
  match = re.match(r'\d', input_str)
  return bool(match) # True if match object exists, False if None

# Example Usage
string1 = "4Runner"
string2 = "Model 3"
string3 = ""

print(f"'{string1}': Starts with digit (regex)? {starts_with_digit_regex(string1)}") # True
print(f"'{string2}': Starts with digit (regex)? {starts_with_digit_regex(string2)}") # False
print(f"'{string3}': Starts with digit (regex)? {starts_with_digit_regex(string3)}") # False

• r'\d': The regex pattern. \d is a special sequence that matches any Unicode digit character (equivalent to [0-9] in many contexts, but broader).
• re.match(...): Returns a match object if the beginning of the string matches \d, otherwise returns None.
• bool(match): Converts the result to True (if a match was found) or False (if None).

Using str.startswith() (for Specific Digits)

If you need to check if a string starts with one or more specific digits, str.startswith() is useful. It checks for an exact prefix.

my_str = "2023 Report"

# Check for a specific prefix
if my_str.startswith("2023"):
    print(f"'{my_str}' starts with '2023'") # This is executed
else:
    print(f"'{my_str}' does not start with '2023'")

# Checking against multiple possible digits (pass a tuple)
possible_starts = ('1', '2', '3')
if my_str.startswith(possible_starts):
     print(f"'{my_str}' starts with one of {possible_starts}")
else:
     print(f"'{my_str}' does not start with one of {possible_starts}")

Output:

'2023 Report' starts with '2023'
'2023 Report' starts with one of ('1', '2', '3')

• startswith() performs a literal string comparison, not a character type check like isdigit().

Checking Multiple Strings in a List

To apply these checks to all strings in a list:

list_of_strings = ["Area 51", "7th Heaven", "", "Route 66"]

print("--- Checking list items ---")
for item in list_of_strings:
    # Using slicing and isdigit()
    if item[:1].isdigit():
        print(f"'{item}' starts with a number.")
    else:
        print(f"'{item}' does NOT start with a number (or is empty).")

print("\n--- Checking if ALL start with a number ---")

# Check if ALL non-empty strings start with a number
all_start_num = all(s[:1].isdigit() for s in list_of_strings if s)      # Check only non-empty
print(f"Do all non-empty strings start with a number? {all_start_num}") # False

Checking if a String Starts with a Letter

Using Indexing and str.isalpha()

Similar to isdigit(), isalpha() checks if a character is an alphabetic letter (as defined in Unicode).

def starts_with_letter_index(input_str):
  """Checks if string starts with a letter using indexing and isalpha()."""
  first_char = input_str[:1] # Handles empty strings
  return first_char.isalpha()

# Example Usage
string1 = "Python"
string2 = " C++"        # Starts with space
string3 = "1Language"   # Starts with digit
string4 = ""            # Empty string
string5 = "é"           # Unicode letter

print(f"'{string1}': Starts with letter? {starts_with_letter_index(string1)}") # True
print(f"'{string2}': Starts with letter? {starts_with_letter_index(string2)}") # False
print(f"'{string3}': Starts with letter? {starts_with_letter_index(string3)}") # False
print(f"'{string4}': Starts with letter? {starts_with_letter_index(string4)}") # False
print(f"'{string5}': Starts with letter? {starts_with_letter_index(string5)}") # True

• isalpha() returns True for standard letters and many Unicode alphabetic characters, but False for numbers, symbols, spaces, etc.

Using Indexing and string.ascii_letters (ASCII Only)

If you specifically need to check for only the standard English alphabet letters (a-z, A-Z), use the string.ascii_letters constant.

import string # Required import

def starts_with_ascii_letter(input_str):
  """Checks if string starts with an ASCII letter."""
  first_char = input_str[:1] # Handles empty strings
  return first_char in string.ascii_letters

# Example Usage
string1 = "Alpha"
string2 = "beta"
string3 = "1Gamma"
string4 = "_delta"
string5 = "épsilon" # Non-ASCII letter

print(f"'{string1}': Starts with ASCII letter? {starts_with_ascii_letter(string1)}") # True
print(f"'{string2}': Starts with ASCII letter? {starts_with_ascii_letter(string2)}") # True
print(f"'{string3}': Starts with ASCII letter? {starts_with_ascii_letter(string3)}") # False
print(f"'{string4}': Starts with ASCII letter? {starts_with_ascii_letter(string4)}") # False
print(f"'{string5}': Starts with ASCII letter? {starts_with_ascii_letter(string5)}") # False

• string.ascii_letters contains 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'.
• The in operator performs a membership check.

Using Regular Expressions (re.match())

Regex provides precise control over which letters to match.

import re # Required import

def starts_with_letter_regex(input_str):
  """Checks if string starts with an ASCII letter using re.match()."""
  # [a-zA-Z] matches one ASCII letter (lowercase or uppercase)
  match = re.match(r'[a-zA-Z]', input_str)
  return bool(match)

# Example Usage
string1 = "Zebra"
string2 = "yacht"
string3 = "$dollar"
string4 = ""
string5 = "你好" # Non-ASCII letters

print(f"'{string1}': Starts with ASCII letter (regex)? {starts_with_letter_regex(string1)}") # True
print(f"'{string2}': Starts with ASCII letter (regex)? {starts_with_letter_regex(string2)}") # True
print(f"'{string3}': Starts with ASCII letter (regex)? {starts_with_letter_regex(string3)}") # False
print(f"'{string4}': Starts with ASCII letter (regex)? {starts_with_letter_regex(string4)}") # False
print(f"'{string5}': Starts with ASCII letter (regex)? {starts_with_letter_regex(string5)}") # False

• r'[a-zA-Z]': Matches a single character if it's within the range a-z OR A-Z. This specifically matches ASCII letters.

note

For Unicode letters with regex, you might use libraries or more complex patterns depending on the specific Unicode character ranges you need to support.

• The simple \w often includes letters, numbers, and underscore.
• For just letters (including Unicode), it's often easier to use isalpha().

Choosing the Right Method

• Starts with Number:
  • isdigit(): Good general-purpose check for digits 0-9. Use slicing [:1] for safety.
  • re.match(r'\d', ...): Equally good, slightly more overhead but more flexible if patterns get complex. Handles Unicode digits.
  • startswith(): Only for checking specific known digit prefixes.
• Starts with Letter:
  • isalpha(): Best for checking if it starts with any letter (including many Unicode letters). Use slicing [:1] for safety.
  • in string.ascii_letters: Use only if you specifically need to restrict to ASCII a-z/A-Z.
  • re.match(r'[a-zA-Z]', ...): Good alternative for specifically ASCII letters, flexible for more complex starting patterns.

Generally, the str.isdigit() and str.isalpha() methods combined with slicing [:1] are the most straightforward and Pythonic ways for simple checks. Use regex when you need more complex pattern matching at the start of the string.

Conclusion

Checking if a Python string begins with a number or a letter involves examining its first character.

Key methods include slicing (my_str[:1]) to safely handle empty strings, str.isdigit() for numeric checks, str.isalpha() for general letter checks (including Unicode), and string.ascii_letters or re.match(r'[a-zA-Z]', ...) for specific ASCII letter checks. Regular expressions (re.match()) offer the most power for matching complex starting patterns.

Choose the method that best matches the specificity (ASCII vs. Unicode, specific digits vs. any digit) and complexity required for your task.