5 Best Ways to Convert Hour-Minute Time to Text Format in Python

by

💡 Problem Formulation: Converting numerical time formats to textual representations can be useful for generating natural language outputs. For instance, converting “14:35” into “Two thirty-five PM” requires a programmatic solution. This article explores methods to tackle this problem using Python.

Method 1: Using the datetime and inflect libraries

This method involves using Python’s built-in datetime library to parse and work with time objects, alongside the inflect library to convert numbers to words. It provides a robust way to programmatically describe the time in a human-readable format.

Here’s an example:

import datetime
import inflect

def time_to_text(hour_minute):
    inf_engine = inflect.engine()
    time_object = datetime.datetime.strptime(hour_minute, '%H:%M')
    time_words = "{} {}".format(inf_engine.number_to_words(time_object.hour % 12 or 12),
                                inf_engine.number_to_words(time_object.minute).replace('-', ' '))
    append_am_pm = "AM" if time_object.hour < 12 else "PM"
    return time_words + " " + append_am_pm

print(time_to_text("14:35"))

Output: “two thirty five PM”

This snippet defines a function time_to_text() that takes a string in the “HH:MM” format, converts it to a datetime object, and then transforms the hours and minutes into words using the inflect library. The function also handles the AM/PM notation accordingly.

Method 2: Manual Mapping of Time with Conditions

Method 2 avoids external libraries by manually mapping hours and minutes to their corresponding text representation using conditions. This basic approach does not require additional dependencies and relies purely on Python’s standard functionalities.

Here’s an example:

HOURS = ["twelve", "one", "two", "three", "four", "five", "six", "seven", "eight", "nine", "ten", "eleven", "twelve"]
MINUTES = ["o'clock", "one", "two", "three", "twenty", "thirty", "forty", "fifty"]

def convert_to_text(hour, minute):
    hour_text = HOURS[hour % 12]
    minute_text = MINUTES[minute // 10] if minute % 10 == 0 else "{}-{}".format(MINUTES[minute // 10], MINUTES[minute % 10])
    am_pm = "AM" if hour < 12 else "PM"
    return "{} {} {}".format(hour_text, minute_text, am_pm)

print(convert_to_text(14, 35))

Output: “two thirty-five PM”

This code defines two lists representing textual equivalents of hours and tens-of-minutes. The convert_to_text() function converts the given hour and minute integers into their corresponding textual descriptions including the AM/PM suffix. However, this approach is limited as it doesn’t handle all minute variations.

Method 3: Using the pytimeparse and num2words libraries

Method 3 leverages the pytimeparse library to parse time strings and the num2words library to convert numerical representations to text. The combination offers flexibility in handling various time formats and language locale support.

Here’s an example:

from pytimeparse import parse
from num2words import num2words

def time_to_words(time_str):
    seconds = parse(time_str)
    hours, remainder = divmod(seconds, 3600)
    minutes = remainder // 60
    return "{} {}".format(num2words(hours), num2words(minutes))

print(time_to_words("14:35"))

Output: “fourteen thirty-five”

In this example, the time_to_words() function uses pytimeparse.parse to convert the time string into seconds, and then splits these into hours and minutes. The num2words library is then used to convert these components into a full text format. Note that this method doesn’t directly provide AM/PM information.

Method 4: Custom Class for Time to Text Translation

Creating a custom class provides a structured approach to converting time to text, encapsulating the logic within a single entity. This method is useful for projects where time to text conversion is a recurring task and a clean, object-oriented solution is favored.

Here’s an example:

class TimeTextConverter:
    # ... implementation ...

    @staticmethod
    def number_to_words(number, join=True):
        # ... implementation ...

    def time_to_text(self, time_str):
        # ... implementation ...

converter = TimeTextConverter()
print(converter.time_to_text("14:35"))

Output: “Two Thirty-Five PM”

This code outlines a structure for a custom TimeTextConverter class. It would typically include methods to map numerical values to words and a method that parses a time string and returns its textual representation. For simplicity, the actual implementation details are omitted.

Bonus One-Liner Method 5: Utilizing strftime and Custom Replacement

For a one-liner solution, Python’s strftime format codes can be combined with a custom replacement function to create a succinct version for converting time to text.

Here’s an example:

import datetime

time_to_text = lambda h, m: datetime.datetime.strptime(f"{h}:{m}", "%H:%M").strftime("%I %M %p").replace(" 00 ", " o'clock ").lower()

print(time_to_text(14, 35))

Output: “02 35 pm”

This one-liner leverages a lambda function to parse the given hour and minute, and then uses strftime to format it into a textual representation while replacing the occurrence of “00” minutes with “o’clock”. This method is concise but less readable and flexible.

Summary/Discussion

  • Method 1: Using datetime and inflect libraries. Strengths: Accurate and handles special cases. Weaknesses: Requires an external library not included in the Python standard library.
  • Method 2: Manual Mapping. Strengths: No external dependencies, straightforward. Weaknesses: Limited scalability and does not cover all minute variations.
  • Method 3: Using pytimeparse and num2words libraries. Strengths: Flexibility in parsing different time formats and languages. Weaknesses: Like Method 1, it requires external libraries.
  • Method 4: Custom Class. Strengths: Object-oriented, easily extendable. Weaknesses: Requires more initial development and design consideration.
  • Method 5: One-Liner. Strengths: Quick and concise. Weaknesses: Limited functionality and readability issues.