Ho il seguente DataFrame indicizzato con colonne e righe con numeri non continui:

          a         b         c         d
2  0.671399  0.101208 -0.181532  0.241273
3  0.446172 -0.243316  0.051767  1.577318
5  0.614758  0.075793 -0.451460 -0.012493

Vorrei aggiungere una nuova colonna 'e'al frame di dati esistente e non voglio cambiare nulla nel frame di dati (ovvero, la nuova colonna ha sempre la stessa lunghezza del DataFrame).

0   -0.335485
1   -1.166658
2   -0.385571
dtype: float64

Come posso aggiungere una colonna eall'esempio sopra?

Utilizzare gli indici df1 originali per creare la serie:

df1['e'] = pd.Series(np.random.randn(sLength), index=df1.index)

Modifica 2015
Alcuni hanno riferito di aver ricevuto SettingWithCopyWarningquesto codice.
Tuttavia, il codice funziona ancora perfettamente con l'attuale versione panda 0.16.1.

>>> sLength = len(df1['a'])
>>> df1
          a         b         c         d
6 -0.269221 -0.026476  0.997517  1.294385
8  0.917438  0.847941  0.034235 -0.448948

>>> df1['e'] = pd.Series(np.random.randn(sLength), index=df1.index)
>>> df1
          a         b         c         d         e
6 -0.269221 -0.026476  0.997517  1.294385  1.757167
8  0.917438  0.847941  0.034235 -0.448948  2.228131

>>> p.version.short_version
'0.16.1'

Lo SettingWithCopyWarningscopo è quello di informare di una possibile assegnazione non valida su una copia del Dataframe. Non dice necessariamente che hai fatto male (può innescare falsi positivi) ma da 0.13.0 ti fa sapere che ci sono metodi più adeguati per lo stesso scopo. Quindi, se ricevi l'avviso, segui i suoi consigli: prova a usare invece .loc [row_index, col_indexer] = value

>>> df1.loc[:,'f'] = pd.Series(np.random.randn(sLength), index=df1.index)
>>> df1
          a         b         c         d         e         f
6 -0.269221 -0.026476  0.997517  1.294385  1.757167 -0.050927
8  0.917438  0.847941  0.034235 -0.448948  2.228131  0.006109
>>> 

In realtà, questo è attualmente il metodo più efficiente come descritto nei documenti di Panda

Modifica 2017

Come indicato nei commenti e da @Alexander, attualmente il metodo migliore per aggiungere i valori di una serie come nuova colonna di un DataFrame potrebbe utilizzare assign:

df1 = df1.assign(e=pd.Series(np.random.randn(sLength)).values)

Questo è il modo semplice di aggiungere una nuova colonna: df['e'] = e

Vorrei aggiungere una nuova colonna, "e", al frame di dati esistente e non modificare nulla nel frame di dati. (La serie ha sempre la stessa lunghezza di un frame di dati.)

Presumo che i valori dell'indice ecorrispondano a quelli in df1.

Il modo più semplice per avviare una nuova colonna denominata ee assegnargli i valori delle serie e:

df['e'] = e.values

assegnare (Panda 0.16.0+)

A partire da Pandas 0.16.0, puoi anche utilizzare assign, che assegna nuove colonne a un DataFrame e restituisce un nuovo oggetto (una copia) con tutte le colonne originali oltre a quelle nuove.

df1 = df1.assign(e=e.values)

Come da questo esempio (che include anche il codice sorgente della assignfunzione), puoi anche includere più di una colonna:

df = pd.DataFrame({'a': [1, 2], 'b': [3, 4]})
>>> df.assign(mean_a=df.a.mean(), mean_b=df.b.mean())
   a  b  mean_a  mean_b
0  1  3     1.5     3.5
1  2  4     1.5     3.5

Nel contesto del tuo esempio:

np.random.seed(0)
df1 = pd.DataFrame(np.random.randn(10, 4), columns=['a', 'b', 'c', 'd'])
mask = df1.applymap(lambda x: x <-0.7)
df1 = df1[-mask.any(axis=1)]
sLength = len(df1['a'])
e = pd.Series(np.random.randn(sLength))

>>> df1
          a         b         c         d
0  1.764052  0.400157  0.978738  2.240893
2 -0.103219  0.410599  0.144044  1.454274
3  0.761038  0.121675  0.443863  0.333674
7  1.532779  1.469359  0.154947  0.378163
9  1.230291  1.202380 -0.387327 -0.302303

