要删除DataFrame中的列，我可以成功使用：
del df['column_name']
但为什么我不能使用以下选项？
del df.column_name
由于可以通过df.column_name访问该系列，所以我希望这能奏效。
当前回答
这里的大多数答案都忽略了实际提出的问题：
为什么不能使用del df.column_name？
首先，我们需要了解这个问题，这需要我们深入研究Python的神奇方法。
正如韦斯在回答中指出的那样，deldf['column']映射到Python的神奇方法df__delitem__（'column'），它在Pandas中实现以删除列。
然而，正如上面关于Python魔术方法的链接中所指出的：
事实上，__del__几乎永远不应该被使用，因为它被称为；小心使用！
您可以认为不应该使用或鼓励del df['column_name]，因此甚至不应该考虑del df.column_name。
然而，理论上，deldf.column_name可以使用魔术方法__delattr_在Pandas中实现。然而，这确实会带来某些问题，deldf['column_name]实现已经存在的问题，但程度较低。
示例问题
如果我在数据帧中定义了一个名为“dtypes”或“columns”的列，该怎么办？
然后假设我想删除这些列。
deldf.dtypes会使__delattr_方法混淆，好像它应该删除“dtypes”属性或“dtype”列一样。
这个问题背后的建筑问题
数据帧是列的集合吗？数据帧是行的集合吗？列是数据帧的属性吗？
熊猫回答：
是的，在所有方面不，但如果您想这样做，可以使用.ix、.loc或.iloc方法。也许，你想读取数据吗？那么是的，除非该属性的名称已经被属于数据帧的另一个属性所采用。是否要修改数据？那就没有了。
太长，读不下去了
你不能做deldf.column_name，因为Pandas有一个相当广泛的架构，需要重新考虑，以避免用户出现这种认知失调。
专业提示：
不要使用df.column_name。它可能很漂亮，但会导致认知失调。
Python之禅引用如下：
删除列有多种方法。
应该有一种——最好只有一种——明显的方法来实现。
列有时是属性，但有时不是。
特殊情况不足以打破规则。
del df.dtypes是否删除dtypes属性或dtypes列？
面对模棱两可的问题，拒绝猜测。
其他回答
总是使用[]符号是一个很好的做法。一个原因是属性表示法（df.column_name）不适用于编号索引：
In [1]: df = DataFrame([[1, 2, 3], [4, 5, 6]])
In [2]: df[1]
Out[2]:
0 2
1 5
Name: 1
In [3]: df.1
File "<ipython-input-3-e4803c0d1066>", line 1
df.1
^
SyntaxError: invalid syntax
正如您所猜测的，正确的语法是
del df['column_name']
由于Python中的语法限制，很难使del df.column_name正常工作。deldf[name]被翻译成df__delitem__（name）在Python的封面下。
按索引删除
删除第一列、第二列和第四列：
df.drop(df.columns[[0,1,3]], axis=1, inplace=True)
删除第一列：
df.drop(df.columns[[0]], axis=1, inplace=True)
此处有一个可选参数可以在不创建副本的情况下修改数据。
被逮捕的
列选择、添加、删除
删除列列名：
df.pop('column-name')
示例：
df = DataFrame.from_items([('A', [1, 2, 3]), ('B', [4, 5, 6]), ('C', [7,8, 9])], orient='index', columns=['one', 'two', 'three'])
打印df:
one two three
A 1 2 3
B 4 5 6
C 7 8 9
df.drop（df.columns[[0]，axis=1，inplace=True）打印df:
two three
A 2 3
B 5 6
C 8 9
三=df.pop（“三”）打印df:
two
A 2
B 5
C 8
一个很好的补充是，只有列存在时才可以删除它们。这样，您可以覆盖更多的用例，并且它只会从传递给它的标签中删除现有列：
例如，只需添加errors='ignore'：
df.drop(['col_name_1', 'col_name_2', ..., 'col_name_N'], inplace=True, axis=1, errors='ignore')
这是熊猫0.16.1以后的新版本。文档在这里。
TL；博士
为找到一个稍微更有效的解决方案付出了很多努力。很难在牺牲df.drop的简单性的同时证明增加的复杂性（dlst，1，errors='ignore'）
df.reindex_axis(np.setdiff1d(df.columns.values, dlst), 1)
序言删除列在语义上与选择其他列相同。我将展示一些需要考虑的其他方法。
我还将重点介绍一次删除多个列并允许尝试删除不存在的列的一般解决方案。
使用这些解决方案是通用的，也适用于简单的情况。
安装程序考虑pd.DataFrame df和列表以删除dlst
df = pd.DataFrame(dict(zip('ABCDEFGHIJ', range(1, 11))), range(3))
dlst = list('HIJKLM')
df
A B C D E F G H I J
0 1 2 3 4 5 6 7 8 9 10
1 1 2 3 4 5 6 7 8 9 10
2 1 2 3 4 5 6 7 8 9 10
dlst
['H', 'I', 'J', 'K', 'L', 'M']
结果应该是：
df.drop(dlst, 1, errors='ignore')
A B C D E F G
0 1 2 3 4 5 6 7
1 1 2 3 4 5 6 7
2 1 2 3 4 5 6 7
由于我将删除一列等同于选择其他列，因此我将其分为两种类型：
标签选择布尔选择
标签选择
我们首先创建标签列表/数组，这些标签表示我们要保留的列，而不表示我们要删除的列。
df.列.差异（dlst）索引（[“A”、“B”、“C”、“D”、“E”、“F”、“G”]，dtype=“对象”）np.setdiff1d（df.columns.values，dlst）数组（['A'，'B'，'C'，'D'，'E'，'F'，'G']，dtype=对象）df.columns.drop（dlst，errors='ignore'）索引（[“A”、“B”、“C”、“D”、“E”、“F”、“G”]，dtype=“对象”）列表（set（df.columns.values.tolist（））.difference（dlst））#不保留顺序[E'，'D'，'B'，'F'，'G'，'A'，'C'][如果x不在dlst中，则df.columns.values.tolist（）中的x为x][‘A’、‘B’、‘C’、‘D’、‘E’、‘F’、‘G’]
标签中的列为了比较选择过程，假设：
cols = [x for x in df.columns.values.tolist() if x not in dlst]
然后我们可以评估
df.loc[：，列]df[列]df.rendex（列=列）df.rendex_axis（列，1）
所有评估结果如下：
A B C D E F G
0 1 2 3 4 5 6 7
1 1 2 3 4 5 6 7
2 1 2 3 4 5 6 7
布尔切片
我们可以构造用于切片的布尔值数组/列表
~df.columns.isin（dlst）~np.ind（数据列值，dlst）[df.columns.values.tolist（）中的x不在dlst中]（df.columns.values[：，None]！=dlst）.all（1）
来自布尔值的列为了便于比较
bools = [x not in dlst for x in df.columns.values.tolist()]
df.loc[：bools]
所有评估结果如下：
A B C D E F G
0 1 2 3 4 5 6 7
1 1 2 3 4 5 6 7
2 1 2 3 4 5 6 7
稳健的时间安排
功能
setdiff1d = lambda df, dlst: np.setdiff1d(df.columns.values, dlst)
difference = lambda df, dlst: df.columns.difference(dlst)
columndrop = lambda df, dlst: df.columns.drop(dlst, errors='ignore')
setdifflst = lambda df, dlst: list(set(df.columns.values.tolist()).difference(dlst))
comprehension = lambda df, dlst: [x for x in df.columns.values.tolist() if x not in dlst]
loc = lambda df, cols: df.loc[:, cols]
slc = lambda df, cols: df[cols]
ridx = lambda df, cols: df.reindex(columns=cols)
ridxa = lambda df, cols: df.reindex_axis(cols, 1)
isin = lambda df, dlst: ~df.columns.isin(dlst)
in1d = lambda df, dlst: ~np.in1d(df.columns.values, dlst)
comp = lambda df, dlst: [x not in dlst for x in df.columns.values.tolist()]
brod = lambda df, dlst: (df.columns.values[:, None] != dlst).all(1)
测试
res1 = pd.DataFrame(
index=pd.MultiIndex.from_product([
'loc slc ridx ridxa'.split(),
'setdiff1d difference columndrop setdifflst comprehension'.split(),
], names=['Select', 'Label']),
columns=[10, 30, 100, 300, 1000],
dtype=float
)
res2 = pd.DataFrame(
index=pd.MultiIndex.from_product([
'loc'.split(),
'isin in1d comp brod'.split(),
], names=['Select', 'Label']),
columns=[10, 30, 100, 300, 1000],
dtype=float
)
res = res1.append(res2).sort_index()
dres = pd.Series(index=res.columns, name='drop')
for j in res.columns:
dlst = list(range(j))
cols = list(range(j // 2, j + j // 2))
d = pd.DataFrame(1, range(10), cols)
dres.at[j] = timeit('d.drop(dlst, 1, errors="ignore")', 'from __main__ import d, dlst', number=100)
for s, l in res.index:
stmt = '{}(d, {}(d, dlst))'.format(s, l)
setp = 'from __main__ import d, dlst, {}, {}'.format(s, l)
res.at[(s, l), j] = timeit(stmt, setp, number=100)
rs = res / dres
rs
10 30 100 300 1000
Select Label
loc brod 0.747373 0.861979 0.891144 1.284235 3.872157
columndrop 1.193983 1.292843 1.396841 1.484429 1.335733
comp 0.802036 0.732326 1.149397 3.473283 25.565922
comprehension 1.463503 1.568395 1.866441 4.421639 26.552276
difference 1.413010 1.460863 1.587594 1.568571 1.569735
in1d 0.818502 0.844374 0.994093 1.042360 1.076255
isin 1.008874 0.879706 1.021712 1.001119 0.964327
setdiff1d 1.352828 1.274061 1.483380 1.459986 1.466575
setdifflst 1.233332 1.444521 1.714199 1.797241 1.876425
ridx columndrop 0.903013 0.832814 0.949234 0.976366 0.982888
comprehension 0.777445 0.827151 1.108028 3.473164 25.528879
difference 1.086859 1.081396 1.293132 1.173044 1.237613
setdiff1d 0.946009 0.873169 0.900185 0.908194 1.036124
setdifflst 0.732964 0.823218 0.819748 0.990315 1.050910
ridxa columndrop 0.835254 0.774701 0.907105 0.908006 0.932754
comprehension 0.697749 0.762556 1.215225 3.510226 25.041832
difference 1.055099 1.010208 1.122005 1.119575 1.383065
setdiff1d 0.760716 0.725386 0.849949 0.879425 0.946460
setdifflst 0.710008 0.668108 0.778060 0.871766 0.939537
slc columndrop 1.268191 1.521264 2.646687 1.919423 1.981091
comprehension 0.856893 0.870365 1.290730 3.564219 26.208937
difference 1.470095 1.747211 2.886581 2.254690 2.050536
setdiff1d 1.098427 1.133476 1.466029 2.045965 3.123452
setdifflst 0.833700 0.846652 1.013061 1.110352 1.287831
fig, axes = plt.subplots(2, 2, figsize=(8, 6), sharey=True)
for i, (n, g) in enumerate([(n, g.xs(n)) for n, g in rs.groupby('Select')]):
ax = axes[i // 2, i % 2]
g.plot.bar(ax=ax, title=n)
ax.legend_.remove()
fig.tight_layout()
这与运行df.drop所需的时间有关（dlst，1，errors='ignore'）。经过这么多努力，我们似乎只会适度提高绩效。
如果事实上，最好的解决方案在黑客列表上使用reindex或reindex_axis（set（df.columns.values.tolist（））.difference（dlst））。最后一秒，比drop稍微好一点的是np.setdiff1d。
rs.idxmin().pipe(
lambda x: pd.DataFrame(
dict(idx=x.values, val=rs.lookup(x.values, x.index)),
x.index
)
)
idx val
10 (ridx, setdifflst) 0.653431
30 (ridxa, setdifflst) 0.746143
100 (ridxa, setdifflst) 0.816207
300 (ridx, setdifflst) 0.780157
1000 (ridxa, setdifflst) 0.861622
推荐文章
- 将Pandas或Numpy Nan替换为None以用于MysqlDB
- 使用pandas对同一列进行多个聚合
- 使用Python解析HTML
- django MultiValueDictKeyError错误，我如何处理它
- 如何在for循环期间修改列表条目?
- 我如何在Django中创建一个鼻涕虫?
- 没有名为'django.core.urlresolvers'的模块
- 蟒蛇导出环境文件
- Django - makemigrations -未检测到任何更改
- SQLAlchemy:引擎、连接和会话差异
- 在Python Pandas中删除多个列中的所有重复行
- 更改pandas DataFrame中的特定列名
- 将Pandas多索引转换为列
- 熊猫在每组中获得最高的n个记录
- 熊猫数据帧得到每组的第一行
