กำหนดค่าสำหรับเซลล์เฉพาะใน pandas DataFrame โดยใช้ดัชนี

ฉันสร้าง Panda DataFrame แล้ว

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

และได้สิ่งนี้

    เซ็กซี่
A NaN NaN
B NaN NaN
C NaN NaN

จากนั้นฉันต้องการกำหนดค่าให้กับเซลล์เฉพาะเช่นแถว 'C' และคอลัมน์ 'x' ฉันคาดว่าจะได้รับผลลัพธ์เช่นนี้:

    เซ็กซี่
A NaN NaN
B NaN NaN
C 10 น่าน

ด้วยรหัสนี้:

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

แต่เนื้อหาของdfยังไม่ได้เปลี่ยน มันเป็นเพียงNaNใน DataFrame เท่านั้น

ข้อเสนอแนะใด ๆ

คำตอบของ RukTech , df.set_value('C', 'x', 10), อยู่ไกลออกไปได้เร็วขึ้นกว่าตัวเลือกที่ผมเคยแนะนำด้านล่าง แต่จะได้รับการกำหนดไว้สำหรับการเลิกใช้

ก้าวไปข้างหน้าในวิธีที่แนะนำคือ.iat/.at

ทำไมdf.xs('C')['x']=10ไม่ทำงาน:

df.xs('C')โดยค่าเริ่มต้นส่งคืน dataframe ใหม่พร้อมสำเนาของข้อมูลดังนั้น

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

แก้ไข dataframe ใหม่นี้เท่านั้น

df['x']ส่งคืนมุมมองของdfdataframe ดังนั้น

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

ปรับdfเปลี่ยนตัวเอง

คำเตือน : บางครั้งมันก็ยากที่จะทำนายว่าการดำเนินการส่งคืนสำเนาหรือมุมมอง ด้วยเหตุนี้เอกสารแนะนำให้หลีกเลี่ยงการมอบหมายงานด้วย "การจัดทำดัชนีที่ถูกล่ามโซ่"

ดังนั้นทางเลือกที่แนะนำคือ

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

ซึ่งไม่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

ปรับปรุงการ.set_valueวิธีการที่เป็นไปได้เลิก .iat/.atเป็นการทดแทนที่ดีน่าเสียดายที่แพนด้ามีเอกสารเล็กน้อย

วิธีที่เร็วที่สุดที่จะทำคือการใช้set_value วิธีนี้เร็วกว่า.ixวิธี100 เท่า ตัวอย่างเช่น:

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

คุณยังสามารถใช้การค้นหาแบบมีเงื่อนไขได้.locตามที่เห็นในที่นี้

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

โดยที่<some_column_nameเป็นคอลัมน์ที่คุณต้องการตรวจสอบ<condition>ตัวแปรและ<another_column_name>เป็นคอลัมน์ที่คุณต้องการเพิ่ม (สามารถเป็นคอลัมน์ใหม่หรือคอลัมน์ที่มีอยู่แล้ว) <value_to_add>คือค่าที่คุณต้องการเพิ่มลงในคอลัมน์ / แถวนั้น

ตัวอย่างนี้ใช้ไม่ได้กับคำถามในมือ แต่อาจมีประโยชน์สำหรับบางคนที่ต้องการเพิ่มค่าเฉพาะตามเงื่อนไข

วิธีที่แนะนำ (ตามผู้ดูแล) เพื่อตั้งค่าคือ:

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

การใช้ 'การจัดทำดัชนีที่ถูกโยง' ( df['x']['C']) อาจนำไปสู่ปัญหา

ดู:

• 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

ลองใช้ดู df.loc[row_index,col_indexer] = value

นี่เป็นสิ่งเดียวที่ใช้ได้สำหรับฉัน!

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

เรียนรู้เพิ่มเติมเกี่ยวกับที่นี่.loc

.iat/.atเป็นทางออกที่ดี สมมติว่าคุณมี data_frame ง่ายๆนี้:

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

หากเราต้องการแก้ไขค่าของเซลล์[0,"A"]u สามารถใช้หนึ่งในวิธีแก้ไขปัญหาเหล่านี้:

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

และนี่คือตัวอย่างที่สมบูรณ์เกี่ยวกับวิธีใช้iatในการรับและกำหนดค่าของเซลล์:

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

y_train ก่อน:

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

y_train หลังจากเรียกฟังก์ชั่น prepossessing ที่iatจะเปลี่ยนเป็นทวีคูณค่าของแต่ละเซลล์ด้วย 2:

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

ในการตั้งค่าใช้:

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

• วิธีที่เร็วที่สุดที่แนะนำสำหรับการตั้งค่าตัวแปร
• set_value, ixเลิกใช้แล้ว
• ไม่มีการเตือนแตกต่างจากilocและloc

.ilocคุณสามารถใช้

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

ในตัวอย่างของฉันฉันแค่เปลี่ยนมันในเซลล์ที่เลือก

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

'result' เป็น dataField ที่มีคอลัมน์ 'น้ำหนัก'

set_value() เลิกใช้แล้ว

เริ่มต้นจากการเปิดตัว 0.23.4 นุ่น " ประกาศอนาคต " ...

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

พิจารณาคำแนะนำนี้ต่อไปนี้เป็นตัวอย่างการใช้งาน:

• ตามตำแหน่งจำนวนเต็มแถว / คอลัมน์

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

• โดยป้ายชื่อแถว / คอลัมน์

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

อ้างอิง:

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

