Tetapkan nilai untuk sel tertentu dalam panda DataFrame menggunakan indeks

Saya telah membuat DataFrame Pandas

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

dan dapatkan ini

    xy
A NaN NaN
B NaN NaN
C NaN NaN

Lalu saya ingin memberikan nilai ke sel tertentu, misalnya untuk baris 'C' dan kolom 'x'. Saya berharap mendapatkan hasil seperti itu:

    xy
A NaN NaN
B NaN NaN
C 10 NaN

dengan kode ini:

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

tapi isinya dfbelum berubah. Lagi-lagi hanya ada NaNdi DataFrame.

Ada saran?

Jawaban RukTech ini , df.set_value('C', 'x', 10)adalah jauh dan jauh lebih cepat daripada pilihan saya disarankan di bawah ini. Namun, telah dijadwalkan untuk penghentian .

Ke depan, metode yang disarankan adalah.iat/.at .

Mengapa df.xs('C')['x']=10tidak berfungsi:

df.xs('C')secara default, mengembalikan bingkai data baru dengan salinan data, jadi

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

memodifikasi kerangka data baru ini saja.

df['x']mengembalikan tampilan dari dfkerangka data, jadi

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

memodifikasi dfsendiri.

Peringatan : Terkadang sulit untuk memprediksi apakah suatu operasi mengembalikan salinan atau tampilan. Untuk alasan ini, dokumen merekomendasikan menghindari tugas dengan "pengindeksan berantai" .

Jadi alternatif yang disarankan adalah

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

yang tidak memodifikasi 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

Pembaruan: .set_valueMetode ini akan ditinggalkan . .iat/.atadalah pengganti yang bagus, sayangnya panda menyediakan sedikit dokumentasi

Cara tercepat untuk melakukan ini adalah menggunakan set_value . Metode ini ~ 100 kali lebih cepat dari .ixmetode. Sebagai contoh:

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

Anda juga dapat menggunakan pencarian bersyarat menggunakan .locseperti yang terlihat di sini:

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

di mana <some_column_namekolom yang ingin Anda periksa <condition>variabelnya dan <another_column_name>merupakan kolom yang ingin Anda tambahkan (bisa berupa kolom baru atau yang sudah ada). <value_to_add>adalah nilai yang ingin Anda tambahkan ke kolom / baris itu.

Contoh ini tidak bekerja secara tepat dengan pertanyaan yang ada, tetapi mungkin berguna bagi seseorang yang ingin menambahkan nilai tertentu berdasarkan suatu kondisi.

Cara yang disarankan (menurut pengelola) untuk menetapkan nilai adalah:

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

Menggunakan 'pengindeksan berantai' ( df['x']['C']) dapat menyebabkan masalah.

Lihat:

• 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

Coba gunakan df.loc[row_index,col_indexer] = value

Ini adalah satu-satunya hal yang berhasil untuk saya!

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

Pelajari lebih lanjut di .loc sini .

.iat/.atadalah solusi yang bagus. Andaikata Anda memiliki data_frame sederhana ini:

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

jika kita ingin memodifikasi nilai sel, kita [0,"A"]dapat menggunakan salah satu dari solusi tersebut:

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

Dan berikut ini adalah contoh lengkap cara menggunakan iatuntuk mendapatkan dan menetapkan nilai sel:

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

y_train sebelumnya:

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

y_train setelah memanggil fungsi prepossessing yang iatakan diubah untuk mengalikan nilai setiap sel dengan 2:

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

Untuk menetapkan nilai, gunakan:

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

• Metode tercepat yang disarankan untuk pengaturan variabel.
• set_value, ixtelah ditinggalkan.
• Tidak ada peringatan, tidak seperti ilocdanloc

Anda dapat menggunakan .iloc.

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

Dalam contoh saya, saya hanya mengubahnya di sel yang dipilih

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

'result' adalah dataField dengan kolom 'weight'

set_value() sudah ditinggalkan.

Mulai dari rilis 0.23.4, Pandas " mengumumkan masa depan " ...

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

Mempertimbangkan saran ini, berikut ini adalah demonstrasi cara menggunakannya:

