如何从数据帧的单元格中获取值？

Question

我构造了一个从我的数据框中提取一行的条件:

d2 = df[(df['l_ext']==l_ext) & (df['item']==item) & (df['wn']==wn) & (df['wd']==1)]

现在我想从特定列中获取值:

val = d2['col_name']

但结果我得到一个包含一行和一列(即一个单元格)的数据帧.这不是我需要的.我需要一个值(一个浮点数).我怎么能在熊猫里做到这一点？

Answer 1

如果您只有一行DataFrame,则使用Series访问第一个(唯一)行iloc,然后使用列名访问该值:

In [3]: sub_df
Out[3]:
          A         B
2 -0.133653 -0.030854

In [4]: sub_df.iloc[0]
Out[4]:
A   -0.133653
B   -0.030854
Name: 2, dtype: float64

In [5]: sub_df.iloc[0]['A']
Out[5]: -0.13365288513107493

Answer 2

这些是标量的快速访问

In [15]: df = pandas.DataFrame(numpy.random.randn(5,3),columns=list('ABC'))

In [16]: df
Out[16]: 
          A         B         C
0 -0.074172 -0.090626  0.038272
1 -0.128545  0.762088 -0.714816
2  0.201498 -0.734963  0.558397
3  1.563307 -1.186415  0.848246
4  0.205171  0.962514  0.037709

In [17]: df.iat[0,0]
Out[17]: -0.074171888537611502

In [18]: df.at[0,'A']
Out[18]: -0.074171888537611502

Answer 3

您可以将1x1数据帧转换为numpy数组,然后访问该数组的第一个也是唯一的值:

val = d2['col_name'].values[0]

Answer 4

它不需要很复杂：

val = df.loc[df.wd==1, 'col_name'].values[0]

Answer 5

大多数答案都是使用iloc哪个有利于按位置选择.

如果您需要按标签选择 loc会更方便.

用于显式获取值(等于弃用的df.get_value('a','A'))

# this is also equivalent to df1.at['a','A']
In [55]: df1.loc['a', 'A'] 
Out[55]: 0.13200317033032932

Answer 6

它看起来像是pandas 10.1/13.1之后的变化

在iloc不可用之前,我从10.1升级到13.1.

现在使用13.1,iloc[0]['label']获取单个值数组而不是标量.

像这样:

lastprice=stock.iloc[-1]['Close']

输出:

date
2014-02-26 118.2
name:Close, dtype: float64

Answer 7

我需要一个由列和索引名称选择的单元格的值。此解决方案为我工作：

original_conversion_frequency.loc[1,:].values[0]

Answer 8

在更高版本中，您可以通过简单地执行以下操作来修复它：

val = float(d2['col_name'].iloc[0])

Answer 9

我在使用带有多重索引的数据帧时遇到过这个问题，并发现挤压很有用。

从文档中：

将一维轴对象压缩为标量。

具有单个元素的系列或数据帧被压缩为标量。具有单列或单行的 DataFrame 被压缩为一个 Series。否则该对象不变。

# Example for a dataframe with MultiIndex
> import pandas as pd

> df = pd.DataFrame(
                    [
                        [1, 2, 3],
                        [4, 5, 6],
                        [7, 8, 9]
                    ],
                    index=pd.MultiIndex.from_tuples( [('i', 1), ('ii', 2), ('iii', 3)] ),
                    columns=pd.MultiIndex.from_tuples( [('A', 'a'), ('B', 'b'), ('C', 'c')] )
)

> df
       A  B  C
       a  b  c
i   1  1  2  3
ii  2  4  5  6
iii 3  7  8  9

> df.loc['ii', 'B']
   b
2  5

> df.loc['ii', 'B'].squeeze()
5

请注意，虽然df.at[]也可以（如果您不需要使用条件），但据我所知，您仍然需要指定 MultiIndex 的所有级别。

例子：

> df.at[('ii', 2), ('B', 'b')]
5

