පැන්ඩා දත්ත රාමුවකින් පේළි තෝරා ගැනීමට ක්‍රම කිහිපයක් තිබේ:
- බූලියන් සුචිගත කිරීම (
df[df['col'] == value])
- ස්ථානීය සුචිගත කිරීම (
df.iloc[...])
- ලේබල් සුචිගත කිරීම (
df.xs(...))
df.query(...) API
පහත දැක්වෙන ක්‍රමෝපායන් භාවිතා කරන විට උපදෙස් සහිතව, එක් එක් උදාහරණ මම ඔබට පෙන්වන්නෙමි. අපගේ නිර්ණායකය තීරුව 'A'== යැයි උපකල්පනය කරන්න'foo'
(කාර්ය සාධනය මත සටහන: එක් එක් පදනමක් වර්ගය, අපි දේවල් සරල වන pandas API භාවිතයෙන් විසින් තබා ගත හැකි හෝ අපි API පිටත ව්යාපාරයක යෙදිය හැක, සාමාන්යයෙන් බවට numpyවේගය දේවල්, සහ.)
සැකසුම
අපට අවශ්‍ය පළමු දෙය නම් පේළි තේරීම සඳහා අපගේ නිර්ණායකය ලෙස ක්‍රියා කරන කොන්දේසියක් හඳුනා ගැනීමයි. අපි OP නඩුව සමඟ ආරම්භ කරමු column_name == some_value, සහ තවත් පොදු භාවිත අවස්ථා කිහිපයක් ඇතුළත් කරන්නෙමු .
Utunutbu වෙතින් ණයට ගැනීම:
import pandas as pd, numpy as np
df = pd.DataFrame({'A': 'foo bar foo bar foo bar foo foo'.split(),
'B': 'one one two three two two one three'.split(),
'C': np.arange(8), 'D': np.arange(8) * 2})
1. බූලියන් සුචිගත කිරීම
... බූලියන් සුචිගත කිරීම සඳහා එක් එක් පේළියේ 'A'තීරුවේ සත්‍ය අගය සමාන බව සොයා ගැනීම අවශ්‍ය වන අතර 'foo', එම සත්‍ය අගයන් භාවිතා කර කුමන පේළි තබා ගත යුතු දැයි හඳුනා ගැනීමට අවශ්‍ය වේ. සාමාන්යයෙන්, අපි මෙම ශ්‍රේණියට නම් කරන්නේ සත්‍ය සාරධර්ම සමූහයකි mask. අපි මෙහි ද එසේ කරන්නෙමු.
mask = df['A'] == 'foo'
දත්ත රාමුව කැපීමට හෝ සුචිගත කිරීමට අපට මෙම ආවරණ භාවිතා කළ හැකිය
df[mask]
A B C D
0 foo one 0 0
2 foo two 2 4
4 foo two 4 8
6 foo one 6 12
7 foo three 7 14
මෙම කාර්යය ඉටු කිරීම සඳහා මෙය සරලම ක්‍රමයක් වන අතර කාර්ය සාධනය හෝ බුද්ධිමය ගැටලුවක් නොවේ නම්, මෙය ඔබ තෝරාගත් ක්රමය විය යුතුය. කෙසේ වෙතත්, කාර්ය සාධනය සැලකිලිමත් වන්නේ නම්, ඔබට එය නිර්මාණය කිරීමේ විකල්ප ක්‍රමයක් සලකා බැලීමට අවශ්‍ය විය හැකිය mask.
2. ස්ථානීය සුචිගත කිරීම
ස්ථානීය සුචිගත කිරීම ( df.iloc[...]) හි භාවිත අවස්ථා තිබේ, නමුත් මෙය ඒවායින් එකක් නොවේ. පෙති දැමිය යුතු ස්ථානය හඳුනා ගැනීම සඳහා, අප මුලින් කළ යුත්තේ අප ඉහත කළ බූලියන් විශ්ලේෂණයමයි. එකම කාර්යය ඉටු කිරීම සඳහා එක් අමතර පියවරක් කිරීමට මෙය අපට ඉඩ දෙයි.
mask = df['A'] == 'foo'
pos = np.flatnonzero(mask)
df.iloc[pos]
A B C D
0 foo one 0 0
2 foo two 2 4
4 foo two 4 8
6 foo one 6 12
7 foo three 7 14
3. ලේබල් සුචිගත කිරීම
ලේබල් සුචිගත කිරීම ඉතා පහසු විය හැකි නමුත් මේ අවස්ථාවේ දී, අපි නැවත කිසිදු ප්‍රතිලාභයක් නොමැතිව වැඩි වැඩ කොටසක් කරන්නෙමු
df.set_index('A', append=True, drop=False).xs('foo', level=1)
A B C D
0 foo one 0 0
2 foo two 2 4
4 foo two 4 8
6 foo one 6 12
7 foo three 7 14
4. df.query()ඒපීඅයි
pd.DataFrame.queryමෙම කාර්යය ඉටු කිරීම සඳහා ඉතා අලංකාර / අවබෝධාත්මක ක්‍රමයක් වන නමුත් බොහෝ විට එය මන්දගාමී වේ. කෙසේ වෙතත් , ඔබ විශාල දත්ත සඳහා පහත වේලාවන් කෙරෙහි අවධානය යොමු කරන්නේ නම්, විමසුම ඉතා කාර්යක්ෂම වේ. සම්මත ප්‍රවේශයට වඩා සහ මගේ හොඳම යෝජනාවට සමාන විශාලත්වයකින්.
df.query('A == "foo"')
A B C D
0 foo one 0 0
2 foo two 2 4
4 foo two 4 8
6 foo one 6 12
7 foo three 7 14
මගේ මනාපය වන්නේ භාවිතා කිරීමයි Boolean mask
අප අපගේ නිර්මාණය කරන ආකාරය වෙනස් කිරීමෙන් සත්‍ය වැඩිදියුණු කිරීම් කළ හැකිය Boolean mask.
maskවිකල්ප 1
යටින් පවතින numpyඅරාව භාවිතා කර තවත් එකක් නිර්මාණය කිරීමේ පොදු කාර්යය අත්හරින්නpd.Series
mask = df['A'].values == 'foo'
මම අවසානයේදී වඩාත් සම්පූර්ණ කාල පරීක්ෂණ පෙන්වන්නම්, නමුත් නියැදි දත්ත රාමුව භාවිතා කර අපට ලැබෙන කාර්යසාධන වාසි දෙස බලන්න. පළමුව, අපි නිර්මාණය කිරීමේ වෙනස දෙස බලමුmask
%timeit mask = df['A'].values == 'foo'
%timeit mask = df['A'] == 'foo'
5.84 µs ± 195 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)
166 µs ± 4.45 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)
අරාව maskසමඟ ඇගයීම numpy~ 30 ගුණයක් වේගවත් වේ. මෙම අර්ධ වශයෙන් නියමිත numpyවේගවත් වීම බොහෝ විට ඇගයීම. දර්ශකයක් සහ ඊට අනුරූප pd.Seriesවස්තුවක් තැනීමට අවශ්‍ය පොදු කාර්ය හිඟකම ද ඊට එක් හේතුවකි.
ඊළඟට, අපි එකක් maskහා අනෙකක් සමඟ පෙති කපන වේලාව දෙස බලමු .
mask = df['A'].values == 'foo'
%timeit df[mask]
mask = df['A'] == 'foo'
%timeit df[mask]
219 µs ± 12.3 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
239 µs ± 7.03 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
කාර්ය සාධන වාසි උච්චාරණය කර නැත. මෙය වඩාත් ශක්තිමත් පරීක්ෂාවකට වඩා වැඩි දැයි අපි බලමු.
maskවිකල්ප 2
අපට දත්ත රාමුව ද ප්‍රතිනිර්මාණය කළ හැකිව තිබුණි. දත්ත රාමුවක් ප්‍රතිනිර්මාණය කිරීමේදී විශාල අවවාදයක් ඇත so එසේ කිරීමේදී ඔබ සැලකිලිමත් විය යුතුය dtypes!
ඒ වෙනුවට df[mask]අපි මෙය කරන්නෙමු
pd.DataFrame(df.values[mask], df.index[mask], df.columns).astype(df.dtypes)
අපගේ උදාහරණය වන දත්ත රාමුව මිශ්‍ර ගණයට අයත් නම්, එවිට අපට df.valuesලැබෙන අරාව ලැබෙන විට dtype objectහා එහි ප්‍රති, ලයක් ලෙස නව දත්ත රාමුවේ සියලුම තීරු වේ dtype object. මේ අනුව astype(df.dtypes)ඕනෑම කාර්ය සාධන ලාභයක් අවශ්‍ය වේ.
%timeit df[m]
%timeit pd.DataFrame(df.values[mask], df.index[mask], df.columns).astype(df.dtypes)
216 µs ± 10.4 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
1.43 ms ± 39.6 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
කෙසේ වෙතත්, දත්ත රාමුව මිශ්‍ර වර්ගයට අයත් නොවේ නම්, මෙය කිරීමට ඉතා ප්‍රයෝජනවත් ක්‍රමයකි.
ලබා දී ඇත
np.random.seed([3,1415])
d1 = pd.DataFrame(np.random.randint(10, size=(10, 5)), columns=list('ABCDE'))
d1
A B C D E
0 0 2 7 3 8
1 7 0 6 8 6
2 0 2 0 4 9
3 7 3 2 4 3
4 3 6 7 7 4
5 5 3 7 5 9
6 8 7 6 4 7
7 6 2 6 6 5
8 2 8 7 5 8
9 4 7 6 1 5
%%timeit
mask = d1['A'].values == 7
d1[mask]
179 µs ± 8.73 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)
එදිරිව
%%timeit
mask = d1['A'].values == 7
pd.DataFrame(d1.values[mask], d1.index[mask], d1.columns)
87 µs ± 5.12 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)
අපි කාලය අඩකින් කපන්නෙමු.
maskවිකල්ප 3
@unutbu ද වටිනාකම් සමූහයක සිටින pd.Series.isinසෑම අංගයක් සඳහාම ගණනය කරන්නේ කෙසේදැයි අපට පෙන්වයි df['A']. අපගේ වටිනාකම් සමූහය එක් අගයක එකතුවක් නම් මෙය එකම දෙයකට ඇගයීමට ලක් කරයි 'foo'. නමුත් අවශ්‍ය නම් විශාල අගයන් ඇතුළත් කිරීම සාමාන්‍යකරණය කරයි. එය වඩාත් පොදු විසඳුමක් වුවද මෙය තවමත් වේගවත් ය. එකම සැබෑ අලාභය සංකල්පයට හුරු නැති අයට සහජ බුද්ධියයි.
mask = df['A'].isin(['foo'])
df[mask]
A B C D
0 foo one 0 0
2 foo two 2 4
4 foo two 4 8
6 foo one 6 12
7 foo three 7 14
කෙසේ වෙතත්, පෙර මෙන්, අපට numpyකිසිවක් කැප නොකර කාර්ය සාධනය වැඩි දියුණු කිරීමට යොදා ගත හැකිය . අපි පාවිච්චි කරමුnp.in1d
mask = np.in1d(df['A'].values, ['foo'])
df[mask]
A B C D
0 foo one 0 0
2 foo two 2 4
4 foo two 4 8
6 foo one 6 12
7 foo three 7 14
වේලාව
මම වෙනත් තනතුරු වල සඳහන් වෙනත් සංකල්ප ද යොමු කිරීම සඳහා ඇතුළත් කරමි.
පහත කේතය
මෙම වගුවේ ඇති සෑම තීරුවක්ම එක් එක් ශ්‍රිතය පරීක්ෂා කරන වෙනස් දිග දත්ත රාමුවක් නියෝජනය කරයි. සෑම තීරුවකම සාපේක්ෂ වේලාව පෙන්වන අතර වේගවත්ම ශ්‍රිතයට මූලික දර්ශකයක් ලබා දී ඇත 1.0.
res.div(res.min())
10 30 100 300 1000 3000 10000 30000
mask_standard 2.156872 1.850663 2.034149 2.166312 2.164541 3.090372 2.981326 3.131151
mask_standard_loc 1.879035 1.782366 1.988823 2.338112 2.361391 3.036131 2.998112 2.990103
mask_with_values 1.010166 1.000000 1.005113 1.026363 1.028698 1.293741 1.007824 1.016919
mask_with_values_loc 1.196843 1.300228 1.000000 1.000000 1.038989 1.219233 1.037020 1.000000
query 4.997304 4.765554 5.934096 4.500559 2.997924 2.397013 1.680447 1.398190
xs_label 4.124597 4.272363 5.596152 4.295331 4.676591 5.710680 6.032809 8.950255
mask_with_isin 1.674055 1.679935 1.847972 1.724183 1.345111 1.405231 1.253554 1.264760
mask_with_in1d 1.000000 1.083807 1.220493 1.101929 1.000000 1.000000 1.000000 1.144175
mask_with_valuesසහ අතර වේගවත්ම වේලාවන් බෙදාගෙන ඇති බව ඔබට පෙනෙනු ඇතmask_with_in1d
res.T.plot(loglog=True)
කාර්යයන්
def mask_standard(df):
mask = df['A'] == 'foo'
return df[mask]
def mask_standard_loc(df):
mask = df['A'] == 'foo'
return df.loc[mask]
def mask_with_values(df):
mask = df['A'].values == 'foo'
return df[mask]
def mask_with_values_loc(df):
mask = df['A'].values == 'foo'
return df.loc[mask]
def query(df):
return df.query('A == "foo"')
def xs_label(df):
return df.set_index('A', append=True, drop=False).xs('foo', level=-1)
def mask_with_isin(df):
mask = df['A'].isin(['foo'])
return df[mask]
def mask_with_in1d(df):
mask = np.in1d(df['A'].values, ['foo'])
return df[mask]
පරීක්ෂා කිරීම
res = pd.DataFrame(
index=[
'mask_standard', 'mask_standard_loc', 'mask_with_values', 'mask_with_values_loc',
'query', 'xs_label', 'mask_with_isin', 'mask_with_in1d'
],
columns=[10, 30, 100, 300, 1000, 3000, 10000, 30000],
dtype=float
)
for j in res.columns:
d = pd.concat([df] * j, ignore_index=True)
for i in res.index:a
stmt = '{}(d)'.format(i)
setp = 'from __main__ import d, {}'.format(i)
res.at[i, j] = timeit(stmt, setp, number=50)
විශේෂ වේලාව සමස්ත දත්ත රාමුව සඳහා
අපට තනි වස්තුවක් නොමැති විට විශේෂ අවස්ථාව දෙස බැලීම dtype.
පහත කේතය
spec.div(spec.min())
10 30 100 300 1000 3000 10000 30000
mask_with_values 1.009030 1.000000 1.194276 1.000000 1.236892 1.095343 1.000000 1.000000
mask_with_in1d 1.104638 1.094524 1.156930 1.072094 1.000000 1.000000 1.040043 1.027100
reconstruct 1.000000 1.142838 1.000000 1.355440 1.650270 2.222181 2.294913 3.406735
පේළි සිය ගණනක් පසුකර ප්‍රතිසංස්කරණය කිරීම වටින්නේ නැත.
spec.T.plot(loglog=True)
කාර්යයන්
np.random.seed([3,1415])
d1 = pd.DataFrame(np.random.randint(10, size=(10, 5)), columns=list('ABCDE'))
def mask_with_values(df):
mask = df['A'].values == 'foo'
return df[mask]
def mask_with_in1d(df):
mask = np.in1d(df['A'].values, ['foo'])
return df[mask]
def reconstruct(df):
v = df.values
mask = np.in1d(df['A'].values, ['foo'])
return pd.DataFrame(v[mask], df.index[mask], df.columns)
spec = pd.DataFrame(
index=['mask_with_values', 'mask_with_in1d', 'reconstruct'],
columns=[10, 30, 100, 300, 1000, 3000, 10000, 30000],
dtype=float
)
පරීක්ෂා කිරීම
for j in spec.columns:
d = pd.concat([df] * j, ignore_index=True)
for i in spec.index:
stmt = '{}(d)'.format(i)
setp = 'from __main__ import d, {}'.format(i)
spec.at[i, j] = timeit(stmt, setp, number=50)