Get POSIX/Unix time in seconds and nanoseconds in Python?

I've been trying to find a way to get the time since 1970-01-01 00:00:00 UTC in seconds and nanoseconds in python and I cannot find anything that will give me the proper precision.

I have tried using time module, but that precision is only to microseconds, so the code I tried was:

import time

print time.time()

which gave me a result like this:

1267918039.01

However, I need a result that looks like this:

1267918039.331291406

Does anyone know a possible way to express UNIX time in seconds and nanoseconds? I cannot find a way to set the proper precision or get a result in the correct format. Thank you for any help

Since Python 3.7 it's easy to achieve with time.time_ns()

> Similar to time() but returns time as an integer number of nanoseconds since the epoch.

All new features that includes nanoseconds in Python 3.7 release: PEP 564: Add new time functions with nanosecond resolution

Your precision is just being lost due to string formatting:

>>> import time
>>> print "%.20f" % time.time()
1267919090.35663390159606933594

It depends on the type of clock and your OS and hardware wether or not you can even get nanosecond precision at all. From the time module documentation:

> The precision of the various real-time functions may be less than suggested by the units in which their value or argument is expressed. E.g. on most Unix systems, the clock “ticks” only 50 or 100 times a second.

On Python 3, the time module gives you access to 5 different types of clock, each with different properties; some of these may offer you nanosecond precision timing. Use the time.get_clock_info() function to see what features each clock offers and what precision time is reported in.

On my OS X 10.11 laptop, the features available are:

>>> for name in ('clock', 'monotonic', 'perf_counter', 'process_time', 'time'):
...     print(name, time.get_clock_info(name), sep=': ')
...
clock: namespace(adjustable=False, implementation='clock()', monotonic=True, resolution=1e-06)
monotonic: namespace(adjustable=False, implementation='mach_absolute_time()', monotonic=True, resolution=1e-09)
perf_counter: namespace(adjustable=False, implementation='mach_absolute_time()', monotonic=True, resolution=1e-09)
process_time: namespace(adjustable=False, implementation='getrusage(RUSAGE_SELF)', monotonic=True, resolution=1e-06)
time: namespace(adjustable=True, implementation='gettimeofday()', monotonic=False, resolution=1e-06)

so using the time.monotonic() or time.perf_counter() functions would theoretically give me nanosecond resolution. Neither clock gives me wall time, only elapsed time; the values are otherwise arbitrary. They are however useful for measuring how long something took.

The problem is probably related to your OS, not Python. See the documentation of the time module: http://docs.python.org/library/time.html

> time.time() > > Return the time as a floating point > number expressed in seconds since the > epoch, in UTC. Note that even though > the time is always returned as a > floating point number, not all > systems provide time with a better > precision than 1 second. While this > function normally returns > non-decreasing values, it can return a > lower value than a previous call if > the system clock has been set back > between the two calls.

In other words: if your OS can't do it, Python can't do it. You can multiply the return value by the appropriate order of magnitude in order to get the nanosecond value, though, imprecise as it may be.

EDIT: The return is a float variable, so the number of digits after the comma will vary, whether your OS has that level of precision or not. You can format it with "%.nf" where n is the number of digits you want, though, if you want a fixed point string representation.

It is unlikely that you will actually get nanosecond precision from any current machine.

The machine can't create precision, and displaying significant digits where not appropriate is not The Right Thing To Do.

I don't think there's a platform-independent way (maybe some third party has coded one, but I can't find it) to get time in nanoseconds; you need to do it in a platform-specific way. For example, this SO question's answer shows how to do it on platform that supply a librt.so system library for "realtime" operations.