使用index with condition的一种方法是首先获取满足条件的所有行的索引，然后简单地以多种方式使用这些行索引

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

示例条件如下

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

然后您可以以各种方式使用这些行索引，例如

替换conditional_index的一列值

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

替换conditional_index的多列值

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

保存conditional_index的一个好处是，您可以将一个列的值分配给具有相同行索引的另一个列

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

这一切都是可能的，因为.index返回一个索引数组，.loc可以直接寻址，这样就避免了一次又一次的遍历。

.iat /。是很好的解决办法。 假设你有这样一个简单的数据帧:

   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

Y_train调用prepossession函数后，iat改变每个单元格的值乘以2:

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

如果想要将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)

或者使用pandas.DataFrame.iloc

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是最快的方法。

我也在搜索这个主题，我把一种方法放在一起，通过一个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'])

RukTech的答案是df。set_value('C'， 'x'， 10)比我下面建议的选项快得多。然而，它已被弃用。

接下来，推荐的方法是.iat/.at。

为什么df.xs('C')['x']=10无效:

df.xs('C')在默认情况下返回一个新的数据框架，其中包含数据的副本，因此

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

只修改这个新的数据帧。

Df ['x']返回Df数据框架的视图，因此

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

我测试了，输出是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应该是更好的选择，因为它们是向量化的。