Hours Minutes to Decimal Time Command Line?

Updated 6 November 2026 · Standard formula, shown below

Yes, you can convert hours and minutes to decimal hours directly from the command line using standard Unix tools like `awk`, `bc`, or `python3`, or with a simple shell function. The core formula is: decimal hours = hours + (minutes / 60), and you can implement this in a one-liner that reads input like “2:30” and outputs “2.5”.

This is a common task for anyone who tracks billable hours, calculates payroll, fills out timesheets, or works with data that expects time in decimal format (e.g., 8.75 hours instead of 8:45). While spreadsheet programs and time-tracking apps often have built-in converters, doing it in the terminal is fast, scriptable, and works on any system with a standard shell.

Why Convert Hours and Minutes to Decimal?

Many professional and technical contexts require time expressed as a decimal number of hours rather than as hours and minutes. The most common reasons include:

Payroll and billing: Many accounting systems and freelance invoices expect hours in decimal form (e.g., 7.5 hours) to simplify multiplication by an hourly rate.
Data analysis: Spreadsheets and statistical software often treat time as a fraction of a day or as a decimal number for calculations.
Project management: Task durations in Gantt charts or resource allocation tools are frequently entered as decimals.
Scientific and engineering work: Time-based measurements in formulas (e.g., speed = distance / time) are easier when time is a single decimal number.

The conversion itself is trivial arithmetic, but doing it manually for dozens of entries is error-prone. The command line offers a way to batch-process or inline-convert values without opening a separate application.

The Basic Formula

The relationship between minutes and hours is fixed: one hour equals 60 minutes. Therefore, to convert a time given as H hours and M minutes to decimal hours, you use:

decimal_hours = H + (M / 60)

For example, 2 hours and 30 minutes becomes 2 + (30/60) = 2.5 hours. Similarly, 1 hour and 15 minutes is 1.25 hours, and 0 hours and 45 minutes is 0.75 hours.

If you want the result in minutes instead of hours, the formula is simply (H * 60) + M. Some tools output decimal minutes, but decimal hours is the standard for most business and technical use.

Command-Line Methods: A Practical Comparison

Several standard command-line tools can perform this conversion. Each has its own strengths, and the best choice depends on your environment and whether you need to process single values or batches.

1. Using `awk` (POSIX, universally available)

`awk` is a text-processing tool present on virtually every Unix-like system (Linux, macOS, BSD). It handles floating-point arithmetic natively, making it ideal for this task. A simple one-liner to convert “2:30” to decimal hours is:

echo "2:30" | awk -F: '{print $1 + ($2 / 60)}'

This sets the field separator to a colon, then prints the sum of the first field (hours) and the second field (minutes) divided by 60. The output will be “2.5”. You can control the number of decimal places by using `printf` instead of `print`:

echo "2:30" | awk -F: '{printf "%.2f\n", $1 + ($2 / 60)}'

This outputs “2.50”. `awk` is ideal for piping data from other commands or processing files with many time values.

2. Using `bc` (arbitrary precision calculator)

`bc` is a command-line calculator that supports arbitrary precision arithmetic. It is less common on macOS by default but is standard on most Linux distributions. To use it, you pipe an expression to it:

echo "2 + 30 / 60" | bc -l

The `-l` flag loads the standard math library and sets the scale to 20 decimal places, so the output will be “2.50000000000000000000”. To get a cleaner result, you can pipe the output through `printf` or use `scale` inside `bc`:

echo "scale=2; 2 + 30 / 60" | bc -l

This yields “2.50”. `bc` is a good choice if you need high precision or are doing additional arithmetic in the same command.

3. Using `python3` (modern, cross-platform)

Python is not strictly a shell tool, but it is nearly ubiquitous on modern systems and offers the most readable and flexible approach. A one-liner using `python3 -c` works well:

echo "2:30" | python3 -c "import sys; h,m = sys.stdin.read().strip().split(':'); print(int(h) + int(m)/60)"

This reads the input, splits it on the colon, converts both parts to integers, and prints the decimal result. Python also makes it easy to handle edge cases like empty strings or non-numeric input, though that requires a longer script.

4. Using a shell function (for repeated use)

If you convert times frequently, define a function in your shell profile (e.g., `~/.bashrc` or `~/.zshrc`). For Bash or Zsh:

hm2dec() { echo "$1" | awk -F: '{printf "%.2f\n", $1 + ($2 / 60)}'; }

Then you can simply run hm2dec 2:30 to get 2.50. This is the most convenient method for interactive use, and you can easily extend it to accept multiple arguments or read from a file.

Handling Edge Cases and Common Mistakes

While the formula is simple, real-world input often has quirks that can break a naive command. Here are the most common issues and how to address them:

