Utc Time Now With Seconds

The first leap second was inserted into the UTC time scale on June 30, 1972. Leap seconds are used to keep the difference between UT1 and UTC to within ±0.9 s. The table below lists all leap seconds that have already occurred, or are scheduled to occur. All leap seconds listed in the table are positive leap seconds, which means an extra second. To convert 18:00 UTC (6:00 p.m.) into your local time, subtract 6 hours, to get 12 noon CST. During daylight saving (summer) time, you would only subtract 5 hours, so 18:00 UTC would convert to 1. Means if you add offset value to date time (1/9/2016 2:27:00 PM) you will get UTC time. It provides a better way to work with different times from different time zones. // Original time: 1/9/2016 2:27:00 PM. It is a web clock showing the official time of day from NIST, displayed as a 12 or 24-hour clock, in a user-selectable time zone. The time reference for the widget is the output of the national time scale called UTC(NIST), which disseminates Coordinated Universal Time UTC(NIST).

Skyfield:Home • Table of Contents • Changelog • API Reference

Astronomers use a variety of different scales to measure time.Skyfield often has to use several timescales within a single computation!The Time class is how Skyfield represents either a single moment in timeor a whole array of moments,and keeps track of all of the different designationsassigned to that momentby the various standard time scales:

The Timescale object returned by load.timescale()manages the conversions between different time scalesand is also how the programmer builds Time objects for specific dates.Most applications create only one Timescale object,which Skyfield programmers conventionally name ts,and use it to build all of their times.

For quick reference,here are the supported timescales:

  • UTC — Coordinated Universal Time (“Greenwich Time”)
  • UT1 — Universal Time
  • TAI — International Atomic Time
  • TT — Terrestrial Time
  • TDB — Barycentric Dynamical Time (the JPL’s Teph)
Utc time now with seconds &

Utc Time Now With Seconds Conversion

And here are links to the API documentation for time scales and times:

Ancient and modern dates¶

Skyfield normally uses the modern Gregorian calendar,even for dates in history before the Gregorian calendar’s adoption in 1582.This “proleptic” use of Gregorian datesmakes date calculations simple,is compatible with Python’s datetime,and is also the behavior of the United States Naval Observatory libraryon which many Skyfield routines were originally based.

But the Gregorian calendar is awkwardfor historians and students of ancient astronomy,because the calendar in actual use before 1582was the old Julian calendarestablished by Julius Caesar’s calendar reform in 45 BC.The two calendars agree over the centurybetween the leap day of AD 200 and the leap day of AD 300.But because the Julian calendar is not quite synchronized with the seasons,its dates run ahead of the Gregorian calendar before that centuryand run behind the Gregorian calendar after it.

If you would like Skyfieldto switch to the Julian calendar for historical dates —both when interpreting the dates you input,and when producing calendar dates as output —simply give your Timescale objectthe Julian dayon which you would like the calendar to switch.

As you can see from these four successive days in history,Pope Gregory had the calendar jumpdirectly from the old Julian calendar date 1582 October 4to the new Gregorian calendar date 1582 October 15,bringing the date of Easter back into sync with the equinox.Skyfield provides two constants for popular cutoff dates:

  • GREGORIAN_START — Julian day 2299161,on which the new Gregorian calendar went into effect in Rome.
  • GREGORIAN_START_ENGLAND — Julian day 2361222,on which the new Gregorian calendar went into effect in England in 1752(the reform having initially been rejected by the English bishops,“Seeing that the Bishop of Rome is Antichrist,therefore we may not communicate with him in any thing”).

You are free to choose your own cutoff Julian dayif you are studying astronomy records from a countrythat adopted the Gregorian calendar on some other date.Russia, for example, did not adopt it until the twentieth century.The default value,that asks the timescale to always use Gregorian dates,is None:

Note that even the Julian calendar becomes anachronisticbefore its adoption in 45 BC,so all dates generated by Skyfield are “proleptic” before that date.And, of course, the Julian calendarwas local to the civilization that ringed the Mediterranean.If you are interested in relating astronomical eventsto more ancient Roman calendars,or the calendars of other civilizations,try searching for a third-party Python packagethat supports the calendar you are interested in.

