최근 내 안전한 곳에서 파이썬으로 분기하기 시작했으며의 셀 현지화 / 선택에 약간 혼란 스럽습니다 Pandas. 설명서를 읽었지만 다양한 현지화 / 선택 옵션의 실제적인 의미를 이해하기 위해 고심하고 있습니다.

• 내가 사용해야하는 이유가 있습니까 .loc또는 .iloc가장 일반적인 옵션 이상은 .ix?
• 나는 이해 .loc, iloc, at, 그리고 iat어떤 보장 정확성을 제공 할 수 있습니다 .ix제공 할 수 없습니다,하지만 어디도 읽었습니다 .ix전반적으로 가장 빠른 해결책이 될 경향이있다.
• .ix? 이외의 다른 것을 활용하는 실제 모범 사례를 설명하십시오 .

LOC : 인덱스에서만 작업
iloc : 위치에 작업
IX : 당신은이 인덱스에없이 dataframe에서 데이터를 얻을 수 있습니다
로는 : 스칼라 값을 얻는다. 매우 빠른 위치 입니다. 스칼라 값을
가져옵니다 . 매우 빠른 iloc입니다

http://pyciencia.blogspot.com/2015/05/obtener-y-filtrar-datos-de-un-dataframe.html

참고 : 현재 pandas 0.20.0의 .ix인덱서가되어 사용되지 않는 더 엄격한 찬성 .iloc및 .loc인덱서.

더 이상 사용되지 않는 pandas 0.20것으로 업데이트되었습니다 ix. 이뿐만 아니라 사용하는 방법을 보여줍니다 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

at- 레이블 기반 스칼라 인덱서
와 매우 유사한 방식 으로 작동 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합니다. 배열 인덱서에서 작동 할 수 없습니다 . 할 수있다! 새로운 지수와 열을 할당

이점 오버 헤드가 거의 없기 때문에, 빠른 슈퍼!
단점pandas 많은 안전 점검을 수행하지 않기 때문에 오버 헤드가 거의 없습니다. 자신의 책임하에 사용하십시오 . 또한 이것은 공개용이 아닙니다.

# 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와takable=True - 위치 기반
유사 작품iloc. 배열 인덱서에서 작업 할 수 없습니다 . 할 수 없습니다! 새로운 지수와 열을 할당합니다.

이점 오버 헤드가 거의 없기 때문에, 빠른 슈퍼!
단점pandas 많은 안전 점검을 수행하지 않기 때문에 오버 헤드가 거의 없습니다. 자신의 책임하에 사용하십시오 . 또한 이것은 공개용이 아닙니다.

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

팬더가 DataFrame에서 선택하는 주요 방법에는 두 가지가 있습니다.

• 으로 라벨
• 으로 정수 위치

문서는 용어의 사용 위치 를 참조하기위한 정수 위치 . 혼란스러워서이 용어가 마음에 들지 않습니다. 정수 위치는 더 설명적이고 정확하게 .iloc의미합니다. 여기서 핵심 단어는 INTEGER - 정수 위치에 따라 선택할 때 정수를 사용해야합니다.

요약을 표시하기 전에 모두 다음을 확인하십시오 ...

.ix는 더 이상 사용되지 않으며 모호하므로 절대 사용해서는 안됩니다.

팬더에 대한 기본 인덱서 에는 세 가지가 있습니다 . 우리는 색인 연산자 자체 (괄호를 []) .loc및 .iloc. 그것들을 요약하자 :

• []-주로 열의 하위 집합을 선택하지만 행도 선택할 수 있습니다. 행과 열을 동시에 선택할 수 없습니다.
• .loc -레이블만으로 행과 열의 하위 집합을 선택합니다
• .iloc -정수 위치로만 행과 열의 하위 집합을 선택합니다

나는 거의 사용하지 않습니다 .at또는 .iat그들이 추가 기능을 추가하지 않고 단지 성능이 약간 증가한다. 시간에 매우 민감한 응용 프로그램이 없으면 사용을 권장하지 않습니다. 어쨌든, 우리는 그들의 요약을 가지고 있습니다 :

• .at 레이블만으로 DataFrame에서 단일 스칼라 값을 선택합니다.
• .iat 정수 위치로만 DataFrame에서 단일 스칼라 값을 선택합니다.

레이블 및 정수 위치 별 선택 외에도 부울 인덱싱 이라고도하는 부울 선택 이 있습니다.

예로 설명 .loc, .iloc부울 선택 및 .at및 .iat이하에 나타낸다

우리는 처음의 차이점에 초점을 맞출 것이다 .loc및 .iloc. 차이점에 대해 이야기하기 전에 DataFrames에 각 열과 각 행을 식별하는 데 도움이되는 레이블이 있음을 이해해야합니다. 샘플 DataFrame을 살펴 보겠습니다.

