Iloc vs Loc em Pandas: Um guia com exemplos

Uma das coisas irritantes que todos nós tentamos entender quando aprendemos a usar o Pandas é a distinção entre .loc e .iloc.

Vamos acabar com essa confusão e esclarecer a diferença entre esses dois métodos. Darei vários exemplos e espero que a distinção fique muito mais clara até o final deste blog.

O que são .loc e .iloc no Pandas?

Tanto o .loc quanto o .iloc são atributos essenciais do Pandas DataFrames e ambos são usados para selecionar subconjuntos específicos de dados. Sua finalidade é acessar e permitir a manipulação de uma parte específica do DataFrame em vez de todo o DataFrame. 

Como você pode ver na tabela, a sintaxe é muito semelhante. A diferença está em como usamos os argumentos row_indexer e column_indexer. Isso ocorre porque os dois métodos oferecem abordagens diferentes para indexar os dados: enquanto o .loc indexa com base nos nomes dos rótulos, o .iloc usa o índice de posição numérica de linhas e colunas como argumentos.

Vamos examinar cada um dos dois métodos em detalhes, começando com .loc.

Usando .loc: Seleção por rótulos

Para ilustrar os conceitos, vamos considerar um banco de dados de clientes hipotético representado por este DataFrame chamado df, com o Customer ID representando o índice da linha:

Existem quatro maneiras principais de selecionar linhas com .loc. Isso inclui:

• Seleção de uma única linha
• Seleção de várias linhas
• Selecionando uma fatia de linhas
• Seleção condicional de linhas

Seleção de uma única linha usando .loc

Para selecionar uma única linha, usamos o rótulo da linha que queremos recuperar como row_indexer. Dessa forma, a sintaxe é a seguinte: df.loc['row_label']. Vamos usar isso para exibir todas as informações sobre nosso cliente Ali Khan:

df.loc['C345']

Seleção de várias linhas usando .loc

Se quisermos selecionar várias linhas que não necessariamente seguem umas às outras em ordem, teremos de passar uma lista de seus rótulos de linha como o argumento row_indexer. Isso significa que precisamos usar não apenas um, mas dois pares de colchetes: um para a sintaxe regular do .loc e outro para a lista de rótulos.

A linha df.loc[['row_label_1', 'row_label_2']] retornará as duas linhas do DataFrame df especificado na lista. Digamos que você queira saber não apenas as informações sobre Ali Khan, mas também sobre David Lee:

df.loc[['C345', 'C567']]

Selecionando uma fatia de linhas usando .loc

Você pode selecionar um intervalo de linhas passando os rótulos da primeira e da última linha com dois pontos no meio: df.loc['row_label_start':'row_label_end']. Poderíamos exibir as quatro primeiras linhas do nosso DataFrame da seguinte forma:

df.loc['C123' : 'C456']

Há duas coisas que você deve ter em mente aqui:

1. A saída inclui a linha especificada em row_label_end. Isso é diferente em .iloc, que abordaremos mais adiante.
2. Usamos apenas um par de colchetes, embora queiramos recuperar várias linhas. Não usamos uma lista para especificar as várias linhas, portanto, o uso de dois colchetes retornaria um SyntaxError.

Seleção condicional de linhas usando .loc

Também podemos retornar linhas com base em uma expressão condicional. Podemos filtrar todas as linhas de acordo com o fato de elas atenderem ou não a uma determinada condição e exibir apenas as que atenderem.

A sintaxe correspondente é df.loc[conditional_expression], sendo que conditional_expression é uma declaração sobre os valores permitidos em uma coluna específica.

Para colunas com dados não numéricos (como Name ou Country), a declaração só pode usar o operador igual ou desigual, pois não há ordem entre os valores. Poderíamos, por exemplo, retornar todas as linhas de clientes que não são da Ásia:

df.loc[df['Region'] != 'Asia']

Seleção de uma única coluna usando .loc

Para selecionar colunas, precisamos especificar o argumento column_indexer, que vem depois do argumento row_indexer. Se quisermos especificar apenas o column_indexer, precisaremos marcar de alguma forma que queremos retornar todas as linhas e filtrar apenas as colunas. Vamos ver como você pode fazer isso!

