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

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

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

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

编辑2017

正如评论和@Alexander所指出的，目前将Series的值添加为DataFrame的新列的最佳方法可以使用#0：

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

编辑2015
有些人报告说使用此代码获得了SettingWithCopyWarning。
但是，该代码仍然可以在当前的熊猫版本0.16.1中完美运行。

>>> sLength = len(df1['a'])>>> df1a         b         c         d6 -0.269221 -0.026476  0.997517  1.2943858  0.917438  0.847941  0.034235 -0.448948
>>> df1['e'] = pd.Series(np.random.randn(sLength), index=df1.index)>>> df1a         b         c         d         e6 -0.269221 -0.026476  0.997517  1.294385  1.7571678  0.917438  0.847941  0.034235 -0.448948  2.228131
>>> pd.version.short_version'0.16.1'

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

>>> df1.loc[:,'f'] = pd.Series(np.random.randn(sLength), index=df1.index)>>> df1a         b         c         d         e         f6 -0.269221 -0.026476  0.997517  1.294385  1.757167 -0.0509278  0.917438  0.847941  0.034235 -0.448948  2.228131  0.006109>>>

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

原答复：

使用原始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)

我得到了可怕的SettingWithCopyWarning，它不是通过使用iloc语法来修复的。我的DataFrame是由read_sql从ODBC源创建的。使用上面低技术的建议，以下对我有用：

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

以下是我所做的……但我对熊猫和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一样，.loc没有解决SettingWithCopyWarning，我不得不求助于df.insert()。在我的情况下，假阳性是由“假”链索引dict['a']['e']生成的，其中'e'是新列，dict['a']是来自字典的DataFrame。

还要注意，如果您知道自己在做什么，您可以使用pd.options.mode.chained_assignment = None而不是使用这里给出的其他解决方案之一。

我想添加一个新的列，'e'，存量数据帧，并且不改变数据帧中的任何内容。

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

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

df['e'] = e.values

分配（熊猫0.16.0+）

从Pandas 0.16.0开始，您还可以使用#0，它将新列分配给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_b0  1  3     1.5     3.51  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))
>>> df1a         b         c         d0  1.764052  0.400157  0.978738  2.2408932 -0.103219  0.410599  0.144044  1.4542743  0.761038  0.121675  0.443863  0.3336747  1.532779  1.469359  0.154947  0.3781639  1.230291  1.202380 -0.387327 -0.302303
>>> e0   -1.0485531   -1.4200182   -1.7062703    1.9507754   -0.509652dtype: float64
df1 = df1.assign(e=e.values)
>>> df1a         b         c         d         e0  1.764052  0.400157  0.978738  2.240893 -1.0485532 -0.103219  0.410599  0.144044  1.454274 -1.4200183  0.761038  0.121675  0.443863  0.333674 -1.7062707  1.532779  1.469359  0.154947  0.378163  1.9507759  1.230291  1.202380 -0.387327 -0.302303 -0.509652

这个新功能首次引入时的描述可以在这里中找到。

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

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

我正在寻找一种通用的方法，将numpy.nan列添加到数据框中，而不会得到愚蠢的SettingWithCopyWarning。

从以下：

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

我想到了这个：

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

为了完整起见-使用DataFrame.eval（）方法的另一个解决方案：

数据说明：

In [44]: eOut[44]:0    1.2255061   -1.0339442   -0.4989533   -0.3733324    0.6150305   -0.622436dtype: float64
In [45]: df1Out[45]:a         b         c         d0 -0.634222 -0.103264  0.745069  0.8012884  0.782387 -0.090279  0.757662 -0.6024085 -0.117456  2.124496  1.057301  0.7654667  0.767532  0.104304 -0.586850  1.0512978 -0.103272  0.958334  1.163092  1.1823159 -0.616254  0.296678 -0.112027  0.679112

解决方案：

In [46]: df1.eval("e = @e.values", inplace=True)
In [47]: df1Out[47]:a         b         c         d         e0 -0.634222 -0.103264  0.745069  0.801288  1.2255064  0.782387 -0.090279  0.757662 -0.602408 -1.0339445 -0.117456  2.124496  1.057301  0.765466 -0.4989537  0.767532  0.104304 -0.586850  1.051297 -0.3733328 -0.103272  0.958334  1.163092  1.182315  0.6150309 -0.616254  0.296678 -0.112027  0.679112 -0.622436

超级简单的列赋值

熊猫数据帧被实现为列的有序字幕。

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