Building and printing UTC¶

The utc parameter in the examples abovespecifies Coordinated Universal Time (UTC),the world clock known affectionately as “Greenwich Mean Time”which is the basis for all of the world’s timezones.If you are comfortable dealing directly with UTCinstead of your local timezone,you can build and display dateswithout needing any other library besides Skyfield.

You can build a Time from a calendar date and UTC timeusing Timescale.utc.Provide only as many parameters as you want —year, month, day, hour, minute, and second —and Skyfield will fill in the restby defaulting to January first and zero hours, minutes, and seconds.

Feel free to use fractional days, hours, and minutes.Here are several ways to specify the exact same time and date:

The 6 values returned by utc()can be accessed as the attributesyear, month, day, hour, minute, and second.

If you want to use the current time,Skyfield leverages the minimal support for UTCin the Python Standard Libraryto offer a now() functionthat reads your system clockand returns the current time as a Time object(assuming that your operating system clock is correctand configured with the correct time zone):

UTC and your timezone¶

To move beyond UTC and work with other world timezones,you will need to install a time zone databasefor your version of Python.

  • Every version of Python that Skyfield supportswill work with the pytz package described in this section.
  • Python 3.6 upgraded the Standard Library datetime typeso that the contortions of pytz are no longer necessary,and instead recommendsdateutilfor working with timezones.Consult its documentation if you are interested in using it.
  • Python 3.9 will offer a nativezoneinfomodule that for the first time brings timezone supportinto the Python Standard Library.

This documentation will focus on the first approach,which works universally across all Python versions.You can install the third-party pytz libraryby listing it in the dependencies of your package,adding it to your project’s requirements.txt file,or simply installing it manually:

Once it is installed,building a Time from a local time is simple.Instantiate a normal Python datetime,pass it to the localize() method of your time zone,and pass the result to Skyfield:


When Skyfield returns a Time at the end of a calculation,you can ask for either a UTC datetimeor a datetime in your own timezone:

As we would expect,1:32 AM in the Eastern time zone in Januaryis 6:32 AM local time in Greenwich, England,five hours to the east across the Atlantic.

Note that Skyfield’s astimezone() methodwill detect that you are using a pytz timezoneand automatically call its normalize() method for you —which makes sure that daylight savings time is handled correctly —to spare you from having to make the call yourself.

If you want a Time to hold an entire array of dates,as discussed below in Date arrays,then you can provide a list of datetime objectsto the Timescale.from_datetimes() method.The UTC methods will then return whole lists of values.

UTC and leap seconds¶

The rate of Earth’s rotation is gradually slowing down.Since the UTC standard specifies a fixed length for the second,promises a day of 24 hours, and limits an hour to 60 minutes,the only way to stay within the ruleswhile keeping UTC synchronized with the Earthis to occasionally add an extra leap secondto one of the year’s minutes.

The International Earth Rotation Servicecurrently restricts itself to appending a leap secondto the last minute of June or the last minute of December.When a leap second is inserted,its minute counts 61 seconds numbered 00–60instead of staying within the usual range 00–59.One recent leap second was in June 2012:

Note that Skyfield has no problem with a calendar tuplethat has hours, minutes, or — as in this case —seconds that are out of range.When we provided a range of numbers 58 through 62 as seconds,Skyfield added exactly the number of seconds we specifiedto the end of Juneand let the value overflow cleanly into the beginning of July.

Keep two consequences in mind when using UTC in your calculations.

First, expect an occasional jump or discrepancyif you are striding forward through timeusing the UTC minute, hour, or day.For example,an hourly plot of planet’s positionwill show the planet moving slightly fartherduring an hour that was lengthened by a leap secondthan during other hours of the year.An Earth satellite’s velocity will seem higherwhen you reach the minute that includes 61 seconds.And so forth.Problems like these are the reasonthat the Time class only uses UTC for input and output,and insists on keeping time internallyusing the uniform time scales discussed below in Uniform time scales: TAI, TT, and TDB.

