python - Pandas একটি কলাম মান উপর ভিত্তি করে একটি ডাটাফ্রেম থেকে সারি নির্বাচন করুন




dataframe (9)

TL; ড

সমতুল্য pandas

select * from table where column_name = some_value

হয়

table[table.column_name == some_value]

একাধিক শর্তাবলী:

table[(table.column_name == some_value) | (table.column_name2 == some_value2)]

অথবা

table.query('column_name == some_value | column_name2 == some_value2')

কোড উদাহরণ

import pandas as pd

# Create data set
d = {'foo':[100, 111, 222], 
     'bar':[333, 444, 555]}
df = pd.DataFrame(d)

# Full dataframe:
df

# Shows:
#    bar   foo 
# 0  333   100
# 1  444   111
# 2  555   222

# Output only the row(s) in df where foo is 222:
df[df.foo == 222]

# Shows:
#    bar  foo
# 2  555  222

উপরের df[df.foo == 222] এটি লাইন df[df.foo == 222] যা এই ক্ষেত্রে কলাম মানের উপর ভিত্তি করে সারি দেয় 222

একাধিক শর্তও সম্ভব:

df[(df.foo == 222) | (df.bar == 444)]
#    bar  foo
# 1  444  111
# 2  555  222

কিন্তু সেই সময়ে আমি query ফাংশনটি ব্যবহার করার পরামর্শ দিই, কারণ এটি কম ক্রিয়াপদ এবং এটি একই ফলাফলের ফলন করে:

df.query('foo == 222 | bar == 444')

প্যান্ডাসের কিছু কলামের মানগুলির উপর ভিত্তি করে একটি ডাটাফ্রেম থেকে কীভাবে সারি নির্বাচন করবেন?
এসকিউএল আমি ব্যবহার করব:

select * from table where colume_name = some_value. 

আমি pandas ডকুমেন্টেশন দেখতে চেষ্টা কিন্তু অবিলম্বে উত্তর খুঁজে না।


আপনি .apply ব্যবহার করতে পারেন:

df.apply(lambda row: row[df['B'].isin(['one','three'])])

এটি আসলে সারি অনুসারে কাজ করে (অর্থাত্, প্রতিটি সারিতে ফাংশন প্রয়োগ করে)।

আউটপুট হয়

   A      B  C   D
0  foo    one  0   0
1  bar    one  1   2
3  bar  three  3   6
6  foo    one  6  12
7  foo  three  7  14

ফলাফল @unutbu দ্বারা উল্লিখিত ব্যবহার হিসাবে একই

df[[df['B'].isin(['one','three'])]]

আমি পূর্ববর্তী উত্তর সিনট্যাক্স অকার্যকর এবং মনে রাখা কঠিন খুঁজে পেতে। Pandas v.1.13 এ query() পদ্ধতি চালু করে এবং আমি এটি পছন্দ করি। আপনার প্রশ্নের জন্য, আপনি df.query('col == val') করতে পারেন df.query('col == val')

http://pandas.pydata.org/pandas-docs/version/0.17.0/indexing.html#indexing-query থেকে পুনরুজ্জীবিত

In [167]: n = 10

In [168]: df = pd.DataFrame(np.random.rand(n, 3), columns=list('abc'))

In [169]: df
Out[169]: 
          a         b         c
0  0.687704  0.582314  0.281645
1  0.250846  0.610021  0.420121
2  0.624328  0.401816  0.932146
3  0.011763  0.022921  0.244186
4  0.590198  0.325680  0.890392
5  0.598892  0.296424  0.007312
6  0.634625  0.803069  0.123872
7  0.924168  0.325076  0.303746
8  0.116822  0.364564  0.454607
9  0.986142  0.751953  0.561512

# pure python
In [170]: df[(df.a < df.b) & (df.b < df.c)]
Out[170]: 
          a         b         c
3  0.011763  0.022921  0.244186
8  0.116822  0.364564  0.454607

# query
In [171]: df.query('(a < b) & (b < c)')
Out[171]: 
          a         b         c
3  0.011763  0.022921  0.244186
8  0.116822  0.364564  0.454607

