La conversion entre datetime, Timestamp et datetime64

Comment puis-je convertir un numpy.datetime64 objet d'un datetime.datetime (ou Timestamp)?

Dans le code suivant, j'ai créer un datetime, timestamp et datetime64 objets.

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

Remarque: il est facile d'obtenir la date de l'Horodatage:

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

Mais comment pouvons-nous extraire les datetime ou Timestamp à partir d'un numpy.datetime64 (dt64)?

.

Mise à jour: un peu méchant exemple dans ma base de données (peut-être la motivation exemple) semble être:

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

qui devrait être datetime.datetime(2002, 6, 28, 1, 0), et non pas une longue (!) (1025222400000000000L)...

  • vous devriez probablement accepter @Wes McKinney réponse qui est beaucoup plus courte et devrait fonctionner sur les récentes numpy, pandas versions.
  • Hmmm, est-ce à dire que la réponse est "ne pas bouger de np.datetime datetime"... il suffit d'utiliser la mp.Timestamp (comme c'est une sous-classe de datetime de toute façon), ou si vous devez vraiment utiliser pd.Timestamp(dt64).to_datetime(). Je suis toujours un peu insatisfaits sur ce sujet, mais certainement de Wes est moins spécifique à mon ancien problème (pour le monde)! Merci encore de prendre le temps de répondre. 🙂
  • Votre question dit "ou Timestamp" et Timestamp est un datetime (une sous-classe) de toute façon 🙂
  • Pour ceux qui viennent à cette question en 2017+, regarde ma réponse ci-dessous pour un tutoriel détaillé de datetime, datetime64 et les Horodatages: stackoverflow.com/a/46921593/3707607
