关于python：如何在Pandas中处理SettingWithCopyWarning？

How to deal with SettingWithCopyWarning in Pandas?

背景

我刚把我的熊猫从0.11升级到0.13.0rc1。现在，应用程序弹出了许多新的警告。其中一个是这样的：

1
2
3

我想知道它到底是什么意思？我需要换点什么吗？

如果我坚持使用quote_df['TVol'] = quote_df['TVol']/TVOL_SCALE，我该如何暂停警告？

产生错误的函数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

def _decode_stock_quote(list_of_150_stk_str):
"""decode the webpage and return dataframe"""

from cStringIO import StringIO

str_of_all ="".join(list_of_150_stk_str)

quote_df = pd.read_csv(StringIO(str_of_all), sep=',', names=list('ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefg')) #dtype={'A': object, 'B': object, 'C': np.float64}
quote_df.rename(columns={'A':'STK', 'B':'TOpen', 'C':'TPCLOSE', 'D':'TPrice', 'E':'THigh', 'F':'TLow', 'I':'TVol', 'J':'TAmt', 'e':'TDate', 'f':'TTime'}, inplace=True)
quote_df = quote_df.ix[:,[0,3,2,1,4,5,8,9,30,31]]
quote_df['TClose'] = quote_df['TPrice']
quote_df['RT'] = 100 * (quote_df['TPrice']/quote_df['TPCLOSE'] - 1)
quote_df['TVol'] = quote_df['TVol']/TVOL_SCALE
quote_df['TAmt'] = quote_df['TAmt']/TAMT_SCALE
quote_df['STK_ID'] = quote_df['STK'].str.slice(13,19)
quote_df['STK_Name'] = quote_df['STK'].str.slice(21,30)#.decode('gb2312')
quote_df['TDate'] = quote_df.TDate.map(lambda x: x[0:4]+x[5:7]+x[8:10])

return quote_df

更多错误消息

1
2
3
4
5
6
7
8
9

E:\FinReporter\FM_EXT.py:449: SettingWithCopyWarning: A value is trying to be set on a copy of a slice from a DataFrame.
Try using .loc[row_index,col_indexer] = value instead
quote_df['TVol'] = quote_df['TVol']/TVOL_SCALE
E:\FinReporter\FM_EXT.py:450: SettingWithCopyWarning: A value is trying to be set on a copy of a slice from a DataFrame.
Try using .loc[row_index,col_indexer] = value instead
quote_df['TAmt'] = quote_df['TAmt']/TAMT_SCALE
E:\FinReporter\FM_EXT.py:453: SettingWithCopyWarning: A value is trying to be set on a copy of a slice from a DataFrame.
Try using .loc[row_index,col_indexer] = value instead
quote_df['TDate'] = quote_df.TDate.map(lambda x: x[0:4]+x[5:7]+x[8:10])

相关讨论

创建SettingWithCopyWarning是为了标记可能混淆的"链接"分配，例如以下分配，这些分配并不总是按预期工作，特别是当第一个选择返回一个副本时。[背景讨论见GH5390和GH5597。]

1	df[df['A'] > 2]['B'] = new_val # new_val not set in df

警告提供了如下重写建议：

1	df.loc[df['A'] > 2, 'B'] = new_val

但是，这不适合您的使用，相当于：

1 2	df = df[df['A'] > 2] df['B'] = new_val

虽然很明显，您不关心将其写回原始帧(因为您重写了对它的引用)，但不幸的是，此模式无法与第一个链接分配示例区分开来，因此出现(误报)警告。如果您想进一步阅读，可以在索引文档中解决误报的可能性。您可以通过以下分配安全地禁用此新警告。

1	pd.options.mode.chained_assignment = None # default='warn'

相关讨论

