ටීඑල්; ඩී.ආර්
ආන්තිකව වඩා කාර්යක්ෂම විසඳුමක් සෙවීම සඳහා විශාල උත්සාහයක්. හි සරල බව පරිත්‍යාග කරන අතරම එකතු කළ සංකීර්ණතාව සාධාරණීකරණය කිරීමට අපහසුයdf.drop(dlst, 1, errors='ignore')
df.reindex_axis(np.setdiff1d(df.columns.values, dlst), 1)
පෙරවදන
තීරුවක් මකා දැමීම අනෙක් තීරු තේරීමට සමාන වේ. සලකා බැලීමට අමතර ක්රම කිහිපයක් මම පෙන්වන්නම්.
එකවර තීරු කිහිපයක් මකා දැමීමේ සහ නොපවතින තීරු මකාදැමීමේ උත්සාහයට ඉඩ දීමේ පොදු විසඳුම කෙරෙහි ද මම අවධානය යොමු කරමි.
මෙම විසඳුම් භාවිතා කිරීම සාමාන්‍ය දෙයක් වන අතර සරල අවස්ථාව සඳහාද ක්‍රියා කරනු ඇත.
සැකසුම මකා දැමීමට සහ ලැයිස්තුව
සලකා බලන්නpd.DataFrame dfdlst
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']
ප්‍රති result ලය මෙසේ විය යුතුය:
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.columns.difference(dlst)
Index(['A', 'B', 'C', 'D', 'E', 'F', 'G'], dtype='object')
np.setdiff1d(df.columns.values, dlst)
array(['A', 'B', 'C', 'D', 'E', 'F', 'G'], dtype=object)
df.columns.drop(dlst, errors='ignore')
Index(['A', 'B', 'C', 'D', 'E', 'F', 'G'], dtype='object')
list(set(df.columns.values.tolist()).difference(dlst))
# does not preserve order
['E', 'D', 'B', 'F', 'G', 'A', 'C']
[x for x in df.columns.values.tolist() if x not in dlst]
['A', 'B', 'C', 'D', 'E', 'F', 'G']
ලේබල වලින් තීරු
තේරීමේ ක්‍රියාවලිය සංසන්දනය කිරීම සඳහා, උපකල්පනය කරන්න:
cols = [x for x in df.columns.values.tolist() if x not in dlst]
එවිට අපට ඇගයීමට ලක් කළ හැකිය
df.loc[:, cols]df[cols]df.reindex(columns=cols)df.reindex_axis(cols, 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.in1d(df.columns.values, dlst)[x not in dlst for x in df.columns.values.tolist()](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හැක් කිරීම list(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