直接通过 NumPy 执行此操作将是最有效的：

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

---

请注意，我最初的（非常古老的）建议是使用（速度要慢得多）：map

df1['e'] = df1['a'].map(lambda x: np.random.random())

编辑 2017

如注释和@Alexander所示，目前将 Series 的值添加为 DataFrame 的新列的最佳方法是使用 assign：

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

---

编辑 2015
一些人报告说使用此代码。
但是，该代码仍然可以在当前的 pandas 版本 0.16.1 上完美运行。SettingWithCopyWarning

>>> 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'] = pd.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

>>> pd.version.short_version
'0.16.1'

旨在通知 Dataframe 副本上可能无效的赋值。它不一定说你做错了（它可能会触发误报），但从 0.13.0 开始，它让你知道有更合适的方法用于相同的目的。然后，如果您收到警告，请按照其建议进行操作：尝试改用 .loc[row_index，col_indexer] = valueSettingWithCopyWarning

>>> df1.loc[:,'f'] = pd.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
>>> 

事实上，这是目前 pandas 文档中描述的更有效的方法

---

原文答案：

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

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

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

不过，需要注意的一件事是，如果你这样做

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

这实际上是 df1.index 上的左连接。因此，如果你想有一个外部连接效果，我可能不完美的解决方案是创建一个数据帧，其索引值覆盖你的数据范围，然后使用上面的代码。例如

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

我得到了可怕的，并且没有使用 iloc 语法修复它。我的 DataFrame 是由 read_sql 从 ODBC 源创建的。使用上面 lowtech 的建议，以下内容对我有用：SettingWithCopyWarning

df.insert(len(df.columns), 'e', pd.Series(np.random.randn(sLength),  index=df.index))

这在末尾插入列效果很好。我不知道它是否是最有效的，但我不喜欢警告消息。我认为有更好的解决方案，但我找不到它，我认为这取决于索引的某些方面。
注意。这只能工作一次，如果尝试覆盖现有列，则会给出错误消息。
注意：如上所述，从 0.16.0 开始，分配是最佳解决方案。请参阅文档 http://pandas.pydata.org/pandas-docs/stable/generated/pandas.DataFrame.assign.html#pandas.DataFrame.assign 适用于不会覆盖中间值的数据流类型。

在分配新列之前，如果已编制索引数据，则需要对索引进行排序。至少在我的情况下，我必须：

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

以下是我所做的...但我对 pandas 和 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)

让我补充一点，就像 hum3 一样，没有解决 ，我不得不求助于 .在我的例子中，误报是由“假”链索引生成的，其中是新列，并且是来自字典的 DataFrame。.locSettingWithCopyWarningdf.insert()dict['a']['e']'e'dict['a']

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

我想在现有数据框中添加一个新列“e”，并且不更改数据框中的任何内容。（序列的长度始终与数据帧相同。

我假设 中的索引值与 中的索引值匹配。edf1

启动一个名为 的新列并为其分配序列中的值的最简单方法：ee

df['e'] = e.values

分配 （Pandas 0.16.0+）

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

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

根据此示例（其中还包括函数的源代码），您还可以包含多个列：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

可以在此处找到首次引入此新功能时的描述。

如果您得到 ，一个简单的解决方法是复制您尝试添加列的 DataFrame。SettingWithCopyWarning

df = df.copy()
df['col_name'] = values

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

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

它不会产生 .SettingWithCopyWarning

向现有数据框添加新列“e”

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

我一直在寻找一种将 s 列添加到数据帧而不会变得愚蠢的通用方法。numpy.nanSettingWithCopyWarning

从以下方面：

• 答案在这里
• 关于将变量作为关键字参数传递的问题
• 此方法用于生成内联 NaN 数组numpy

我想出了这个：

col = 'column_name'
df = df.assign(**{col:numpy.full(len(df), numpy.nan)})

为了完整起见 - 使用 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

超简单的列分配

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

这是因为默认情况下，a 的索引枚举从 0 到 n。而熊猫方法试图变得“聪明”pd.Series[] =

到底发生了什么。

使用该方法时，pandas 会使用左侧数据帧的索引和右侧序列的索引悄悄地执行外部连接或外部合并。[] =df['column'] = series

旁注

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

解决问题

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

您可以将 downcast 为 a 或 a ，这样就可以了。pd.Seriesnp.ndarraylist

df['protected'] = pd.Series(['no', 'no', 'no', 'yes']).values

或

df['protected'] = list(pd.Series(['no', 'no', 'no', 'yes']))

但这并不是很明确。

一些编码人员可能会说“嘿，这看起来是多余的，我会优化它”。

显式方式

将 的索引设置为显式的索引。pd.Seriesdf

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.assignselfdf.assign

df.assign(self=pd.Series(['no', 'no', 'no', 'yes'])
TypeError: assign() got multiple values for keyword argument 'self'

你可能会说，“好吧，那我就不用了”。但谁知道这个函数将来会如何变化以支持新的论点。也许您的列名将成为 pandas 新更新中的参数，从而导致升级问题。self

如果数据框和 Series 对象具有相同的索引，则此处也有效：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)

万无一失：

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