A seleção de uma única coluna pode ser feita especificando o endereço column_indexercom o rótulo da respectiva coluna. Para recuperar todas as linhas, precisamos especificar o endereço row_indexer com dois pontos simples. Chegamos a uma sintaxe parecida com a seguinte: df.loc[:, 'column_name'].

Vamos exibir o endereço Name de cada cliente:

df.loc[:, 'Name']

Seleção de várias colunas usando .loc

De modo semelhante à seleção de várias linhas, precisamos passar uma lista de rótulos de coluna se quisermos retornar várias colunas de um DataFrame que não necessariamente seguem umas às outras em ordem: df.loc[:, [col_label_1, 'col_label_2']].

Supondo que você queira adicionar o endereço Age de todos os clientes à nossa última saída, isso funcionaria da seguinte forma:

df.loc[:, ['Name', 'Age']]

Seleção de uma fatia de colunas usando .loc

Se você usar dois pontos entre os rótulos de duas colunas, selecionará todas as colunas no intervalo de ordem entre as duas colunas especificadas. Ela inclui a coluna final, o que significa que a coluna chamada col_end também será selecionada na sintaxe padrão, que é a seguinte: df.loc[:, 'col_start':'col_end'].

Se estivéssemos interessados em Name, Country e Region de nossos clientes, nossa linha de código poderia ser:

df.loc[:, 'Name':'Region']

Seleção combinada de linhas e colunas usando .loc

Também é possível especificar tanto o row_indexer quanto o column_indexer. Isso pode ser usado para recuperar uma única informação, ou seja, uma célula do DataFrame. Para fazer isso, especificamos uma linha e uma coluna usando a sintaxe df.loc['row_label', 'column_name'] .

O caso mais útil é retornar um sub-DataFrame que se concentre exatamente no conjunto de linhas e colunas em que estamos interessados. É possível especificar ambos os indexadores como listas usando colchetes ou como uma fatia usando dois pontos, e até mesmo combiná-los com uma expressão condicional para a seleção de linha.

Aqui está um exemplo de retorno de Name, Country e Region de cada cliente com um Age acima de 30:

df.loc[df['Age'] > 30, 'Name':'Region']

Usando .iloc: Seleção por posição inteira

.iloc seleciona por posição em vez de rótulo. Essa é a sintaxe padrão para você usar .iloc: df.iloc[row_indexer, column_indexer]. Há dois aspectos especiais que você deve observar:

• Contagem começando em 0: A primeira linha e coluna têm o índice 0, a segunda tem o índice 1, etc.
• Exclusividade do valor final do intervalo: Ao usar uma fatia, a linha ou coluna especificada atrás dos dois pontos não é incluída na seleção.

Seleção de uma única linha usando .iloc

Uma única linha pode ser selecionada usando o número inteiro que representa o número de índice da linha como row_indexer. Não precisamos de aspas, pois estamos inserindo um número inteiro e não uma cadeia de rótulos, como fizemos com .loc. Para retornar a primeira linha de um DataFrame chamado df, digite df.iloc[0].

Em nosso DataFrame de exemplo, essa mesma linha de código retorna as informações de John Doe:

df.iloc[0]

Seleção de várias linhas usando .iloc

A seleção de várias linhas funciona em .iloc da mesma forma que em .loc- inserimos os números inteiros do índice de linha em uma lista com colchetes. A sintaxe é a seguinte: df.iloc[[0, 3, 4]].

A respectiva saída em nossa tabela de clientes pode ser vista abaixo:

df.iloc[[0, 3, 4]]

Selecionando uma fatia de linhas usando .iloc

Para selecionar uma fatia de linhas, usamos dois pontos entre dois números inteiros de índice de linha especificados. Agora, precisamos prestar atenção à exclusividade mencionada anteriormente. 

Podemos usar a linha df.iloc[1:4] como exemplo para ilustrar esse conceito. O número de índice 1 significa a segunda linha, portanto, nossa fatia começa ali. O índice inteiro 4 representa a quinta linha, mas como .iloc não é inclusivo para a seleção de fatias, nossa saída incluirá todas as linhas até a última antes desta. Portanto, ele retornará a segunda, terceira e quarta linhas. 

Vamos provar que a linha funciona como deveria:

df.iloc[1:4]

Seleção de uma única coluna usando .iloc

