SettingWithCopyWarning创建它是为了标记可能令人困惑的"链式"赋值,例如以下内容,它们并不总是按预期工作,特别是当第一个选择返回副本时.[ 有关背景讨论,请参见GH5390和GH5597.]

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

该警告提供了重写建议,如下所示:

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

但是,这不符合您的用法,相当于:

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

虽然很明显你不关心写回到原始帧(因为你覆盖了对它的引用),但遗憾的是这种模式不能与第一个链式赋值示例区分开来,因此(误报)警告.如果您想进一步阅读,可以在索引文档中解决误报的可能性.您可以使用以下分配安全地禁用此新警告.

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

一般而言,重点SettingWithCopyWarning是向用户(尤其是新用户)展示他们可能在副本上操作而不是他们想到的原始用户.这里是误报(IOW如果你知道你在做什么,它可能是好的).一种可能性就是关闭@Garrett建议的(默认情况下警告)警告.

这是另一种选择:

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有效关闭该对象的检查:

In [5]: dfa.is_copy = False

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

如果您明确复制,则不会再发出警告:

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

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

OP在上面显示的代码,虽然合法,也可能是我做的事情,但在技术上是这种警告的情况,而不是误报.另一种没有警告的方法是通过reindex例如进行选择操作

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

要么,

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

这篇文章适合读者,

想了解这个警告意味着什么

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

想了解如何改进他们的代码并遵循良好做法以避免将来出现此警告.

建立

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？

要知道如何处理这个警告,重要的是要了解它的含义以及为什么它首先被提出.

过滤DataFrame时,可以对一个帧进行切片/索引以返回视图或副本,具体取决于内部布局和各种实现细节.正如术语所暗示的,"视图"是原始数据的视图,因此修改视图可以修改原始对象.另一方面,"复制"是原始数据的复制,修改副本对原始数据没有影响.

正如其他答案所提到的那样,SettingWithCopyWarning创建了标记"链式赋值"操作.请考虑SettingWithCopyWarning上面的设置.假设您要选择"B"列中的所有值,其中"A"列中的值> 5.Pandas允许您以不同的方式执行此操作,其中一些更正确.例如,

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

1    3
2    6
Name: B, dtype: int64

和,

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

1    3
2    6
Name: B, dtype: int64

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

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

只需一次df通话即可__setitem__.OTOH,请考虑以下代码:

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

现在,根据是df返回视图还是复制,__getitem__操作可能无效.

通常,您应该使用__setitem__基于标签的赋值,以及loc基于整数/位置的赋值,因为规范保证它们始终在原始操作上运行.此外,要设置单个单元格,您应该使用iloc和at.

更多信息可以在文档中找到.

注意完成的
所有布尔索引操作iat也可以使用loc.唯一的区别是iloc期望索引的整数/位置或布尔值的numpy数组,以及列的整数/位置索引.

例如,

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

可以写成nas

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

和,

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

可以写成

df.iloc[1, 0] = 100

等等.

告诉我如何压制警告!

考虑对"A"列的简单操作iloc.选择"A"并除以2将引发警告,但操作将起作用.

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

有几种方法可以消除此警告,如下所示.

做一个 df

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

设置deepcopy
通过设置关闭对特定DataFrame的检查pd.options.mode.chained_assignment.

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

更改None
可以设置为"warn","raise"或"warn".None是默认值."raise"将完全抑制警告,SettingWithCopyError并将抛出一个loc,以防止操作通过.

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

@Peter Cotton提出了一种非侵入式改变模式的好方法(参见本要点),只要需要设置模式,并在完成时将其重置回原始状态.

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

用法如下:

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

或者,提出异常

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

"XY问题":我做错了什么？

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

问题1
我有一个DataFrame

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

我想在col"A"> 5到1000中分配值.我的预期输出是

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

错误的方法:

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

正确使用方式df['D'][1]:

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

问题2
_{这个问题与警告没有特别的关系,但是理解如何正确地进行这种特定操作以避免将来可能出现警告的情况是很好的.}

我试图将单元格(1,'D')中的值设置为12345.我的预期输出是

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

我尝试了不同的方法来访问这个单元格,例如 SettingWithCopyWarning.做这个的最好方式是什么？

