在Python pandas中向现有DataFrame添加新列-Java 学习之路

665

我有以下索引的DataFrame与命名列和行不连续数字：

a         b         c         d
2  0.671399  0.101208 -0.181532  0.241273
3  0.446172 -0.243316  0.051767  1.577318
5  0.614758  0.075793 -0.451460 -0.012493

我想在现有数据框中添加一个新列 'e' ，并且不希望更改数据框中的任何内容（即，新列的长度始终与DataFrame相同） .

0   -0.335485
1   -1.166658
2   -0.385571
dtype: float64

我尝试了 join ， append ， merge 的不同版本，但我没有得到我想要的结果，最多只有错误 . 如何在上面的示例中添加 e 列？

21 回答

最简单的方法： -

data['new_col'] = list_of_values

data.loc[ : , 'new_col'] = list_of_values

回复于 2024-04-28T21:41:46+08:00

739
- 首先创建一个包含相关数据的python list_of_e .
- 使用此： df['e'] = list_of_e
回复于 2024-04-28T21:41:46+08:00
101

让我补充一点，就像hum3一样， .loc 没有解决 SettingWithCopyWarning 而且我不得不求助于 df.insert() . 在我的情况下，"fake"链索引 dict['a']['e'] 生成误报，其中 'e' 是新列， dict['a'] 是来自字典的DataFrame .

另请注意，如果您知道自己在做什么，可以使用 pd.options.mode.chained_assignment = None 切换警告，而不是使用此处给出的其他解决方案 .

回复于 2024-04-28T21:41:46+08:00
6
如果你得到 SettingWithCopyWarning ，一个简单的解决方法是复制你想要添加列的DataFrame .
```
df = df.copy()
df['col_name'] = values
```
回复于 2024-04-28T21:41:46+08:00

在分配新列之前，如果您有索引数据，则需要对索引进行排序 . 至少在我的情况下，我不得不：

data.set_index(['index_column'], inplace=True)
"if index is unsorted, assignment of a new column will fail"        
data.sort_index(inplace = True)
data.loc['index_value1', 'column_y'] = np.random.randn(data.loc['index_value1', 'column_x'].shape[0])

回复于 2024-04-28T21:41:46+08:00

166

这是添加新列的简单方法： df['e'] = e

回复于 2024-04-28T21:41:46+08:00
5
我一直在寻找一种将 numpy.nan 列添加到数据帧而不会得到哑巴 SettingWithCopyWarning 的一般方法 .

从以下内容：
- 这里的答案
- this question关于将变量作为关键字参数传递
- this method用于生成内联的 numpy NaN数组
我想出了这个：
```
col = 'column_name'
df = df.assign(**{col:numpy.full(len(df), numpy.nan)})
```
回复于 2024-04-28T21:41:46+08:00

我想在现有数据框中添加一个新列'e'，并且不要更改数据框中的任何内容 . （该系列的长度始终与数据帧相同 . ）

我假设 e 中的索引值与 df1 中的索引值匹配 .

启动名为 e 的新列的最简单方法，并为其分配系列 e 中的值：

df['e'] = e.values

assign (Pandas 0.16.0+)

从Pandas 0.16.0开始，您还可以使用assign，它将新列分配给DataFrame并返回一个新对象（副本），除了新的列之外还包含所有原始列 .

df1 = df1.assign(e=e.values)

根据this example（其中还包括 assign 函数的源代码），您还可以包含多个列：

df = pd.DataFrame({'a': [1, 2], 'b': [3, 4]})
>>> df.assign(mean_a=df.a.mean(), mean_b=df.b.mean())
   a  b  mean_a  mean_b
0  1  3     1.5     3.5
1  2  4     1.5     3.5

在您的示例的上下文中：

np.random.seed(0)
df1 = pd.DataFrame(np.random.randn(10, 4), columns=['a', 'b', 'c', 'd'])
mask = df1.applymap(lambda x: x <-0.7)
df1 = df1[-mask.any(axis=1)]
sLength = len(df1['a'])
e = pd.Series(np.random.randn(sLength))

>>> df1
          a         b         c         d