我有一个具有六级索引和两级列的数据框，因此只需指定外部级别就非常有帮助。

Answer 10

对于 pandas 0.10，其中iloc不可用的地方，过滤 aDF并获取列的第一行数据VALUE：

df_filt = df[df['C1'] == C1val & df['C2'] == C2val]
result = df_filt.get_value(df_filt.index[0],'VALUE')

如果过滤了多于 1 行，则获取第一行值。如果过滤器导致空数据框，则会出现异常。

Answer 11

不知道这是否是一个好习惯，但是我注意到我也可以通过将序列强制转换为来获得值float。

例如

rate

3 0.042679

名称：Unemployment_rate，dtype：float64

float(rate)

0.0426789

Answer 12

我找到的最快/最简单的选项如下。501表示行索引。

df.at[501,'column_name']
df.get_value(501,'column_name')

Answer 13

df_gdp.columns

Index([u'Country', u'Country Code', u'Indicator Name', u'Indicator Code', u'1960', u'1961', u'1962', u'1963', u'1964' , u'1965', u'1966', u'1967', u'1968', u'1969', u'1970', u'1971', u'1972', u'1973', u'1974' , u'1975', u'1976', u'1977', u'1978', u'1979', u'1980', u'1981', u'1982', u'1983', u'1984' , u'1985', u'1986', u'1987', u'1988', u'1989', u'1990', u'1991', u'1992', u'1993', u'1994' , u'1995', u'1996', u'1997', u'1998', u'1999', u'2000',u'2001', u'2002', u'2003', u'2004', u'2005', u'2006', u'2007', u'2008', u'2009', u'2010', u'2011', u'2012', u'2013', u'2014', u'2015', u'2016'], dtype='object')

df_gdp[df_gdp["Country Code"] == "USA"]["1996"].values[0]

8100000000000.0

Answer 14

如果从数据帧中过滤出单行，则从单个单元格获取标量值的一种方法是squeeze()(或item())：

\n

df = pd.DataFrame({\'A\':range(5), \'B\': range(5)})\nd2 = df[df[\'A\'].le(5) & df[\'B\'].eq(3)]\nval = d2[\'A\'].squeeze()                 # 3\n\nval = d2[\'A\'].item()                    # 3\n

\n

事实上，item()可能会在索引上调用，所以item+at组合可以工作。

\n

msk = df[\'A\'].le(5) & df[\'B\'].eq(3)\nval = df.at[df.index[msk].item(), \'B\']  # 3\n

\n

事实上，后一种方法比此处列出的获取单个单元格值的任何其他方法都要快得多。

\n

df = pd.DataFrame({\'A\':range(10000), \'B\': range(10000)})\nmsk = df[\'A\'].le(5) & df[\'B\'].eq(3)\n\n%timeit df.at[df.index[msk].item(), \'A\']\n# 31.4 \xc2\xb5s \xc2\xb1 5.83 \xc2\xb5s per loop (mean \xc2\xb1 std. dev. of 7 runs, 10,000 loops each)\n%timeit df.loc[msk, \'A\'].squeeze()\n# 143 \xc2\xb5s \xc2\xb1 8.99 \xc2\xb5s per loop (mean \xc2\xb1 std. dev. of 7 runs, 10,000 loops each)\n%timeit df.loc[msk, \'A\'].item()\n# 125 \xc2\xb5s \xc2\xb1 1.56 \xc2\xb5s per loop (mean \xc2\xb1 std. dev. of 7 runs, 10,000 loops each)\n%timeit df.loc[msk, \'A\'].iat[0]\n# 125 \xc2\xb5s \xc2\xb1 1.96 \xc2\xb5s per loop (mean \xc2\xb1 std. dev. of 7 runs, 10,000 loops each)\n%timeit df[msk][\'A\'].values[0]\n# 189 \xc2\xb5s \xc2\xb1 8.67 \xc2\xb5s per loop (mean \xc2\xb1 std. dev. of 7 runs, 10,000 loops each)\n

\n