Konvertieren zwischen datetime, Timestamp und datetime64

Wie konvertiere ich ein numpy.datetime64Objekt in ein datetime.datetime(oder Timestamp)?

Im folgenden Code erstelle ich ein datetime-, timestamp- und datetime64-Objekt.

import datetime
import numpy as np
import pandas as pd
dt = datetime.datetime(2012, 5, 1)
# A strange way to extract a Timestamp object, there's surely a better way?
ts = pd.DatetimeIndex([dt])[0]
dt64 = np.datetime64(dt)

In [7]: dt
Out[7]: datetime.datetime(2012, 5, 1, 0, 0)

In [8]: ts
Out[8]: <Timestamp: 2012-05-01 00:00:00>

In [9]: dt64
Out[9]: numpy.datetime64('2012-05-01T01:00:00.000000+0100')

Hinweis: Es ist einfach, die Datums- und Uhrzeitangabe aus dem Zeitstempel abzurufen:

In [10]: ts.to_datetime()
Out[10]: datetime.datetime(2012, 5, 1, 0, 0)

Aber wie extrahieren wir das datetimeoder Timestampaus einem numpy.datetime64( dt64)?

.

Update: Ein etwas unangenehmes Beispiel in meinem Datensatz (vielleicht das motivierende Beispiel) scheint zu sein:

dt64 = numpy.datetime64('2002-06-28T01:00:00.000000000+0100')

das sollte sein datetime.datetime(2002, 6, 28, 1, 0), und nicht lange (!) ( 1025222400000000000L) ...

So konvertieren Sie numpy.datetime64in ein Datum / Uhrzeit-Objekt, das die Zeit in UTC darstellt numpy-1.8:

>>> from datetime import datetime
>>> import numpy as np
>>> dt = datetime.utcnow()
>>> dt
datetime.datetime(2012, 12, 4, 19, 51, 25, 362455)
>>> dt64 = np.datetime64(dt)
>>> ts = (dt64 - np.datetime64('1970-01-01T00:00:00Z')) / np.timedelta64(1, 's')
>>> ts
1354650685.3624549
>>> datetime.utcfromtimestamp(ts)
datetime.datetime(2012, 12, 4, 19, 51, 25, 362455)
>>> np.__version__
'1.8.0.dev-7b75899'

Im obigen Beispiel wird davon ausgegangen, dass ein naives Datum / Uhrzeit-Objekt np.datetime64in UTC als Zeit interpretiert wird .

So konvertieren Sie datetime in np.datetime64 und zurück ( numpy-1.6):

>>> np.datetime64(datetime.utcnow()).astype(datetime)
datetime.datetime(2012, 12, 4, 13, 34, 52, 827542)

Es funktioniert sowohl mit einem einzelnen np.datetime64-Objekt als auch mit einem numpy-Array von np.datetime64.

Stellen Sie sich np.datetime64 genauso vor wie np.int8, np.int16 usw. und wenden Sie dieselben Methoden an, um zwischen Python-Objekten wie int, datetime und entsprechenden numpy-Objekten zu konvertieren.

Dein "böses Beispiel" funktioniert richtig:

>>> from datetime import datetime
>>> import numpy 
>>> numpy.datetime64('2002-06-28T01:00:00.000000000+0100').astype(datetime)
datetime.datetime(2002, 6, 28, 0, 0)
>>> numpy.__version__
'1.6.2' # current version available via pip install numpy

Ich kann den longWert auf numpy-1.8.0installiert wie folgt reproduzieren :

pip install git+https://github.com/numpy/numpy.git#egg=numpy-dev

Das gleiche Beispiel:

>>> from datetime import datetime
>>> import numpy
>>> numpy.datetime64('2002-06-28T01:00:00.000000000+0100').astype(datetime)
1025222400000000000L
>>> numpy.__version__
'1.8.0.dev-7b75899'

