How do I verify that a string only contains letters, numbers, underscores and dashes in Python?

To verify that a string contains only letters, numbers, underscores, and dashes in Python, you can use regular expressions or set-based validation. Both approaches ensure your input meets specific character restrictions commonly required for usernames, identifiers, or secure input validation.

Many systems restrict input to certain characters for security or formatting reasons. In this case, the allowed characters are alphabets (A-Z, a-z), digits (0-9), underscores (_), and hyphens (-).

Using Regular Expressions

The re module in Python allows you to define patterns to validate strings. You can use re.fullmatch() function to check if the entire string matches a specific pattern, such as allowing only letters, digits, underscores, or dashes.

Example

In the following example, we use re.fullmatch() function with a regex pattern that matches the entire string ?

import re

def is_valid_regex(text):
    return re.fullmatch(r"[A-Za-z0-9_-]+", text) is not None

# Test cases
print(is_valid_regex("User_123-Name"))   # Valid
print(is_valid_regex("Invalid@Name"))    # Invalid
print(is_valid_regex("test_file-v2"))    # Valid
print(is_valid_regex(""))                # Invalid (empty string)

The pattern [A-Za-z0-9_-]+ ensures that all characters belong to the allowed set ?

True
False
True
False

Using Set Comparison

Set comparison checks if all characters in the string are part of a predefined set of valid characters. This approach uses Python's built-in string module for cleaner code and works without regular expressions.

Example

In this example, we use the string module to create our allowed character set ?

import string

def is_valid_set(text):
    if not text:  # Handle empty string
        return False
    allowed = set(string.ascii_letters + string.digits + "_-")
    return all(char in allowed for char in text)

# Test cases
print(is_valid_set("Safe_String-42"))  # Valid
print(is_valid_set("Oops!"))           # Invalid
print(is_valid_set("data_file-v1"))    # Valid
print(is_valid_set("test@domain"))     # Invalid

This method gives you full control over character rules and works without regular expressions ?

True
False
True
False

Comparison

Handling Edge Cases

Both methods should handle edge cases like empty strings. Here's an improved version that handles empty strings appropriately ?

import re
import string

def validate_string(text, allow_empty=False):
    if not text:
        return allow_empty
    
    # Method 1: Regex
    regex_valid = re.fullmatch(r"[A-Za-z0-9_-]+", text) is not None
    
    # Method 2: Set comparison  
    allowed = set(string.ascii_letters + string.digits + "_-")
    set_valid = all(char in allowed for char in text)
    
    return regex_valid and set_valid

# Test edge cases
print(validate_string("valid_name-123"))  # True
print(validate_string(""))                # False
print(validate_string("", allow_empty=True))  # True

True
False
True

Conclusion

Use regular expressions for concise pattern matching when you're comfortable with regex syntax. Use set comparison for clearer, more readable code when validating custom character rules. Both methods effectively validate strings containing only letters, numbers, underscores, and dashes.