我想我大多数时候都赞成不要对此提出警告。如果您使用链接分配语法，那么您一定可以确定需要执行的索引顺序，以便它在任何给定情况下按预期工作。我认为有这些详尽的预防措施是过于偏执的。与"让每个人都长大"一样，我认为让熊猫在"私有"的课堂方法或属性上成长，对熊猫来说，让用户在连锁任务上成长更好。只有当你知道自己在做什么的时候才使用它们。
当人们四处闲逛寻找替代方案时，试图警告他们是有点不合时宜的。新风格的熊猫访问方法(改进的.ix、改进的.iloc等)可以被视为"主要途径"，而不必不断地警告每个人其他途径。相反，让他们长大成人，如果他们想做连锁作业，那就顺其自然吧。不管怎样，我的两分钱。人们经常在这里看到熊猫开发人员的不满评论，当链接的任务可以解决一个问题，但不会被认为是"主要"的方式。
@EMS的问题是，在代码中，复制视图的位置并不总是很清楚，并且这个问题会导致许多错误/混淆。我们正在考虑放入一个rc文件/选项来自动进行配置，考虑到复制警告设置的工作方式，这可能更有用。
在我看来，从准则上看是否清楚是一个意见问题。通过处理足够的案例，可以像其他复杂的第三方API一样清楚。我不知道有什么大不了的。如果这是修补与警告，那么肯定吨和吨的其他东西也应该，你得到一个免费的警告为所有人。
@ems你也可以用同样的理由允许bool(arr)在numpy ndarrays上运行。目标是让人们使用正确的东西，当他们尝试做一些事情时不会感到惊讶，因为这次他们在一个列中有一个NaN值，而这个列是他们之前没有的。
我认为应该允许bool(arr)有一些实现，而不是引发错误。如果你使用的是ndarray，你应该知道bool在这个输入上做了什么，而不是库阻止它或警告，因为有些人可能不会。我想说的是，如果numpy选择使其产生错误，Python的最小惊异原则是不满足的。如果它返回True，就不那么令人吃惊了。也就是说，bool([1,2,3])返回True，但bool(np.asarray([1,2,3]))会产生错误。更糟的是，我的意思是，现在这是一个长期的惯例。
我的2分：我也用和op相同的模式点击了这个警告：过滤并将结果存储回相同的变量名中。第一个问题是：发生了什么变化和/或将要发生什么变化？由于Jeff Tratner在其他地方指出，没有任何变化，而且从我所知，在我需要准备的范围内，没有"视图对副本"的变化，我现在将禁用此警告。我支持减少混乱的努力，但不会说OP做了什么错事。
当然，警告的原因是为了升级旧代码。我绝对需要一个警告，因为我正在处理一些非常丑陋的旧代码。
另一方面，我发现禁用链接的"分配警告：pd.options.mode.chained_assignment = None"导致我的代码运行速度快了大约6倍。其他人也经历过类似的结果吗？

一般来说，SettingWithCopyWarning的目的是向用户(尤其是新用户)展示他们可能在副本上操作，而不是他们认为的原始版本。有误报(如果你知道自己在做什么，就看情况没问题)。一种可能是按照@garrett的建议关闭(默认警告)警告。

下面是另一个选项：

1
2
3
4
5
6
7
8
9
10
11

In [1]: df = DataFrame(np.random.randn(5, 2), columns=list('AB'))

In [2]: dfa = df.ix[:, [1, 0]]

In [3]: dfa.is_copy
Out[3]: True

In [4]: dfa['A'] /= 2
/usr/local/bin/ipython:1: SettingWithCopyWarning: A value is trying to be set on a copy of a slice from a DataFrame.
Try using .loc[row_index,col_indexer] = value instead
#!/usr/local/bin/python

您可以将is_copy标志设置为False，这将有效地关闭该对象的检查：

1
2
3

In [5]: dfa.is_copy = False

In [6]: dfa['A'] /= 2

如果显式复制，则不会出现进一步的警告：

1
2
3

In [7]: dfa = df.ix[:, [1, 0]].copy()

In [8]: dfa['A'] /= 2

上面显示的代码虽然是合法的，而且可能也是我所做的，但从技术上讲，这是一个警告，而不是一个误报。另一种没有警告的方法是通过reindex进行选择操作，例如

1	quote_df = quote_df.reindex(columns=['STK', ...])

或者，

1	quote_df = quote_df.reindex(['STK', ...], axis=1) # v.0.21

相关讨论

