建议的设置方法(根据维护人员)为:

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

使用“链式索引”(df['x']['C'])可能会导致问题。

See:

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

除了上面的答案之外，这里还有一个基准测试，比较了向已有的数据框架添加数据行的不同方法。它表明使用at或set-value对于大数据帧是最有效的方法(至少对于这些测试条件)。

为每一行创建新的数据框架，然后… ．.． 追加它(13.0 s) ．.． 串联它(13.1秒) 首先将所有新行存储在另一个容器中，转换为新数据帧一次，然后追加… 容器=列表的列表(2.0 s) 容器=列表字典(1.9 s) 预分配整个数据框架，遍历新行和所有列，并使用填充 ．.． (0.6秒) ．.． Set_value (0.4 s)

在测试中，使用了包含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))

使用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可以直接寻址，这样就避免了一次又一次的遍历。

苏，你的问题是将['x'，C]的NaN转换为值10

答案是…

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

另一种代码是

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

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