>>> e
0   -1.048553
1   -1.420018
2   -1.706270
3    1.950775
4   -0.509652
dtype: float64

df1 = df1.assign(e=e.values)

>>> df1
          a         b         c         d         e
0  1.764052  0.400157  0.978738  2.240893 -1.048553
2 -0.103219  0.410599  0.144044  1.454274 -1.420018
3  0.761038  0.121675  0.443863  0.333674 -1.706270
7  1.532779  1.469359  0.154947  0.378163  1.950775
9  1.230291  1.202380 -0.387327 -0.302303 -0.509652

La descrizione di questa nuova funzionalità quando è stata introdotta per la prima volta è disponibile qui .

Sembra che nelle recenti versioni di Pandas la strada da percorrere sia usare df.assign :

df1 = df1.assign(e=np.random.randn(sLength))

Non produce SettingWithCopyWarning.

Farlo direttamente tramite NumPy sarà il più efficiente:

df1['e'] = np.random.randn(sLength)

Nota il mio suggerimento originale (molto vecchio) era di usare map(che è molto più lento):

df1['e'] = df1['a'].map(lambda x: np.random.random())

Assegnazione di colonne super semplice

Un frame di dati panda è implementato come un ordine ordinato di colonne.

Ciò significa che __getitem__ []non può essere utilizzato solo per ottenere una determinata colonna, ma __setitem__ [] =può essere utilizzato per assegnare una nuova colonna.

Ad esempio, questo frame di dati può avere una colonna aggiunta semplicemente usando l' []accessor

    size      name color
0    big      rose   red
1  small    violet  blue
2  small     tulip   red
3  small  harebell  blue

df['protected'] = ['no', 'no', 'no', 'yes']

    size      name color protected
0    big      rose   red        no
1  small    violet  blue        no
2  small     tulip   red        no
3  small  harebell  blue       yes

Si noti che funziona anche se l'indice del frame di dati è disattivato.

df.index = [3,2,1,0]
df['protected'] = ['no', 'no', 'no', 'yes']
    size      name color protected
3    big      rose   red        no
2  small    violet  blue        no
1  small     tulip   red        no
0  small  harebell  blue       yes

[] = è la strada da percorrere, ma attenzione!

Tuttavia, se si dispone di un pd.Seriese si tenta di assegnarlo a un frame di dati in cui gli indici sono disattivati, si verificherà un problema. Vedi esempio:

df['protected'] = pd.Series(['no', 'no', 'no', 'yes'])
    size      name color protected
3    big      rose   red       yes
2  small    violet  blue        no
1  small     tulip   red        no
0  small  harebell  blue        no

Questo perché a pd.Seriesdi default ha un indice elencato da 0 a n. E il [] =metodo panda cerca di essere "intelligente"

Cosa sta realmente succedendo.

Quando si utilizza il [] = metodo panda esegue silenziosamente un join esterno o unione esterna utilizzando l'indice del frame di dati sinistro e l'indice delle serie di destra.df['column'] = series

Nota a margine

Ciò provoca rapidamente dissonanza cognitiva, poiché il []=metodo sta cercando di fare molte cose diverse a seconda dell'input e il risultato non può essere previsto a meno che non si sappia semplicemente come funzionano i panda. Vorrei quindi sconsigliare le []=basi di codice in, ma quando si esplorano i dati in un notebook, va bene.

Aggirare il problema

Se hai un pd.Seriese lo desideri assegnato dall'alto verso il basso, o se stai codificando un codice produttivo e non sei sicuro dell'ordine dell'indice, vale la pena salvaguardarlo per questo tipo di problema.

È possibile pd.Serieseseguire il downcast di a np.ndarrayo a list, questo farà il trucco.

df['protected'] = pd.Series(['no', 'no', 'no', 'yes']).values

o

df['protected'] = list(pd.Series(['no', 'no', 'no', 'yes']))

Ma questo non è molto esplicito.

Alcuni programmatori potrebbero arrivare e dire "Ehi, sembra ridondante, lo ottimizzerò semplicemente".

Modo esplicito

L'impostazione dell'indice di pd.Seriescome indice di dfè esplicita.

df['protected'] = pd.Series(['no', 'no', 'no', 'yes'], index=df.index)

O più realisticamente, probabilmente ne hai pd.Seriesgià uno disponibile.

protected_series = pd.Series(['no', 'no', 'no', 'yes'])
protected_series.index = df.index