您可以使用以下任何方法执行此操作.

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

问题3
我试图根据某些条件对值进行子集化.我有一个DataFrame

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

我想将"D"中的值分配给123,使"C"== 5.我试过了

df2 = df[df.A > 5]

这似乎很好,但我仍然得到了 df2!我该如何解决？

这实际上可能是因为您的管道中的代码更高.你是df2从更大的东西创造的,比如

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

？在这种情况下,布尔索引将返回一个视图,因此df2将引用原始.你需要做的是分配SettingWithCopyWarning一份副本:

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

要么,

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

问题4
我试图将"C"列放在原位

df2 = df[df.A > 5]

但是使用

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

投掷df2.为什么会这样？

这是因为copy()必须已经创建为来自其他切片操作的视图,例如

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

1    3
2    6
Name: B, dtype: int64

这里的解决方案是要么做df的loc,或使用SettingWithCopyWarning,如前.

熊猫数据帧复制警告

当你去做这样的事情时:

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

pandas.ix 在这种情况下,返回一个新的,独立的数据帧.

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

这是大熊猫试图警告你的事情.

为什么.ix是个坏主意

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

鉴于此数据框:

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

两种行为:

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

行为一:dfcopy现在是一个独立的数据框架.改变它不会改变df

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

行为二:这会更改原始数据帧.

请.loc改用

大熊猫开发人员认识到该.ix对象非常[推测性],因此创建了两个新对象,这有助于数据的加入和分配.(另一个.iloc)

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

.loc 用于修改现有的数据帧,这样可以提高内存效率.

.loc 是可预测的,它有一种行为.

解决方案

您在代码示例中所做的是加载包含大量列的大文件,然后将其修改为更小.

该pd.read_csv功能可以帮助您解决很多问题,并且可以更快地加载文件.

所以不要这样做

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

做这个

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物体做神奇的东西.

为了消除任何疑问,我的解决方案是制作切片的深层副本而不是常规副本.这可能不适用,具体取决于您的上下文(内存约束/切片大小,性能下降的可能性 - 特别是如果副本发生在像我这样的循环中,等等......)

要清楚,这是我收到的警告:

/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:删除原始列上的列会影响副本

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

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

>> 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:删除副本上的列可能会影响原始列

这实际上说明了警告.

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

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

干杯!

这个话题确实让Pandas感到困惑。幸运的是，它有一个相对简单的解决方案。

问题在于，并不总是清楚数据过滤操作（例如loc）是否返回DataFrame的副本或视图。因此，这种过滤后的DataFrame的进一步使用可能会造成混淆。

一个简单的解决方案是（除非您需要处理非常大的数据集）：

每当需要更新任何值时，请始终确保在分配之前隐式复制DataFrame。

df  # Some DataFrame
df = df.loc[:, 0:2]  # Some filtering (unsure whether a view or copy is returned)
df = df.copy()  # Ensuring a copy is made
df[df["Name"] == "John"] = "Johny"  # Assignment can be done now (no warning)

在这里，我直接回答这个问题。怎么处理呢？

.copy(deep=False)切片后做一个。参见pandas.DataFrame.copy。

等等，切片不返回副本吗？毕竟，这是警告消息要说的内容？阅读详细答案：

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

这给出了警告：

df0 = df[df.x>2]
df0['foo'] = 'bar'

这不是：

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

这两个df0和df1的DataFrame对象，但一些关于他们是不同的，它使大熊猫打印的警告。让我们找出它是什么。

import inspect
slice= df[df.x>2]
slice_copy = df[df.x>2].copy(deep=False)
inspect.getmembers(slice)
inspect.getmembers(slice_copy)

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

|          | slice   | slice_copy |
| _is_copy | weakref | None       |

决定是否发出警告的方法是DataFrame._check_setitem_copy检查_is_copy。所以，你去。进行设置，copy使您的DataFrame不会_is_copy。

建议使用警告.loc，但如果在上使用.loc该框架_is_copy，您仍会收到相同的警告。误导？是。烦人吗 你打赌 有帮助吗？可能在使用链接分配时。但是它不能正确检测链条分配，并且会随意打印警告。