আপনি পরিবেশে ভেরিয়েবল অ্যাক্সেস করতে পারেন @

exclude = ('red', 'orange')
df.query('color not in @exclude')

আমি শুধু এটিকে সম্পাদনা করার চেষ্টা করেছি, কিন্তু আমি লগ ইন ছিলাম না, তাই আমি নিশ্চিত নই যে আমার সম্পাদনা কোথায় গিয়েছিল। আমি একাধিক নির্বাচন অন্তর্ভুক্ত করার চেষ্টা ছিল। সুতরাং আমি একটি ভাল উত্তর মনে হয়:

একক মানের জন্য সর্বাধিক সহজবোধ্য (মানব পঠনযোগ্য) সম্ভবত:

df.loc[df['column_name'] == some_value]

মান তালিকাগুলির জন্য আপনি এটি ব্যবহার করতে পারেন:

df.loc[df['column_name'].isin(some_values)]

উদাহরণ স্বরূপ,

import pandas as pd
import 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})
print(df)
#      A      B  C   D
# 0  foo    one  0   0
# 1  bar    one  1   2
# 2  foo    two  2   4
# 3  bar  three  3   6
# 4  foo    two  4   8
# 5  bar    two  5  10
# 6  foo    one  6  12
# 7  foo  three  7  14

