Konwertowanie między datetime, datownikiem i datetime64

Jak przekonwertować numpy.datetime64obiekt na datetime.datetime(lub Timestamp)?

W poniższym kodzie tworzę obiekty datetime, timestamp i datetime64.

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')

Uwaga: łatwo jest uzyskać datę i godzinę ze znacznika czasu:

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

Ale jak wyodrębnić datetimelub Timestampz numpy.datetime64( dt64)?

.

Aktualizacja: nieco nieprzyjemny przykład w moim zbiorze danych (być może motywujący) wydaje się:

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

który powinien być datetime.datetime(2002, 6, 28, 1, 0), a nie długi (!) ( 1025222400000000000L) ...

Aby przekonwertować numpy.datetime64na obiekt datetime reprezentujący czas w UTC 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'

Powyższy przykład zakłada, że ​​naiwny obiekt typu data- np.datetime64godzina jest interpretowany jako czas w UTC.

Aby przekonwertować datetime na np.datetime64 i back ( numpy-1.6):

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

Działa zarówno na pojedynczym obiekcie np.datetime64, jak i tablicy numpy np.datetime64.

Pomyśl o np.datetime64 w taki sam sposób, jak o np.int8, np.int16 itp. I zastosuj te same metody do konwersji między obiektami Python, takimi jak int, datetime i odpowiadające im obiekty numpy.

Twój „nieprzyjemny przykład” działa poprawnie:

>>> 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

Mogę odtworzyć longwartość po numpy-1.8.0zainstalowaniu jako:

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

Ten sam przykład:

>>> 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'

Zwraca, longponieważ dla numpy.datetime64typu .astype(datetime)jest równoważne z .astype(object)tą, która zwraca liczbę całkowitą Python ( long) na numpy-1.8.

Aby uzyskać obiekt datetime, możesz:

>>> 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)

Aby uzyskać datetime64, który używa sekund bezpośrednio:

>>> 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)

Dokumenty numpy mówią, że interfejs API datetime jest eksperymentalny i może ulec zmianie w przyszłych wersjach numpy.

Możesz po prostu użyć konstruktora pd.Timestamp. Poniższy schemat może być przydatny w przypadku tego i powiązanych pytań.

Witaj w piekle.

Możesz po prostu przekazać obiekt datetime64 do pandas.Timestamp:

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

Zauważyłem, że to nie działa poprawnie w NumPy 1.6.1:

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

Ponadto, pandas.to_datetimemoże być stosowany (ta jest wyłączona w wersji dev, nie sprawdził 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))

Myślę, że może być bardziej skonsolidowany wysiłek w odpowiedzi, aby lepiej wyjaśnić związek między modułem datetime Pythona, datetime64 / timedelta64 numpy a obiektami Timestamp / Timedelta pand.

Standardowa biblioteka języka Python dla datetime

Standardowa biblioteka datetime ma cztery główne obiekty

• czas - tylko czas mierzony w godzinach, minutach, sekundach i mikrosekundach
• data - tylko rok, miesiąc i dzień
• datetime - Wszystkie składniki godziny i daty
• timedelta - ilość czasu z maksymalną jednostką dni

Utwórz te cztery obiekty

>>> 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)

Obiekty datetime64 i timedelta64 NumPy

NumPy nie ma osobnych obiektów daty i godziny, tylko jeden obiekt datetime64 reprezentujący pojedynczy moment w czasie. Obiekt datetime modułu datetime ma mikrosekundową precyzję (jedna milionowa sekundy). Obiekt Datetime64 obiektu NumPy pozwala ustawić precyzję od godzin aż do attosekund (10 ^ -18). Konstruktor jest bardziej elastyczny i może przyjmować różne dane wejściowe.

Konstruuj obiekty Datetime64 i timedelta64 NumPy

Podaj liczbę całkowitą z ciągiem znaków dla jednostek. Zobacz wszystkie jednostki tutaj . Konwertuje się na tak wiele jednostek po epoce UNIX: 1 stycznia 1970 r

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

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

Możesz także używać ciągów, o ile są one w formacie ISO 8601.

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

Timedeltas mają jedną jednostkę

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

Można je również utworzyć, odejmując dwa obiekty datetime64

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

Pandas Timestamp i Timedelta budują znacznie więcej funkcji na NumPy