Second, leap seconds disqualify the Python datetimefrom use as a general way to represent timebecause in many versions of Pythonthe datetime refuses to accept seconds greater than 59:

That limitation is why Skyfield offers a second versionof each method that returns a datetime.These fancier methods return a leap-second flag as an additional return value:

The leap-second return value is usually 0 but jumps to 1when Skyfield is forced to represent a leap secondas a datetime with the incorrect time 23:59:59.

Using calendar tuples to represent UTC times is more elegantthan using Python datetime objectsbecause leap seconds can be represented accurately.If your application cannot avoid using datetime objects,then you will have to decidewhether to simply ignore the leap_second valueor to somehow output the leap second information.

Date arrays¶

If you want to ask where a planet or satellite wasacross a whole series of times and dates,then Skyfield will work most efficiently if,instead of building many separate Time objects,you build a single Time object that holds the entire array of dates.

There are three techniques for building a Time array.

  • Provide tai() or tt()or tdb() or ut1()with a Python list or NumPy array of numbersfor one of the six components of the calendar date(year, month, day, hour, minute, or second).
  • Provide tai_jd() or tt_jd()or tdb_jd() or ut1_jd()with a list or NumPy array of floating point numbers.
  • Provide from_datetimes()with a Python list of datetime objects.

The first possibility is generally the one that is the most fun,because its lets you vary whichever time unit you wantwhile holding the others constant.You are free to provide out-of-range valuesand leave it to Skyfield to work out the correct result.Here are some examples:

The resulting Time object will hold an array of times.As illustrated in the previous section (on leap seconds),you can use a Python for to print each time separately:

When you provide a time array as input to a Skyfield calculation,the output array will have an extra dimensionthat expands what would normally be a single resultinto as many results as you provided dates.We can compute the position of the Earth as an example:

Note the shape of the resulting NumPy array.If you unpack this array into three names,then you get three four-element arrayscorresponding to the four dates.These four-element arrays are ready to be submitted to matplotliband other scientific Python tools:

If you instead slice along the second axis,then you can retrieve an individual position for a particular date —and the first position is exactly what was returned abovewhen we computed the January 1st position by itself:

You can combine a Python for loop with Python’s zip() builtinto print each time alongside the corresponding coordinates.There are two techniques,one of which is less efficient and the other more efficient.

Utc Time Now With Seconds

Finally, converting an array Time back into a calendar tupleresults in the year, month, day, hour, minute, and secondeach having the same dimension as the array itself:


Simply slice across the second dimension of the arrayto pull a particular calendar tuple out of the larger result:

Slicing in the other direction,the rows can be fetched not only by indexbut also through the attribute names year, month, day,hour, minute, and second.

Uniform time scales: TAI, TT, and TDB¶

Date arithmetic becomes very simpleas we leave UTC behind and consider completely uniform time scales.Days are always 24 hours, hours always 60 minutes,and minutes always 60 seconds without any variation or exceptions.Such time scales are not appropriate for your morning alarm clockbecause they are never delayed or adjustedto stay in sync with the slowing rotation of the earth.But that is what makes them useful for astronomical calculation —because physics keeps up its dance,and the stars and planets move in their courses,whether humanity pauses to observe a UTC leap second or not.

Because they make every day the same length,uniform time scales can express datesas a simple floating-point count of days elapsed.To make all historical dates come out as positive numbers,astronomers traditionally assign each date a “Julian day” numberthat starts counting at 4713 BC January 1 in the old Julian calendar —the same date as 4714 BC November 24 in our Gregorian calendar.Following a tradition going back to the Greeks and Ptolemy,the count starts at noon,since the sun’s transit is an observable eventbut the moment of midnight is not.

So twelve noon was the moment of Julian date zero:

