5 Best Ways to Reformat Phone Numbers in Python

by

💡 Problem Formulation: When working with phone numbers in various formats, it’s often necessary to standardize them by reformatting. For instance, the input could be “(123) 456-7890” and the desired output might be “123-456-7890”. The following methods describe how to programmatically achieve this using Python.

Method 1: Using Regular Expressions with re.sub()

This method uses Python’s regular expression module, re, to find patterns in the phone number and substitute them accordingly. The function re.sub() is utilized to replace parts of the string that match the given pattern with a new format.

Here’s an example:

import re

def format_phone_number(phone):
    return re.sub(r'\D', '', phone)

formatted_phone = format_phone_number("(123) 456-7890")
print(formatted_phone)

Output: 1234567890

In this snippet, re.sub() is given a regular expression that matches any non-digit (\D) and replaces them with an empty string, effectively removing them and returning a clean sequence of digits.

Method 2: Using str.replace() in a Loop

This method involves iterating over a set of characters to remove from the phone number and using string’s replace() method to remove them. It’s a straightforward approach for characters known in advance.

Here’s an example:

def format_phone_number(phone):
    chars_to_remove = ['(', ')', ' ', '-']
    for char in chars_to_remove:
        phone = phone.replace(char, '')
    return phone

formatted_phone = format_phone_number("(123) 456-7890")
print(formatted_phone)

Output: 1234567890

This code iterates through a list of characters to be removed and replaces each with an empty string. The method is simple but might not be as efficient or flexible as using regular expressions for more complex patterns.

Method 3: String Translation with str.maketrans() and str.translate()

This method makes use of the string methods maketrans() and translate() to replace or remove specific characters in the phone number. It creates a translation table that is then used to perform the replacements.

Here’s an example:

def format_phone_number(phone):
    translation_table = str.maketrans('', '', '()- ')
    return phone.translate(translation_table)

formatted_phone = format_phone_number("(123) 456-7890")
print(formatted_phone)

Output: 1234567890

This snippet creates a translation table that specifies which characters to remove ('()- ') and then translates the original phone string, removing these characters. It’s a fast and efficient method for character removal.

Method 4: List Comprehensions

List comprehensions provide a concise way to create a list or string by iterating over an existing iterable and conditionally including elements. In this case, we use a list comprehension to include only digit characters from the phone number.

Here’s an example:

def format_phone_number(phone):
    return ''.join([char for char in phone if char.isdigit()])

formatted_phone = format_phone_number("(123) 456-7890")
print(formatted_phone)

Output: 1234567890

The code uses a list comprehension to iterate over each character in the input string, including only those that are digits, then joins them back into a string. It’s a Pythonic and readable way to filter out unwanted characters.

Bonus One-Liner Method 5: Functional Programming with filter()

Python’s functional programming feature, filter(), allows you to filter an iterable based on a function that evaluates to True or False. Here we filter out anything that is not a digit.

Here’s an example:

formatted_phone = ''.join(filter(str.isdigit, "(123) 456-7890"))
print(formatted_phone)

Output: 1234567890

This concise one-liner uses filter() alongside str.isdigit to keep digits only and then joins them into a string. It’s a compact solution but might be less clear to those unfamiliar with functional programming concepts.

Summary/Discussion

  • Method 1: Regular Expressions with re.sub(). Highly versatile and powerful for pattern matching. Can be complex for beginners.
  • Method 2: Using str.replace() in a Loop. Intuitive for simple patterns. Not efficient for large datasets or more complex formatting needs.
  • Method 3: String Translation with str.maketrans() and str.translate(). Efficient for removing a known set of characters. Limited to character replacement and deletion only.
  • Method 4: List Comprehensions. Pythonic and readable. May be slower due to the creation of a temporary list.
  • Bonus Method 5: Functional Programming with filter(). Elegant and concise one-liner. Potentially less readable for those not versed in functional programming principles.