例如，这个数据帧可以通过简单地使用[]访问器添加一列

    size      name color0    big      rose   red1  small    violet  blue2  small     tulip   red3  small  harebell  blue
df['protected'] = ['no', 'no', 'no', 'yes']
size      name color protected0    big      rose   red        no1  small    violet  blue        no2  small     tulip   red        no3  small  harebell  blue       yes

请注意，即使数据框的索引关闭，这也有效。

df.index = [3,2,1,0]df['protected'] = ['no', 'no', 'no', 'yes']size      name color protected3    big      rose   red        no2  small    violet  blue        no1  small     tulip   red        no0  small  harebell  blue       yes

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

但是，如果您有一个pd.Series并尝试将其分配给索引关闭的数据帧，您将遇到麻烦。参见示例：

df['protected'] = pd.Series(['no', 'no', 'no', 'yes'])size      name color protected3    big      rose   red       yes2  small    violet  blue        no1  small     tulip   red        no0  small  harebell  blue        no

这是因为pd.Series默认具有从0到n的枚举索引。而熊猫[] =方法试图要“聪明”

到底是怎么回事。

当您使用[] =方法时，熊猫正在悄悄地使用左手数据框的索引和右手序列的索引执行外连接或外合并。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']))

但这并不是很明确。

一些程序员可能会过来说：“嘿，这看起来是多余的，我会把它优化掉”。

明确的方式

将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     no2     no1     no0    yes

现在可以分配

df['protected'] = protected_series
size      name color protected3    big      rose   red        no2  small    violet  blue        no1  small     tulip   red        no0  small  harebell  blue       yes

df.reset_index()的替代方式

由于索引不和谐是问题所在，如果你觉得dataframe应该的索引没有指示事情，你可以简单地删除索引，这应该更快，但它不是很干净，因为你的函数现在可能做了两件事。

df.reset_index(drop=True)protected_series.reset_index(drop=True)df['protected'] = protected_series
size      name color protected0    big      rose   red        no1  small    violet  blue        no2  small     tulip   red        no3  small  harebell  blue       yes

注意df.assign

虽然df.assign使它更明确你在做什么，但它实际上与上面的[]=有相同的问题

df.assign(protected=pd.Series(['no', 'no', 'no', 'yes']))size      name color protected3    big      rose   red       yes2  small    violet  blue        no1  small     tulip   red        no0  small  harebell  blue        no

只需注意df.assign，您的列没有被称为self。它会导致错误。这使得df.assign臭，因为函数中存在此类工件。

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

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

如果数据帧和Series对象有相同的索引，pandas.concat也在这里工作：

import pandas as pddf#          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 resultdf = 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.indexdf = 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         D0  -0.761269  0.477348  1.170614  0.7527141   1.217250 -0.930860 -0.769324 -0.4086422  -0.619679 -1.227659 -0.259135  1.7002943  -0.147354  0.778707  0.479145  2.2841434  -0.529529  0.000571  0.913779  1.3958945   2.592400  0.637253  1.441096 -0.6314686   0.757178  0.240012 -0.553820  1.1772027  -0.986128 -1.313843  0.788589 -0.7078368   0.606985 -2.232903 -1.358107 -2.8554949  -0.692013  0.671866  1.179466 -1.18035110 -1.093707 -0.530600  0.182926 -1.29649411 -0.143273 -0.503199 -1.328728  0.61055212 -0.923110 -1.365890 -1.366202 -1.18599913 -2.026832  0.273593 -0.440426 -0.62742314 -0.054503 -0.788866 -0.228088 -0.40478315  0.955298 -1.430019  1.434071 -0.08821516 -0.227946  0.047462  0.373573 -0.11167517  1.627912  0.043611  1.743403 -0.01271418  0.693458  0.144327  0.329500 -0.65504519  0.104425  0.037412  0.450598 -0.923387

df.drop([3, 5, 8, 10, 18], inplace=True)
df
A         B         C         D0  -0.761269  0.477348  1.170614  0.7527141   1.217250 -0.930860 -0.769324 -0.4086422  -0.619679 -1.227659 -0.259135  1.7002944  -0.529529  0.000571  0.913779  1.3958946   0.757178  0.240012 -0.553820  1.1772027  -0.986128 -1.313843  0.788589 -0.7078369  -0.692013  0.671866  1.179466 -1.18035111 -0.143273 -0.503199 -1.328728  0.61055212 -0.923110 -1.365890 -1.366202 -1.18599913 -2.026832  0.273593 -0.440426 -0.62742314 -0.054503 -0.788866 -0.228088 -0.40478315  0.955298 -1.430019  1.434071 -0.08821516 -0.227946  0.047462  0.373573 -0.11167517  1.627912  0.043611  1.743403 -0.01271419  0.104425  0.037412  0.450598 -0.923387
df.loc[:, 'NewCol'] = 0
dfA         B         C         D  NewCol0  -0.761269  0.477348  1.170614  0.752714       01   1.217250 -0.930860 -0.769324 -0.408642       02  -0.619679 -1.227659 -0.259135  1.700294       04  -0.529529  0.000571  0.913779  1.395894       06   0.757178  0.240012 -0.553820  1.177202       07  -0.986128 -1.313843  0.788589 -0.707836       09  -0.692013  0.671866  1.179466 -1.180351       011 -0.143273 -0.503199 -1.328728  0.610552       012 -0.923110 -1.365890 -1.366202 -1.185999       013 -2.026832  0.273593 -0.440426 -0.627423       014 -0.054503 -0.788866 -0.228088 -0.404783       015  0.955298 -1.430019  1.434071 -0.088215       016 -0.227946  0.047462  0.373573 -0.111675       017  1.627912  0.043611  1.743403 -0.012714       019  0.104425  0.037412  0.450598 -0.923387       0

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

如果您想将整个新列设置为初始基值（例如None），您可以这样做：df1['e'] = None

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

如果您尝试添加的列是一个序列变量，那么只需：

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

即使您要替换与要替换的列new_columns_name相同的现有column.just，这也可以正常工作。它只会用新系列数据覆盖现有列数据。

最简单的方法：

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

通过这种方式，当在熊猫对象中设置新值时，您可以避免所谓的链式索引。点击这里进一步阅读。

要在数据帧中的给定位置（0<=loc<=列数）插入新列，只需使用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)

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

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

创建一个空列

df['i'] = None

这是向熊猫数据框添加新列的特殊情况。在这里，我基于数据框的现有列数据添加一个新功能/列。

所以，让我们的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 areturn 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 rowdata.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现在将在所有行中具有value=10的新列new_col。

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

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

您可以通过for循环插入新列，如下所示：

for label,row in your_dframe.iterrows():your_dframe.loc[label,"new_column_length"]=len(row["any_of_column_in_your_dframe"])

示例代码在这里：

import pandas as pd
data = {"any_of_column_in_your_dframe" : ["ersingulbahar","yagiz","TS"],"calories": [420, 380, 390],"duration": [50, 40, 45]}
#load data into a DataFrame object:your_dframe = pd.DataFrame(data)

for label,row in your_dframe.iterrows():your_dframe.loc[label,"new_column_length"]=len(row["any_of_column_in_your_dframe"])      
      
print(your_dframe)

输出在这里：

不是：你也可以这样使用：

your_dframe["new_column_length"]=your_dframe["any_of_column_in_your_dframe"].apply(len)

将新列添加到现有数据框的简单方法是：

new_cols = ['a' , 'b' , 'c' , 'd']
for col in new_cols:df[f'{col}'] = 0 #assiging 0 for the placeholder
print(df.columns)

import pandas as pd
# Define a dictionary containing datadata = {'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 DataFramedf = pd.DataFrame(data)
# Declare a list that is to be converted into a columncol_e = [-0.335485,-1.166658,-0.385571,0,0,0]

df['e'] = col_e
# add column 'e'df['e'] = col_e
# Observe the resultdf

4种方法可以将新列插入熊猫数据帧

using simple assignment, insert(), assign() and Concat() methods.
import pandas as pd
df = pd.DataFrame({'col_a':[True, False, False],'col_b': [1, 2, 3],})print(df)col_a  col_b0   True     11  False     22  False     3

使用简单赋值

ser = pd.Series(['a', 'b', 'c'], index=[0, 1, 2])print(ser)0    a1    b2    cdtype: object
df['col_c'] = pd.Series(['a', 'b', 'c'], index=[1, 2, 3])print(df)col_a  col_b col_c0   True     1  NaN1  False     2    a2  False     3    b

使用赋值（）

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_c0   True   1.0    a1  False   3.0    b2  False   2.0    c

使用插入（）

df.insert(len(df.columns), 'col_c', ser.values)print(df)col_a  col_b col_c0   True     1    a1  False     2    b2  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_c0    True   1.0  NaN1   False   2.0  NaN2   False   3.0  NaN10    NaN   NaN    a20    NaN   NaN    b30    NaN   NaN    c