df = pd.DataFrame({'age':[30, 2, 12, 4, 32, 33, 69],
                   'color':['blue', 'green', 'red', 'white', 'gray', 'black', 'red'],
                   'food':['Steak', 'Lamb', 'Mango', 'Apple', 'Cheese', 'Melon', 'Beans'],
                   'height':[165, 70, 120, 80, 180, 172, 150],
                   'score':[4.6, 8.3, 9.0, 3.3, 1.8, 9.5, 2.2],
                   'state':['NY', 'TX', 'FL', 'AL', 'AK', 'TX', 'TX']
                   },
                  index=['Jane', 'Nick', 'Aaron', 'Penelope', 'Dean', 'Christina', 'Cornelia'])

굵게 표시된 모든 단어 는 레이블입니다. 라벨은, age, color, food, height, score및 state에 사용되는 열 . 다른 레이블, Jane, Nick, Aaron, Penelope, Dean, Christina, Cornelia행 레이블로 사용됩니다. 이러한 행 레이블을 통틀어 index라고 합니다.

DataFrame에서 특정 행을 선택하는 기본 방법은 .loc및 .iloc인덱서를 사용하는 것입니다. 이러한 각 인덱서를 사용하여 열을 동시에 선택할 수도 있지만 지금은 행에 집중하는 것이 더 쉽습니다. 또한 각 인덱서는 이름 바로 다음에 오는 일련의 대괄호를 사용하여 선택합니다.

.loc은 레이블로만 데이터를 선택합니다.

먼저 .loc인덱스 또는 열 레이블로 데이터를 선택 하는 인덱서 에 대해 이야기하겠습니다 . 샘플 DataFrame에서 인덱스의 값으로 의미있는 이름을 제공했습니다. 많은 DataFrame에는 의미있는 이름이 없으며 대신 0에서 n-1 사이의 정수로 기본 설정됩니다. 여기서 n은 DataFrame의 길이 (행 수)입니다.

그중 3 개에 사용할 수있는 다양한 입력 이 있습니다..loc

• 끈
• 문자열 목록
• 문자열을 시작 및 중지 값으로 사용하는 슬라이스 표기법

문자열이있는 .loc을 사용하여 단일 행 선택

단일 데이터 행을 선택하려면 다음에 괄호 안에 색인 레이블을 배치하십시오 .loc.

df.loc['Penelope']

이것은 데이터 행을 Series로 리턴합니다.

age           4
color     white
food      Apple
height       80
score       3.3
state        AL
Name: Penelope, dtype: object

문자열 목록이있는 .loc을 사용하여 여러 행 선택

df.loc[['Cornelia', 'Jane', 'Dean']]

목록에 지정된 순서대로 행이있는 DataFrame을 반환합니다.

슬라이스 표기법이있는 .loc를 사용하여 여러 행 선택

슬라이스 표기법은 시작, 중지 및 단계 값으로 정의됩니다. 레이블로 슬라이스 할 때 팬더는 리턴 값에 중지 값을 포함합니다. Aaron에서 Dean까지 다음 조각이 포함됩니다. 단계 크기는 명시 적으로 정의되어 있지 않지만 기본값은 1입니다.

df.loc['Aaron':'Dean']

복잡한 슬라이스는 Python 목록과 같은 방식으로 가져올 수 있습니다.

.iloc은 정수 위치로만 데이터를 선택합니다

이제로 돌아가 봅시다 .iloc. DataFrame의 모든 데이터 행과 열에는이를 정의하는 정수 위치가 있습니다. 이것은 출력에 시각적으로 표시되는 레이블에 추가됩니다. 정수 위치는 단순히 0에서 시작하는 상단 / 왼쪽의 행 / 열 수입니다.

그중 3 개에 사용할 수있는 다양한 입력 이 있습니다..iloc

• 정수
• 정수 목록
• 시작 및 중지 값으로 정수를 사용하는 슬라이스 표기법

정수가있는 .iloc을 사용하여 단일 행 선택

df.iloc[4]

5 번째 행 (정수 위치 4)을 Series로 반환합니다.

age           32
color       gray
food      Cheese
height       180
score        1.8
state         AK
Name: Dean, dtype: object

정수 목록이있는 .iloc을 사용하여 여러 행 선택

df.iloc[[2, -2]]

세 번째와 두 번째 행부터 마지막 ​​행까지의 DataFrame을 반환합니다.

슬라이스 표기법이있는 .iloc을 사용하여 여러 행 선택

df.iloc[:5:3]

.loc 및 .iloc을 사용하여 행과 열을 동시에 선택

