最近开始从我的安全位置(R)扩展到Python，并且我对Pandas中的单元格定位/选择有点困惑。我已经阅读了文档，但我很难理解各种本地化/选择选项的实际含义。
是否有一个原因，为什么我应该使用。loc或。iloc在，和iat或反之亦然?在什么情况下我应该使用哪种方法?
注意:以后的读者注意，这个问题很老了，是在pandas v0.20之前写的，当时存在一个叫.ix的函数。这种方法后来被分为two - loc和iloc -，以明确区分基于位置和基于标签的索引。请注意，由于不一致的行为和难以grok, ix已被终止，并且在当前版本的pandas(>= 1.0)中不再存在。
当前回答
Loc:只在索引上工作 Iloc:在职工作 At:获取标量值。这是一个非常快的loc iat:获取标量值。这是一个非常快的iloc
同时,
At和iat意味着访问一个标量，即单个元素 在数据帧中，而loc和iloc是用来访问几个的 元素的同时，可能要执行向量化 操作。
http://pyciencia.blogspot.com/2015/05/obtener-y-filtrar-datos-de-un-dataframe.html
其他回答
Loc:只在索引上工作 Iloc:在职工作 At:获取标量值。这是一个非常快的loc iat:获取标量值。这是一个非常快的iloc
同时,
At和iat意味着访问一个标量，即单个元素 在数据帧中，而loc和iloc是用来访问几个的 元素的同时，可能要执行向量化 操作。
http://pyciencia.blogspot.com/2015/05/obtener-y-filtrar-datos-de-un-dataframe.html
df = pd.DataFrame({'A':['a', 'b', 'c'], 'B':[54, 67, 89]}, index=[100, 200, 300])
df
A B
100 a 54
200 b 67
300 c 89
In [19]:
df.loc[100]
Out[19]:
A a
B 54
Name: 100, dtype: object
In [20]:
df.iloc[0]
Out[20]:
A a
B 54
Name: 100, dtype: object
In [24]:
df2 = df.set_index([df.index,'A'])
df2
Out[24]:
B
A
100 a 54
200 b 67
300 c 89
In [25]:
df2.ix[100, 'a']
Out[25]:
B 54
Name: (100, a), dtype: int64
需要注意的是，如果只是访问一个列，.loc比[]慢7-10倍:
测试脚本:
import os
import sys
from timeit import timeit
import numpy as np
import pandas as pd
def setup():
arr = np.arange(0, 10 ** 2)
return pd.DataFrame(arr.reshape(10, 10))
if __name__ == "__main__":
print(f"Python: {sys.version}")
print(f"Numpy: {np.__version__}")
print(f"Pandas: {pd.__version__}")
iters = 10000
print(
"[] Method:",
timeit(
"data = df[0]",
setup="from __main__ import setup; df = setup()",
number=iters,
),
)
print(
".loc() Method:",
timeit(
"data = df.loc[:, 0]",
setup="from __main__ import setup; df = setup()",
number=iters,
),
)
输出:
Python: 3.8.10 (tags/v3.8.10:3d8993a, May 3 2021, 11:48:03) [MSC v.1928 64 bit (AMD64)]
Numpy: 1.21.1
Pandas: 1.3.3
[] Method: 0.0923579000000001
.loc() Method: 0.6762988000000001
我们从这个小df开始:
import pandas as pd
import time as tm
import numpy as np
n=10
a=np.arange(0,n**2)
df=pd.DataFrame(a.reshape(n,n))
我们一定会有
df
Out[25]:
0 1 2 3 4 5 6 7 8 9
0 0 1 2 3 4 5 6 7 8 9
1 10 11 12 13 14 15 16 17 18 19
2 20 21 22 23 24 25 26 27 28 29
3 30 31 32 33 34 35 36 37 38 39
4 40 41 42 43 44 45 46 47 48 49
5 50 51 52 53 54 55 56 57 58 59
6 60 61 62 63 64 65 66 67 68 69
7 70 71 72 73 74 75 76 77 78 79
8 80 81 82 83 84 85 86 87 88 89
9 90 91 92 93 94 95 96 97 98 99
我们有:
df.iloc[3,3]
Out[33]: 33
df.iat[3,3]
Out[34]: 33
df.iloc[:3,:3]
Out[35]:
0 1 2 3
0 0 1 2 3
1 10 11 12 13
2 20 21 22 23
3 30 31 32 33
df.iat[:3,:3]
Traceback (most recent call last):
... omissis ...
ValueError: At based indexing on an integer index can only have integer indexers
因此，我们不能使用.iat作为子集，而只能使用.iloc。
但是让我们尝试从更大的df中选择，让我们检查速度…
# -*- coding: utf-8 -*-
"""
Created on Wed Feb 7 09:58:39 2018
@author: Fabio Pomi
"""
import pandas as pd
import time as tm
import numpy as np
n=1000
a=np.arange(0,n**2)
df=pd.DataFrame(a.reshape(n,n))
t1=tm.time()
for j in df.index:
for i in df.columns:
a=df.iloc[j,i]
t2=tm.time()
for j in df.index:
for i in df.columns:
a=df.iat[j,i]
t3=tm.time()
loc=t2-t1
at=t3-t2
prc = loc/at *100
print('\nloc:%f at:%f prc:%f' %(loc,at,prc))
loc:10.485600 at:7.395423 prc:141.784987
因此，使用.loc我们可以管理子集，而使用.at只能管理单个标量，但.at比.loc快
:-)
鉴于ix已弃用，为pandas 0.20更新。这不仅演示了如何使用loc, iloc, at, iat, set_value，还演示了如何完成基于位置/标签的混合索引。
基于Loc标签 允许您传递1-D数组作为索引器。数组可以是索引或列的切片(子集)，也可以是长度与索引或列相等的布尔数组。
特别注意:当传递标量索引器时，loc可以分配一个以前不存在的新索引或列值。
# label based, but we can use position values
# to get the labels from the index object
df.loc[df.index[2], 'ColName'] = 3
df.loc[df.index[1:3], 'ColName'] = 3
Iloc -基于职位 类似于loc，除了位置而不是索引值。但是，不能分配新的列或索引。
# position based, but we can get the position
# from the columns object via the `get_loc` method
df.iloc[2, df.columns.get_loc('ColName')] = 3
df.iloc[2, 4] = 3
df.iloc[:3, 2:4] = 3
基于标签的 工作原理与用于标量索引器的loc非常相似。不能操作数组索引器。可以!分配新的索引和列。
与loc相比，它的优点是更快。 缺点是不能将数组用于索引器。
# label based, but we can use position values
# to get the labels from the index object
df.at[df.index[2], 'ColName'] = 3
df.at['C', 'ColName'] = 3
Iat -基于职位 类似于iloc。不能在数组索引器中工作。不能!分配新的索引和列。
与iloc相比，它的优点是更快。 缺点是不能将数组用于索引器。
# position based, but we can get the position
# from the columns object via the `get_loc` method
IBM.iat[2, IBM.columns.get_loc('PNL')] = 3
Set_value -基于标签 工作原理与用于标量索引器的loc非常相似。不能操作数组索引器。可以!分配新的索引和列
优势超快，因为开销很小! 缺点:由于熊猫没有做一堆安全检查，所以开销很小。使用风险自负。此外，这不是为公共用途。
# label based, but we can use position values
# to get the labels from the index object
df.set_value(df.index[2], 'ColName', 3)
set_value with takable=True -基于位置 类似于iloc。不能在数组索引器中工作。不能!分配新的索引和列。
优势超快，因为开销很小! 缺点:由于熊猫没有做一堆安全检查，所以开销很小。使用风险自负。此外，这不是为公共用途。
# position based, but we can get the position
# from the columns object via the `get_loc` method
df.set_value(2, df.columns.get_loc('ColName'), 3, takable=True)