1. 首先创建一个具有相关数据的 python。list_of_e
2. 使用这个：df['e'] = list_of_e

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

这实际上会为单元格分配“对象”类型。因此，稍后您可以自由地将复杂的数据类型（如列表）放入单个单元格中。

如果您尝试添加的列是序列变量，则只需：

df["new_columns_name"]=series_variable_name #this will do it for you

即使您要替换现有列，这也非常有效。只需键入与要替换的列相同的new_columns_name即可。它只会用新的序列数据覆盖现有的列数据。

最简单的方法：-

data['new_col'] = list_of_values

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

这样，就可以避免在 pandas 对象中设置新值时出现所谓的链式索引。点击这里进一步阅读。

要在数据框中的给定位置（0 <= loc <= number of columns）插入新列，只需使用 Dataframe.insert：

DataFrame.insert(loc, column, value)

因此，如果要在名为 df 的数据框的末尾添加列 e，可以使用：

e = [-0.335485, -1.166658, -0.385571]    
DataFrame.insert(loc=len(df.columns), column='e', value=e)

value 可以是 Series、整数（在这种情况下，所有单元格都用这个值填充）或类似数组的结构

https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.DataFrame.insert.html

创建空列

df['i'] = None

这是向 Pandas DataFrame 添加新列的特例。在这里，我将根据 DataFrame 的现有列数据添加一个新特征/列。

因此，让我们的 dataFrame 具有列 'feature_1'， 'feature_2'， 'probability_score'，我们必须根据列 'probability_score' 中的数据添加一个new_column 'predicted_class'。

我将使用 python 中的 map（） 函数，并定义我自己的函数，该函数将实现有关如何为我的 dataFrame 中的每一行提供特定class_label的逻辑。

data = pd.read_csv('data.csv')

def myFunction(x):
   //implement your logic here

   if so and so:
        return a
   return b

variable_1 = data['probability_score']
predicted_class = variable_1.map(myFunction)

data['predicted_class'] = predicted_class

// check dataFrame, new column is included based on an existing column data for each row
data.head()

x=pd.DataFrame([1,2,3,4,5])

y=pd.DataFrame([5,4,3,2,1])

z=pd.concat([x,y],axis=1)

如果您只需要创建一个新的空列，那么最短的解决方案是：

df.loc[:, 'e'] = pd.Series()

如果我们想为 df 中新列的所有行分配一个缩放器值，例如：10：

df = df.assign(new_col=lambda x:10)  # x is each row passed in to the lambda func

DF 现在将在所有行中具有值 = 10 的新列“new_col”。

每当将 Series 对象作为新列添加到现有 DF 时，都需要确保它们都具有相同的索引。 然后将其添加到 DF 中

e_series = pd.Series([-0.335485, -1.166658,-0.385571])
print(e_series)
e_series.index = d_f.index
d_f['e'] = e_series
d_f

import pandas as pd

# Define a dictionary containing data
data = {'a': [0,0,0.671399,0.446172,0,0.614758],
    'b': [0,0,0.101208,-0.243316,0,0.075793],
    'c': [0,0,-0.181532,0.051767,0,-0.451460],
    'd': [0,0,0.241273,1.577318,0,-0.012493]}

# Convert the dictionary into DataFrame
df = pd.DataFrame(data)

# Declare a list that is to be converted into a column
col_e = [-0.335485,-1.166658,-0.385571,0,0,0]


df['e'] = col_e

# add column 'e'
df['e'] = col_e

# Observe the result
df

有 4 种方法可以向 pandas DataFrame 插入新列：

1. 简单的分配
2. 插入（）
3. assign（） 函数
4. 康卡特（）

让我们考虑以下示例：

import pandas as pd

df = pd.DataFrame({
    'col_a':[True, False, False], 
    'col_b': [1, 2, 3],
})
print(df)
    col_a  col_b
0   True     1
1  False     2
2  False     3

使用简单赋值

ser = pd.Series(['a', 'b', 'c'], index=[0, 1, 2])
print(ser)
0    a
1    b
2    c
dtype: object

df['col_c'] = pd.Series(['a', 'b', 'c'], index=[1, 2, 3])
print(df)
     col_a  col_b col_c
0   True     1  NaN
1  False     2    a
2  False     3    b

使用 assign（）

e = pd.Series([1.0, 3.0, 2.0], index=[0, 2, 1])
ser = pd.Series(['a', 'b', 'c'], index=[0, 1, 2])
df.assign(colC=s.values, colB=e.values)
     col_a  col_b col_c
0   True   1.0    a
1  False   3.0    b
2  False   2.0    c

使用 insert（）

df.insert(len(df.columns), 'col_c', ser.values)
print(df)
    col_a  col_b col_c
0   True     1    a
1  False     2    b
2  False     3    c

使用 concat（）

ser = pd.Series(['a', 'b', 'c'], index=[10, 20, 30])
df = pd.concat([df, ser.rename('colC')], axis=1)
print(df)
     col_a  col_b col_c
0    True   1.0  NaN
1   False   2.0  NaN
2   False   3.0  NaN
10    NaN   NaN    a
20    NaN   NaN    b
30    NaN   NaN    c