Imposta il valore per una particolare cella in Panda DataFrame usando index

Ho creato un Pandas DataFrame

df = DataFrame(index=['A','B','C'], columns=['x','y'])

e ottenuto questo

    xy
A NaN NaN
B NaN NaN
C NaN NaN

Quindi desidero assegnare un valore a una cella particolare, ad esempio per la riga 'C' e la colonna 'x'. Mi aspettavo di ottenere questo risultato:

    xy
A NaN NaN
B NaN NaN
C 10 NaN

con questo codice:

df.xs('C')['x'] = 10

ma i contenuti di dfnon sono cambiati. È di nuovo solo NaNin DataFrame.

Eventuali suggerimenti?

La risposta di RukTech , df.set_value('C', 'x', 10), è di gran lunga più veloce rispetto alle opzioni che ho suggerito di seguito. Tuttavia, è stato programmato per la deprecazione .

Andando avanti, il metodo raccomandato è.iat/.at .

Perché df.xs('C')['x']=10non funziona:

df.xs('C')per impostazione predefinita, restituisce un nuovo frame di dati con una copia dei dati, quindi

df.xs('C')['x']=10

modifica solo questo nuovo frame di dati.

df['x']restituisce una vista del dfframe di dati, quindi

df['x']['C'] = 10

si modifica da dfsolo.

Avviso : a volte è difficile prevedere se un'operazione restituisce una copia o una vista. Per questo motivo i documenti raccomandano di evitare assegnazioni con "indicizzazione concatenata" .

Quindi l'alternativa consigliata è

df.at['C', 'x'] = 10

che non modifica df.

In [18]: %timeit df.set_value('C', 'x', 10)
100000 loops, best of 3: 2.9 µs per loop

In [20]: %timeit df['x']['C'] = 10
100000 loops, best of 3: 6.31 µs per loop

In [81]: %timeit df.at['C', 'x'] = 10
100000 loops, best of 3: 9.2 µs per loop

Aggiornamento: il .set_valuemetodo sarà obsoleto . .iat/.atsono buoni sostituti, purtroppo i panda forniscono poca documentazione

Il modo più veloce per farlo è usare set_value . Questo metodo è ~ 100 volte più veloce del .ixmetodo. Per esempio:

df.set_value('C', 'x', 10)

Puoi anche usare una ricerca condizionale usando .loccome visto qui:

df.loc[df[<some_column_name>] == <condition>, [<another_column_name>]] = <value_to_add>

dove si <some_column_nametrova la colonna in cui si desidera verificare la <condition>variabile ed <another_column_name>è la colonna che si desidera aggiungere (può essere una nuova colonna o una già esistente). <value_to_add>è il valore che desideri aggiungere a quella colonna / riga.

Questo esempio non funziona esattamente con la domanda a portata di mano, ma potrebbe essere utile per qualcuno che desidera aggiungere un valore specifico basato su una condizione.

Il modo consigliato (secondo i manutentori) di impostare un valore è:

df.ix['x','C']=10

L'uso di "indicizzazione concatenata" ( df['x']['C']) può causare problemi.

Vedere:

• https://stackoverflow.com/a/21287235/1579844
• http://pandas.pydata.org/pandas-docs/dev/indexing.html#indexing-view-versus-copy
• https://github.com/pydata/pandas/pull/6031

Prova a usare df.loc[row_index,col_indexer] = value

Questa è l'unica cosa che ha funzionato per me!

df.loc['C', 'x'] = 10

Ulteriori informazioni .loc qui .

.iat/.atè la buona soluzione. Supponendo di avere questo semplice frame_dati:

   A   B   C
0  1   8   4 
1  3   9   6
2  22 33  52

se vogliamo modificare il valore della cella [0,"A"]puoi usare una di quelle soluzioni:

1. df.iat[0,0] = 2
2. df.at[0,'A'] = 2

Ed ecco un esempio completo su come usare iatper ottenere e impostare un valore di cella:

def prepossessing(df):
  for index in range(0,len(df)): 
      df.iat[index,0] = df.iat[index,0] * 2
  return df

y_train prima:

    0
0   54
1   15
2   15
3   8
4   31
5   63
6   11

y_train dopo aver chiamato la funzione di pre-acquisizione che iatper cambiare per moltiplicare il valore di ogni cella per 2:

     0
0   108
1   30
2   30
3   16
4   62
5   126
6   22

Per impostare i valori, utilizzare:

df.at[0, 'clm1'] = 0

• Il metodo consigliato più veloce per impostare le variabili.
• set_value, ixsono stati deprecati.
• Nessun avvertimento, a differenza di iloceloc

puoi usare .iloc.

df.iloc[[2], [0]] = 10

Nel mio esempio, lo cambio nella cella selezionata

    for index, row in result.iterrows():
        if np.isnan(row['weight']):
            result.at[index, 'weight'] = 0.0

'risultato' è un campo dati con colonna 'peso'

set_value() è deprecato.

A partire dalla versione 0.23.4, Pandas " annuncia il futuro " ...

>>> df
                   Cars  Prices (U$)
