如何在Pandas中处理SettingWithCopyWarning?

时间:2013-12-17 03:48:03

标签: python pandas dataframe chained-assignment

背景

我刚刚将我的Pandas从0.11升级到0.13.0rc1。现在,该应用程序正在弹出许多新的警告。其中一个是这样的:

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

我想知道究竟是什么意思?我需要改变什么吗?

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

提供错误的函数

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

更多错误消息

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

16 个答案:

答案 0 :(得分:568)

创建SettingWithCopyWarning是为了标记可能令人困惑的“链式”分配,例如以下内容,这些分配并不总是按预期工作,特别是当第一个选择返回副本时。 [有关背景讨论,请参阅GH5390GH5597。]

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

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

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

答案 1 :(得分:128)

一般来说,SettingWithCopyWarning的目的是向用户(尤其是新用户)显示他们可能在副本上运行而不是他们想到的原始用户。 误报(IOW,如果你知道你在做什么,可能 ok )。一种可能性就是关闭@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

答案 2 :(得分:72)

  

如何处理熊猫中的SettingWithCopyWarning

这篇文章是为那些

的读者准备的。
  1. 想了解这个警告的意思
  2. 想了解抑制此警告的不同方式
  3. 想了解如何改进其代码并遵循良好做法,以避免将来出现此警告。

设置

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时,可以对帧进行切片/索引以返回 view copy ,具体取决于内部布局和各种实现细节。顾名思义,“视图”是原始数据的视图,因此修改视图可能会修改原始对象。另一方面,“副本”是原始数据的复制,修改副本不会影响原始数据。

如其他答案所述,创建SettingWithCopyWarning来标记“链接分配”操作。在上述设置中考虑df。假设您要选择“ 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)

通过一次__setitem__调用df。 OTOH,请考虑以下代码:

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

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

通常,您应使用loc进行基于标签的分配,并使用iloc进行基于整数/位置的分配,因为该规范保证了它们始终在原始文件上运行。另外,要设置单个单元格,应使用atiat

更多信息可以在documentation中找到。

  

注意
  使用loc完成的所有布尔索引操作也可以使用iloc完成。唯一的区别是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
     

以此类推。


只要告诉我如何抑制警告!

考虑对df的“ A”列进行简单的操作。选择“ 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

有两种方法可以直接静默此警告:

  1. 创建一个deepcopy

    df2 = df[['A']].copy(deep=True)
    df2['A'] /= 2
    
  2. 更改pd.options.mode.chained_assignment
    可以设置为None"warn""raise""warn"是默认设置。 None将完全禁止警告,而"raise"将抛出SettingWithCopyError,从而阻止操作进行。

    pd.options.mode.chained_assignment = None
    df2['A'] /= 2
    
注释中的

@Peter Cotton提出了一种不错的方法,即使用上下文管理器以非侵入方式更改模式(从this gist修改),以仅在需要时设置模式,完成后将其重置为原始状态。

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

用法如下:

# 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

“ XY问题”:我在做什么错了?

很多时候,用户试图寻找抑制此异常的方法,而没有完全理解为什么首先出现该异常。这是XY problem的一个很好的示例,其中用户尝试解决问题“ Y”,这实际上是更深层次的问题“ X”的症状。将基于遇到此警告的常见问题提出问题,然后提出解决方案。

  

问题1
  我有一个DataFrame

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

我想在col“ A”> 5到1000中分配值。我的预期输出是

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

错误的方法:

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的正确方法:

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


  

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

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

我尝试了不同的方式访问此单元格,例如   df['D'][1]。最好的方法是什么?

     

1。这个问题与警告没有特别的关系,但是   很好地了解如何正确执行此特定操作   以避免可能出现警告的情况   未来。

您可以使用以下任何一种方法来完成此操作。

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


  

问题3
  我正在尝试根据某些条件对值进行子集化。我有一个   数据框

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

我想将“ D”中的值分配给123,以使“ C” ==5。I   尝试过

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

哪个看起来还不错,但我仍然   SettingWithCopyWarning!我该如何解决?

这实际上可能是因为您的管道中的代码更高。您是否从较大的对象(例如

)创建了df2
df2 = df[df.A > 5]

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

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


  

问题4
  我正在尝试从

中就地删除列“ C”
   A  B  C  D  E
1  9  3  5  2  4
2  7  6  8  8  1
     

但是使用

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

抛出SettingWithCopyWarning。为什么会这样?

这是因为df2必须已经通过其他切片操作(例如

)作为视图创建
df2 = df[df.A > 5]

这里的解决方案是像以前一样将copy()做成df,或使用loc

答案 3 :(得分:34)

Pandas数据帧复制警告

当你去做这样的事情时:

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对象做神奇的事情。

答案 4 :(得分:6)

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

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

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

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

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

干杯!

答案 5 :(得分:5)

从使用.apply()方法的现有数据帧分配新数据帧时,我遇到了.query()这个问题。例如:

prop_df = df.query('column == "value"')
prop_df['new_column'] = prop_df.apply(function, axis=1)

将返回此错误。在这种情况下,似乎可以解决该错误的解决方法是将其更改为:

prop_df = df.copy(deep=True)
prop_df = prop_df.query('column == "value"')
prop_df['new_column'] = prop_df.apply(function, axis=1)

但是,由于必须进行新的复制,这在使用大型数据帧时效率不高。

如果在生成新列及其值时使用.apply()方法,则可以通过添加.reset_index(drop=True)来解决错误并提高效率:

prop_df = df.query('column == "value"').reset_index(drop=True)
prop_df['new_column'] = prop_df.apply(function, axis=1)

答案 6 :(得分:4)

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

切片后制作.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'

df0df1都是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,仍然会收到相同的警告。误导?是。烦人吗你打赌有帮助吗?可能在使用链接分配时。但是它不能正确检测链条分配,并且会随意打印警告。

答案 7 :(得分:2)

如果已将切片指定给变量,并希望使用变量进行设置,如下所示:

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

并且您不想使用Jeffs解决方案,因为计算df2的条件很长或者出于其他原因,那么您可以使用以下内容:

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

df2.index.tolist()返回df2中所有条目的索引,然后用于在原始数据框中设置B列。

答案 8 :(得分:2)

这应该有效:

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

答案 9 :(得分:2)

由于这个问题已经在现有答案中得到了充分的解释和讨论,所以我将为使用pandas的上下文管理器(到docs和{{3}的链接)提供一种简洁的pandas.option_context方法})-绝对不需要使用所有dunder方法和其他花哨功能创建自定义类。

首先,上下文管理器代码本身:

from contextlib import contextmanager

@contextmanager
def SuppressPandasWarning():
    with pd.option_context("mode.chained_assignment", None):
        yield

再举一个例子:

import pandas as pd
from string import ascii_letters

a = pd.DataFrame({"A": list(ascii_letters[0:4]), "B": range(0,4)})

mask = a["A"].isin(["c", "d"])
# Even shallow copy below is enough to not raise the warning, but why is a mystery to me.
b = a.loc[mask]  # .copy(deep=False)

# Raises the `SettingWithCopyWarning`
b["B"] = b["B"] * 2

# Does not!
with SuppressPandasWarning():
    b["B"] = b["B"] * 2

值得一提的是,这两个方法都不会修改a,这让我有些惊讶,即使是带有.copy(deep=False)的浅df副本也将阻止发出此警告(就我而言)理解浅拷贝至少也应该修改a,但这不是。pandas的魔力。)

答案 10 :(得分:1)

你可以避免像这样的整个问题,我相信:

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

使用Assign。从documentation:将新列分配给DataFrame,返回包含除新列之外的所有原始列的新对象(副本)。

请参阅Tom Augspurger关于熊猫方法链的文章:https://tomaugspurger.github.io/method-chaining

答案 11 :(得分:1)

对我来说,这个问题发生在以下>简化<例。我也能够解决它(希望有一个正确的解决方案):

带有警告的旧代码:

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类型,因此我将该行替换为:

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

即。 method用于访问/查找Series。虽然两者都运行得很好并且结果相同,但这样我就不必禁用警告(=将其保留在其他地方的其他链索引问题上)。

我希望这可以帮助别人。

答案 12 :(得分:1)

这个话题真的让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)

答案 13 :(得分:1)

我在执行这部分代码时遇到了同样的警告:

    def scaler(self, numericals):
        scaler = MinMaxScaler()
        self.data.loc[:, numericals[0]] = scaler.fit_transform(self.data.loc[:, numericals[0]])
        self.data.loc[:, numericals[1]] = scaler.fit_transform(self.data.loc[:, numericals[1]])

其中 scaler 是 MinMaxScaler,numericals[0] 包含我的 3 个数字列的名称。 当我将代码更改为:

时,警告被删除了
    def scaler(self, numericals):
        scaler = MinMaxScaler()
        self.data.loc[:][numericals[0]] = scaler.fit_transform(self.data.loc[:][numericals[0]])
        self.data.loc[:][numericals[1]] = scaler.fit_transform(self.data.loc[:][numericals[1]])

所以,只需将 [:, ~] 更改为 [:][~]

答案 14 :(得分:0)

后续新手提问/评论

也许是对其他像我这样的初学者的澄清(我来自R,似乎在幕后工作有所不同)。以下看起来无害且功能正常的代码不断产生SettingWithCopy警告,但我不知道为什么。我已经阅读并理解了带有“链式索引”的文档,但是我的代码不包含任何内容:

Xcode 10.1.

但是后来,太晚了,我查看了plot()函数的调用位置:

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

“ df”不是数据框,而是某种对象,它以某种方式记住它是通过索引数据框而创建的(是视图吗?),它将在plot()中成为一行

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

等同于

 df['target'] = ...

是链接索引。我说对了吗?

无论如何

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

修复了该问题。

答案 15 :(得分:0)

有些人可能想简单地消除警告:

library(ggrepel)
+geom_text_repel(aes(labels=colnames(wine_subset)))