Trouver le plus proche ligne de DataFrame de temps donné dans les Pandas

J'ai une Pandas dataframe qui est indexé par un DatetimeIndex:

<class 'pandas.core.frame.DataFrame'>
DatetimeIndex: 53732 entries, 1993-01-07 12:23:58 to 2012-12-02 20:06:23
Data columns:
Date(dd-mm-yy)_Time(hh-mm-ss)       53732  non-null values
Julian_Day                          53732  non-null values
AOT_870                             53732  non-null values
440-870Angstrom                     53732  non-null values
440-675Angstrom                     53732  non-null values
500-870Angstrom                     53732  non-null values
Last_Processing_Date(dd/mm/yyyy)    53732  non-null values
Solar_Zenith_Angle                  53732  non-null values
time                                53732  non-null values
dtypes: datetime64[ns](2), float64(6), object(1)

Je veux trouver la ligne qui est plus proche d'un certain temps:

image_time = dateutil.parser.parse('2009-07-28 13:39:02')

et de trouver comment fermer. Jusqu'à présent, j'ai essayé diverses choses, fondé sur l'idée de soustraire le temps que je veux de tous les temps et de trouver la plus petite valeur absolue, mais aucun n'est tout à fait l'air de fonctionner.

Par exemple:

aeronet.index - image_time

Donne une erreur qui, je pense, est due à +/- sur un Datetime indice de décalage de choses, donc j'ai essayé de mettre l'index dans une autre colonne, puis en travaillant sur:

aeronet['time'] = aeronet.index
aeronet.time - image_time

Cela semble fonctionner, mais pour faire ce que je veux, j'ai besoin d'obtenir l'ABSOLU de la différence de temps, de ne pas la différence relative. Toutefois, en cours d'exécution juste abs ou np.abs sur il donne une erreur:

abs(aeronet.time - image_time)

C:\Python27\lib\site-packages\pandas\core\series.pyc in __repr__(self)
   1061         Yields Bytestring in Py2, Unicode String in py3.
   1062         """
-> 1063         return str(self)
   1064 
   1065     def _tidy_repr(self, max_vals=20):

C:\Python27\lib\site-packages\pandas\core\series.pyc in __str__(self)
   1021         if py3compat.PY3:
   1022             return self.__unicode__()
-> 1023         return self.__bytes__()
   1024 
   1025     def __bytes__(self):

C:\Python27\lib\site-packages\pandas\core\series.pyc in __bytes__(self)
   1031         """
   1032         encoding = com.get_option("display.encoding")
-> 1033         return self.__unicode__().encode(encoding, 'replace')
   1034 
   1035     def __unicode__(self):

C:\Python27\lib\site-packages\pandas\core\series.pyc in __unicode__(self)
   1044                     else get_option("display.max_rows"))
   1045         if len(self.index) > (max_rows or 1000):