Es wird zurückgegeben, longda for numpy.datetime64type dem .astype(datetime)entspricht, für .astype(object)das Python integer ( long) zurückgegeben wird numpy-1.8.

Um ein Datum / Uhrzeit-Objekt zu erhalten, können Sie:

>>> dt64.dtype
dtype('<M8[ns]')
>>> ns = 1e-9 # number of seconds in a nanosecond
>>> datetime.utcfromtimestamp(dt64.astype(int) * ns)
datetime.datetime(2002, 6, 28, 0, 0)

So erhalten Sie datetime64, das Sekunden direkt verwendet:

>>> dt64 = numpy.datetime64('2002-06-28T01:00:00.000000000+0100', 's')
>>> dt64.dtype
dtype('<M8[s]')
>>> datetime.utcfromtimestamp(dt64.astype(int))
datetime.datetime(2002, 6, 28, 0, 0)

Die numpy-Dokumente besagen, dass die datetime-API experimentell ist und sich in zukünftigen numpy-Versionen ändern kann.

Sie können einfach den Konstruktor pd.Timestamp verwenden. Das folgende Diagramm kann für diese und verwandte Fragen hilfreich sein.

Willkommen in der Hölle.

Sie können ein datetime64-Objekt einfach übergeben an pandas.Timestamp:

In [16]: Timestamp(numpy.datetime64('2012-05-01T01:00:00.000000'))
Out[16]: <Timestamp: 2012-05-01 01:00:00>

Ich habe festgestellt, dass dies in NumPy 1.6.1 nicht richtig funktioniert:

numpy.datetime64('2012-05-01T01:00:00.000000+0100')

Auch pandas.to_datetimekann verwendet werden (dies ist aus der Entwickler - Version, nicht geprüft v0.9.1):

In [24]: pandas.to_datetime('2012-05-01T01:00:00.000000+0100')
Out[24]: datetime.datetime(2012, 5, 1, 1, 0, tzinfo=tzoffset(None, 3600))

Ich denke, es könnte eine konsolidiertere Anstrengung in einer Antwort geben, um die Beziehung zwischen Pythons datetime-Modul, numpys datetime64 / timedelta64 und den Timestamp / Timedelta-Objekten von pandas besser zu erklären.

Die datetime Standardbibliothek von Python

Die datetime-Standardbibliothek enthält vier Hauptobjekte

• Zeit - nur Zeit, gemessen in Stunden, Minuten, Sekunden und Mikrosekunden
• Datum - nur Jahr, Monat und Tag
• datetime - Alle Komponenten von Uhrzeit und Datum
• Zeitdelta - Eine Zeitspanne mit maximaler Tageseinheit

Erstellen Sie diese vier Objekte

>>> import datetime
>>> datetime.time(hour=4, minute=3, second=10, microsecond=7199)
datetime.time(4, 3, 10, 7199)

>>> datetime.date(year=2017, month=10, day=24)
datetime.date(2017, 10, 24)

>>> datetime.datetime(year=2017, month=10, day=24, hour=4, minute=3, second=10, microsecond=7199)
datetime.datetime(2017, 10, 24, 4, 3, 10, 7199)

>>> datetime.timedelta(days=3, minutes = 55)
datetime.timedelta(3, 3300)

>>> # add timedelta to datetime
>>> datetime.timedelta(days=3, minutes = 55) + \
    datetime.datetime(year=2017, month=10, day=24, hour=4, minute=3, second=10, microsecond=7199)
datetime.datetime(2017, 10, 27, 4, 58, 10, 7199)

NumPys datetime64- und timedelta64-Objekte

NumPy hat keine separaten Datums- und Zeitobjekte, sondern nur ein einzelnes datetime64-Objekt, um einen einzelnen Zeitpunkt darzustellen. Das datetime-Objekt des datetime-Moduls hat eine Genauigkeit von Mikrosekunden (eine Millionstel Sekunde). Mit dem datetime64-Objekt von NumPy können Sie die Genauigkeit von Stunden bis zu Attosekunden (10 ^ -18) festlegen. Der Konstruktor ist flexibler und kann eine Vielzahl von Eingaben vornehmen.

