Créer un DataFrame Pandas vide, puis le remplir ?

Je commence à partir de la documentation sur les DataFrames de pandas ici : http://pandas.pydata.org/pandas-docs/stable/dsintro.html

J'aimerais remplir itérativement le DataFrame avec des valeurs dans une sorte de calcul de série chronologique. En gros, je voudrais initialiser le DataFrame avec les colonnes A, B et les lignes de timestamp, toutes à 0 ou toutes à NaN.

J'ajouterais ensuite des valeurs initiales et passerais sur ces données en calculant la nouvelle ligne à partir de la ligne précédente, disons row[A][t] = row[A][t-1]+1 ou quelque chose comme ça.

J&#8217utilise actuellement le code ci-dessous, mais je pense qu&#8217il est plutôt laid et qu&#8217il doit y avoir un moyen de faire cela directement avec un DataFrame, ou simplement un meilleur moyen en général. Remarque : j'utilise Python 2.7.

import datetime as dt
import pandas as pd
import scipy as s

if __name__ == '__main__':
    base = dt.datetime.today().date()
    dates = [ base - dt.timedelta(days=x) for x in range(0,10) ]
    dates.sort()

    valdict = {}
    symbols = ['A','B', 'C']
    for symb in symbols:
        valdict[symb] = pd.Series( s.zeros( len(dates)), dates )

    for thedate in dates:
        if thedate > dates[0]:
            for symb in valdict:
                valdict[symb][thedate] = 1+valdict[symb][thedate - dt.timedelta(days=1)]

    print valdict
Daniel Holmes
Question modifiée 25 février 2019 в 5:29
Programmation
python pandas dataframe
9 décembre 2012 в 2:50
15 vues
Solution

Voici quelques suggestions :

Utilisez date_range pour l'index :

import datetime
import pandas as pd
import numpy as np

todays_date = datetime.datetime.now().date()
index = pd.date_range(todays_date-datetime.timedelta(10), periods=10, freq='D')

columns = ['A','B', 'C']

Note : nous pourrions créer un DataFrame vide (avec NaNs) en écrivant simplement :

df_ = pd.DataFrame(index=index, columns=columns)
df_ = df_.fillna(0) # with 0s rather than NaNs

Pour effectuer ce type de calculs pour les données, utilisez un tableau numpy :

data = np.array([np.arange(10)]*3).T

Nous pouvons donc créer le DataFrame :

In [10]: df = pd.DataFrame(data, index=index, columns=columns)

In [11]: df
Out[11]: 
            A  B  C
2012-11-29  0  0  0
2012-11-30  1  1  1
2012-12-01  2  2  2
2012-12-02  3  3  3
2012-12-03  4  4  4
2012-12-04  5  5  5
2012-12-05  6  6  6
2012-12-06  7  7  7
2012-12-07  8  8  8
2012-12-08  9  9  9
Ninjakannon
Réponse modifiée 31 janvier 2017 в 2:26
Commentaires (7)

Si vous voulez simplement créer un cadre de données vide et le remplir plus tard avec des cadres de données entrants, essayez ceci :

Dans cet exemple, j'utilise [this pandas doc][1] pour créer un nouveau cadre de données, puis j'utilise [append][2] pour écrire dans le newDF avec les données de l'oldDF.

Jetez un coup d'œil à ce qui suit.

newDF = pd.DataFrame() #creates a new dataframe that's empty
newDF = newDF.append(oldDF, ignore_index = True) # ignoring index is optional
# try printing some data from newDF
print newDF.head() #again optional
  • si je dois continuer à ajouter de nouvelles données dans ce newDF à partir de plusieurs de plusieurs anciens FDF, j'utilise simplement une boucle for pour itérer sur [pandas.DataFrame.append()] [2]

[1] : http://pandas.pydata.org/pandas-docs/stable/generated/pandas.DataFrame.html [2] : http://pandas.pydata.org/pandas-docs/stable/generated/pandas.DataFrame.append.html

geekidharsh
Réponse modifiée 23 mai 2017 в 3:56
Commentaires (3)

Si vous voulez que les noms de vos colonnes soient en place dès le début, utilisez cette approche : .

import pandas as pd

col_names =  ['A', 'B', 'C']
my_df  = pd.DataFrame(columns = col_names)
my_df

Si vous voulez ajouter un enregistrement au dataframe, il serait préférable d'utiliser:

my_df.loc[len(my_df)] = [2, 4, 5]

Vous pouvez également passer un dictionnaire :

my_dic = {'A':2, 'B':4, 'C':5}
my_df.loc[len(my_df)] = my_dic

Cependant, si vous souhaitez ajouter un autre cadre de données à mon_df, procédez comme suit : .

col_names =  ['A', 'B', 'C']
my_df2  = pd.DataFrame(columns = col_names)
my_df = my_df.append(my_df2)

Si vous ajoutez des lignes à l'intérieur d'une boucle, tenez compte des problèmes de performances :
Pour les 1000 premiers enregistrements environ, les performances de "my_df.loc&quot ; sont meilleures, mais elles deviennent progressivement plus lentes lorsque le nombre d'enregistrements dans la boucle augmente.

Si vous envisagez d'effectuer des opérations dans une grande boucle (disons 10 millions d'enregistrements ou plus) :
Il est préférable d'utiliser un mélange de ces deux méthodes ; remplir un cadre de données avec iloc jusqu'à ce que sa taille atteigne environ 1000, puis l'ajouter au cadre de données original et vider le cadre de données temporaire. Cela améliorerait vos performances d'environ 10 fois.

DanTan
Réponse modifiée 21 mai 2019 в 9:05
Commentaires (0)