Znacznik czasu pandy jest momentem bardzo podobnym do daty i godziny, ale z dużo większą funkcjonalnością. Można skonstruować je albo pd.Timestampalbo 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 działa bardzo podobnie (z kilkoma dodatkowymi opcjami) i może konwertować listę ciągów znaków na znaczniki czasu.

>>> 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)

Konwertowanie datetime Pythona na datetime64 i znacznik czasu

>>> 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')

Konwertowanie numpy datetime64 na datetime i Datownik

>>> 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)

Konwertuj na znacznik czasu

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

Konwertuj z datownika na datetime i datetime64

Jest to dość łatwe, ponieważ znaczniki czasu pand są bardzo potężne

>>> 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)

Dla DatetimeIndextego, tolistzwraca listę datetimeobiektów. Dla pojedynczego datetime64obiektu zwraca pojedynczy datetimeobiekt.

Jeśli chcesz przekonwertować całą serię danych pandas na zwykłe dane python, możesz również użyć .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)
   ....

Obsługuje także strefy czasowe:

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>)
....

UWAGA : Jeśli korzystasz z serii Pandas, nie możesz dzwonić to_pydatetime()z całej serii. Będziesz musiał wywoływać .to_pydatetime()każdy indywidualny datetime64 przy użyciu listy lub czegoś podobnego:

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

Jedną z opcji jest użycie str, a następnie to_datetime(lub podobne):

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))

Uwaga: nie jest równy, dtponieważ stał się „świadomy przesunięcia” :

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

To wydaje się nieeleganckie.

.

Aktualizacja: poradzi sobie z „przykrym przykładem”:

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)

Ten post jest aktywny od 4 lat i nadal mam problem z tym problemem konwersji - więc problem jest nadal aktywny w 2017 roku. Byłem nieco zszokowany, że dokumentacja numpy nie oferuje prostego algorytmu konwersji, ale to już inna historia.

Natknąłem się na inny sposób wykonania konwersji, który obejmuje tylko moduły numpyi datetimenie wymaga importowania pand, co wydaje mi się dużym kodem do zaimportowania w przypadku tak prostej konwersji. Zauważyłem, że datetime64.astype(datetime.datetime)zwróci datetime.datetimeobiekt, jeśli oryginał datetime64jest w jednostkach mikrosekund, podczas gdy inne jednostki zwracają znacznik czasu liczby całkowitej. Używam modułu xarraydo danych I / O z plików Netcdf, który wykorzystuje jednostki datetime64w nanosekundach, co powoduje niepowodzenie konwersji, chyba że najpierw przekonwertujesz na jednostki mikro-sekundowe. Oto przykładowy kod konwersji,

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

Został przetestowany tylko na mojej maszynie, którą jest Python 3.6 z najnowszą dystrybucją Anaconda 2017. Patrzyłem tylko na konwersję skalarną i nie sprawdziłem konwersji opartych na macierzy, choć sądzę, że będzie dobrze. Nie szukałem też kodu źródłowego numpy datetime64, aby sprawdzić, czy operacja ma sens, czy nie.

Wróciłem do tej odpowiedzi więcej razy, niż potrafię zliczyć, więc postanowiłem zebrać małą szybką klasę, która konwertuje datetime64wartość Numpy na wartość Pythona datetime. Mam nadzieję, że to pomaga innym.

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)

Zatrzymam to w torbie z narzędziami, coś mi mówi, że będę jej potrzebować ponownie.

import numpy as np
import pandas as pd 

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

użyj tej funkcji, aby uzyskać natywny obiekt datetime python

Niektóre rozwiązania działają dla mnie dobrze, ale numpy spowoduje utratę niektórych parametrów. Rozwiązaniem, które działa dla mnie lepiej, jest odczytanie daty jako daty i godziny pandy i wyraźne wycięcie roku, miesiąca i dnia obiektu pandy. Poniższy kod działa w najczęstszej sytuacji.

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)

w rzeczywistości wszystkie te typy dat mogą być trudne i potencjalnie problematyczne (muszą uważnie śledzić informacje o strefie czasowej). oto co zrobiłem, choć przyznaję, że martwię się, że przynajmniej część tego jest „nie z założenia”. można to również uczynić nieco bardziej kompaktowym w razie potrzeby. zaczynając od numpy.datetime64 dt_a:

dt_a

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

dt_a1 = dt_a.tolist () # zwraca obiekt datetime w UTC, ale bez 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'))

... i oczywiście można je skompresować w jedną linię w razie potrzeby.