0  1.764052  0.400157  0.978738  2.240893
2 -0.103219  0.410599  0.144044  1.454274
3  0.761038  0.121675  0.443863  0.333674
7  1.532779  1.469359  0.154947  0.378163
9  1.230291  1.202380 -0.387327 -0.302303

>>> e
0   -1.048553
1   -1.420018
2   -1.706270
3    1.950775
4   -0.509652
dtype: float64

df1 = df1.assign(e=e.values)

>>> df1
          a         b         c         d         e
0  1.764052  0.400157  0.978738  2.240893 -1.048553
2 -0.103219  0.410599  0.144044  1.454274 -1.420018
3  0.761038  0.121675  0.443863  0.333674 -1.706270
7  1.532779  1.469359  0.154947  0.378163  1.950775
9  1.230291  1.202380 -0.387327 -0.302303 -0.509652

首次引入此新功能的描述可以在here找到 .

回复于 2024-04-28T21:41:46+08:00

使用原始df1索引创建系列：

df1['e'] = Series(np.random.randn(sLength), index=df1.index)

Edit 2015
有些人报道用这段代码获得 SettingWithCopyWarning .
但是，当前的pandas版本0.16.1仍然可以完美运行 .

>>> sLength = len(df1['a'])
>>> df1
          a         b         c         d
6 -0.269221 -0.026476  0.997517  1.294385
8  0.917438  0.847941  0.034235 -0.448948

>>> df1['e'] = p.Series(np.random.randn(sLength), index=df1.index)
>>> df1
          a         b         c         d         e
6 -0.269221 -0.026476  0.997517  1.294385  1.757167
8  0.917438  0.847941  0.034235 -0.448948  2.228131

>>> p.version.short_version
'0.16.1'

SettingWithCopyWarning 旨在通知Dataframe副本上可能无效的分配 . 它并不一定说你做错了（它可以触发误报），但是从0.13.0开始，它会让你知道有更多适当的方法用于同一目的 . 然后，如果您收到警告，请按照其建议：尝试使用.loc [row_index，col_indexer] = value

>>> df1.loc[:,'f'] = p.Series(np.random.randn(sLength), index=df1.index)
>>> df1
          a         b         c         d         e         f
6 -0.269221 -0.026476  0.997517  1.294385  1.757167 -0.050927
8  0.917438  0.847941  0.034235 -0.448948  2.228131  0.006109
>>>

事实上，这是目前更有效的方法described in pandas docs

Edit 2017

正如评论和@Alexander所示，目前将系列的值添加为DataFrame的新列的最佳方法可能是使用 assign ：

df1 = df1.assign(e=p.Series(np.random.randn(sLength)).values)

回复于 2024-04-28T21:41:46+08:00

23

似乎在最近的Pandas版本中，要走的路是使用df.assign：

df1 = df1.assign(e=np.random.randn(sLength))

它不会产生 SettingWithCopyWarning .

回复于 2024-04-28T21:41:46+08:00
18
超级简单的列分配

pandas数据帧实现为列的有序字典 .

这意味着 __getitem__ [] 不仅可以用于获取某个列，而且可以使用 __setitem__ [] = 来分配新列 .

例如，只需使用 [] 访问器，此数据框就可以添加一列
```
size      name color
0    big      rose   red
1  small    violet  blue
2  small     tulip   red
3  small  harebell  blue

df['protected'] = ['no', 'no', 'no', 'yes']

    size      name color protected
0    big      rose   red        no
1  small    violet  blue        no
2  small     tulip   red        no
3  small  harebell  blue       yes
```
请注意，即使数据帧的索引处于关闭状态，这仍然有效 .
```
df.index = [3,2,1,0]
df['protected'] = ['no', 'no', 'no', 'yes']
    size      name color protected
3    big      rose   red        no
2  small    violet  blue        no
1  small     tulip   red        no
0  small  harebell  blue       yes
```
[] =是要走的路，但要小心！

但是，如果您有 pd.Series 并尝试将其分配给索引关闭的数据帧，则会遇到麻烦 . 见例子：
```
df['protected'] = pd.Series(['no', 'no', 'no', 'yes'])
    size      name color protected
3    big      rose   red       yes
2  small    violet  blue        no
1  small     tulip   red        no
0  small  harebell  blue        no
```
这是因为 pd.Series 默认情况下具有从0到n枚举的索引 . 并且大熊猫 [] = 方法 tries 将"smart"