Did you notice how negative years work —that we expressed 4714 BC using the negative number -4713?People still counted by starting at one, not zero,when the scholar Dionysius Exiguus created the eras BC and ADin around the year AD 500.So his scheme has 1 BC followed immediately by AD 1 without a break.To avoid an off-by-one error,astronomers usually ignore BC and count backwards through a year zeroand on into negative years.So negative year −n is what might otherwise be calledeither “n+1 BC” or “n+1 BCE” in a history textbook.

More than two million days have passed since 4714 BC,so modern dates tend to be rather large numbers:

What are these three different uniform time scales?

International Atomic Time (TAI) is maintainedby the worldwide network of atomic clocksreferenced by researchers with a need for very accurate time.The official leap second tableis actually a table of offsets between TAI and UTC.At the end of June 2012, for example,the TAI−UTC offset was changed from 34.0 to 35.0which is what generated the leap second in UTC.

Terrestrial Time (TT) differs from TAIonly because astronomerswere already maintaining a uniform time scale of their ownbefore TAI was established,using a slightly different starting point for the day.For practical purposes, TT is simply TAIplus exactly 32.184 seconds.So it is now more than a minute ahead of UTC.You can also retrieve Terrestrial Time as a floating point number of yearsof exactly 365.25 days each:

Finally,Barycentric Dynamical Time (TDB) runs at approximately the ratethat an atomic clock would runif it were at rest with respect to the Solar System barycenter,and therefore unaffected by the Earth’s motion.The acceleration that Earth experiences in its orbit —sometimes speeding up, sometimes slowing down —varies the rate at which our atomic clocksseem to run to an outside observer,as predicted by Einstein’s theory of General Relativity.So physical simulations of the Solar System tend to use TDB,which is continuous with the Teph time scaletraditionally used for Solar System and spacecraft simulationsat the Jet Propulsion Laboratory.

UT1 and downloading IERS data¶

Finally, UT1 is the least uniform time scale of allbecause its clock cannot be housed in a laboratory,nor is its rate established by any human convention.It is, rather, the clockwhose “hand” is the rotation of the Earth itself!The direction that the Earth is facing determinesnot only the coordinates of every city and observatory in the world,but also the local directions that each sitewill designate as their local “up”, “north”, and “east”.

It is hard to predict future values for UT1.The Earth is a young worldwith a still-molten iron core,a viscous mantle,and ice ages that move water weight into glaciers at the polesthen release it back into the ocean.While we think we can predict, for example,Jupiter’s position thousands of years from now,predicting the fluid dynamics of the elastic rotating ellipsoid we call homeis — at the moment — beyond us.We can only watch with sensitive instrumentsto see what the Earth does next.

Skyfield relies on the IERS,the International Earth Rotation Service,for accurate measurements of UT1and for the schedule of leap seconds (discussed above)that keeps UTC from straying more than 0.9 seconds away from UT1.

Each new version of Skyfield carries recent IERS data in internal tables.This data will gradually fall out of date after each Skyfield release,however, with two consequences:

  • The next time the IERS declares a new leap secondthat is not listed in Skyfield’s built-in tables,Skyfield’s UTC time will be off by 1 secondfor every date that falls after the leap second.
  • As the Earth’s rotation speeds up or slows down in the coming yearsmore than was predicted in Skyfield’s built-in UT1 tables,Skyfield’s idea of where the Earth is pointing will grow less accurate.This will affect both the position and directionof each GeographicPosition —whether used as an observer or a target —and will also affect Earth satellite positions.
Utc Time Now With Seconds

You can avoid both of these problemsby periodically downloading new data from the IERS.Simply specify that you don’t want Skyfield to use its builtin tables.In that case timescale()will instead download finals2000A.all from the IERS:

As usual with data files,Skyfield will only download the file the first time you need it,then will keep using that same copy of the file that it finds on disk.If your script will always have Internet accessand you worry about the file falling out of date(and if you can trust the “modify time” file attribute on your filesystem),then you can have Skyfield download a new copyonce the file on disk has grown too old(where “too old” for your applicationmust be determined by comparing your accuracy needswith how quickly UT1 diverges without fresh IERS data;this example uses 30 days only as an illustration):