นี่คือบทสรุปของโซลูชันที่ถูกต้องที่จัดทำโดยผู้ใช้ทั้งหมดสำหรับเฟรมข้อมูลที่จัดทำดัชนีโดยจำนวนเต็มและสตริง

df.iloc, df.loc และ df.at ทำงานกับเฟรมข้อมูลทั้งสองชนิด, df.iloc ใช้ได้กับดัชนีแถว / คอลัมน์จำนวนเต็ม, df.loc และ df.at รองรับการตั้งค่าโดยใช้ชื่อคอลัมน์และ / หรือดัชนีจำนวนเต็ม .

เมื่อดัชนีที่ระบุไม่มีอยู่ทั้ง df.loc และ df.at จะผนวกแถว / คอลัมน์ที่แทรกใหม่ลงในเฟรมข้อมูลที่มีอยู่ แต่ df.iloc จะเพิ่ม "IndexError: ตำแหน่งดัชนีอยู่นอกขอบเขต" ตัวอย่างการทำงานที่ทดสอบใน Python 2.7 และ 3.7 มีดังนี้:

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

ฉันทดสอบแล้วและผลลัพธ์จะdf.set_valueเร็วขึ้นเล็กน้อย แต่วิธีการอย่างเป็นทางการdf.atดูเหมือนว่าวิธีที่เร็วที่สุดที่ไม่คัดค้านที่จะทำ

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)

หมายเหตุนี่เป็นการตั้งค่าสำหรับเซลล์เดียว สำหรับเวกเตอร์locและilocควรเป็นตัวเลือกที่ดีกว่าเนื่องจากมันถูกทำให้เป็นเวกเตอร์

วิธีหนึ่งในการใช้ดัชนีที่มีเงื่อนไขคือรับดัชนีของแถวทั้งหมดที่เป็นไปตามเงื่อนไขของคุณก่อนแล้วจึงใช้ดัชนีแถวเหล่านั้นได้หลายวิธี

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

เงื่อนไขตัวอย่างเป็นเช่น

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

จากนั้นคุณสามารถใช้ดัชนีแถวเหล่านี้ได้หลายวิธี

1. แทนที่ค่าของหนึ่งคอลัมน์สำหรับ conditional_index

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

2. แทนที่ค่าของหลายคอลัมน์สำหรับ conditional_index

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

3. ประโยชน์อย่างหนึ่งของการบันทึก conditional_index คือคุณสามารถกำหนดค่าของคอลัมน์หนึ่งให้กับคอลัมน์อื่นที่มีดัชนีแถวเดียวกัน

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

สิ่งนี้เป็นไปได้ทั้งหมดเนื่องจาก. index ส่งกลับอาร์เรย์ของดัชนีซึ่ง. loc สามารถใช้กับการกำหนดที่อยู่โดยตรงเพื่อหลีกเลี่ยงการแวะผ่านอีกครั้ง

df.loc['c','x']=10 สิ่งนี้จะเปลี่ยนค่าของแถวที่cและ คอลัมน์ที่x

นอกเหนือจากคำตอบข้างต้นนี่คือมาตรฐานเปรียบเทียบวิธีที่แตกต่างกันในการเพิ่มแถวของข้อมูลไปยัง dataframe ที่มีอยู่แล้ว มันแสดงให้เห็นว่าการใช้ at หรือ set-value เป็นวิธีที่มีประสิทธิภาพมากที่สุดสำหรับ dataframes ขนาดใหญ่ (อย่างน้อยสำหรับเงื่อนไขการทดสอบเหล่านี้)

• สร้าง dataframe ใหม่สำหรับแต่ละแถวและ ...
  • ... ผนวก (13.0 s)
  • ... เชื่อมต่อกัน (13.1 วิ)
• เก็บแถวใหม่ทั้งหมดในคอนเทนเนอร์อื่นก่อนแปลงเป็น dataframe ใหม่หนึ่งครั้งและต่อท้าย ...
  • container = รายการของรายการ (2.0 s)
  • container = พจนานุกรมของรายการ (1.9 วิ)
• preocallate ทั้ง dataframe วนซ้ำแถวใหม่และคอลัมน์ทั้งหมดแล้วเติมให้เต็ม
  • ... ที่ (0.6 วิ)
  • ... set_value (0.4 วิ)

สำหรับการทดสอบจะใช้ dataframe ที่มีอยู่ 100,000 แถวและ 1,000 คอลัมน์และใช้ค่า numpy แบบสุ่ม ใน dataframe นี้มีการเพิ่ม 100 แถวใหม่

รหัสดูด้านล่าง:

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

หากคุณต้องการเปลี่ยนค่าไม่ใช่ทั้งแถว แต่สำหรับบางคอลัมน์เท่านั้น:

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

จากเวอร์ชัน 0.21.1 คุณสามารถใช้.atวิธีการได้เช่นกัน มีความแตกต่างบางอย่างเมื่อเทียบกับ.locที่กล่าวถึงที่นี่ - pandas .at เทียบกับ. locแต่มันเร็วกว่าในการเปลี่ยนค่าเดียว

Soo คำถามของคุณที่จะแปลง NaN ที่ ['x', C] เป็นค่า 10

คำตอบคือ..

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

รหัสทางเลือกคือ

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

ฉันก็กำลังค้นหาหัวข้อนี้และฉันได้รวบรวมวิธีการวนซ้ำผ่าน DataFrame และอัปเดตด้วยค่าการค้นหาจาก DataFrame ที่สอง นี่คือรหัสของฉัน

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