두 가지의 뛰어난 기능 중 하나 .loc/.iloc는 행과 열을 동시에 선택할 수 있다는 것입니다. 위의 예에서 모든 열은 각 선택 항목에서 반환되었습니다. 행과 동일한 입력 유형을 가진 열을 선택할 수 있습니다. 행과 열 선택을 쉼표로 구분하면 됩니다.

예를 들어 다음과 같이 열 높이, 점수 및 상태만으로 Jane과 Dean 열을 선택할 수 있습니다.

df.loc[['Jane', 'Dean'], 'height':]

행의 레이블 목록과 열의 슬라이스 표기법을 사용합니다.

.iloc정수만 사용하여 자연스럽게 유사한 작업을 수행 할 수 있습니다 .

df.iloc[[1,4], 2]
Nick      Lamb
Dean    Cheese
Name: food, dtype: object

라벨과 정수 위치를 통한 동시 선택

.ix유용하지만 때로는 혼란스럽고 모호한 레이블 및 정수 위치와 동시에 선택하는 데 사용되었으며 고맙게도 더 이상 사용되지 않습니다. 레이블과 정수 위치를 혼합하여 선택해야하는 경우 선택 레이블 또는 정수 위치를 모두 선택해야합니다.

우리가 행을 선택하려는 경우 예를 들어, Nick및 Cornelia열 2, 4와 함께를, 우리가 사용할 수있는 .loc다음과 라벨에 정수를 변환 :

col_names = df.columns[[2, 4]]
df.loc[['Nick', 'Cornelia'], col_names] 

또는 get_locindex 메소드 를 사용하여 인덱스 레이블을 정수로 변환하십시오 .

labels = ['Nick', 'Cornelia']
index_ints = [df.index.get_loc(label) for label in labels]
df.iloc[index_ints, [2, 4]]

부울 선택

.loc 인덱서는 부울 선택을 수행 할 수도 있습니다. 예를 들어, 우리가 나이가 돌아 단지 30 위에 어디 모든 행을 찾는 데 관심이 있다면 food및 score열은 우리가 다음을 수행 할 수 있습니다 :

df.loc[df['age'] > 30, ['food', 'score']] 

이것을 복제 .iloc할 수 는 있지만 부울 시리즈를 전달할 수는 없습니다. 부울 시리즈를 다음과 같이 numpy 배열로 변환해야합니다.

df.iloc[(df['age'] > 30).values, [2, 4]] 

모든 행 선택

.loc/.iloc열 선택에만 사용할 수 있습니다 . 다음과 같이 콜론을 사용하여 모든 행을 선택할 수 있습니다.

df.loc[:, 'color':'score':2]

인덱싱 연산자 인 []은 슬라이스로 행과 열을 동시에 선택할 수는 없습니다.

대부분의 사람들은 열을 선택하는 DataFrame 인덱싱 연산자의 기본 목적에 익숙합니다. 문자열은 단일 열을 Series로 선택하고 문자열 목록은 여러 열을 DataFrame으로 선택합니다.

df['food']

Jane          Steak
Nick           Lamb
Aaron         Mango
Penelope      Apple
Dean         Cheese
Christina     Melon
Cornelia      Beans
Name: food, dtype: object

목록을 사용하여 여러 열을 선택합니다

df[['food', 'score']]

사람들이 익숙하지 않은 것은 슬라이스 표기법을 사용할 때 행 레이블 또는 정수 위치로 선택이 발생한다는 것입니다. 이것은 매우 혼란스럽고 거의 사용하지 않는 것이지만 작동합니다.

df['Penelope':'Christina'] # slice rows by label

df[2:6:2] # slice rows by integer location

명확성의 .loc/.iloc선택 행에 대해 매우 바람직하다. 인덱싱 연산자만으로는 행과 열을 동시에 선택할 수 없습니다.

df[3:5, 'color']
TypeError: unhashable type: 'slice'

.at와에 의해 선택.iat

선택 .at은 거의 동일 .loc하지만 DataFrame에서 단일 '셀'만 선택합니다. 일반적으로이 셀을 스칼라 값이라고합니다. 을 사용하려면 .at쉼표로 구분 된 행 및 열 레이블을 모두 전달하십시오.

df.at['Christina', 'color']
'black'

선택 .iat은 거의 동일 .iloc하지만 단일 스칼라 값만 선택합니다. 행과 열 위치 모두에 정수를 전달해야합니다.

df.iat[2, 5]
'FL'

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

이 작은 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

따라서 .iloc 만 사용해야하는 하위 집합에 .iat를 사용할 수 없습니다.

그러나 더 큰 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보다 빠릅니다.

:-)