A lógica de seleção de colunas usando .iloc segue o que aprendemos até agora. Vamos ver como isso funciona para colunas únicas, várias colunas e fatias de colunas.

Assim como no caso do .loc, é importante que você especifique o row_indexer antes de prosseguir para o column_indexer. Para recuperar os valores da terceira coluna de df para cada linha, digitamos df.iloc[:, 2].

Como Region é a terceira coluna em nosso DataFrame, ela será recuperada como consequência dessa linha de código:

df.iloc[:, 2]

Seleção de várias colunas usando .iloc

Para selecionar várias colunas que não são necessariamente subsequentes, podemos novamente inserir uma lista contendo números inteiros como column_indexer. A linha df.iloc[:, [0, 3]] retorna a primeira e a quarta colunas. 

Em nosso caso, as informações exibidas são Name e Age de cada cliente:

df.iloc[:, [0, 3]]

Selecionando uma fatia de colunas usando .iloc

Para a seleção de fatias usando .iloc, a lógica do column_indexer segue a do row_indexer. A coluna representada pelo número inteiro após os dois pontos não é incluída na saída. Para recuperar a segunda e a terceira colunas, a linha de código deve ter a seguinte aparência: df.iloc[:, 1:3].

Essa linha abaixo retorna todas as informações geográficas que temos sobre nossos clientes:

df.iloc[:, 1:3]

Seleção combinada de linhas e colunas usando .iloc

Podemos juntar o que aprendemos sobre .iloc para combinar a seleção de linhas e colunas. Novamente, é possível retornar uma única célula ou um sub-DataFrame. Para retornar a célula única na interseção da linha 3 e da coluna 4, digitamos df.iloc[2, 3].

Assim como em .loc, podemos especificar ambos os indexadores como listas, usando colchetes, ou como uma fatia, usando dois pontos. Se quisermos selecionar linhas usando expressões condicionais, isso também é tecnicamente possível com .iloc, mas não é recomendado. Usar os nomes dos rótulos e .loc geralmente é muito mais intuitivo e menos propenso a erros.

Esse último exemplo exibe Country, Region e Age para a primeira, segunda e quinta linha em nosso DataFrame:

df.iloc[[0,1,4], 1:4]

.iloc vs .loc: Quando usar o Which

Em geral, há uma regra geral simples em que a escolha do método depende do conhecimento que você tem do DataFrame:

• Use .loc quando você conhece os rótulos (nomes) das linhas/colunas.
• Use .iloc quando você souber as posições inteiras das linhas/colunas.

Alguns cenários favorecem o .loc ou o .iloc por sua natureza. Por exemplo, é mais fácil e intuitivo iterar sobre linhas ou colunas usando números inteiros do que rótulos. Como já mencionamos, a filtragem de linhas com base nas condições dos valores das colunas é menos propensa a erros quando você usa os nomes dos rótulos das colunas.

KeyError, NameError e erro de índice com .loc e .iloc

Vamos dar uma olhada nos possíveis problemas. Uma armadilha comum ao usar .loc é encontrar um KeyError. Esse erro ocorre quando tentamos acessar um rótulo de linha ou coluna que não existe em nosso DataFrame. Para evitar isso, precisamos sempre garantir que os rótulos que estamos usando sejam precisos e que correspondam aos rótulos existentes em seu DataFrame e verificar novamente se há erros de digitação.

Além disso, é importante que você sempre use aspas nos rótulos especificados usando .loc. Se você esquecê-las, terá como retorno um NameError.

Pode ocorrer um IndexError ao usar .iloc se especificarmos uma posição inteira que esteja fora do intervalo válido dos índices do nosso DataFrame. Isso acontece quando o índice que você está tentando acessar não existe, seja porque está além do número de linhas ou colunas no DataFrame ou porque é um valor negativo. Para evitar esse erro, verifique as dimensões do DataFrame e use valores de índice apropriados dentro do intervalo válido.

Conclusão

Espero que este blog tenha sido útil e que a distinção entre .loc e .iloc esteja clara para você. Para saber mais, aqui estão algumas boas próximas etapas:

• SettingWithCopyWarning em Pandas: Como corrigir esse aviso
• Curso: Manipulação de dados com pandas
• Curso: Escrevendo código eficiente com pandas
• Folha de dicas: Processamento de dados com pandas
• Folha de dicas: Reformulando dados com o pandas