3     no
2     no
1     no
0    yes

Ora può essere assegnato

df['protected'] = protected_series

    size      name color protected
3    big      rose   red        no
2  small    violet  blue        no
1  small     tulip   red        no
0  small  harebell  blue       yes

Modo alternativo con df.reset_index()

Poiché la dissonanza dell'indice è il problema, se ritieni che l'indice del frame di dati non debba dettare le cose, puoi semplicemente rilasciare l'indice, questo dovrebbe essere più veloce, ma non è molto pulito, poiché la tua funzione ora probabilmente fa due cose.

df.reset_index(drop=True)
protected_series.reset_index(drop=True)
df['protected'] = protected_series

    size      name color protected
0    big      rose   red        no
1  small    violet  blue        no
2  small     tulip   red        no
3  small  harebell  blue       yes

Nota su df.assign

Mentre df.assignrendi più esplicito ciò che stai facendo, in realtà ha tutti gli stessi problemi di cui sopra[]=

df.assign(protected=pd.Series(['no', 'no', 'no', 'yes']))
    size      name color protected
3    big      rose   red       yes
2  small    violet  blue        no
1  small     tulip   red        no
0  small  harebell  blue        no

Fai attenzione a df.assignche la tua colonna non viene chiamata self. Causerà errori. Questo rende df.assign puzzolente , dal momento che ci sono questo tipo di artefatti nella funzione.