究竟发生了什么 .

当您使用 [] = 方法时，pandas正在使用左侧数据帧的索引和右侧系列的索引安静地执行外部联接或外部合并 . df['column'] = series

旁注

这很快导致认知失调，因为 []= 方法试图根据输入做很多不同的事情，除非你只知道熊猫是如何工作的，否则结果无法预测 . 因此，我会建议反对代码库中的 []= ，但是什么时候在笔记本中探索数据，很好 .

解决问题

如果您有 pd.Series 并希望从上到下分配，或者如果您正在编写生产环境代码并且您不确定索引顺序，那么保护此类问题是值得的 .

你可以将 pd.Series 转发给 np.ndarray 或 list ，这样就可以了 .
```
df['protected'] = pd.Series(['no', 'no', 'no', 'yes']).values
```
要么
```
df['protected'] = list(pd.Series(['no', 'no', 'no', 'yes']))
```
But this is not very explicit.

一些程序员可能会说“嘿，这看起来多余，我只会优化它” .

明确的方式

将 pd.Series 的索引设置为 df 的索引是显式的 .
```
df['protected'] = pd.Series(['no', 'no', 'no', 'yes'], index=df.index)
```
或者更现实地说，你可能已经有了 pd.Series .
```
protected_series = pd.Series(['no', 'no', 'no', 'yes'])
protected_series.index = df.index

3     no
2     no
1     no
0    yes
```
现在可以分配
```
df['protected'] = protected_series

    size      name color protected
3    big      rose   red        no
2  small    violet  blue        no
1  small     tulip   red        no
0  small  harebell  blue       yes
```
与df.reset_index（）的替代方式

由于索引不一致是问题所在，如果你觉得数据框的索引不应该决定事情，你可以简单地删除索引，这应该更快，但它不是很干净，因为你的函数现在可能做两件事 .
```
df.reset_index(drop=True)
protected_series.reset_index(drop=True)
df['protected'] = protected_series

    size      name color protected
0    big      rose   red        no
1  small    violet  blue        no
2  small     tulip   red        no
3  small  harebell  blue       yes
```
关于df.assign的注意事项

虽然 df.assign 让你更清楚你正在做什么，它实际上有与上面所有相同的问题 []=
```
df.assign(protected=pd.Series(['no', 'no', 'no', 'yes']))
    size      name color protected
3    big      rose   red       yes
2  small    violet  blue        no
1  small     tulip   red        no
0  small  harebell  blue        no
```
请注意 df.assign 您的专栏未被称为 self . 这会导致错误 . 这使得 df.assign smelly ，因为函数中存在这些伪像 .
```
df.assign(self=pd.Series(['no', 'no', 'no', 'yes'])
TypeError: assign() got multiple values for keyword argument 'self'
```
你可能会说，“好吧，我当时就不会使用 self ” . 但谁知道这个函数将来如何变化以支持新的论点 . 也许您的列名将成为新的pandas更新中的参数，从而导致升级问题 .
回复于 2024-04-28T21:41:46+08:00

为了完整起见 - 使用DataFrame.eval()方法的另一种解决方案：

数据：

In [44]: e
Out[44]:
0    1.225506
1   -1.033944
2   -0.498953
3   -0.373332
4    0.615030
5   -0.622436
dtype: float64

In [45]: df1
Out[45]:
          a         b         c         d
0 -0.634222 -0.103264  0.745069  0.801288
4  0.782387 -0.090279  0.757662 -0.602408
5 -0.117456  2.124496  1.057301  0.765466
7  0.767532  0.104304 -0.586850  1.051297
8 -0.103272  0.958334  1.163092  1.182315
9 -0.616254  0.296678 -0.112027  0.679112

解：

In [46]: df1.eval("e = @e.values", inplace=True)

In [47]: df1
Out[47]:
          a         b         c         d         e
