获取给定列的第一行值 [英] Get first row value of a given column

问题描述

这似乎是一个非常简单的问题……但我没有看到我期待的简单答案.

This seems like a ridiculously easy question... but I'm not seeing the easy answer I was expecting.

那么，如何获取 Pandas 中给定列的第 n 行的值?(我对第一行特别感兴趣，但也会对更一般的做法感兴趣).

So, how do I get the value at an nth row of a given column in Pandas? (I am particularly interested in the first row, but would be interested in a more general practice as well).

例如，假设我想将 Btime 中的 1.2 值提取为变量.

For example, let's say I want to pull the 1.2 value in Btime as a variable.

这样做的正确方法是什么?

Whats the right way to do this?

>>> df_test
    ATime   X   Y   Z   Btime  C   D   E
0    1.2  2  15   2    1.2  12  25  12
1    1.4  3  12   1    1.3  13  22  11
2    1.5  1  10   6    1.4  11  20  16
3    1.6  2   9  10    1.7  12  29  12
4    1.9  1   1   9    1.9  11  21  19
5    2.0  0   0   0    2.0   8  10  11
6    2.4  0   0   0    2.4  10  12  15

推荐答案

要选择 ith<​​/code> 行，使用iloc:

In [31]: df_test.iloc[0]
Out[31]: 
ATime     1.2
X         2.0
Y        15.0
Z         2.0
Btime     1.2
C        12.0
D        25.0
E        12.0
Name: 0, dtype: float64

要在 Btime 列中选择第 i 个值，您可以使用:

To select the ith value in the Btime column you could use:

In [30]: df_test['Btime'].iloc[0]
Out[30]: 1.2

<小时>

df_test['Btime'].iloc[0](推荐)和df_test.iloc[0]['Btime']的区别:

DataFrames 将数据存储在基于列的块中(其中每个块都有一个类型).如果您先按列选择，则可以返回一个 view(即比返回副本更快)并保留原始数据类型.相比之下，如果您先按行选择，并且 DataFrame 具有不同的列dtypes，然后 Pandas 将数据复制到一个新的 Series 对象 dtype 中.所以选择列比选择行快一点.因此，虽然df_test.iloc[0]['Btime'] 有效，df_test['Btime'].iloc[0] 有点效率更高.

---

There is a difference between df_test['Btime'].iloc[0] (recommended) and df_test.iloc[0]['Btime']:

DataFrames store data in column-based blocks (where each block has a single dtype). If you select by column first, a view can be returned (which is quicker than returning a copy) and the original dtype is preserved. In contrast, if you select by row first, and if the DataFrame has columns of different dtypes, then Pandas copies the data into a new Series of object dtype. So selecting columns is a bit faster than selecting rows. Thus, although df_test.iloc[0]['Btime'] works, df_test['Btime'].iloc[0] is a little bit more efficient.

在分配方面，两者之间存在很大差异.df_test['Btime'].iloc[0] = x 影响 df_test，但 df_test.iloc[0]['Btime']不得.有关原因的解释，请参见下文.因为细微的差别索引的顺序对行为有很大的影响，最好使用单个索引分配:

There is a big difference between the two when it comes to assignment. df_test['Btime'].iloc[0] = x affects df_test, but df_test.iloc[0]['Btime'] may not. See below for an explanation of why. Because a subtle difference in the order of indexing makes a big difference in behavior, it is better to use single indexing assignment:

df.iloc[0, df.columns.get_loc('Btime')] = x

<小时>

df.iloc[0, df.columns.get_loc('Btime')] = x(推荐):

推荐方式 将新值分配给DataFrame 是为了避免链式索引，而是使用由安德鲁,

---

df.iloc[0, df.columns.get_loc('Btime')] = x (recommended):

The recommended way to assign new values to a DataFrame is to avoid chained indexing, and instead use the method shown by andrew,

df.loc[df.index[n], 'Btime'] = x