Konstruieren Sie die datetime64- und timedelta64-Objekte von NumPy

Übergeben Sie eine Ganzzahl mit einer Zeichenfolge für die Einheiten. Sehen Sie alle Einheiten hier . Es wird nach der UNIX-Epoche in so viele Einheiten umgewandelt: 1. Januar 1970

>>> np.datetime64(5, 'ns') 
numpy.datetime64('1970-01-01T00:00:00.000000005')

>>> np.datetime64(1508887504, 's')
numpy.datetime64('2017-10-24T23:25:04')

Sie können auch Zeichenfolgen verwenden, sofern diese im ISO 8601-Format vorliegen.

>>> np.datetime64('2017-10-24')
numpy.datetime64('2017-10-24')

Timedeltas haben eine einzige Einheit

>>> np.timedelta64(5, 'D') # 5 days
>>> np.timedelta64(10, 'h') 10 hours

Sie können sie auch erstellen, indem Sie zwei datetime64-Objekte subtrahieren

>>> np.datetime64('2017-10-24T05:30:45.67') - np.datetime64('2017-10-22T12:35:40.123')
numpy.timedelta64(147305547,'ms')

Pandas Timestamp und Timedelta bieten viel mehr Funktionen als NumPy

Ein Pandas-Zeitstempel ist ein Moment, der einem Datum und einer Uhrzeit sehr ähnlich ist, aber viel mehr Funktionen bietet. Sie können sie entweder mit pd.Timestampoder konstruieren pd.to_datetime.

>>> pd.Timestamp(1239.1238934) #defautls to nanoseconds
Timestamp('1970-01-01 00:00:00.000001239')

>>> pd.Timestamp(1239.1238934, unit='D') # change units
Timestamp('1973-05-24 02:58:24.355200')

>>> pd.Timestamp('2017-10-24 05') # partial strings work
Timestamp('2017-10-24 05:00:00')

pd.to_datetime funktioniert sehr ähnlich (mit einigen weiteren Optionen) und kann eine Liste von Zeichenfolgen in Zeitstempel konvertieren.

>>> pd.to_datetime('2017-10-24 05')
Timestamp('2017-10-24 05:00:00')

>>> pd.to_datetime(['2017-1-1', '2017-1-2'])
DatetimeIndex(['2017-01-01', '2017-01-02'], dtype='datetime64[ns]', freq=None)

Konvertieren von Python datetime in datetime64 und Timestamp

>>> dt = datetime.datetime(year=2017, month=10, day=24, hour=4, 
                   minute=3, second=10, microsecond=7199)
>>> np.datetime64(dt)
numpy.datetime64('2017-10-24T04:03:10.007199')

>>> pd.Timestamp(dt) # or pd.to_datetime(dt)
Timestamp('2017-10-24 04:03:10.007199')

Konvertieren von numpy datetime64 in datetime und Timestamp

>>> dt64 = np.datetime64('2017-10-24 05:34:20.123456')
>>> unix_epoch = np.datetime64(0, 's')
>>> one_second = np.timedelta64(1, 's')
>>> seconds_since_epoch = (dt64 - unix_epoch) / one_second
>>> seconds_since_epoch
1508823260.123456

>>> datetime.datetime.utcfromtimestamp(seconds_since_epoch)
>>> datetime.datetime(2017, 10, 24, 5, 34, 20, 123456)

In Zeitstempel konvertieren

>>> pd.Timestamp(dt64)
Timestamp('2017-10-24 05:34:20.123456')

Konvertieren Sie von Timestamp nach datetime und datetime64

Dies ist recht einfach, da Pandas Zeitstempel sehr leistungsfähig sind

>>> ts = pd.Timestamp('2017-10-24 04:24:33.654321')

>>> ts.to_pydatetime()   # Python's datetime
datetime.datetime(2017, 10, 24, 4, 24, 33, 654321)