df.assign(self=pd.Series(['no', 'no', 'no', 'yes'])
TypeError: assign() got multiple values for keyword argument 'self'

Potresti dire "Bene, non userò selfallora". Ma chissà come questa funzione cambierà in futuro per supportare nuovi argomenti. Forse il nome della tua colonna sarà un argomento in un nuovo aggiornamento di Panda, causando problemi con l'aggiornamento.

Modi più semplici: -

data['new_col'] = list_of_values

data.loc[ : , 'new_col'] = list_of_values

In questo modo si evita ciò che viene chiamato indicizzazione concatenata quando si impostano nuovi valori in un oggetto Panda. Clicca qui per leggere più lontano .

Se si desidera impostare l'intera nuova colonna su un valore di base iniziale (ad es None ), Puoi farlo:df1['e'] = None

Questo in realtà assegnerebbe il tipo di "oggetto" alla cella. Quindi in seguito sei libero di inserire tipi di dati complessi, come l'elenco, in singole celle.

Ho avuto il temuto SettingWithCopyWarning, e non è stato risolto usando la sintassi iloc. Il mio DataFrame è stato creato da read_sql da un'origine ODBC. Utilizzando un suggerimento di Lowtech sopra, per me ha funzionato:

df.insert(len(df.columns), 'e', pd.Series(np.random.randn(sLength),  index=df.index))

Questo ha funzionato bene per inserire la colonna alla fine. Non so se sia il più efficiente, ma non mi piacciono i messaggi di avviso. Penso che ci sia una soluzione migliore, ma non riesco a trovarla e penso che dipenda da alcuni aspetti dell'indice.
Nota . Che questo funzioni solo una volta e fornirà un messaggio di errore se si tenta di sovrascrivere e la colonna esistente.
Nota Come sopra e da 0.16.0 assegnare è la soluzione migliore. Vedere la documentazione http://pandas.pydata.org/pandas-docs/stable/generated/pandas.DataFrame.assign.html#pandas.DataFrame.assign Funziona bene per il tipo di flusso di dati in cui non si sovrascrive i valori intermedi.

1. Per prima cosa crea un pitone list_of_econ dati rilevanti.
2. Usa questo: df['e'] = list_of_e

Se la colonna che stai tentando di aggiungere è una variabile di serie, allora:

df["new_columns_name"]=series_variable_name #this will do it for you

Funziona bene anche se stai sostituendo una colonna esistente. Basta digitare new_columns_name come la colonna che vuoi sostituire. Sovrascriverà semplicemente i dati della colonna esistente con i dati della nuova serie.

Se il frame di dati e l'oggetto Series hanno lo stesso indice , pandas.concatfunziona anche qui:

import pandas as pd
df
#          a            b           c           d
#0  0.671399     0.101208   -0.181532    0.241273
#1  0.446172    -0.243316    0.051767    1.577318
#2  0.614758     0.075793   -0.451460   -0.012493

e = pd.Series([-0.335485, -1.166658, -0.385571])    
e
#0   -0.335485
#1   -1.166658
#2   -0.385571
#dtype: float64

# here we need to give the series object a name which converts to the new  column name 
# in the result
df = pd.concat([df, e.rename("e")], axis=1)
df

#          a            b           c           d           e
#0  0.671399     0.101208   -0.181532    0.241273   -0.335485
#1  0.446172    -0.243316    0.051767    1.577318   -1.166658
#2  0.614758     0.075793   -0.451460   -0.012493   -0.385571

Nel caso in cui non abbiano lo stesso indice:

e.index = df.index
df = pd.concat([df, e.rename("e")], axis=1)

Infallibile:

df.loc[:, 'NewCol'] = 'New_Val'

Esempio:

df = pd.DataFrame(data=np.random.randn(20, 4), columns=['A', 'B', 'C', 'D'])

df

           A         B         C         D
0  -0.761269  0.477348  1.170614  0.752714
1   1.217250 -0.930860 -0.769324 -0.408642
2  -0.619679 -1.227659 -0.259135  1.700294
3  -0.147354  0.778707  0.479145  2.284143
4  -0.529529  0.000571  0.913779  1.395894
5   2.592400  0.637253  1.441096 -0.631468
6   0.757178  0.240012 -0.553820  1.177202
7  -0.986128 -1.313843  0.788589 -0.707836
8   0.606985 -2.232903 -1.358107 -2.855494
9  -0.692013  0.671866  1.179466 -1.180351
10 -1.093707 -0.530600  0.182926 -1.296494
11 -0.143273 -0.503199 -1.328728  0.610552
12 -0.923110 -1.365890 -1.366202 -1.185999
13 -2.026832  0.273593 -0.440426 -0.627423
14 -0.054503 -0.788866 -0.228088 -0.404783
15  0.955298 -1.430019  1.434071 -0.088215
16 -0.227946  0.047462  0.373573 -0.111675
17  1.627912  0.043611  1.743403 -0.012714
18  0.693458  0.144327  0.329500 -0.655045
19  0.104425  0.037412  0.450598 -0.923387


df.drop([3, 5, 8, 10, 18], inplace=True)

df

           A         B         C         D
0  -0.761269  0.477348  1.170614  0.752714
1   1.217250 -0.930860 -0.769324 -0.408642
2  -0.619679 -1.227659 -0.259135  1.700294
4  -0.529529  0.000571  0.913779  1.395894
6   0.757178  0.240012 -0.553820  1.177202
7  -0.986128 -1.313843  0.788589 -0.707836
9  -0.692013  0.671866  1.179466 -1.180351
11 -0.143273 -0.503199 -1.328728  0.610552
12 -0.923110 -1.365890 -1.366202 -1.185999
13 -2.026832  0.273593 -0.440426 -0.627423
14 -0.054503 -0.788866 -0.228088 -0.404783
15  0.955298 -1.430019  1.434071 -0.088215
16 -0.227946  0.047462  0.373573 -0.111675
17  1.627912  0.043611  1.743403 -0.012714
19  0.104425  0.037412  0.450598 -0.923387

df.loc[:, 'NewCol'] = 0

df
           A         B         C         D  NewCol
0  -0.761269  0.477348  1.170614  0.752714       0
1   1.217250 -0.930860 -0.769324 -0.408642       0
2  -0.619679 -1.227659 -0.259135  1.700294       0
4  -0.529529  0.000571  0.913779  1.395894       0
6   0.757178  0.240012 -0.553820  1.177202       0
7  -0.986128 -1.313843  0.788589 -0.707836       0
9  -0.692013  0.671866  1.179466 -1.180351       0
11 -0.143273 -0.503199 -1.328728  0.610552       0
12 -0.923110 -1.365890 -1.366202 -1.185999       0
13 -2.026832  0.273593 -0.440426 -0.627423       0
14 -0.054503 -0.788866 -0.228088 -0.404783       0
15  0.955298 -1.430019  1.434071 -0.088215       0
16 -0.227946  0.047462  0.373573 -0.111675       0
17  1.627912  0.043611  1.743403 -0.012714       0
19  0.104425  0.037412  0.450598 -0.923387       0

Vorrei solo aggiungere che, proprio come per Hum3 , .locnon ho risolto il problema SettingWithCopyWarninge ho dovuto ricorrere a df.insert(). Nel mio caso, i falsi positivi sono stati generati dall'indicizzazione di catene "false" dict['a']['e'], dove si 'e'trova la nuova colonna, edict['a'] è un DataFrame proveniente dal dizionario.

Si noti inoltre che se si sa cosa si sta facendo, è possibile cambiare l'avviso utilizzando pd.options.mode.chained_assignment = None e che utilizzare una delle altre soluzioni fornite qui.

per inserire una nuova colonna in una determinata posizione (0 <= loc <= quantità di colonne) in un frame di dati, basta usare Dataframe.insert:

DataFrame.insert(loc, column, value)

Pertanto, se si desidera aggiungere la colonna e alla fine di un frame di dati chiamato df , è possibile utilizzare:

e = [-0.335485, -1.166658, -0.385571]    
DataFrame.insert(loc=len(df.columns), column='e', value=e)

il valore può essere una serie, un numero intero (nel qual caso tutte le celle vengono riempite con questo valore unico) o una struttura simile a matrice

https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.DataFrame.insert.html

Prima di assegnare una nuova colonna, se si dispone di dati indicizzati, è necessario ordinare l'indice. Almeno nel mio caso ho dovuto:

data.set_index(['index_column'], inplace=True)
"if index is unsorted, assignment of a new column will fail"        
data.sort_index(inplace = True)
data.loc['index_value1', 'column_y'] = np.random.randn(data.loc['index_value1', 'column_x'].shape[0])

Una cosa da notare, tuttavia, è che se lo fai

df1['e'] = Series(np.random.randn(sLength), index=df1.index)

questo sarà effettivamente un join sinistro su df1.index. Quindi, se vuoi avere un effetto di join esterno , la mia soluzione probabilmente imperfetta è quella di creare un frame di dati con valori di indice che coprono l'universo dei tuoi dati e quindi utilizzare il codice sopra. Per esempio,

data = pd.DataFrame(index=all_possible_values)
df1['e'] = Series(np.random.randn(sLength), index=df1.index)

Stavo cercando un modo generale per aggiungere una colonna di numpy.nans a un frame di dati senza ottenere lo stupido SettingWithCopyWarning.

Da quanto segue:

• le risposte qui
• questa domanda sul passaggio di una variabile come argomento della parola chiave
• questo metodo per generare un numpyarray di NaN in linea

Ho pensato a questo:

col = 'column_name'
df = df.assign(**{col:numpy.full(len(df), numpy.nan)})

Per aggiungere una nuova colonna, "e", al frame di dati esistente

 df1.loc[:,'e'] = Series(np.random.randn(sLength))

Per completezza - ancora un'altra soluzione che utilizza il metodo DataFrame.eval () :

Dati:

In [44]: e
Out[44]:
0    1.225506
1   -1.033944
2   -0.498953
3   -0.373332
4    0.615030
5   -0.622436
dtype: float64

In [45]: df1
Out[45]:
          a         b         c         d
0 -0.634222 -0.103264  0.745069  0.801288
4  0.782387 -0.090279  0.757662 -0.602408
5 -0.117456  2.124496  1.057301  0.765466
7  0.767532  0.104304 -0.586850  1.051297
8 -0.103272  0.958334  1.163092  1.182315
9 -0.616254  0.296678 -0.112027  0.679112

Soluzione:

In [46]: df1.eval("e = @e.values", inplace=True)

In [47]: df1
Out[47]:
          a         b         c         d         e
0 -0.634222 -0.103264  0.745069  0.801288  1.225506
4  0.782387 -0.090279  0.757662 -0.602408 -1.033944
5 -0.117456  2.124496  1.057301  0.765466 -0.498953
7  0.767532  0.104304 -0.586850  1.051297 -0.373332
8 -0.103272  0.958334  1.163092  1.182315  0.615030
9 -0.616254  0.296678 -0.112027  0.679112 -0.622436

Per creare una colonna vuota

df['i'] = None

Quello che ho fatto è quello che ho fatto ... Ma sono abbastanza nuovo per i panda e davvero Python in generale, quindi nessuna promessa.

df = pd.DataFrame([[1, 2], [3, 4], [5,6]], columns=list('AB'))

newCol = [3,5,7]
newName = 'C'

values = np.insert(df.values,df.shape[1],newCol,axis=1)
header = df.columns.values.tolist()
header.append(newName)

df = pd.DataFrame(values,columns=header)

In questo caso SettingWithCopyWarning, una soluzione semplice consiste nel copiare il DataFrame a cui stai tentando di aggiungere una colonna.

df = df.copy()
df['col_name'] = values