-> 1046             result = self._tidy_repr(min(30, max_rows - 4))
   1047         elif len(self.index) > 0:
   1048             result = self._get_repr(print_header=True,

C:\Python27\lib\site-packages\pandas\core\series.pyc in _tidy_repr(self, max_vals)
   1069         """
   1070         num = max_vals //2
-> 1071         head = self[:num]._get_repr(print_header=True, length=False,
   1072                                     name=False)
   1073         tail = self[-(max_vals - num):]._get_repr(print_header=False,

AttributeError: 'numpy.ndarray' object has no attribute '_get_repr'

Suis-je aborder ce la bonne manière? Si oui, comment doit-je obtenir abs de travail, de sorte que je peux ensuite sélectionner le minimum absolu de la différence de temps, et donc d'obtenir le plus proche du temps. Si non, quel est le meilleur moyen de faire cela avec une Pandas temps de la série?

OriginalL'auteur robintw | 2013-02-27

6

Je pense que vous pouvez essayer DatetimeIndex.asof pour trouver la plus récente de l'étiquette jusqu'à et y compris l'entrée. Utilisez ensuite le retour de l'datetime pour sélectionner la ligne appropriée.
Si vous avez seulement besoin de valeurs d'une colonne particulière, Series.asof existe et combine les deux étapes ci-dessus en un seul.

Cela suppose que vous voulez le plus proche datetime. Si vous n'avez pas de soins sur la date et veulent juste la même heure chaque jour, l'utilisation at_time dans DataFrame.

Suivi:

Edit: fausse alerte, j'avais une vieille version localement. Plus tard le maître doit travailler avec des np.abs.
```
In [10]: np.abs(df.time - image_time)
Out[10]: 
0    27 days, 13:39:02
1    26 days, 13:39:02
2    25 days, 13:39:02
3    24 days, 13:39:02
4    23 days, 13:39:02
5    22 days, 13:39:02
```
Aussi juste pour clarifier:

aeronet.index - image_time ne fonctionne pas parce que la soustraction des Index est un ensemble de différence (à l'époque de l'Indice utilisé pour être contraint d'être unique).

Merci - aide. Cependant, je ne pense pas qu'il va faire ce que je veux tout le temps. Par exemple, si j'ai des données à 10:25, 10:32 et l'appel asof à 10:30, ça va revenir 10:25, plutôt qu'à 10:32, qui est en fait plus proche. C'est ce que je veux, c'est le plus proche, pas forcément le plus proche du temps avant, le temps que j'ai donné. Peut-être que j'ai besoin de le faire en utilisant ma méthode manuelle, mais je ne vois pas pourquoi np.abs ne fonctionne pas.
Merci pour le suivi. J'ai installé la dernière version de développement à partir de pandas.pydata.org/pandas-build/dev plus tôt aujourd'hui (environ 3 h UTC) - elle a changé depuis pour permettre np.abs? (Je vais tester avec la dernière dev version demain au travail)
Je ne le pense pas. Également à la recherche de l'erreur, elle n'est pas dans le calcul, mais à la sortie des résultats. Si vous attribuer les résultats à une variable, vous pourriez être en mesure de fouiller et comprendre ce qu'est la question
J'ai essayé d'assigner à une variable, mais n'a obtenu exactement les mêmes résultats. Semble plutôt étrange. Dois-je augmenter d'un bug avec les pandas de l'équipe?
Oui s'il vous plaît ne faire une question sur github. Lorsque vous ne, pouvez vous s'il vous plaît fournir des détails plus clairs, c'est à dire, pouvez-vous réduire votre jeu de données jusqu'à une petite taille et de mettre en place une auto-contenue reproductible exemple? Qui va nous aider à déboguer le problème. Merci

OriginalL'auteur Chang She
15

Cette méthode simple sera de retour l' (integer index de l') TimeSeriesIndex entrée la plus proche à un objet datetime. Il n'y a pas besoin de la copie de l'index d'une colonne régulière: il suffit d'utiliser la .to_pydatetime méthode à la place.
```
import numpy as np

i = np.argmin(np.abs(df.index.to_pydatetime() - image_time))
```
Alors il suffit d'utiliser le DataFrame de .iloc indexeur:
```
df.iloc[i]
```
Voici une fonction pour ce faire:
```
def fcl(df, dtObj):
    return df.iloc[np.argmin(np.abs(df.index.to_pydatetime() - dtObj))]
```
Vous pouvez ensuite filtrer de façon transparente, par exemple
```
fcl(df, dtObj)['column']
```
semble comme il devrait y avoir un moyen plus facile, mais c'est une solution sympa qui m'a aidé à continuer!

OriginalL'auteur cmeeren
0

J'ai été confronté au même problème aujourd'hui. Je voulais une fonction capable de me donner la valeur la plus proche avant un timestamp. Voici la fonction que j'ai:
```
def get_nearest_past(data, timestamp):
    index = data.index.get_loc(timestamp,"ffill")
    return data.iloc[index]
```
Dans le cas où vous avez besoin de la mondiale la plus proche (et pas le plus proche de l'avant, comme dans mon cas), vous pouvez utiliser:
```
def get_nearest(data, timestamp):
    index = data.index.get_loc(timestamp,"nearest")
    return data.iloc[index]
```
Vous pouvez trouver plus d'informations dans la get_loc de la documentation.

OriginalL'auteur silgon

Vous devez vous connecter pour publier un commentaire.

Suivi: