摘要：问题描述：背景我刚刚将我的 Pandas 从 0.11 升级到 0.13.0rc1。现在，应用程序弹出许多新警告。其中一个是这样的：E:FinReporterFM_EXT.py:449: SettingWithCopyWarning: A value is trying to be set on a copy...

问题描述：

背景

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

E:FinReporterFM_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

解决方案 1：

创建的目的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

虽然很明显您并不关心写入是否返回到原始框架（因为您正在覆盖对它的引用），但不幸的是，这种模式无法与第一个链式分配示例区分开来。因此出现了（误报）警告。如果您想进一步阅读，可以在索引文档中解决误报的可能性。您可以使用以下分配安全地禁用此新警告。

import pandas as pd
pd.options.mode.chained_assignment = None  # default='warn'

其他资源

pandas 用户指南：索引和选择数据
Python 数据科学手册：数据索引和选择
真正的 Python：Pandas 中的 SettingWithCopyWarning：视图与副本
Dataquest：SettingwithCopyWarning：如何在 Pandas 中修复此警告
走向数据科学：解释 Pandas 中的 SettingWithCopyWarning

解决方案 2：

如何处理Pandas 中的SettingWithCopyWarningand ？ChainedAssignmentError

这篇文章适合以下读者：

想了解这个警告的含义
想要了解抑制此警告的不同方法
想要了解如何改进他们的代码并遵循良好的做法以避免将来出现此警告。

设置

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

要知道如何处理此警告，首先重要的是了解它的含义以及为什么会出现此警告。

过滤 DataFrames 时，可以对帧进行切片/索引以返回视图或副本，具体取决于内部布局和各种实现细节。正如术语所暗示的那样，“视图”是原始数据的视图，因此修改视图可能会修改原始对象。另一方面，“副本”是从原始数据复制而来，修改副本对原始数据没有影响。

正如其他答案所提到的，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。另一方面，考虑以下代码：

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

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

一般来说，您应该使用loc基于标签的分配，以及iloc基于整数/位置的分配，因为规范保证它们始终在原始位置进行操作。此外，要设置单个单元格，您应该使用at和iat。

更多内容可以在文档中找到。

注意：
所有用完成的布尔索引操作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
等等。

从 pandas >= 2.0 开始，您可以启用写时复制优化以节省内存并避免在写入之前复制数据（如果可能）。

可以通过以下方式启用

pd.options.mode.copy_on_write = True

在此之后，尝试进行链式赋值将导致

ChainedAssignmentError: A value is trying to be set on a copy of a DataFrame or Series through chained assignment.
When using the Copy-on-Write mode, such chained assignment never works to update the original DataFrame or Series, because the intermediate object on which we are setting values always behaves as a copy.

Try using '.loc[row_indexer, col_indexer] = value' instead, to perform the assignment in a single step.

该错误是在与类似的设置中引发的SettingWithCopyWarning。

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

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

有几种方法可以直接消除此警告：

（推荐）用于loc切片子集：

 df2 = df.loc[:, ['A']]
 df2['A'] /= 2     # Does not raise

更改pd.options.mode.chained_assignment
可以设置为None、"warn"或"raise"。"warn"是默认值。None将完全抑制警告，并将"raise"抛出SettingWithCopyError，阻止操作进行。

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

做一个deepcopy

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

@Peter Cotton在评论中，想出了一个使用上下文管理器以非侵入方式更改模式（根据此要点修改）的好方法，仅在需要时设置模式，并在完成后将其重置回原始状态。

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 问题的一个很好的例子，用户试图解决问题“Y”，而问题“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
我想将列“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]。最好的方法是什么？
这个问题与警告没有特别的关系，但了解如何正确执行这个特定的操作以避免将来可能出现警告的情况是有好处的。

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

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

问题 3
我尝试根据某些条件对值进行子集化。我有一个 DataFrame
   A  B  C  D  E
1  9  3  5  2  4
2  7  6  8  8  1
我想将“D”中的值赋给 123，使得“C”==5。我试过
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
我试图从
   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：

总的来说，这样做的目的SettingWithCopyWarning是向用户（尤其是新用户）表明他们可能正在操作副本，而不是他们所认为的原始副本。存在误报（换句话说，如果你知道自己在做什么，那就没问题）。一种可能性是简单地关闭（默认情况下是warn）警告，正如@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

楼主上面展示的代码虽然合法，而且我可能也会这么做，但从技术上讲，这是出现此警告的一个案例，而不是误报。另一种避免出现警告的方法是通过进行选择操作reindex，例如

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

或者，

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

解决方案 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'