0 -0.634222 -0.103264  0.745069  0.801288  1.225506
4  0.782387 -0.090279  0.757662 -0.602408 -1.033944
5 -0.117456  2.124496  1.057301  0.765466 -0.498953
7  0.767532  0.104304 -0.586850  1.051297 -0.373332
8 -0.103272  0.958334  1.163092  1.182315  0.615030
9 -0.616254  0.296678 -0.112027  0.679112 -0.622436

回复于 2024-04-28T21:41:46+08:00

4
我得到了可怕的 SettingWithCopyWarning ，并且没有使用iloc语法修复它 . 我的DataFrame是由ODBC源的read_sql创建的 . 使用上面的lowtech建议，以下工作对我有用：
```
df.insert(len(df.columns), 'e', pd.Series(np.random.randn(sLength),  index=df.index))
```
这样可以在最后插入列 . 我不喜欢警告信息 . 我认为有一个更好的解决方案，但我找不到它，我认为这取决于索引的某些方面 .
注意 . 这只能工作一次，并在尝试覆盖现有列时会给出错误消息 .
Note 如上所述，从0.16.0分配是最好的解决方案 . 请参阅文档http://pandas.pydata.org/pandas-docs/stable/generated/pandas.DataFrame.assign.html#pandas.DataFrame.assign适用于不覆盖中间值的数据流类型 .
回复于 2024-04-28T21:41:46+08:00

Foolproof:

df.loc[:, 'NewCol'] = 'New_Val'

例：

df = pd.DataFrame(data=np.random.randn(20, 4), columns=['A', 'B', 'C', 'D'])

df

           A         B         C         D
0  -0.761269  0.477348  1.170614  0.752714
1   1.217250 -0.930860 -0.769324 -0.408642
2  -0.619679 -1.227659 -0.259135  1.700294
3  -0.147354  0.778707  0.479145  2.284143
4  -0.529529  0.000571  0.913779  1.395894
5   2.592400  0.637253  1.441096 -0.631468
6   0.757178  0.240012 -0.553820  1.177202
7  -0.986128 -1.313843  0.788589 -0.707836
8   0.606985 -2.232903 -1.358107 -2.855494
9  -0.692013  0.671866  1.179466 -1.180351
10 -1.093707 -0.530600  0.182926 -1.296494
11 -0.143273 -0.503199 -1.328728  0.610552
12 -0.923110 -1.365890 -1.366202 -1.185999
13 -2.026832  0.273593 -0.440426 -0.627423
14 -0.054503 -0.788866 -0.228088 -0.404783
15  0.955298 -1.430019  1.434071 -0.088215
16 -0.227946  0.047462  0.373573 -0.111675
17  1.627912  0.043611  1.743403 -0.012714
18  0.693458  0.144327  0.329500 -0.655045
19  0.104425  0.037412  0.450598 -0.923387


df.drop([3, 5, 8, 10, 18], inplace=True)

df

           A         B         C         D
0  -0.761269  0.477348  1.170614  0.752714
1   1.217250 -0.930860 -0.769324 -0.408642
2  -0.619679 -1.227659 -0.259135  1.700294
4  -0.529529  0.000571  0.913779  1.395894
6   0.757178  0.240012 -0.553820  1.177202
7  -0.986128 -1.313843  0.788589 -0.707836
9  -0.692013  0.671866  1.179466 -1.180351
11 -0.143273 -0.503199 -1.328728  0.610552
12 -0.923110 -1.365890 -1.366202 -1.185999
13 -2.026832  0.273593 -0.440426 -0.627423
14 -0.054503 -0.788866 -0.228088 -0.404783
15  0.955298 -1.430019  1.434071 -0.088215
16 -0.227946  0.047462  0.373573 -0.111675
17  1.627912  0.043611  1.743403 -0.012714
19  0.104425  0.037412  0.450598 -0.923387

df.loc[:, 'NewCol'] = 0

df
           A         B         C         D  NewCol
