如何处理 Pandas 中的 SettingWithCopyWarning

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

虽然很明显您并不关心将其写入原始帧（因为您正在覆盖对它的引用），但不幸的是，这种模式无法与第一个链式分配示例区分开来。因此（误报）警告。如果您想进一步阅读，docs on indexing 中解决了误报的可能性。您可以通过以下分配安全地禁用此新警告。

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

其他资源

pandas 用户指南：索引和选择数据

Python 数据科学手册：数据索引和选择

真正的 Python：Pandas 中的 SettingWithCopyWarning：视图与副本

Dataquest：SettingwithCopyWarning：如何在 Pandas 中修复此警告

迈向数据科学：解释 Pandas 中的 SettingWithCopyWarning

---

如何处理 Pandas 中的 SettingWithCopyWarning？

这篇文章是为读者准备的，

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

设置

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 是为了标记“链式分配”操作。考虑上述设置中的 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)

通过对 df 的一次 __setitem__ 调用。 OTOH，请考虑以下代码：

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

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

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

更多信息可在 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

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

（推荐）使用 loc 对子集进行切片： df2 = df.loc[:, ['A']] df2['A'] /= 2 # 不引发改变 pd.options.mode.chained_assignment 可以设置为None， “警告”或“提高”。 “警告”是默认值。 None 将完全抑制警告，“raise”将引发 SettingWithCopyError，阻止操作通过。 pd.options.mode.chained_assignment = 无 df2['A'] /= 2 进行深度复制 df2 = df[['A']].copy(deep=True) df2['A'] /= 2

@Peter Cotton 在评论中提出了一种使用上下文管理器非侵入式更改模式（从 this gist 修改）的好方法，仅在需要时设置模式，然后将其重置回完成时的原始状态。

类 ChainedAssignent: def __init__(self, chained=None): 可接受 = [None, 'warn', 'raise'] 断言链接在可接受的范围内，“链接必须在” + 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 ABCDE 0 5 0 3 3 7 1 9 3 5 2 4 2 7 6 8 8 1 我想将 col "A" > 5 中的值分配给 1000。我的预期输出是 ABCDE 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

问题 21 我正在尝试将单元格 (1, 'D') 中的值设置为 12345。我的预期输出是 ABCDE 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 我正在尝试根据某些条件对值进行子集化。我有一个 DataFrame ABCDE 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 我正在尝试从

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

---

一般而言，SettingWithCopyWarning 的目的是向用户（尤其是新用户）显示他们可能在操作副本而不是他们认为的原件。 有误报（如果你知道自己在做什么，IOW 可能是 ok）。一种可能性是像@Garrett 建议的那样简单地关闭（默认情况下warn）警告。

这是另一种选择：

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

---

熊猫数据框复制警告

当你去做这样的事情时：

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

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

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

这是 pandas 试图警告你的。

为什么 .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 对象来做神奇的事情。

---

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

切片后做一个.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 对象，但它们的某些不同之处在于使 pandas 能够打印警告。让我们找出它是什么。

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       |

决定是否发出警告的方法是检查 _is_copy 的 DataFrame._check_setitem_copy。所以给你。制作一个 copy，使您的 DataFrame 不是 _is_copy。

该警告建议使用 .loc，但如果您在具有 _is_copy 的框架上使用 .loc，您仍然会收到相同的警告。误导？是的。恼人的？你打赌。有帮助吗？潜在地，当使用链式赋值时。但它无法正确检测链分配并不加选择地打印警告。

---

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

---

从我使用 .query() 方法的预先存在的数据帧分配新数据帧时，我遇到了 .apply() 的这个问题。例如：

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)

---

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

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

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

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

干杯!

---

对我来说工作：

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

---

这应该有效：

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

---

有些人可能想简单地抑制警告：

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

---

后续初学者问题/备注

也许是对像我这样的其他初学者的澄清（我来自 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

解决它。

---

由于这个问题已经在现有答案中得到充分解释和讨论，我将只使用 pandas.option_context 为上下文管理器提供一个简洁的 pandas 方法（指向 docs 和 example 的链接） - 绝对不需要创建一个具有所有 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 魔术。）。

---

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

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

使用分配。从 documentation：将新列分配给 DataFrame，返回一个新对象（副本），其中包含除新列之外的所有原始列。

请参阅 Tom Augspurger 关于 pandas 中的方法链接的文章：https://tomaugspurger.github.io/method-chaining

---

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

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

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

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

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

---

这可能仅适用于 numpy，这意味着您可能需要导入它，但我用于示例 numpy 的数据对于计算并不重要，但您可以使用下面的 1 行代码简单地停止此设置并带有复制警告消息,

np.warnings.filterwarnings('ignore')

---

对我来说，这个问题发生在以下 >simplified< 示例中。而且我也能够解决它（希望有一个正确的解决方案）：

带有警告的旧代码：

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。尽管两者都可以正常工作并且结果相同，但这样我就不必禁用警告（=保留它们以用于其他地方的其他链索引问题）。

我希望这可以帮助某人。

---

当我执行这部分代码时，我面临同样的警告：

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

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

---

就我而言，我会根据索引创建一个新列，但我收到了这个警告：

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

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

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

---

只需在警告出现之前使用 .copy() 方法创建数据帧的副本，即可删除所有警告。发生这种情况是因为我们不想更改原始的 quote_df。换句话说，我们不想使用我们为quote_df 创建的quote_df 对象的引用。

quote_df = quote_df.copy()

---