和都是对象，但它们之间存在一些差异，这使得 pandas 能够打印警告。让我们来看看它是什么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，您仍会收到相同的警告。误导？是的。烦人？当然。有帮助？在使用链式赋值时可能有帮助。但它无法正确检测链式赋值并随意打印警告。

解决方案 5：

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`

Pandas 开发人员意识到该.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对象来做神奇的事情。

解决方案 6：

这个问题对于 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)

解决方案 7：

简单来说：

import pandas as pd
# ...
pd.set_option('mode.chained_assignment', None)

解决方案 8：

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

解决方案 9：

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

需要明确的是，以下是我收到的警告：

/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。注意：您可以copy.deepcopy通过df.copy()以下方式避免导入。

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

解决方案 10：

这应该有效：

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

解决方案 11：

有些人可能只想抑制警告：

class SupressSettingWithCopyWarning:
    def __enter__(self):
        pd.options.mode.chained_assignment = None

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

with SupressSettingWithCopyWarning():
    #code that produces warning

解决方案 12：

由于这个问题已经在现有答案中得到了充分解释和讨论，我将只提供一个简洁的pandas方法来使用上下文管理器（文档和示例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，这让我有点惊讶，甚至使用浅 df 复制.copy(deep=False)也会阻止引发此警告（据我所知，浅复制至少也应该修改a，但事实并非如此。熊猫魔法。）。

解决方案 13：

这可能仅适用于 NumPy，这意味着您可能需要导入它，但我用于示例 NumPy 的数据对于计算来说并不是必不可少的，但您可以使用下面这一行代码简单地停止此设置并显示复制警告消息：

np.warnings.filterwarnings('ignore')

解决方案 14：

后续初学者问题/评论

也许对像我这样的其他初学者来说，这是一个澄清（我来自R，其底层工作方式似乎有点不同）。以下看似无害且功能齐全的代码不断产生 SettingWithCopy 警告，我不明白为什么。我既阅读了也理解了“链式索引”的问题，但我的代码不包含任何问题：

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

但是后来，已经太晚了，我查看了 plot() 函数的调用位置：

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

因此，“df”不是一个数据框，而是一个以某种方式记住它是通过索引数据框创建的对象（所以这是一个视图吗？），这将在 plot() 中绘制线条，

 df['target'] = ...

相当于

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

这是一个链式索引。

反正，

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

修好了。

解决方案 15：

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

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。来自文档：将新列分配给 DataFrame，返回一个新对象（副本），其中包含新列和所有原始列。

请参阅 Tom Augspurger 关于 Pandas 中方法链的文章：现代 Pandas（第 2 部分）：方法链

解决方案 16：

如果您已将切片分配给变量并想要使用该变量进行设置，如下所示：

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

并且您不想使用Jeff 的解决方案，因为您的条件计算df2太长或由于其他原因，那么您可以使用以下命令：

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

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

解决方案 17：

我的“下一步”开头的这一行帮我解决了这个问题：

df = df.iloc[:] #To avoid SettingWithCopyWarning

解决方案 18：

为什么会发生这种情况？

选择一列列表并将其分配给变量会创建一个副本。在 Pandas 中，对数据框进行切片或索引会创建一个副本。但与也会创建副本的函数调用（例如filter()等）不同query()，您可以为切片或索引的数据框分配一个值，这会成为一个问题，因为新的分配（即链式分配）可能不起作用。因此，SettingWithCopyWarning基本上是在提醒您正在为副本分配新值。

有时令人困惑的是，如果对副本的分配没有改变原始数据框的形状（或使副本具有与原始数据框相同的形状），则不会引发该异常。

df1 = pd.DataFrame({'A': [1, 2, 3], 'B': [1, 2, 3]})
df2 = df1[df1['A']<3]        # <--- one row is filtered out
df2.loc[0, 'C'] = 1          # <--- SettingWithCopyWarning (because it is replacing a value on the copy)
df2.loc[3, 'C'] = 1          # <--- no warning (because it adds a new row which makes df2's shape the same as df1)

与过滤列相同；更改原始数据框子集的副本会引发警告，但如果副本不再是子集，则不会出现警告。

df2 = df1[['A']]               # <--- filters one column out
df2.loc[2, 'A'] = 100          # <--- SettingWithCopyWarning (tries to change a value on the copy)
df2['C'] = 100                 # <--- no warning (adds new column to copy)

解决方案：启用写时复制

自 pandas 1.5.0 起，pandas 具有写入时复制 (CoW)模式，该模式使任何从另一个派生的数据框/系列都表现得像副本一样；因此，启用该模式后，只能通过修改对象本身来更改数据框/系列中的值。一个后果是SettingWithCopyWarning永远不会发生。另一个后果是链式赋值永远不会起作用。此外，只有与另一个对象共享数据时才会创建副本（通常，大多数 pandas 方法都会创建副本，这会减慢代码速度），因此使用 CoW 时 pandas 操作速度更快。

这计划是 pandas 3.0 的默认行为，但截至目前，您必须将其打开。

为了在全球范围内启用它，

pd.options.mode.copy_on_write = True

或者使用上下文管理器在本地打开它：

with pd.option_context("mode.copy_on_write", True):
    # do operations

示例 1（SettingWithCopyWarning静音）：

def func():
    df = pd.DataFrame({'A': range(5), 'B': range(5,0,-1)})
    df1 = df[['B']]           # select a list of columns
    df1.loc[0, 'B'] = 1       # assign a value to the copy
    
func()                        # <---- SettingWithCopyWarning


pd.options.mode.copy_on_write = True
func()                        # <---- no warning

示例 2（链式赋值不起作用）：

pd.options.mode.copy_on_write = False
df = pd.DataFrame({'A': range(5), 'B': range(5,0,-1)})
df['B'][df['A']<4] = 10     # <---- df changes; no warning
df[df['A']<4]['B'] = 10     # <---- df doesn't change; throws SettingWithCopyWarning



pd.options.mode.copy_on_write = True
df = pd.DataFrame({'A': range(5), 'B': range(5,0,-1)})
df['B'][df['A']<4] = 10     # <---- df doesn't change; no warning
df[df['A']<4]['B'] = 10     # <---- df doesn't change; no warning

示例3（视图通过链式方法返回，大大提高了性能）：

df = pd.DataFrame({'A': range(1_000_000), 'B': range(1_000_000)})

%%timeit
with pd.option_context('mode.copy_on_write', False):
    df.add_prefix('col ').set_index('col A').rename_axis('index col').reset_index()
# 30.5 ms ± 561 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)


%%timeit
with pd.option_context('mode.copy_on_write', True):
    df.add_prefix('col ').set_index('col A').rename_axis('index col').reset_index()
# 18 ms ± 513 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)

解决方案 19：

当我执行这部分代码时，我遇到了同样的警告：

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]包含我的三个数字列的名称。

当我将代码更改为以下内容时，警告被删除：

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

因此，只需改为[:, ~]。[:][~]

解决方案 20：

就我而言，我会根据索引创建一个新列，但我收到与您相同的警告：

df_temp["Quarter"] = df_temp.index.quarter

我使用 insert() 而不是直接赋值，它对我有用：

df_temp.insert(loc=0, column='Quarter', value=df_temp.index.quarter)

解决方案 21：

对我来说，这个问题发生在以下简化的示例中。我也能够解决它（希望得到正确的解决方案）：

带有警告的旧代码：

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]

即，一种用于访问/查找的方法Series。尽管两者都可以正常工作并且结果相同，但这样我就不必禁用警告（=将它们保留在其他地方以备其他链式索引问题）。

解决方案 22：

我正在使用 .copy() 来创建新的 df 以避免警告。

df_new = quote_df.copy()
df_new['TVol'] = quote_df['TVol']/TVOL_SCALE

解决方案 23：

只需使用警告出现之前的方法创建数据框的副本.copy()，即可删除所有警告。

发生这种情况是因为我们不想对原始的 quote_df 进行更改。换句话说，我们不想使用为 quote_df 创建的 quote_df 对象的引用。

quote_df = quote_df.copy()

解决方案 24：

就我而言，我仅使用PDCsv.loc[index, name]= NewVal 来实现该功能：

PDCsv.loc[0, 'Name'] = 'Anthony Dave'

解决方案 25：

我使用.loc索引器（属性）对DataFrames 进行子集化，以便SettingWithCopyWarning在操作结果子集时避免 s（new_df如下所示）：

# GOOD way to select a columns subset:
new_df = df.loc[:, cols_subset]

#.. vs. bad way:
new_df = df[cols_subset]
# works but gives this warning:
# 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

解决方案 26：

我遇到了这个问题
df1.Age.fillna(df1.Age.mean(), inplace=True)

然后，我只需将修改后的 DataFrame 直接分配回原始 DataFrame 即可。

前任：df1['Age'] = df1['Age'].fillna(df1.Age.mean())

解决方案 27：

如果我坚持使用，该如何暂停警告？

#Disable warning
pd.options.mode.chained_assignment = None

注意：这不是处理警告的最佳方法。我个人不喜欢忽略这些警告。