我已经创建了一个Pandas DataFrame
df = DataFrame(index=['A','B','C'], columns=['x','y'])
并得到了这个
x y A NaN NaN B NaN NaN C NaN NaN
然后我想为特定单元格赋值，例如行'C'和列'x'。
我期望得到这样的结果：
x y A NaN NaN B NaN NaN C 10 NaN
使用此代码：
df.xs('C')['x'] = 10
但df的内容未发生变化。它只是DataFrame中的NaN个。
有什么建议吗？
答案 0 :(得分：404)
RukTech's answer，df.set_value('C', 'x', 10)远远超过我在下面建议的选项。但是，它一直是slated for deprecation。
前进，recommended method is .iat/.at。
为什么df.xs('C')['x']=10不起作用
df.xs('C')会返回数据的新数据框with a copy，所以
df.xs('C')['x']=10
仅修改此新数据框。
df['x']会返回df数据框的视图，因此
df['x']['C'] = 10
修改df本身。
警告：有时很难预测操作是返回副本还是视图。出于这个原因docs recommend avoiding assignments with "chained indexing"。
所以推荐的替代方案是
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
答案 1 :(得分：198)
更新：.set_value方法将为deprecated。 .iat / .at是很好的替代品，不幸的是，pandas提供的文档很少
执行此操作的最快方法是使用set_value。此方法比.ix方法快约100倍。例如：
df.set_value('C', 'x', 10)
答案 2 :(得分：72)
您还可以使用.loc使用条件查找，如下所示：
df.loc[df[<some_column_name>] == <condition>, [<another_column_name>]] = <value_to_add>
其中<some_column_name是要检查<condition>变量的列，而<another_column_name>是要添加的列（可以是新列或已存在的列） 。 <value_to_add>是您要添加到该列/行的值。
此示例并不能准确处理手头的问题，但对于想要根据条件添加特定值的人来说，这可能很有用。
答案 3 :(得分：30)
建议的方法（根据维护者）设置一个值是：
df.ix['x','C']=10
使用“链式索引”（df['x']['C']）可能会导致问题。
请参阅：
答案 4 :(得分：18)
尝试使用df.loc[row_index,col_indexer] = value
答案 5 :(得分：18)
答案 6 :(得分：6)
.iat/.at是一个很好的解决方案。
假设您有一个简单的data_frame：
A B C
0 1 8 4
1 3 9 6
2 22 33 52
如果我们要修改单元格[0,"A"]的值，则可以使用以下解决方案之一：
df.iat[0,0] = 2 df.at[0,'A'] = 2 这是一个完整的示例，说明如何使用iat获取并设置cell的值：
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
iat进行更改以将每个单元格的值乘以2后，y_train：
0
0 108
1 30
2 30
3 16
4 62
5 126
6 22
答案 7 :(得分：5)
在我的示例中，我只是在选定的单元格中对其进行了更改
for index, row in result.iterrows():
if np.isnan(row['weight']):
result.at[index, 'weight'] = 0.0
“结果”是带有“权重”列的数据字段
答案 8 :(得分：4)
您可以使用.iloc。
df.iloc[[2], [0]] = 10
答案 9 :(得分：3)
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
参考文献：
答案 10 :(得分：2)
如果想要将 df 位置 (0,0) 的单元格更改为字符串，例如 '"236"76"'，以下选项将起作用：
df[0][0] = '"236"76"'
# %timeit df[0][0] = '"236"76"'
# 938 µs ± 83.4 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
或者使用 pandas.DataFrame.at
df.at[0, 0] = '"236"76"'
# %timeit df.at[0, 0] = '"236"76"'
#15 µs ± 2.09 µs per loop (mean ± std. dev. of 7 runs, 100000 loops each)
或者使用 pandas.DataFrame.iat
df.iat[0, 0] = '"236"76"'
# %timeit df.iat[0, 0] = '"236"76"'
# 41.1 µs ± 3.09 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)
或者使用 pandas.DataFrame.loc
df.loc[0, 0] = '"236"76"'
# %timeit df.loc[0, 0] = '"236"76"'
# 5.21 ms ± 401 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)
df.iloc[0, 0] = '"236"76"'
# %timeit df.iloc[0, 0] = '"236"76"'
# 5.12 ms ± 300 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)
如果时间相关，使用 pandas.DataFrame.at 是最快的方法。
答案 11 :(得分：1)
df.loc['c','x']=10
这将更改第 c 行的值，并
第 x 列。
答案 12 :(得分：1)
除上述答案外，这是一个基准测试，比较了将数据行添加到现有数据框的不同方法。它表明，对于大型数据框（至少在这些测试条件下），使用at或set-value是最有效的方法。
对于该测试，使用了包含100,000行和1,000列以及随机numpy值的现有数据框。向该数据框添加了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))
答案 13 :(得分：1)
以下是所有用户针对以整数和字符串索引的数据帧提供的有效解决方案的摘要。
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
答案 14 :(得分：1)
要设置值，请使用：
df.at[0, 'clm1'] = 0
set_value，ix已弃用。iloc和loc 答案 15 :(得分：1)
将索引与条件结合使用的一种方法是，首先获取满足条件的所有行的索引，然后简单地以多种方式使用这些行索引
conditional_index = df.loc[ df['col name'] <condition> ].index
然后，您可以通过多种方式使用这些行索引
df.loc[conditional_index , [col name]]= <new value>
df.loc[conditional_index, [col1,col2]]= <new value>
df.loc[conditional_index, [col1,col2]]= df.loc[conditional_index,'col name']
这都是可能的，因为.index返回一个索引数组，.loc可以将其用于直接寻址，从而避免了一次又一次的遍历。
答案 16 :(得分：1)
我建议：
df.loc[index_position, "column_name"] = some_value
答案 17 :(得分：0)
从0.21.1版开始，您还可以使用.at方法。与此处提到的.loc相比有一些差异-pandas .at versus .loc，但是在替换单个值时更快
答案 18 :(得分：0)
如果您想更改的值不是整行，而是仅针对某些列：
x = pd.DataFrame({'A': [1, 2, 3], 'B': [4, 5, 6]})
x.iloc[1] = dict(A=10, B=-10)
答案 19 :(得分：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应该是更好的选择，因为它们是向量化的。
答案 20 :(得分：0)
S，您的问题是将['x'，C]的NaN转换为值10
答案是..
df['x'].loc['C':]=10
df
替代代码是
df.loc['C':'x']=10
df
答案 21 :(得分：-4)
我也在搜索这个主题，我整理了一种迭代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'])