• menurut posisi integer baris / kolom

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

• dengan label baris / kolom

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

Referensi:

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

Berikut ini adalah ringkasan dari solusi valid yang disediakan oleh semua pengguna, untuk frame data yang diindeks oleh integer dan string.

df.iloc, df.loc dan df.at bekerja untuk kedua jenis frame data, df.iloc hanya bekerja dengan indeks integer baris / kolom, df.loc dan df.at mendukung untuk menetapkan nilai menggunakan nama kolom dan / atau indeks integer .

Ketika indeks yang ditentukan tidak ada, baik df.loc dan df.at akan menambahkan baris / kolom yang baru disisipkan ke bingkai data yang ada, tetapi df.iloc akan menaikkan "IndexError: pengindeksional posisi berada di luar batas". Contoh kerja yang diuji dengan Python 2.7 dan 3.7 adalah sebagai berikut:

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

Saya menguji dan hasilnya df.set_valuesedikit lebih cepat, tetapi metode resmi df.atsepertinya cara tercepat yang tidak ketinggalan untuk melakukannya.

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)

Perhatikan ini mengatur nilai untuk sel tunggal. Untuk vektor locdan ilocharus menjadi pilihan yang lebih baik karena vektor.

Salah satu cara untuk menggunakan indeks dengan kondisi adalah pertama-tama dapatkan indeks dari semua baris yang memenuhi kondisi Anda dan kemudian cukup gunakan indeks baris itu dalam berbagai cara

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

Contoh kondisi seperti

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

Kemudian Anda dapat menggunakan indeks baris ini dalam berbagai cara seperti

1. Ganti nilai satu kolom untuk conditional_index

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

2. Ganti nilai beberapa kolom untuk conditional_index

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

3. Satu manfaat dengan menyimpan conditional_index adalah Anda dapat menetapkan nilai satu kolom ke kolom lain dengan indeks baris yang sama

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

Ini semua dimungkinkan karena .index mengembalikan array indeks yang .loc dapat digunakan dengan pengalamatan langsung sehingga menghindari traversal lagi dan lagi.

df.loc['c','x']=10 Ini akan mengubah nilai dari baris ke- c dan kolom ke- x .

Selain jawaban di atas, berikut ini adalah tolok ukur yang membandingkan berbagai cara untuk menambahkan baris data ke kerangka data yang sudah ada. Ini menunjukkan bahwa menggunakan at atau set-value adalah cara yang paling efisien untuk kerangka data yang besar (setidaknya untuk kondisi pengujian ini).

• Buat kerangka data baru untuk setiap baris dan ...
  • ... tambahkan (13.0 dtk)
  • ... menyatukannya (13.1 dtk)
• Simpan semua baris baru dalam wadah lain terlebih dahulu, konversi ke kerangka data baru satu kali dan tambahkan ...
  • container = daftar daftar (2.0 dtk)
  • container = kamus daftar (1.9 s)
• Preallocate seluruh dataframe, iterate di atas baris baru dan semua kolom dan isi menggunakan
  • ... at (0,6 dtk)
  • ... set_value (0,4 s)

Untuk pengujian, digunakan kerangka data yang terdiri dari 100.000 baris dan 1.000 kolom dan nilai numpy acak. Untuk kerangka data ini, 100 baris baru ditambahkan.

Kode lihat di bawah:

#!/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))

Jika Anda ingin mengubah nilai bukan untuk seluruh baris, tetapi hanya untuk beberapa kolom:

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

Dari versi 0.21.1 Anda juga dapat menggunakan .atmetode. Ada beberapa perbedaan dibandingkan dengan yang .locdisebutkan di sini - panda. Pada versus .loc , tetapi lebih cepat pada penggantian nilai tunggal

Soo, pertanyaan Anda untuk mengonversi NaN di ['x', C] ke nilai 10

jawabannya adalah..

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

kode alternatif adalah

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

Saya juga sedang mencari topik ini dan saya menyusun cara untuk beralih melalui DataFrame dan memperbaruinya dengan nilai pencarian dari DataFrame kedua. Ini kode saya.

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