print(df.loc[df['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

যদি আপনার বিরুদ্ধে একাধিক মানদণ্ড নির্বাচন করতে চান তবে আপনি তাদের তালিকায় রাখতে এবং 'isin' ব্যবহার করতে পারেন:

print(df.loc[df['B'].isin(['one','three'])])

উৎপাদনের

      A      B  C   D
0  foo    one  0   0
1  bar    one  1   2
3  bar  three  3   6
6  foo    one  6  12
7  foo  three  7  14

উল্লেখ্য, তবে, যদি আপনি এটি অনেকবার করতে চান তবে প্রথমে সূচীটি তৈরি করা আরও কার্যকর এবং df.loc ব্যবহার করুন:

df = df.set_index(['A'])
print(df.loc['foo'])

উৎপাদনের

  A      B  C   D
foo    one  0   0
foo    two  2   4
foo    two  4   8
foo    one  6  12
foo  three  7  14

একটি pandas ডেটাফ্রেম থেকে সারি নির্বাচন করতে কয়েকটি মৌলিক উপায় রয়েছে।

  1. বুলিয়ান সূচক
  2. অবস্থানগত সূচক
  3. লেবেল সূচী
  4. এপিআই

প্রতিটি বেস টাইপের জন্য, আমরা প্যান্ডাস numpy নিজেদের সীমাবদ্ধ করে জিনিসগুলিকে সহজ রাখতে পারি অথবা আমরা API- এর বাইরে numpy করতে পারি, সাধারণত নষ্ট হয়ে numpy এবং গতির জিনিসগুলিকে আপ করতে পারি।

আমি আপনাকে প্রতিটি উদাহরণ দেখাব এবং নির্দিষ্ট কৌশলগুলি কখন ব্যবহার করব তা আপনাকে নির্দেশ করব।

সেটআপ
আমাদের যা দরকার তা হল একটি শর্ত সনাক্ত করা যা সারি নির্বাচন করার জন্য আমাদের মানদণ্ড হিসাবে কাজ করবে। OP আপ column_name == some_value । আমরা সেখানে শুরু এবং কিছু অন্যান্য সাধারণ ব্যবহারের ক্ষেত্রে অন্তর্ভুক্ত করব।

@Unutbu থেকে ঋণগ্রহণ:

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

আমাদের মাপদণ্ড অনুমান করুন কলাম 'A' = 'foo'

1।
বুলিয়ান ইনডেক্সিংয়ের প্রতিটি সারির 'A' কলামের সত্য মান খোঁজার জন্য 'foo' সমান, তারপর সেই সত্য মানগুলি ব্যবহার করে কোন সারি রাখতে হবে তা সনাক্ত করতে হবে। সাধারণত, আমরা এই সিরিজ, সত্য মান একটি অ্যারের নাম, mask । আমরা এখানে পাশাপাশি তাই করব।

mask = df['A'] == 'foo'

আমরা তারপর ডাটাফ্রেম slice বা সূচী এই মাস্ক ব্যবহার করতে পারেন

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।
পজিশনিং সূচক তার ব্যবহার ক্ষেত্রে আছে, কিন্তু এই তাদের মধ্যে একটি নয়। কোথায় টাইস করতে হবে তা সনাক্ত করার জন্য, আমাদের প্রথমে উপরের বুলিয়ান বিশ্লেষণটি সম্পাদন করতে হবে। এটি আমাদের একই কাজটি সম্পন্ন করার জন্য একটি অতিরিক্ত পদক্ষেপ সম্পাদন করে।

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

numpy অ্যারের সাথে mask মূল্যায়ন ~ 30 গুণ দ্রুত। এই আংশিকভাবে numpy মূল্যায়ন প্রায়ই কারণে দ্রুত হচ্ছে। এটি একটি pd.Series অভাবের কারণে আংশিকভাবে একটি সূচক এবং অনুরূপ pd.Series বস্তু pd.Series

পরবর্তী আমরা অন্য বিপরীত একটি mask সঙ্গে slicing জন্য সময় তাকান করব।

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
আমরা পাশাপাশি ডেটাফ্রেম পুনর্গঠন করতে পারে। ডেটাফ্রেম পুনঃনির্মাণ করার সময় একটি বড় সতর্কতা রয়েছে- আপনাকে এটি dtypes সময় আপনাকে অবশ্যই 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'] প্রতিটি উপাদানের pd.Series.isin জন্য অ্যাকাউন্টের জন্য অ্যাকাউন্ট দেখায়। মানগুলির আমাদের সেটটি একটি মানের একটি সেট, যেমন '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

যাইহোক, আগে হিসাবে, আমরা virtually কিছুই sacrificing যখন কর্মক্ষমতা উন্নতি 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)

এখানে একটি সহজ উদাহরণ

from pandas import DataFrame

# Create data set
d = {'Revenue':[100,111,222], 
     'Cost':[333,444,555]}
df = DataFrame(d)


# mask = Return True when the value in column "Revenue" is equal to 111
mask = df['Revenue'] == 111

print mask

# Result:
# 0    False
# 1     True
# 2    False
# Name: Revenue, dtype: bool


# Select * FROM df WHERE Revenue = 111
df[mask]

# Result:
#    Cost    Revenue
# 1  444     111

প্যান্ডাসে দেওয়া মানের জন্য একাধিক কলামের মধ্যে শুধুমাত্র নির্দিষ্ট কলাম নির্বাচন করার জন্য:

select col_name1, col_name2 from table where column_name = some_value.

বিকল্প:

df.loc[df['column_name'] == some_value][[col_name1, col_name2]]

অথবা

df.query['column_name' == 'some_value'][[col_name1, col_name2]]

যদি আপনি এখানে এসেছেন যার মাধ্যমে কলামের মূল্য মানগুলির একটি তালিকা না সহ ডেটাফেম থেকে সারিগুলি নির্বাচন করতে চান তবে এখানে উপরের মানগুলির তালিকাটির জন্য unutbu এর উত্তরটি কীভাবে ফ্লিপ করবেন তা এখানে দেখুন:

df.loc[~df['column_name'].isin(some_values)]

(একটি একক মান অন্তর্ভুক্ত করতে, অবশ্যই, আপনি নিয়মিত না সমান অপারেটর ব্যবহার করুন != ।)

উদাহরণ:

import pandas as pd
df = pd.DataFrame({'A': 'foo bar foo bar foo bar foo foo'.split(),
                   'B': 'one one two three two two one three'.split()})
print(df)

আমাদের দেয়

     A      B
0  foo    one
1  bar    one
2  foo    two
3  bar  three
4  foo    two
5  bar    two
6  foo    one
7  foo  three    

কলাম B one বা three নয় এমন সারিতে কেবল সাবসেট করতে:

df.loc[~df['B'].isin(['one', 'three'])]

উৎপাদনের

     A    B
2  foo  two
4  foo  two
5  bar  two

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})
df[df['A']=='foo']

OUTPUT:
   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




dataframe