Input with seconds: If your time is in H:MM:SS format, you need a slightly different formula: H + (M/60) + (S/3600). In `awk`, this becomes echo "2:30:15" | awk -F: '{print $1 + ($2/60) + ($3/3600)}'.
Leading zeros: Times like “02:05” are fine, but if you use `bc`, the leading zero in “05” can be interpreted as an octal number in some contexts. `awk` and Python treat it as a decimal, so they are safer choices for arbitrary input.
Whitespace: If your input has spaces (e.g., “2 : 30”), the field separator in `awk` won’t match. You can trim whitespace first with tr -d ' ' or adjust the `-F` option to a regular expression.
Invalid input: None of the simple one-liners will gracefully handle input like “abc” or “2:70”. For production scripts, you should add validation, which is much easier in Python than in `awk` or `bc`.
Rounding: The default output of `awk` and `bc` may have many decimal places. Use `printf` with a format specifier to control precision, as shown above.

A common misconception is that you need a special “time conversion” utility. In fact, the arithmetic is so basic that any calculator or scripting language will do. The only real challenge is parsing the input format, which is why `awk`’s field separator is so handy.

Batch Conversion and Scripting

One of the biggest advantages of the command line is the ability to process many values at once. Suppose you have a file called times.txt with one time per line:

You can convert all of them in one command:

awk -F: '{printf "%.2f\n", $1 + ($2 / 60)}' times.txt

This outputs:

You can redirect the output to a new file with > decimal_times.txt. If your file has other columns, you can include them in the output by referencing the appropriate field numbers. For example, if the first column is an employee ID and the second is the time, you could do:

awk -F'[,\t]' '{printf "%s %.2f\n", $1, $2 + ($3/60)}' data.csv

This flexibility makes `awk` the tool of choice for log processing, report generation, and data cleanup tasks.

Alternatives: Spreadsheets and Online Tools

If you are not working in a terminal, there are other options for converting hours and minutes to decimal:

Spreadsheet formulas: In Excel or Google Sheets, if cell A1 contains “2:30” as a time value, you can use =A1*24 to get the decimal hours (2.5). If A1 is text, you can parse it with =VALUE(LEFT(A1,2)) + VALUE(RIGHT(A1,2))/60.
Online converters: Many websites offer free time-to-decimal calculators. These are convenient for one-off conversions but are not scriptable and require copying and pasting.
Dedicated time-tracking apps: Tools like Toggl, Harvest, and Clockify often display both formats and can export decimal hours.

For most users, the command line is faster and more reliable than a web browser, especially when you have a list of values to convert. It also works offline and can be incorporated into larger shell pipelines.

Frequently Asked Questions

How do I convert “2:30 PM” (12-hour format) to decimal hours?

You need to convert the time to 24-hour format first. For PM times, add 12 to the hour (except 12 PM, which stays 12). So “2:30 PM” becomes 14:30, and the decimal is 14 + (30/60) = 14.5. For AM times, use the hour as-is, except 12 AM becomes 0. A simple `awk` command cannot handle AM/PM without additional logic, so you would need a longer script or a tool like `date` to parse it.

What is the difference between decimal hours and decimal minutes?

Decimal hours express time as a fraction of an hour (e.g., 1.5 hours = 90 minutes). Decimal minutes express time as a fraction of a minute (e.g., 1.5 minutes = 90 seconds). The command-line methods above all produce decimal hours. To get decimal minutes, multiply the result by 60, or use the formula (H * 60) + M directly.

Can I use `date` to do this conversion?

The `date` command is primarily for displaying and setting system time, not for arbitrary arithmetic conversions. You can use it to convert between timezones or formats, but for H:MM to decimal hours, `awk` or `bc` is much simpler. There is no standard `date` option that outputs decimal hours from a given input.

Why does my `awk` command output “2.5” instead of “2.50”?

By default, `awk` prints numbers with the minimum number of digits needed to represent them. To force two decimal places, use printf "%.2f\n", ... instead of print. The same applies to `bc`, where you must set the `scale` variable to control precision.

Is there a way to handle negative times or times over 24 hours?

Yes, the formula works for any real numbers. For example, “-1:30” would be -1 + (30/60) = -0.5 hours, and “26:15” would be 26.25 hours. `awk` and Python handle negative numbers and values over 24 without issue, as long as the input is valid.

What if I have seconds in my input but want decimal hours?

Use the extended formula: H + (M/60) + (S/3600). In `awk`, this is echo "2:30:15" | awk -F: '{print $1 + ($2/60) + ($3/3600)}', which gives 2.504166… hours. You can round to two decimal places with printf if needed.

Method: the standard formula for this calculation, rounded as each result states. See how the calculators work or report an error.