But, beware!For compatibility with versions of Skyfield ≤ 1.30,Skyfield will ignore finals2000A.allif the three old filesdeltat.data, deltat.preds, and Leap_Second.datexist in the loader’s directory,in which case it will use them instead.This is to prevent users who specify builtins=False,but who downloaded the three necessary files long ago,from experiencing an unexpected download attempt.The hope is that all scriptswhich did not previously need Internet accesswill continue to run without it.

If you ever want to display or plot the behavior of UT1,astronomers use two common conventionsfor stating the difference between clock time and UT1.Skyfield supports them both.

The two quantities are:

Convert Utc Seconds To Time

  • DUT1 — The difference between UTC and UT1,which should always be less than 0.9 if the IERS succeeds at its mission.Note that there are two different reasons that this value changes:every day it changes a small amount because of the drift of UT1;and superimposed on this driftis a big jump of 1.0 secondsevery time a leap second passes.
  • ∆T — The difference between TT and UT1.This is a much more straightforward value than DUT1,without all the ugly discontinuities caused by leap seconds.Because TT is a uniform timescale,∆T provides a pure and continuous recordof how UT1 has changed over the decadesthat we have been measuring the Earth’s rotation to high precision.

Setting a Custom Value For ∆T¶

If you ever want to specify your own value for ∆T,then provide a delta_t keyword argumentwhen creating your timescale:

Values cached on the Time object¶

When you create a Timeit goes ahead and computes its tt Terrestrial Time attributestarting from whatever time argument you provide.If you provide the utc parameter, for example,then the date first computes and sets taiand then computes and sets tt.Each of the other time attributes only gets computed once,the first time you access it.

The general rule is that attributes are only computed once,and can be accessed again and again for free,while methods never cache their results —think of the () parentheses after a method nameas your reminder that “this will do a fresh computation every time.”

In addition to time scales,each Time object caches several other quantitiesthat are often needed in astronomy.Skyfield only computes these attributes on-demand,the first time the user tries to access themor invokes a computation that needs their value:

Greenwich Mean Sidereal Time in hours,in the range 0.0 ≤ gmst < 24.0.
Greenwich Apparent Sidereal Time in hours,in the range 0.0 ≤ gast < 24.0.
This 3×3 matrix and its inverseperform the complete rotation between a vector in the ICRFand a vector in the dynamical reference system for this time and date.
This 3×3 matrix and its inverseperform the complete rotation between a vector in the ICRFand a vector in the celestial intermediate reference system (CIRS)of this time and date.

You will typically never need to access these matrices yourself,as they are used automaticallyby the radec()method when you use its epoch= parameterto ask for a right ascension and declinationin the dynamical reference system,and when you ask a GeographicPosition objectfor its position.

A UNIX timestamp, also known as Epoch Time or POSIX timestamp, is a representation of a moment defined as the time that has elapsed since a reference known as the UNIX epoch: 1970-01-01 00:00:00 UTC (what is UTC). Using Java as an example, System.currentTimeMillis() returns just that, a UNIX timestamp in milliseconds - UNIX timestamps will often be measured in seconds as well (but System.currentTimeMillis() will always be in milliseconds). Following is a table that unifies these concepts:
A human readable moment in time2015-03-07 16:00 UTC
The same moment as a
UNIX timestamp in milliseconds
1425744000000get it with System.currentTimeMillis() in Java
get it with new Date().getTime() in Javascript
get it with round(microtime(true) * 1000) in PHP
The same moment as a
UNIX timestamp in seconds
1425744000get it with System.currentTimeMillis() / 1000 in Java
get it with new Date().getTime() / 1000 in Javascript
get it with time() in PHP

You can therefore say that on 2015-03-07 16:00 UTC, 1425744000000 milliseconds (or 1425744000 seconds) have passed since 1970-01-01 00:00:00 UTC.
Note that System.currentTimeMillis() is based on the time of the system / machine it's running on.

Utc Time Now With Seconds Chart

In conclusion, the UNIX timestamp is just a system / format for representing a moment in time.
Check out some other date / time systems.