0               Audi TT        120.0
1 Lamborghini Aventador        245.0
2      Chevrolet Malibu        190.0
>>> df.set_value(2, 'Prices (U$)', 240.0)
__main__:1: FutureWarning: set_value is deprecated and will be removed in a future release.
Please use .at[] or .iat[] accessors instead

                   Cars  Prices (U$)
0               Audi TT        120.0
1 Lamborghini Aventador        245.0
2      Chevrolet Malibu        240.0

Considerando questo consiglio, ecco una dimostrazione di come usarli:

• per posizioni intere di riga / colonna

>>> df.iat[1, 1] = 260.0
>>> df
                   Cars  Prices (U$)
0               Audi TT        120.0
1 Lamborghini Aventador        260.0
2      Chevrolet Malibu        240.0

• per etichette di riga / colonna

>>> df.at[2, "Cars"] = "Chevrolet Corvette"
>>> df
                  Cars  Prices (U$)
0               Audi TT        120.0
1 Lamborghini Aventador        260.0
2    Chevrolet Corvette        240.0

Riferimenti:

• pandas.DataFrame.iat
• pandas.DataFrame.at

Ecco un riepilogo delle soluzioni valide fornite da tutti gli utenti, per i frame di dati indicizzati da numero intero e stringa.

df.iloc, df.loc e df.at funzionano per entrambi i tipi di frame di dati, df.iloc funziona solo con indici interi di riga / colonna, df.loc e df.at supporta l'impostazione di valori usando nomi di colonne e / o indici interi .

Quando l'indice specificato non esiste, sia df.loc che df.at aggiungerebbero le righe / colonne appena inserite al frame di dati esistente, ma df.iloc genererebbe "IndexError: gli indicizzatori di posizione sono fuori limite". Un esempio funzionante testato in Python 2.7 e 3.7 è il seguente:

import numpy as np, pandas as pd

df1 = pd.DataFrame(index=np.arange(3), columns=['x','y','z'])
df1['x'] = ['A','B','C']
df1.at[2,'y'] = 400

# rows/columns specified does not exist, appends new rows/columns to existing data frame
df1.at['D','w'] = 9000
df1.loc['E','q'] = 499

# using df[<some_column_name>] == <condition> to retrieve target rows
df1.at[df1['x']=='B', 'y'] = 10000
df1.loc[df1['x']=='B', ['z','w']] = 10000

# using a list of index to setup values
df1.iloc[[1,2,4], 2] = 9999
df1.loc[[0,'D','E'],'w'] = 7500
df1.at[[0,2,"D"],'x'] = 10
df1.at[:, ['y', 'w']] = 8000

df1
>>> df1
     x     y     z     w      q
0   10  8000   NaN  8000    NaN
1    B  8000  9999  8000    NaN
2   10  8000  9999  8000    NaN
D   10  8000   NaN  8000    NaN
E  NaN  8000  9999  8000  499.0

Ho testato e l'output è un df.set_valuepo 'più veloce, ma il metodo ufficiale df.atsembra il modo più veloce non deprecato per farlo.

import numpy as np
import pandas as pd

df = pd.DataFrame(np.random.rand(100, 100))

%timeit df.iat[50,50]=50 # ✓
%timeit df.at[50,50]=50 #  ✔
%timeit df.set_value(50,50,50) # will deprecate
%timeit df.iloc[50,50]=50
%timeit df.loc[50,50]=50

7.06 µs ± 118 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)
5.52 µs ± 64.2 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)
3.68 µs ± 80.8 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)
98.7 µs ± 1.07 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)
109 µs ± 1.42 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)

Nota che si sta impostando il valore per una singola cella. Per i vettori loce ilocdovrebbero essere opzioni migliori poiché sono vettorializzate.

Un modo per utilizzare l'indice con condizione è innanzitutto ottenere l'indice di tutte le righe che soddisfano la propria condizione e quindi semplicemente utilizzare tali indici di riga in più modi

conditional_index = df.loc[ df['col name'] <condition> ].index

La condizione di esempio è simile

==5, >10 , =="Any string", >= DateTime

Quindi è possibile utilizzare questi indici di riga in vari modi come

1. Sostituisci il valore di una colonna per conditional_index

df.loc[conditional_index , [col name]]= <new value>

2. Sostituisci il valore di più colonne per conditional_index

df.loc[conditional_index, [col1,col2]]= <new value>

3. Un vantaggio con il salvataggio di conditional_index è che è possibile assegnare il valore di una colonna a un'altra colonna con lo stesso indice di riga

df.loc[conditional_index, [col1,col2]]= df.loc[conditional_index,'col name']

Tutto ciò è possibile perché .index restituisce una matrice di indice che .loc può utilizzare con l'indirizzamento diretto in modo da evitare ripetutamente gli attraversamenti.

df.loc['c','x']=10 Questo cambierà il valore di c esima riga e x esima colonna.

Oltre alle risposte di cui sopra, ecco un benchmark che confronta diversi modi per aggiungere righe di dati a un frame di dati già esistente. Mostra che l'utilizzo di at o set-value è il modo più efficiente per grandi frame di dati (almeno per queste condizioni di test).