0  -0.761269  0.477348  1.170614  0.752714       0
1   1.217250 -0.930860 -0.769324 -0.408642       0
2  -0.619679 -1.227659 -0.259135  1.700294       0
4  -0.529529  0.000571  0.913779  1.395894       0
6   0.757178  0.240012 -0.553820  1.177202       0
7  -0.986128 -1.313843  0.788589 -0.707836       0
9  -0.692013  0.671866  1.179466 -1.180351       0
11 -0.143273 -0.503199 -1.328728  0.610552       0
12 -0.923110 -1.365890 -1.366202 -1.185999       0
13 -2.026832  0.273593 -0.440426 -0.627423       0
14 -0.054503 -0.788866 -0.228088 -0.404783       0
15  0.955298 -1.430019  1.434071 -0.088215       0
16 -0.227946  0.047462  0.373573 -0.111675       0
17  1.627912  0.043611  1.743403 -0.012714       0
19  0.104425  0.037412  0.450598 -0.923387       0

回复于 2024-04-28T21:41:46+08:00

5
但有一点需要注意的是，如果你这样做的话
```
df1['e'] = Series(np.random.randn(sLength), index=df1.index)
```
这实际上是df1.index上的 left 连接 . 因此，如果您想要具有 outer 连接效果，我可能不完美的解决方案是创建一个数据框，其索引值覆盖数据范围，然后使用上面的代码 . 例如，
```
data = pd.DataFrame(index=all_possible_values)
df1['e'] = Series(np.random.randn(sLength), index=df1.index)
```
回复于 2024-04-28T21:41:46+08:00

以下是我的所作所为...但我对熊猫和Python一般都是新手，所以没有任何承诺 .

df = pd.DataFrame([[1, 2], [3, 4], [5,6]], columns=list('AB'))

newCol = [3,5,7]
newName = 'C'

values = np.insert(df.values,df.shape[1],newCol,axis=1)
header = df.columns.values.tolist()
header.append(newName)

df = pd.DataFrame(values,columns=header)

回复于 2024-04-28T21:41:46+08:00

6

如果要将整个新列设置为初始基值（例如 None ），则可以执行以下操作： df1['e'] = None

这实际上会将“对象”类型分配给单元格 . 所以稍后您可以将复杂的数据类型（如list）放入单个单元格中 .

回复于 2024-04-28T21:41:46+08:00
31
如果您要添加的列是一个系列变量，那么只需：
```
df["new_columns_name"]=series_variable_name #this will do it for you
```
即使您要替换现有列，这也很有效 . 只需键入与要替换的列相同的new_columns_name . 它将仅使用新系列数据覆盖现有列数据 .
回复于 2024-04-28T21:41:46+08:00
8
要向现有数据框添加新列“e”
```
df1.loc[:,'e'] = Series(np.random.randn(sLength))
```
回复于 2024-04-28T21:41:46+08:00
6
通过NumPy直接执行此操作将是最有效的：
```
df1['e'] = np.random.randn(sLength)
```
请注意我的原始（非常古老）建议是使用 map （这要慢得多）：
```
df1['e'] = df1['a'].map(lambda x: np.random.random())
```
回复于 2024-04-28T21:41:46+08:00

如果数据框和Series对象有 the same index ， pandas.concat 也可以在这里工作：

import pandas as pd
df
#          a            b           c           d
#0  0.671399     0.101208   -0.181532    0.241273
#1  0.446172    -0.243316    0.051767    1.577318
#2  0.614758     0.075793   -0.451460   -0.012493

e = pd.Series([-0.335485, -1.166658, -0.385571])    
e
#0   -0.335485
#1   -1.166658
#2   -0.385571
#dtype: float64

# here we need to give the series object a name which converts to the new  column name 
# in the result
df = pd.concat([df, e.rename("e")], axis=1)
df

#          a            b           c           d           e
#0  0.671399     0.101208   -0.181532    0.241273   -0.335485
#1  0.446172    -0.243316    0.051767    1.577318   -1.166658
#2  0.614758     0.075793   -0.451460   -0.012493   -0.385571

如果它们没有相同的索引：

e.index = df.index
df = pd.concat([df, e.rename("e")], axis=1)

回复于 2024-04-28T21:41:46+08:00

在Python pandas中向现有DataFrame添加新列

21 回答

超级简单的列分配

[] =是要走的路，但要小心！

究竟发生了什么 .

旁注

解决问题

明确的方式

与df.reset_index（）的替代方式

关于df.assign的注意事项

相关问题