感谢您的信息和讨论，我只是关闭了警告，让控制台对此保持沉默。听起来像SQL数据库中的视图和表。我需要更多地了解引入"copy"概念的好处，但是要注意细微的语义、语法差异，这多少有点负担。
@bigbug复制行为并不是新的，它一直在进行，而是人们意外地创建了副本，而不是视图，并且遇到了细微的bug。
@杰夫，你是说False而不是Flag吗？
打字错误-更正为错误
@杰夫，这里也有类似的问题。有什么想法吗？
我同意copy()；很明显，它解决了我的问题(这是一个错误的肯定)。
在更新到0.16之后，我看到更多的误报，误报的问题是人们学会忽略它，即使有时它是合法的。
@如果你认为你有假阳性，请报告一个问题。关键是这些不是误报。你可以忽略不计，风险自负。
@杰夫，我认为我看到一些误报的原因是他们做了预期的行为(他们改变了原始数据帧，而不是拷贝)，所以他们是误报吗？我可以理解，在api中有一个不赞成的警告，不允许这样做，但是发出的警告有时是合法的，有时是不合法的，使他们像deprecated，但不是完全的。这就像numpy在任何时候对两个数组进行拆分时发出警告一样，关于分母中有0的可能性。这类事情(角落案件)应该只是记录在案(除非他们可以被警告而不假阳性)。
@你很快就失去了重点。有时甚至在大多数时候它都可能工作。但是，例如，如果帧更大/更小，或者您添加了一个列，比如一个不同的数据类型，它就不起作用了。这就是重点。你所做的事情可能有效，但不能保证。这与折旧警告非常不同。如果你想继续使用它并且它可以工作，那就太好了。但要预先警告。
@杰夫现在讲得通了，所以这是一种以东式的行为。如果有任何错误，那么(为了避免在C中看到的陷阱)，由于api被冻结，当前的警告行为对于向后兼容性是有意义的。我会让它们抛出来捕获我的生产代码中的错误(warnings.filterwarnings('error', r'SettingWithCopyWarning)。另外，使用.loc的建议有时也没有帮助(如果它是一个组)。
谢谢您！dfa.is_copy=false-非常有用

How to deal with SettingWithCopyWarning in Pandas?

这篇文章是为那些，好的。

希望了解此警告的含义

希望了解抑制此警告的不同方法

希望了解如何改进他们的代码并遵循良好的实践来避免将来出现这种警告。

安装程序好的。

1
2
3
4
5
6
7

np.random.seed(0)
df = pd.DataFrame(np.random.choice(10, (3, 5)), columns=list('ABCDE'))
df
A B C D E
0 5 0 3 3 7
1 9 3 5 2 4
2 7 6 8 8 1

什么是SettingWithCopyWarning？

要知道如何处理这个警告，首先要了解它的含义和为什么会被提出是很重要的。好的。

筛选数据帧时，根据内部布局和各种实现细节，可以对帧进行切片/索引以返回视图或副本。顾名思义，"视图"是将视图转换为原始数据的视图，因此修改视图可能会修改原始对象。另一方面，"副本"是对原始数据的复制，修改副本对原始数据没有影响。好的。

如其他答案所述，创建SettingWithCopyWarning是为了标记"链接分配"操作。在上面的设置中考虑df。假设您要选择"B"列中的所有值，其中"A"列中的值大于5。熊猫允许你以不同的方式做这件事，有些比其他更正确。例如，好的。

1
2
3
4
5

df[df.A > 5]['B']

1 3
2 6
Name: B, dtype: int64

而且，好的。

1
2
3
4
5

df.loc[df.A > 5, 'B']

1 3
2 6
Name: B, dtype: int64

这些返回相同的结果，因此如果您只读取这些值，那么它没有任何区别。那么，问题是什么？链式分配的问题是，通常很难预测是否返回视图或副本，因此当您试图重新分配值时，这在很大程度上成为一个问题。要基于前面的示例进行构建，请考虑解释器如何执行此代码：好的。

1
2
3

df.loc[df.A > 5, 'B'] = 4
# becomes
df.__setitem__((df.A > 5, 'B'), 4)

用一个__setitem__呼叫df。Otoh，考虑以下代码：好的。

1
2
3

df[df.A > 5]['B'] = 4
# becomes
df.__getitem__(df.A > 5).__setitem__('B", 4)

现在，根据__getitem__返回的是视图还是副本，__setitem__操作可能不起作用。好的。

一般来说，您应该使用loc进行基于标签的分配，使用iloc进行基于整数/位置的分配，因为规范保证它们始终在原始的基础上运行。另外，为了设置单个单元，应该使用at和iat。好的。

更多信息可以在文档中找到。好的。

Note
All boolean indexing operations done with loc can also be done with iloc. The only difference is that iloc expects either
integers/positions for index or a numpy array of boolean values, and
integer/position indexes for the columns.

Ok.

For example,

Ok.

1
df.loc[df.A > 5, 'B'] = 4

Can be written nas

Ok.

1
df.iloc[(df.A > 5).values, 1] = 4

And,

Ok.

1
df.loc[1, 'A'] = 100

Can be written as

Ok.

1
df.iloc[1, 0] = 100

And so on.

Ok.

告诉我如何压制警告！

考虑对df的"a"列进行一个简单的操作。选择"A"并除以2将发出警告，但操作将起作用。好的。

1
2
3
4
5
6
7
8
9
10
11

df2 = df[['A']]
df2['A'] /= 2
/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages/IPython/__main__.py:1: SettingWithCopyWarning:
A value is trying to be set on a copy of a slice from a DataFrame.
Try using .loc[row_indexer,col_indexer] = value instead

df2
A
0 2.5
1 4.5
2 3.5

有两种方法可以直接消除此警告：好的。

制作一个deepcopy。好的。

1 2	df2 = df[['A']].copy(deep=True) df2['A'] /= 2

变更pd.options.mode.chained_assignment。可以设置为None、"warn"或"raise"。默认为"warn"。None将完全禁止警告，"raise"将抛出SettingWithCopyError以阻止操作进行。好的。

1 2	pd.options.mode.chained_assignment = None df2['A'] /= 2

@彼得科顿在评论中，想出了一个不错的方法，使用上下文管理器非侵入性地改变模式(从这个要点修改)，以设置模式只要是必要的，并在完成时将其重置回原始状态。好的。

1
2
3
4
5
6
7
8
9
10
11
12
13
class ChainedAssignent:
def __init__(self, chained=None):
acceptable = [None, 'warn', 'raise']
assert chained in acceptable,"chained must be in" + str(acceptable)
self.swcw = chained

def __enter__(self):
self.saved_swcw = pd.options.mode.chained_assignment
pd.options.mode.chained_assignment = self.swcw
return self

def __exit__(self, *args):
pd.options.mode.chained_assignment = self.saved_swcw

用法如下：好的。

1
2
3
4

# some code here
with ChainedAssignent():
df2['A'] /= 2
# more code follows

或者，提出例外好的。

1
2
3
4
5
6

with ChainedAssignent(chained='raise'):
df2['A'] /= 2

SettingWithCopyError:
A value is trying to be set on a copy of a slice from a DataFrame.
Try using .loc[row_indexer,col_indexer] = value instead

"xy问题"：我做错了什么？

很多时候，用户试图寻找抑制这个异常的方法，而不完全理解为什么它首先被提出。这是一个很好的x y问题的例子，用户试图解决一个问题"y"，这实际上是一个根深蒂固的问题"x"的症状。将根据遇到此警告的常见问题提出问题，然后提出解决方案。好的。

Question 1
I have a DataFrame

Ok.

1
2
3
4
5
df
A B C D E
0 5 0 3 3 7
1 9 3 5 2 4
2 7 6 8 8 1

I want to assign values in col"A"> 5 to 1000. My expected output is

Ok.

1
2
3
4
A B C D E
0 5 0 3 3 7
1 1000 3 5 2 4
2 1000 6 8 8 1

这样做的方法不对：好的。

1
2
3

df.A[df.A > 5] = 1000 # works, because df.A returns a view
df[df.A > 5]['A'] = 1000 # does not work
df.loc[df.A 5]['A'] = 1000 # does not work

正确使用loc：好的。

1	df.loc[df.A > 5, 'A'] = 1000

< BR>好的。

Question 21
I am trying to set the value in cell (1, 'D') to 12345. My expected output is

Ok.

1
2
3
4
A B C D E
0 5 0 3 3 7
1 9 3 5 12345 4
2 7 6 8 8 1

I have tried different ways of accessing this cell, such as
df['D'][1]. What is the best way to do this?

Ok.

_{1. This question isn't specifically related to the warning, but

it is good to understand how to do this particular operation correctly

so as to avoid situations where the warning could potentially arise in

future.}

Ok.

您可以使用以下任何方法来执行此操作。好的。

1
2
3
4

df.loc[1, 'D'] = 12345
df.iloc[1, 3] = 12345
df.at[1, 'D'] = 12345
df.iat[1, 3] = 12345

< BR>好的。

Question 3
I am trying to subset values based on some condition. I have a
DataFrame

Ok.

1
2
3
A B C D E
1 9 3 5 2 4
2 7 6 8 8 1

I would like to assign values in"D" to 123 such that"C" == 5. I
tried

Ok.

1
df2.loc[df2.C == 5, 'D'] = 123

Which seems fine but I am still getting the
SettingWithCopyWarning! How do I fix this?

Ok.

这可能是因为您的管道中的代码更高。你是从更大的东西，比如好的。

1	df2 = df[df.A > 5]

？在这种情况下，布尔索引将返回一个视图，因此df2将引用原始视图。您需要做的是将df2分配给一个副本：好的。

1
2
3

df2 = df[df.A > 5].copy()
# Or,
# df2 = df.loc[df.A > 5, :]

< BR>好的。< Buff行情>

问题4我想把C栏从好的。

1
2
3

A B C D E
1 9 3 5 2 4
2 7 6 8 8 1

但使用好的。

1	df2.drop('C', axis=1, inplace=True)

抛出SettingWithCopyWarning。为什么会这样？好的。< /块引用>

这是因为df2必须创建为其他切片操作的视图，例如好的。

1	df2 = df[df.A > 5]

这里的解决方案是要么制作一个df的copy()，要么像以前那样使用loc。好的。好啊。

相关讨论

熊猫数据帧复制警告

当你去做这样的事情时：

1	quote_df = quote_df.ix[:,[0,3,2,1,4,5,8,9,30,31]]

在本例中，pandas.ix返回一个新的独立数据帧。

您决定在此数据帧中更改的任何值都不会更改原始数据帧。

这就是熊猫试图警告你的。

为什么.ix是个坏主意

.ix对象试图做不止一件事，对于任何读过任何关于干净代码的东西的人来说，这是一种强烈的气味。

给定此数据帧：

1	df = pd.DataFrame({"a": [1,2,3,4],"b": [1,1,2,2]})

两种行为：

1 2	dfcopy = df.ix[:,["a"]] dfcopy.a.ix[0] = 2

行为一：dfcopy现在是一个独立的数据帧。改变它不会改变df。

1	df.ix[0,"a"] = 3

行为二：这将更改原始数据帧。

用.loc代替

熊猫开发人员认识到，.ix对象非常难闻(推测)，因此创建了两个新对象，有助于数据的获取和分配。(另一个是.iloc)

.loc更快，因为它不尝试创建数据的副本。

.loc的目的是修改现有的数据帧，这样更节省内存。

.loc是可预测的，它有一个行为。

解决方案

在代码示例中，您要做的是加载一个包含大量列的大文件，然后将其修改为较小的文件。

pd.read_csv函数可以帮助您解决很多问题，并使文件加载更快。

所以不要这样做

1
2
3

quote_df = pd.read_csv(StringIO(str_of_all), sep=',', names=list('ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefg')) #dtype={'A': object, 'B': object, 'C': np.float64}
quote_df.rename(columns={'A':'STK', 'B':'TOpen', 'C':'TPCLOSE', 'D':'TPrice', 'E':'THigh', 'F':'TLow', 'I':'TVol', 'J':'TAmt', 'e':'TDate', 'f':'TTime'}, inplace=True)
quote_df = quote_df.ix[:,[0,3,2,1,4,5,8,9,30,31]]

这样做

1
2
3

columns = ['STK', 'TPrice', 'TPCLOSE', 'TOpen', 'THigh', 'TLow', 'TVol', 'TAmt', 'TDate', 'TTime']
df = pd.read_csv(StringIO(str_of_all), sep=',', usecols=[0,3,2,1,4,5,8,9,30,31])
df.columns = columns

这将只读取您感兴趣的列，并正确命名它们。不需要用邪恶的.ix物体做魔法。

相关讨论

为了消除任何疑问，我的解决方案是对切片进行深度拷贝，而不是常规拷贝。这可能不适用，具体取决于您的上下文(内存限制/切片大小、性能下降的可能性-特别是如果复制发生在循环中，就像对我一样，等等…)

为了清楚起见，这里是我收到的警告：

1
2
3
4

/opt/anaconda3/lib/python3.6/site-packages/ipykernel/__main__.py:54:
SettingWithCopyWarning: A value is trying to be set on a copy of a slice from a DataFrame
See the caveats in the documentation:
http://pandas.pydata.org/pandas-docs/stable/indexing.html#indexing-view-versus-copy

插图

我怀疑这个警告是因为我在一个切片副本上放了一列而抛出的。虽然技术上并没有试图在切片副本中设置值，但这仍然是对切片副本的修改。以下是我为证实这一怀疑所采取的(简化)步骤，我希望它能帮助我们这些试图理解这一警告的人。

示例1：将列拖到原始列上会影响副本

我们已经知道了，但这是一个健康的提醒。这不是警告的内容。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

>> data1 = {'A': [111, 112, 113], 'B':[121, 122, 123]}
>> df1 = pd.DataFrame(data1)
>> df1

A B
0 111 121
1 112 122
2 113 123

>> df2 = df1
>> df2

A B
0 111 121
1 112 122
2 113 123

# Dropping a column on df1 affects df2
>> df1.drop('A', axis=1, inplace=True)
>> df2
B
0 121
1 122
2 123

可以避免对df1所做的更改影响df2

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

>> data1 = {'A': [111, 112, 113], 'B':[121, 122, 123]}
>> df1 = pd.DataFrame(data1)
>> df1

A B
0 111 121
1 112 122
2 113 123

>> import copy
>> df2 = copy.deepcopy(df1)
>> df2
A B
0 111 121
1 112 122
2 113 123

# Dropping a column on df1 does not affect df2
>> df1.drop('A', axis=1, inplace=True)
>> df2
A B
0 111 121
1 112 122
2 113 123

示例2：在副本上删除列可能会影响原始列

这实际上说明了警告。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

>> data1 = {'A': [111, 112, 113], 'B':[121, 122, 123]}
>> df1 = pd.DataFrame(data1)
>> df1

A B
0 111 121
1 112 122
2 113 123

>> df2 = df1
>> df2

A B
0 111 121
1 112 122
2 113 123

# Dropping a column on df2 can affect df1
# No slice involved here, but I believe the principle remains the same?
# Let me know if not
>> df2.drop('A', axis=1, inplace=True)
>> df1

B
0 121
1 122
2 123

可以避免对df2所做的更改影响df1

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

>> data1 = {'A': [111, 112, 113], 'B':[121, 122, 123]}
>> df1 = pd.DataFrame(data1)
>> df1

A B
0 111 121
1 112 122
2 113 123

>> import copy
>> df2 = copy.deepcopy(df1)
>> df2

A B
0 111 121
1 112 122
2 113 123

>> df2.drop('A', axis=1, inplace=True)
>> df1

A B
0 111 121
1 112 122
2 113 123

干杯！

这应该有效：

1	quote_df.loc[:,'TVol'] = quote_df['TVol']/TVOL_SCALE

如果已将切片指定给变量，并希望使用变量进行如下设置：

1 2	df2 = df[df['A'] > 2] df2['B'] = value

您不想使用Jeffs解决方案，因为您的条件计算df2太长或出于其他原因，那么您可以使用以下方法：

1	df.loc[df2.index.tolist(), 'B'] = value

df2.index.tolist()返回df2中所有条目的索引，然后使用这些索引在原始数据帧中设置B列。

相关讨论

在这里我直接回答这个问题。如何处理？

滑完后做一个.copy()。

等等，一个切片不是返回一个副本吗？毕竟，这就是警告信息试图表达的内容？阅读长答案：

1
2
3

import pandas as pd
df = pd.DataFrame({'x':[1,2,3]})
df0 = df[df.x>2]

这会给出警告：

1	df0['foo'] = 'bar'

这不：

1 2	df1 = df[df.x>2].copy() df1['foo'] = 'bar'

df0和df1都是DataFrame对象，但它们之间的某些不同之处使熊猫能够打印警告。让我们看看是什么。

1
2
3
4
5

import inspect
test = df[df.x>2]
test_copy = df[df.x>2].copy()
inspect.getmembers(test)
inspect.getmembers(test_copy)

使用您选择的diff工具，您将看到除了几个地址之外，唯一的实质性差异是：

1
2
3

决定是否发出警告的方法是检查_is_copy的DataFrame._check_setitem_copy。

警告是建议使用.loc，但如果在_is_copy的框架上使用.loc，则仍然会收到相同的警告。误导？对。烦人的？当然。有用吗？当使用链式分配时，可能是这样。但它甚至无法区分这一案件并不加区别地打印警告。

1这将生成数据的深度副本，因此您可能不想对大型数据帧或需要浅层副本时使用此方法。警告：如果数据框中有python对象，那么将只复制引用，而不是复制copy.deepcopy。文档中的详细信息。

对于我来说，这个问题发生在下面的一个>简化<示例中。我也能解决这个问题(希望有一个正确的解决方案)：

带警告的旧代码：

1
2
3
4
5
6
7
8
9

def update_old_dataframe(old_dataframe, new_dataframe):
for new_index, new_row in new_dataframe.iterrorws():
old_dataframe.loc[new_index] = update_row(old_dataframe.loc[new_index], new_row)

def update_row(old_row, new_row):
for field in [list_of_columns]:
# line with warning because of chain indexing old_dataframe[new_index][field]
old_row[field] = new_row[field]
return old_row

这打印了行old_row[field] = new_row[field]的警告。

由于update_row方法中的行实际上是Series类型，因此我将该行替换为：

1	old_row.at[field] = new_row.at[field]

即访问/查找Series的方法。尽管这两种方法都很好，结果也一样，但这样我就不必禁用警告(=将它们保留在其他地方以解决其他链索引问题)。

我希望这能对某人有所帮助。

我相信你可以避免这样的问题：

1
2
3
4
5
6
7
8
9
10
11
12
13
14

return (
pd.read_csv(StringIO(str_of_all), sep=',', names=list('ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefg')) #dtype={'A': object, 'B': object, 'C': np.float64}
.rename(columns={'A':'STK', 'B':'TOpen', 'C':'TPCLOSE', 'D':'TPrice', 'E':'THigh', 'F':'TLow', 'I':'TVol', 'J':'TAmt', 'e':'TDate', 'f':'TTime'}, inplace=True)
.ix[:,[0,3,2,1,4,5,8,9,30,31]]
.assign(
TClose=lambda df: df['TPrice'],
RT=lambda df: 100 * (df['TPrice']/quote_df['TPCLOSE'] - 1),
TVol=lambda df: df['TVol']/TVOL_SCALE,
TAmt=lambda df: df['TAmt']/TAMT_SCALE,
STK_ID=lambda df: df['STK'].str.slice(13,19),
STK_Name=lambda df: df['STK'].str.slice(21,30)#.decode('gb2312'),
TDate=lambda df: df.TDate.map(lambda x: x[0:4]+x[5:7]+x[8:10]),
)
)

使用赋值。从文档中：将新列分配给一个数据框架，返回一个新对象(一个副本)，除了新列之外，还返回所有原始列。

参见Tom Augspurger关于熊猫中方法链接的文章：https://tom augspurger.github.io/method-chaining

跟进初学者问题/评论

也许对像我这样的初学者有一个解释(我来自R，它在引擎盖下的工作方式有点不同)。下面的无害的外观和功能代码不断生成带有复制警告的设置，我不知道为什么。我已经阅读并理解了用"链接索引"发布的，但我的代码不包含任何：

1
2
3

def plot(pdb, df, title, **kw):
df['target'] = (df['ogg'] + df['ugg']) / 2
# ...

但后来，太晚了，我看了一下plot()函数的调用位置：

1 2	df = data[data['anz_emw'] > 0] pixbuf = plot(pdb, df, title)

所以"df"不是一个数据帧，而是一个对象，它以某种方式记住它是通过索引一个数据帧创建的(这是一个视图吗？)这将使plot()中的行

1	df['target'] = ...

相当于

1	data[data['anz_emw'] > 0]['target'] = ...

这是一个链接索引。我说得对吗？

不管怎样，

1 2	def plot(pdb, df, title, **kw): df.loc[:,'target'] = (df['ogg'] + df['ugg']) / 2

修理它。