>>> ts.to_datetime64()
numpy.datetime64('2017-10-24T04:24:33.654321000')

>>> dt64.tolist()
datetime.datetime(2012, 5, 1, 0, 0)

Für DatetimeIndexgibt das tolisteine Liste von datetimeObjekten zurück. Für ein einzelnes datetime64Objekt wird ein einzelnes datetimeObjekt zurückgegeben.

Wenn Sie eine ganze Pandas-Reihe von Datumsangaben in reguläre Python-Datumsangaben konvertieren möchten, können Sie auch verwenden .to_pydatetime().

pd.date_range('20110101','20110102',freq='H').to_pydatetime()

> [datetime.datetime(2011, 1, 1, 0, 0) datetime.datetime(2011, 1, 1, 1, 0)
   datetime.datetime(2011, 1, 1, 2, 0) datetime.datetime(2011, 1, 1, 3, 0)
   ....

Es unterstützt auch Zeitzonen:

pd.date_range('20110101','20110102',freq='H').tz_localize('UTC').tz_convert('Australia/Sydney').to_pydatetime()

[ datetime.datetime(2011, 1, 1, 11, 0, tzinfo=<DstTzInfo 'Australia/Sydney' EST+11:00:00 DST>)
 datetime.datetime(2011, 1, 1, 12, 0, tzinfo=<DstTzInfo 'Australia/Sydney' EST+11:00:00 DST>)
....

HINWEIS : Wenn Sie mit einer Pandas-Serie arbeiten, können Sie nicht to_pydatetime()die gesamte Serie aufrufen . Sie müssen .to_pydatetime()jedes einzelne datetime64 mit einem Listenverständnis oder ähnlichem aufrufen:

datetimes = [val.to_pydatetime() for val in df.problem_datetime_column]

Eine Option ist zu verwenden strund dann to_datetime(oder ähnlich):

In [11]: str(dt64)
Out[11]: '2012-05-01T01:00:00.000000+0100'

In [12]: pd.to_datetime(str(dt64))
Out[12]: datetime.datetime(2012, 5, 1, 1, 0, tzinfo=tzoffset(None, 3600))

Hinweis: Es ist nicht gleich, dtweil es "Offset-fähig" geworden ist :

In [13]: pd.to_datetime(str(dt64)).replace(tzinfo=None)
Out[13]: datetime.datetime(2012, 5, 1, 1, 0)

Dies scheint unelegant.

.

Update: Dies kann mit dem "bösen Beispiel" umgehen:

In [21]: dt64 = numpy.datetime64('2002-06-28T01:00:00.000000000+0100')

In [22]: pd.to_datetime(str(dt64)).replace(tzinfo=None)
Out[22]: datetime.datetime(2002, 6, 28, 1, 0)

Dieser Beitrag ist seit 4 Jahren aktiv und ich hatte immer noch Probleme mit diesem Konvertierungsproblem. Daher ist das Problem auch 2017 in gewissem Sinne noch aktiv. Ich war etwas schockiert, dass die Numpy-Dokumentation nicht ohne weiteres einen einfachen Konvertierungsalgorithmus bietet, aber das ist eine andere Geschichte.

Ich bin auf eine andere Möglichkeit gestoßen, die Konvertierung durchzuführen, die nur Module umfasst, numpyund datetimees müssen keine Pandas importiert werden, was für mich eine Menge Code zu importieren scheint, um eine so einfache Konvertierung durchzuführen. Ich habe festgestellt, dass datetime64.astype(datetime.datetime)ein datetime.datetimeObjekt zurückgegeben wird, wenn sich das Original datetime64in Mikrosekundeneinheiten befindet, während andere Einheiten einen ganzzahligen Zeitstempel zurückgeben. Ich verwende ein Modul xarrayfür Daten-E / A aus Netcdf-Dateien, das die datetime64In-Nanosekunden-Einheiten verwendet, wodurch die Konvertierung fehlschlägt, es sei denn, Sie konvertieren zuerst in Mikrosekunden-Einheiten. Hier ist der Beispielkonvertierungscode:

import numpy as np
import datetime

def convert_datetime64_to_datetime( usert: np.datetime64 )->datetime.datetime:
    t = np.datetime64( usert, 'us').astype(datetime.datetime)
return t

Es wurde nur auf meinem Computer getestet, nämlich Python 3.6 mit einer aktuellen Anaconda-Distribution von 2017. Ich habe mir nur die Skalarkonvertierung angesehen und keine Array-basierten Konvertierungen überprüft, obwohl ich davon ausgehe, dass dies gut sein wird. Ich habe mir auch nicht den numpy datetime64-Quellcode angesehen, um festzustellen, ob die Operation sinnvoll ist oder nicht.

Ich bin öfter auf diese Antwort zurückgekommen, als ich zählen kann, und habe mich daher entschlossen, eine kurze kleine Klasse zusammenzustellen, die einen Numpy- datetime64Wert in einen Python- datetimeWert konvertiert . Ich hoffe es hilft anderen da draußen.

from datetime import datetime
import pandas as pd

class NumpyConverter(object):
    @classmethod
    def to_datetime(cls, dt64, tzinfo=None):
        """
        Converts a Numpy datetime64 to a Python datetime.
        :param dt64: A Numpy datetime64 variable
        :type dt64: numpy.datetime64
        :param tzinfo: The timezone the date / time value is in
        :type tzinfo: pytz.timezone
        :return: A Python datetime variable
        :rtype: datetime
        """
        ts = pd.to_datetime(dt64)
        if tzinfo is not None:
            return datetime(ts.year, ts.month, ts.day, ts.hour, ts.minute, ts.second, tzinfo=tzinfo)
        return datetime(ts.year, ts.month, ts.day, ts.hour, ts.minute, ts.second)

Ich werde das in meiner Werkzeugtasche aufbewahren, irgendetwas sagt mir, dass ich es wieder brauchen werde.

import numpy as np
import pandas as pd 

def np64toDate(np64):
    return pd.to_datetime(str(np64)).replace(tzinfo=None).to_datetime()

Verwenden Sie diese Funktion, um das native datetime-Objekt von Python abzurufen

Einige Lösungen funktionieren gut für mich, aber numpy wird einige Parameter verwerfen. Die Lösung, die für mich besser funktioniert, besteht darin, das Datum als Pandas-Datum / Uhrzeit zu lesen und das Jahr, den Monat und den Tag eines Pandas-Objekts explizit zu extrahieren. Der folgende Code funktioniert für die häufigste Situation.

def format_dates(dates):
    dt = pd.to_datetime(dates)
    try: return [datetime.date(x.year, x.month, x.day) for x in dt]    
    except TypeError: return datetime.date(dt.year, dt.month, dt.day)

In der Tat können alle diese Datums- / Uhrzeittypen schwierig und möglicherweise problematisch sein (müssen die Zeitzoneninformationen sorgfältig verfolgen). Hier ist, was ich getan habe, obwohl ich zugebe, dass ich besorgt bin, dass zumindest ein Teil davon "nicht beabsichtigt" ist. Dies kann bei Bedarf auch etwas kompakter gestaltet werden. beginnend mit einer numpy.datetime64 dt_a:

dt_a

numpy.datetime64 ('2015-04-24T23: 11: 26.270000-0700')

dt_a1 = dt_a.tolist () # liefert ein Datum / Uhrzeit-Objekt in UTC, jedoch ohne tzinfo

dt_a1

datetime.datetime (2015, 4, 25, 6, 11, 26, 270000)

# now, make your "aware" datetime:

dt_a2 = datetime.datetime (* list (dt_a1.timetuple () [: 6]) + [dt_a1.microsecond], tzinfo = pytz.timezone ('UTC'))

... und das kann natürlich nach Bedarf zu einer Zeile komprimiert werden.