InformationsquelleAutor Andy Hayden | 2012-12-04
  1. 108

    Pour convertir numpy.datetime64 pour objet datetime qui représente l'heure UTC sur 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'

    L'exemple ci-dessus suppose que le naïf objet datetime est interprété par np.datetime64 que l'heure UTC.

    Pour convertir datetime pour les np.datetime64 et à l'arrière (numpy-1.6):

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

    Il fonctionne à la fois sur un seul np.datetime64 objet et un tableau numpy de np.datetime64.

    Pense de np.datetime64 de la même manière que vous le feriez sur np.int8, np.int16, etc et d'appliquer les mêmes méthodes pour convertir entre Python objets tels que int, datetime et correspondant numpy objets.

    Votre "méchant exemple" fonctionne correctement:

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

    Je peux reproduire le long valeur sur numpy-1.8.0 installé comme:

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

    Le même exemple:

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

    Il retourne long parce que pour numpy.datetime64 type .astype(datetime) est équivalent à .astype(object) qui renvoie Python entier (long) sur numpy-1.8.

    Pour obtenir l'objet datetime vous pouvez:

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

    Pour obtenir datetime64 qui utilise secondes directement:

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

    La numpy docs dire que la date /heure API est expérimental et peut changer dans le futur numpy versions.

    • J'ai peur que cela ne semble pas toujours: par exemple,dt64 = numpy.datetime64('2002-06-28T01:00:00.000000000+0100'), qui donne une longue (1025222400000000000L) (!)
    • essayez type(dt64). dt64.astype(datetime) == datetime.utcfromtimestamp(dt64.astype(int)*1e-6)
    • est numpy.datetime64 et dt64.astype(datetime) est le même long int... :s
    • Qu'est-ce que votre numpy version? La mienne: numpy.__version__ -> '1.6.1'
    • La Version 1.8.0 (en python 2.7.3), si cela fonctionne pour vous, il ne le suggèrent qu'il s'agit d'un bug sur mon système!
    • Je peux le reproduire sur 1.8. J'ai mis à jour la réponse.
    • Merci beaucoup pour la recherche dans ce! Maintenant je me rappelle de voir que l'API était expérimentale, oups. Je souhaite que je pourrais +1 encore une fois 🙂
    • Aucun de ces exemples pour moi. Si j'essaie datetime.datetime.utcfromtimestamp, je vois deux erreurs: (1) TypeError: don't know how to convert scalar number to float quand j'ai essayer de passer dans la inchangée np.datetime64 et puis (2) ValueError: year is out of range lorsque j'essaie d'abord à l'aide de .astype(int). La date du test est pour 2012: xx = numpy.datetime64(datetime.date(2012,1,31)) si l'année est parfaitement valide. Je suis à l'aide de NumPy 1.6.1.
    • href="https://gist.github.com/5556838" >exécuter ceci (sur le succès, vous devriez voir rien). Si vous voyez des erreurs; fournir un lien vers le code peut être exécuté.

    InformationsquelleAutor jfs
  2. 170

    Vous pouvez simplement utiliser les mp.Timestamp constructeur. Le diagramme suivant peut être utile à cet effet et de questions connexes.

    La conversion entre datetime, Timestamp et datetime64

    • Nice!!! (La peine de mentionner que la situation s'est améliorée depuis que j'ai écrit à cette question, beaucoup de travail a été fait ici 🙂 )
    • Jusqu'au sommet! Bon travail, m'a sauvé un peu de temps!
    • Simplement en regardant ce schéma me dit il y a quelque chose de fondamentalement mauvais dans tout ce temps-là des choses.
    • Il est très déroutant que pd.to_datetime serait de produire un TimeStamp, si, étant donné le nombre de ms ou de ns, mais serait de produire un datetime.datetime si un datetime.datetime ou un np.datetime64 si np.datetime64... Pourquoi tout le monde pense que c'est raisonnable?
    • Pour ceux d'écrémage: pd.Timestamp() changements np.datetime mp.Timestamp
    • Ce diagramme doit être mis à jour. pd.to_datetime convertit tout à pd.Timestamp. Un pd.Timestamp objet a la méthode to_pydatetime pour revenir à une datetime.datetime objet et un to_datetime64 méthode pour convertir np.datetime64.
    • C'est beaucoup plus raisonnable - savez-vous depuis quelle version c'est le cas?
    • Comment puis-je obtenir une résolution plus élevée de ce pic?
    • Ce graphique a besoin de la string -> mappages sur elle. Essayez ces: x = pd.to_datetime('2012-05-01T01:00:00.000000+0100'); print(type(x)); print(type(x.to_datetime()); -- le premier est un class 'pandas._libs.tslib.Timestamp' et le second est un class 'datetime.datetime'. (Et vous obtenez un avertissement que to_datetime() est déconseillé pour to_pydatetime() ) (Dans les Pandas 0.22.0 et Python 3.5.2)

    InformationsquelleAutor Quant
  3. 112

    Bienvenue en enfer.

    Vous pouvez passer un datetime64 objet de pandas.Timestamp:

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

    J'ai remarqué que cela ne fonctionne pas bien dans NumPy 1.6.1:

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

    Aussi, pandas.to_datetime peut être utilisé (ce qui est hors de la dev version, vous n'avez pas vérifié 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))
    • Vous devez mentionner que issubclass(pd.Timestamp, datetime) est True. Et Timestamp classe elle-même a to_datetime() méthode.
    • pd.to_datetime('2012-05-01T01:00:00.000000+0100') retourne Timestamp('2012-05-01 00:00:00') au moins dans les pandas 0.17.1.
    InformationsquelleAutor Wes McKinney
  4. 66

    Je pense qu'il pourrait être un plus consolidée de l'effort dans une réponse afin de mieux expliquer la relation entre Python module datetime, numpy est datetime64/timedelta64 et les pandas' Timestamp/Timedelta objets.

    Datetime bibliothèque standard de Python

    Datetime de la bibliothèque standard a quatre principaux objets

    • temps - seul le temps, mesuré en heures, minutes, secondes et microsecondes
    • date seulement de l'année, le mois et le jour
    • datetime - Tous les composants de l'heure et de la date
    • timedelta - Un montant de temps le maximum de l'unité de jours

    Créer ces quatre objets

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

    NumPy est datetime64 et timedelta64 objets

    NumPy n'a pas d'autre date et l'heure des objets, un seul datetime64 objet pour représenter un seul moment dans le temps. Le module datetime de l'objet datetime a la microseconde de précision (un millionième de seconde). NumPy est datetime64 objet permet de définir la précision des heures, tout le chemin à attoseconds (10 ^ -18). Son constructeur est plus flexible et peut prendre une variété d'entrées.

    Construire NumPy est datetime64 et timedelta64 objets

    Passer d'un nombre entier avec une chaîne pour les unités. Voir toutes les unités ici. Il est converti que de nombreuses unités après l'époque UNIX: 1 janvier 1970

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

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

    Vous pouvez également utiliser des chaînes, aussi longtemps qu'ils sont au format ISO 8601.

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

    Timedeltas ont une seule unité

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

    Pouvez aussi créer par la soustraction de deux datetime64 objets

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

    Pandas Horodatage et Timedelta construire beaucoup plus de fonctionnalités sur le dessus de NumPy

    Une pandas Timestamp est un moment très similaire à un datetime, mais avec beaucoup plus de fonctionnalités. Vous pouvez construire avec pd.Timestamp ou 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 fonctionne de manière similaire (avec un peu plus d'options) et permet de convertir une liste de chaînes de caractères dans les Horodatages.

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

    La conversion de Python datetime pour datetime64 et 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')

    La conversion de numpy datetime64 de type datetime et 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)

    Convertir le Timestamp

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

    Convertir à partir d'Horodatage date /heure et datetime64

    C'est assez facile comme les pandas horodatages sont très puissants

    >>> 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')
    • C'est fou comment numpy datetime est toujours dur/hacky... il n'y a vraiment pas de meilleure façon? C'est une bonne réponse, je pense d'accepter ou de le déplacer vers le haut-niveau, je dois lire les autres plus profondément une fois par un ordinateur.
    • Ce qui est bizarre à ce sujet? Les Pandas Horodateurs fonctionnent bien et sont assez simples.
    • Numpy datetime.
    • Je pense que c'est la meilleure réponse que j'ai jamais vu. À venir à partir d'Excel, VBA, SAS, SQL, Python semble bizarre parce que il n'y a pas "une façon de" travailler avec des dates/heures. Comme avec beaucoup de choses en Python ou R, il semble que l'on doit choisir un favori de la méthode/de/de module de classe et de rester avec elle.
    InformationsquelleAutor Ted Petrou
  5. 27
    >>> dt64.tolist()
datetime.datetime(2012, 5, 1, 0, 0)

    Pour DatetimeIndex, le tolist renvoie une liste de datetime objets. Pour un seul datetime64 objet qu'elle renvoie un seul datetime objet.

    • J'ai vraiment devrait avoir essayé toutes les méthodes 🙂 (je suis choqué de voir combien de temps j'ai été aux prises avec celui-ci) Merci
    • si vous savez que c'est un scalaire/0-d tableau je préfère utiliser .item() qui est beaucoup plus explicite (et personne ne peut venir autour et commencer à discuter qu'il doit renvoyer une liste).
    • c'est un bon appel, il lit beaucoup mieux, merci.
    • J'ai peur que cela ne semble pas toujours: par exemple,dt64 = numpy.datetime64('2002-06-28T01:00:00.000000000+0100'), qui donne une longue (1025222400000000000L) (!)
    • le type retourné par .item() (suggéré par @seberg), .tolist() dépend de ce que les unités de datetime64 utilise par exemple, D produit datetime.date(), us (microsecondes) produire datetime.datetime(), ns (nanosecondes) produire long. Et les unités de changer en fonction des valeurs d'entrée par exemple, numpy.datetime64('2012-05-01') utilise 'D', numpy.datetime64('2012-05-01T00:00:00.000') utilise ms, numpy.datetime64('2012-05-01T00:00:00.000000000') utilise ns. Vous pourriez ouvrir si vous trouvez qu'il est source de confusion.
    • Vous pourriez tout aussi bien ajouter un argument supplémentaire, "nous" ou " ms " pour assurer le même format est appliqué le même datetime élément produite dans tolist()

    InformationsquelleAutor eumiro
  6. 10

    Si vous voulez convertir un ensemble de pandas série de datetimes régulièrement python datetimes, vous pouvez également utiliser .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)
   ....

    Il prend également en charge les fuseaux horaires:

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

    NOTE: Si vous êtes sur un des Pandas de la Série vous ne pouvez pas appeler to_pydatetime() sur l'ensemble de la série. Vous aurez besoin de faire appel .to_pydatetime() sur chaque datetime64 à l'aide d'une compréhension de liste ou quelque chose de similaire: 

    datetimes = [val.to_pydatetime() for val in df.problem_datetime_column]
    InformationsquelleAutor fantabolous
  7. 8

    Une option est d'utiliser str, puis to_datetime (ou similaire):

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

    Remarque: il n'est pas égal à dt parce qu'il est devenu "le décalage de courant":

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

    Cela semble peu élégante.

    .

    Mise à jour: il peut traiter avec le "méchant" exemple:

    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)
    • Merci Andy pour le partage de cette astuce. Pour une raison que je suis incapable de le faire fonctionner, comme je l'ai discuter ici: stackoverflow.com/questions/22825349/...
    • cela n'a jamais été une solution très robuste, je suppose que vous pouvez passer d'un format datetime constructeur de travailler de manière plus générale. Pas très pandastic si!
    InformationsquelleAutor Andy Hayden
  8. 4

    Ce post a été mis en place depuis 4 ans et j'ai toujours eu du mal avec ce problème de conversion - donc, la question est toujours actif en 2017, dans un certain sens. J'ai été un peu choqué par le fait que la numpy la documentation n'est pas facile de proposer un simple algorithme de conversion, mais c'est une autre histoire.

    J'ai trouver une autre façon de faire la conversion qui concerne uniquement les modules numpy et datetime, il ne nécessite pas de pandas à être importés, ce qui me semble être beaucoup de code à l'importation pour une simple conversion. J'ai remarqué que datetime64.astype(datetime.datetime) sera de retour d'une datetime.datetime objet si l'original datetime64 est dans micro-seconde unités tandis que d'autres unités de renvoyer un nombre entier d'horodatage. J'utilise le module xarray pour les données d'e/S de fichiers Netcdf qui utilise le datetime64 dans l'ordre de la nanoseconde unités faisant la conversion échoue à moins que vous convertissez d'abord à la micro-seconde unités. Voici l'exemple de la conversion de code,

    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

    Son uniquement testé sur ma machine, qui est Python 3.6 avec une récente 2017 Anaconda de distribution. J'ai seulement regardé scalaire de conversion et n'ont pas vérifié réseau sur la base des conversions bien que j'imagine qu'il sera bon. Je n'ai pas regardé le numpy datetime64 code source pour voir si l'opération a du sens ou pas.

    • Ce qui est excellent. Merci à vous pour cet.
    InformationsquelleAutor ndl303
  9. 1

    J'ai en revenir à cette réponse plus de fois que je peux compter, j'ai donc décidé de jeter ensemble un peu rapide de classe, qui le convertit en un Numpy datetime64 valeur de Python datetime valeur. J'espère que cela aidera d'autres. 

    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)

    Je vais garder dans mon sac à outils, quelque chose me dit que je vais avoir besoin de lui encore.

    • Vous pourriez faire ts.to_pydatetime()
    InformationsquelleAutor MikeyE
  10. 0

    en effet, tous ces types datetime peut être difficile, et potentiellement problématiques (doit suivre attentivement informations de fuseau horaire). voici ce que j'ai fait, mais je dois admettre que je suis concerné, au moins une partie de c'est pas "by design". aussi, il peut être un peu plus compact que le nécessaire.
    en commençant par un numpy.datetime64 dt_a:

    dt_a

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

    dt_a1 = dt_a.tolist() # renvoie un objet datetime au format UTC, mais sans tzinfo

    dt_a1

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

    # now, make your "aware" datetime:

    dt_a2=datetime.datetime(*liste(dt_a1.timetuple()[:6]) + [dt_a1.microseconde], tzinfo=pytz.le fuseau horaire('UTC'))

    ... et bien sûr, qui peut être comprimé en une seule ligne si nécessaire.

    InformationsquelleAutor yoder
  11. 0
    import numpy as np
import pandas as pd 

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

    utilisez cette fonction pour obtenir des pythons natif objet datetime

    • J'ai eu un message d'erreur indiquant replace() got an unexpected keyword argument 'tzinfo'
    • qui pandas version utilisez-vous?J'ai la Version: 0.18.1 (pip montrer pandas)
    • même chose que vous. . .
    • Je ne sais pas alors, mais il fonctionne pour moi comme un charme. pix.toile-libre.org/upload/original/1475645621.png
    InformationsquelleAutor Crystal
  12. 0

    Certaines solutions fonctionnent bien pour moi, mais numpy va déprécier certains paramètres.
    La solution qui fonctionne mieux pour moi est de lire la date comme les pandas datetime et excract explicitement l'année, le mois et le jour de pandas objet.
    Le code suivant fonctionne pour la situation la plus courante.

    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)
    InformationsquelleAutor João Gabriel John