或

df.iloc[n, df.columns.get_loc('Btime')] = x

后一种方法要快一些，因为 df.loc 必须将行和列标签转换为位置索引，所以如果你使用的话，需要的转换会少一点df.iloc 代替.

The latter method is a bit faster, because df.loc has to convert the row and column labels to positional indices, so there is a little less conversion necessary if you use df.iloc instead.

虽然这有效，但它利用了当前实现数据帧的方式.不能保证 Pandas 将来必须以这种方式工作.特别是，它利用了这样一个事实，即(当前)df['Btime'] 总是返回一个查看(不是副本)所以 df['Btime'].iloc[n] = x 可用于分配一个新值在df的Btime列的第n个位置.

Although this works, it is taking advantage of the way DataFrames are currently implemented. There is no guarantee that Pandas has to work this way in the future. In particular, it is taking advantage of the fact that (currently) df['Btime'] always returns a view (not a copy) so df['Btime'].iloc[n] = x can be used to assign a new value at the nth location of the Btime column of df.

由于 Pandas 没有明确保证索引器何时返回视图还是副本，因此使用链式索引的赋值通常总是引发 SettingWithCopyWarning，即使在这种情况下赋值成功修改了 df:

Since Pandas makes no explicit guarantees about when indexers return a view versus a copy, assignments that use chained indexing generally always raise a SettingWithCopyWarning even though in this case the assignment succeeds in modifying df:

In [22]: df = pd.DataFrame({'foo':list('ABC')}, index=[0,2,1])
In [24]: df['bar'] = 100
In [25]: df['bar'].iloc[0] = 99
/home/unutbu/data/binky/bin/ipython:1: SettingWithCopyWarning: 
A value is trying to be set on a copy of a slice from a DataFrame

See the caveats in the documentation: http://pandas.pydata.org/pandas-docs/stable/indexing.html#indexing-view-versus-copy
  self._setitem_with_indexer(indexer, value)

In [26]: df
Out[26]: 
  foo  bar
0   A   99  <-- assignment succeeded
2   B  100
1   C  100

<小时>

df.iloc[0]['Btime'] = x 不起作用:

相反，df.iloc[0]['bar'] = 123 的赋值不起作用，因为 df.iloc[0] 正在返回一个副本:

---

df.iloc[0]['Btime'] = x does not work:

In contrast, assignment with df.iloc[0]['bar'] = 123 does not work because df.iloc[0] is returning a copy:

In [66]: df.iloc[0]['bar'] = 123
/home/unutbu/data/binky/bin/ipython:1: SettingWithCopyWarning: 
A value is trying to be set on a copy of a slice from a DataFrame

See the caveats in the documentation: http://pandas.pydata.org/pandas-docs/stable/indexing.html#indexing-view-versus-copy

In [67]: df
Out[67]: 
  foo  bar
0   A   99  <-- assignment failed
2   B  100
1   C  100

<小时>

警告:我之前曾建议使用 df_test.ix[i, 'Btime'].但这并不能保证给你 ith<​​/code> 值，因为 ix 在尝试按 positionlabel 索引em>.因此，如果 DataFrame 的整数索引不是从 0 开始的排序顺序，那么使用 ix[i] 将返回行 labeled i> 而不是 ith<​​/code> 行.例如，

---

Warning: I had previously suggested df_test.ix[i, 'Btime']. But this is not guaranteed to give you the ith value since ix tries to index by label before trying to index by position. So if the DataFrame has an integer index which is not in sorted order starting at 0, then using ix[i] will return the row labeled i rather than the ith row. For example,

In [1]: df = pd.DataFrame({'foo':list('ABC')}, index=[0,2,1])

In [2]: df
Out[2]: 
  foo
0   A
2   B
1   C

In [4]: df.ix[1, 'foo']
Out[4]: 'C'

这篇关于获取给定列的第一行值的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！