• Crea un nuovo frame di dati per ogni riga e ...
  • ... aggiungilo (13.0 s)
  • ... concatenalo (13.1 s)
• Archivia prima tutte le nuove righe in un altro contenitore, converti una volta in un nuovo frame di dati e aggiungi ...
  • container = elenchi di elenchi (2.0 s)
  • container = dizionario degli elenchi (1.9 s)
• Preallocare l'intero frame di dati, scorrere su nuove righe e tutte le colonne e riempire usando
  • ... a (0,6 s)
  • ... set_value (0.4 s)

Per il test, è stato utilizzato un frame di dati esistente comprendente 100.000 righe e 1.000 colonne e valori casuali numpy. A questo frame di dati sono state aggiunte 100 nuove righe.

Codice vedi sotto:

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Wed Nov 21 16:38:46 2018

@author: gebbissimo
"""

import pandas as pd
import numpy as np
import time

NUM_ROWS = 100000
NUM_COLS = 1000
data = np.random.rand(NUM_ROWS,NUM_COLS)
df = pd.DataFrame(data)

NUM_ROWS_NEW = 100
data_tot = np.random.rand(NUM_ROWS + NUM_ROWS_NEW,NUM_COLS)
df_tot = pd.DataFrame(data_tot)

DATA_NEW = np.random.rand(1,NUM_COLS)


#%% FUNCTIONS

# create and append
def create_and_append(df):
    for i in range(NUM_ROWS_NEW):
        df_new = pd.DataFrame(DATA_NEW)
        df = df.append(df_new)
    return df

# create and concatenate
def create_and_concat(df):
    for i in range(NUM_ROWS_NEW):
        df_new = pd.DataFrame(DATA_NEW)
        df = pd.concat((df, df_new))
    return df


# store as dict and 
def store_as_list(df):
    lst = [[] for i in range(NUM_ROWS_NEW)]
    for i in range(NUM_ROWS_NEW):
        for j in range(NUM_COLS):
            lst[i].append(DATA_NEW[0,j])
    df_new = pd.DataFrame(lst)
    df_tot = df.append(df_new)
    return df_tot

# store as dict and 
def store_as_dict(df):
    dct = {}
    for j in range(NUM_COLS):
        dct[j] = []
        for i in range(NUM_ROWS_NEW):
            dct[j].append(DATA_NEW[0,j])
    df_new = pd.DataFrame(dct)
    df_tot = df.append(df_new)
    return df_tot




# preallocate and fill using .at
def fill_using_at(df):
    for i in range(NUM_ROWS_NEW):
        for j in range(NUM_COLS):
            #print("i,j={},{}".format(i,j))
            df.at[NUM_ROWS+i,j] = DATA_NEW[0,j]
    return df


# preallocate and fill using .at
def fill_using_set(df):
    for i in range(NUM_ROWS_NEW):
        for j in range(NUM_COLS):
            #print("i,j={},{}".format(i,j))
            df.set_value(NUM_ROWS+i,j,DATA_NEW[0,j])
    return df


#%% TESTS
t0 = time.time()    
create_and_append(df)
t1 = time.time()
print('Needed {} seconds'.format(t1-t0))

t0 = time.time()    
create_and_concat(df)
t1 = time.time()
print('Needed {} seconds'.format(t1-t0))

t0 = time.time()    
store_as_list(df)
t1 = time.time()
print('Needed {} seconds'.format(t1-t0))

t0 = time.time()    
store_as_dict(df)
t1 = time.time()
print('Needed {} seconds'.format(t1-t0))

t0 = time.time()    
fill_using_at(df_tot)
t1 = time.time()
print('Needed {} seconds'.format(t1-t0))

t0 = time.time()    
fill_using_set(df_tot)
t1 = time.time()
print('Needed {} seconds'.format(t1-t0))

Se si desidera modificare i valori non per l'intera riga, ma solo per alcune colonne:

x = pd.DataFrame({'A': [1, 2, 3], 'B': [4, 5, 6]})
x.iloc[1] = dict(A=10, B=-10)

Dalla versione 0.21.1 puoi anche usare il .atmetodo. Ci sono alcune differenze rispetto a .locquelle menzionate qui - panda .at contro .loc , ma è più veloce sulla sostituzione di un singolo valore

Quindi, la tua domanda per convertire NaN a ['x', C] in valore 10

la risposta è..

df['x'].loc['C':]=10
df

codice alternativo è

df.loc['C':'x']=10
df

Anch'io stavo cercando questo argomento e ho messo insieme un modo per scorrere un DataFrame e aggiornarlo con i valori di ricerca di un secondo DataFrame. Ecco il mio codice

src_df = pd.read_sql_query(src_sql,src_connection)
for index1, row1 in src_df.iterrows():
    for index, row in vertical_df.iterrows():
        src_df.set_value(index=index1,col=u'etl_load_key',value=etl_load_key)
        if (row1[u'src_id'] == row['SRC_ID']) is True:
            src_df.set_value(index=index1,col=u'vertical',value=row['VERTICAL'])