Pandas iloc и loc: эффективный выбор строки по индексу в Python

Для кого эта статья:

• Аналитики данных и специалисты по работе с данными
• Студенты и начинающие разработчики, изучающие Python и библиотеки для анализа данных

• Практикующие разработчики, желающие улучшить свои навыки в работе с pandas и индексами данных

  Работа с данными в Python — как езда по городу: знание правильных маршрутов критически важно для достижения цели. При использовании pandas выбор строки по индексу может показаться тривиальной задачей, но именно здесь многие аналитики данных попадают в неожиданные тупики. Различие между методами iloc и loc — то самое разветвление дорог, где неверный поворот приводит к ошибкам в коде и потере времени. Давайте разберёмся в нюансах и научимся безошибочно извлекать данные, не путаясь в целочисленных индексах. 🔍

Изучаете pandas и хотите мастерски управлять данными? Курс Обучение Python-разработке от Skypro поможет вам освоить не только основы DataFrame, но и продвинутые техники работы с iloc/loc. Вместо бесконечных проб и ошибок — структурированные знания от практикующих разработчиков, которые применяют pandas для решения реальных бизнес-задач каждый день. Инвестируйте в навыки, которые окупаются!

Основы доступа к строкам в pandas: iloc vs loc

Работа с DataFrame в pandas невозможна без понимания методов доступа к данным. Два основных инструмента — iloc и loc — имеют принципиальные различия, которые определяют точность и эффективность вашего кода.

Ключевое различие между iloc и loc можно сформулировать одной фразой: iloc работает с позициями, loc — с метками. Это фундаментальное правило, незнание которого приводит к непредсказуемым результатам при обработке данных. 📊

Рассмотрим простой пример, иллюстрирующий разницу:

import pandas as pd

# Создаем DataFrame с настраиваемым индексом
df = pd.DataFrame({
'A': [1, 2, 3, 4, 5],
'B': [10, 20, 30, 40, 50]
}, index=[100, 101, 102, 103, 104])

# iloc использует позиционное индексирование (начиная с 0)
print(df.iloc[0]) # Возвращает первую строку: A=1, B=10

# loc использует значения индекса
print(df.loc[100]) # Также возвращает первую строку: A=1, B=10

В этом примере df.iloc[0] и df.loc[100] возвращают одну и ту же строку, но концептуально это совершенно разные операции:

• df.iloc[0]: "Дай мне строку, находящуюся в позиции 0 (первая строка)"
• df.loc[100]: "Дай мне строку, у которой значение индекса равно 100"

Эта разница становится критичной при работе со сложными индексами, пользовательской нумерацией или при выполнении операций фильтрации и трансформации данных.

Андрей Петров, Senior Data Scientist Однажды я потратил почти целый день, пытаясь найти ошибку в коде, который обрабатывал финансовые данные. Программа работала идеально на тестовом наборе, но ломалась на производственных данных. Проблема оказалась в том, что я использовал loc там, где должен был применить iloc. Дело в том, что наш тестовый набор данных имел индексы, идентичные позициям (0, 1, 2, 3...), поэтому код с loc[i] и iloc[i] давал одинаковый результат. Но в производственных данных индексы представляли собой коды транзакций (например, 1001, 2052, 3754), и мой код с loc[i] искал несуществующие метки. Переход на iloc мгновенно решил проблему и научил меня всегда четко различать эти методы.

Выбор строки по позиции с помощью iloc в pandas

Метод iloc — это мощный инструмент для позиционного доступа к данным в pandas. Его название происходит от "integer location", что подчеркивает работу именно с целочисленными позициями, а не значениями индекса.

Синтаксис iloc прост и интуитивно понятен для тех, кто знаком с индексированием в Python:

# Выбор одной строки
single_row = df.iloc[3] # Возвращает 4-ю строку (индекс 3)

# Выбор нескольких строк
multiple_rows = df.iloc[[0, 2, 4]] # Возвращает 1-ю, 3-ю и 5-ю строки

# Использование среза
row_slice = df.iloc[1:4] # Возвращает 2-ю, 3-ю и 4-ю строки (строки с индексами 1, 2, 3)

# Выбор строки и конкретного столбца
cell = df.iloc[2, 1] # Значение в 3-й строке и 2-м столбце

# Выбор строк и подмножества столбцов
subset = df.iloc[0:2, [0, 2]] # Первые две строки и 1-й и 3-й столбцы

Важно помнить, что iloc всегда работает с целочисленными позициями от 0 до (n-1), где n — количество строк или столбцов. Попытка обратиться к позиции за пределами этого диапазона приведет к ошибке IndexError.

При работе с iloc особенно полезны следующие приемы:

• Отрицательное индексирование — позволяет отсчитывать с конца: df.iloc[-1] вернет последнюю строку
• Шаг в срезах — df.iloc[0:10:2] выберет каждую вторую строку из первых десяти
• Комбинирование с условиями — можно использовать булевы маски: df.iloc[df['A'] > 5].iloc[0] выберет первую строку, где значение в столбце A больше 5

Для работы с большими наборами данных iloc особенно эффективен, поскольку обращение по позиции — это операция O(1), не требующая поиска по значениям индекса.

Метод loc: особенности работы с целочисленными индексами

Метод loc предназначен для доступа к данным по меткам индекса, но часто вызывает путаницу при работе с целочисленными индексами. Особенность loc заключается в том, что он интерпретирует числа как значения индекса, а не как позиции строк.

Мария Соколова, Data Engineer Работая над проектом анализа продаж, я столкнулась с интересным случаем, когда индекс DataFrame содержал идентификаторы товаров — целые числа от 1000 до 9999. Мой коллега, анализируя код, спросил: "Почему ты используешь loc[1234], а не iloc[1234]? Это же число!" Это был отличный момент для объяснения: "Смотри, 1234 здесь — это не позиция, а конкретный ID товара в нашем индексе. Используя loc[1234], я получаю данные по товару с этим ID, независимо от его положения в таблице. С iloc[1234] мы бы обратились к 1235-й строке, которая, вероятно, даже не существует в нашем DataFrame." После этого случая мы добавили в документацию проекта раздел о правильном использовании методов доступа в pandas, что спасло не один час работы новых членов команды.

Рассмотрим несколько сценариев работы loc с целочисленными индексами:

# Создаем DataFrame с целочисленным индексом
df_int = pd.DataFrame({
'A': [10, 20, 30, 40, 50],
'B': [100, 200, 300, 400, 500]
}, index=[5, 10, 15, 20, 25])

# Доступ по значению индекса
print(df_int.loc[15]) # Возвращает строку с индексом 15 (3-я строка)

# Доступ по срезу индексов
print(df_int.loc[10:20]) # Возвращает строки с индексами 10, 15, 20

# Обращение к несуществующему индексу вызовет ошибку
# print(df_int.loc[7]) # KeyError: 7

Особое внимание следует уделить ситуациям, когда индекс DataFrame состоит из последовательных целых чисел, начиная с 0. В этом случае loc и iloc будут работать одинаково, что создает иллюзию их взаимозаменяемости:

# DataFrame с дефолтным индексом (0, 1, 2...)
df_default = pd.DataFrame({'A': [1, 2, 3], 'B': [4, 5, 6]})

# В этом случае результаты будут идентичны
print(df_default.loc[1]) # A=2, B=5
print(df_default.iloc[1]) # A=2, B=5

# Но это совпадение, а не правило!

Критические различия, которые необходимо учитывать при работе с loc и целочисленными индексами:

Важно: если ваш индекс DataFrame содержит целые числа, обязательно документируйте в коде, почему вы используете loc или iloc в конкретном месте, чтобы избежать путаницы и ошибок при поддержке кода. 🧩

Распространённые ошибки при выборе строк по индексу

Работа с индексами в pandas часто сопровождается типичными ошибками, которые могут привести к неочевидным багам или некорректным результатам анализа. Рассмотрим наиболее распространенные проблемы и пути их решения.

1. Путаница между позицией и значением индекса

Самая частая ошибка — использование loc для доступа по позиции или iloc для доступа по значению индекса:

df = pd.DataFrame({'A': [1, 2, 3]}, index=[10, 20, 30])

# Ошибка: пытаемся получить первую строку через loc
try:
print(df.loc[0]) # KeyError: 0 не является значением индекса
except KeyError:
print("Ошибка: индекс 0 не существует")

# Ошибка: пытаемся получить строку с индексом 20 через iloc
try:
print(df.iloc[20]) # IndexError: позиция 20 выходит за границы
except IndexError:
print("Ошибка: позиция 20 вне диапазона")

# Правильно:
print(df.iloc[0]) # Первая строка
print(df.loc[20]) # Строка с индексом 20

2. Неучет границ при срезах

Различное поведение iloc и loc при использовании срезов часто приводит к ошибкам:

df = pd.DataFrame({'val': range(5)}, index=list('abcde'))

# iloc не включает правую границу
print(df.iloc[0:3]) # Возвращает строки 0, 1, 2 (индексы 'a', 'b', 'c')

# loc включает правую границу
print(df.loc['a':'c']) # Возвращает строки с индексами 'a', 'b', 'c'

3. Ошибки при сбросе или изменении индекса

После операций, меняющих индекс (resetindex, setindex), доступ к данным может неожиданно измениться:

df = pd.DataFrame({'A': [1, 2, 3]}, index=[10, 20, 30])
print(df.loc[10]) # Работает, возвращает первую строку

# Сбрасываем индекс
df_reset = df.reset_index()
# Теперь столбец 'index' содержит старые значения индекса
# А индекс стал стандартным: 0, 1, 2

try:
print(df_reset.loc[10]) # KeyError
except KeyError:
print("После reset_index старые индексы недоступны через loc")

# Правильно:
print(df_reset.iloc[0]) # Первая строка
print(df_reset.loc[0]) # Тоже первая строка, т.к. индекс теперь 0

4. Проблемы с типами данных в индексе

Неожиданные преобразования типов могут привести к сложно отлавливаемым ошибкам:

# DataFrame с целочисленным индексом
df_int = pd.DataFrame({'A': [1, 2]}, index=[1, 2])
print(df_int.loc[1]) # Работает

# Если мы случайно передаем float вместо int
try:
print(df_int.loc[1\.0]) # В старых версиях pandas это работало, в новых – KeyError
except Exception as e:
print(f"Ошибка: {e}")

# Аналогично с преобразованием строк в числа
df_mixed = pd.DataFrame({'A': [1, 2]}, index=[1, '2'])
try:
print(df_mixed.loc[2]) # Ищет индекс 2 (int), но существует '2' (str)
except KeyError:
print("Ошибка: строковый и числовой индексы различаются")

5. Игнорирование MultiIndex особенностей

При работе с многоуровневым индексом синтаксис доступа меняется:

import numpy as np
# Создаем DataFrame с MultiIndex
arrays = [['A', 'A', 'B', 'B'], [1, 2, 1, 2]]
index = pd.MultiIndex.from_arrays(arrays, names=('letter', 'number'))
df_multi = pd.DataFrame({'value': np.random.randn(4)}, index=index)

# Доступ ко всем строкам с первым уровнем индекса 'A'
print(df_multi.loc['A'])

# Доступ к конкретной строке с индексом ('A', 1)
print(df_multi.loc[('A', 1)])

# Ошибка: неправильная структура для MultiIndex
try:
print(df_multi.loc['A', 1]) # Это работает только с .xs()
except Exception as e:
print(f"Неправильный синтаксис для MultiIndex: {e}")

Чтобы избежать большинства этих ошибок, придерживайтесь следующих правил:

• Всегда используйте iloc для позиционного доступа и loc для доступа по меткам
• Проверяйте типы данных индекса при работе с внешними данными
• После операций, меняющих индекс, явно обновляйте все последующие обращения к данным
• Пишите тесты, проверяющие корректность доступа к данным в критических частях кода
• В сомнительных случаях используйте методы .head() или .info() для проверки структуры DataFrame

Придерживаясь этих принципов, вы значительно снизите количество ошибок при работе с индексами в pandas. 🛠️

Практические сценарии использования iloc и loc

Понимание теоретических различий между iloc и loc — лишь первый шаг. Настоящее мастерство приходит с практическим применением этих методов в реальных задачах анализа данных. Рассмотрим несколько типичных сценариев и покажем, как эффективно использовать оба метода.

Сценарий 1: Валидация и очистка данных

При подготовке данных часто требуется проверить и исправить значения в определенных позициях:

# Проверка аномалий в первых и последних строках
def check_anomalies(df):
# Проверяем первые 5 строк
head_sample = df.iloc[:5]

# Проверяем последние 5 строк
tail_sample = df.iloc[-5:]

# Проверяем каждую десятую строку
step_sample = df.iloc[::10]

# Анализируем выборки...
return anomalies

# Исправление значений в конкретных строках
def fix_known_issues(df):
# Предположим, мы знаем, что строки с ID 1001, 1004 и 1008 содержат ошибки
problem_ids = [1001, 1004, 1008]

for id in problem_ids:
if id in df.index:
# Используем loc для доступа по индексу
df.loc[id, 'value'] = df.loc[id, 'value'] * correction_factor

return df

Сценарий 2: Временные ряды и скользящие окна

При анализе временных рядов часто требуется обрабатывать данные по определенным периодам:

# Предположим, у нас есть временной ряд с DatetimeIndex
df_timeseries = pd.DataFrame({
'value': [1, 2, 3, 4, 5, 6, 7]
}, index=pd.date_range('2023-01-01', periods=7, freq='D'))

# Получаем данные за конкретную дату
jan_third = df_timeseries.loc['2023-01-03']

# Получаем данные за период
jan_first_to_fifth = df_timeseries.loc['2023-01-01':'2023-01-05']

# Реализация скользящего окна
def rolling_window_operation(df, window_size=3):
results = []
# Используем iloc для итерации по позициям
for i in range(len(df) – window_size + 1):
window = df.iloc[i:i+window_size]
result = some_calculation(window)
results.append(result)
return results

Сценарий 3: Создание новых признаков на основе условий

В задачах машинного обучения часто требуется создавать новые признаки на основе существующих данных:

# Предположим, у нас есть данные о продажах
sales_df = pd.DataFrame({
'product_id': [101, 102, 103, 104],
'sales_count': [150, 200, 50, 300],
'category': ['A', 'B', 'A', 'C']
})

# Создаем бинарный признак для товаров с высокими продажами
sales_df['high_volume'] = False
high_sales_positions = sales_df[sales_df['sales_count'] > 100].index
sales_df.loc[high_sales_positions, 'high_volume'] = True

# Добавляем ранг внутри категории
for category in sales_df['category'].unique():
category_positions = sales_df[sales_df['category'] == category].index
# Сортируем по продажам внутри категории и присваиваем ранг
sorted_positions = sales_df.loc[category_positions].sort_values('sales_count', ascending=False).index
for rank, position in enumerate(sorted_positions, 1):
sales_df.loc[position, 'category_rank'] = rank

Сценарий 4: Оптимизация производительности при работе с большими данными

При работе с большими датасетами правильный выбор метода доступа может существенно влиять на производительность:

# Для больших датасетов с дефолтным индексом iloc работает быстрее
def process_large_dataframe(df, chunk_size=1000):
results = []
# Обрабатываем данные блоками фиксированного размера
for i in range(0, len(df), chunk_size):
# Используем iloc для эффективного получения блока строк
chunk = df.iloc[i:i+chunk_size]
result = process_chunk(chunk)
results.append(result)
return pd.concat(results)

# Если у нас есть специфический индекс, используем loc для точечного доступа
def lookup_specific_records(df, record_ids):
results = []
for id in record_ids:
try:
# Используем loc для быстрого поиска по индексу
record = df.loc[id]
results.append(process_record(record))
except KeyError:
# Обработка случая, когда записи нет
results.append(None)
return results

Сравнение эффективности методов в различных сценариях:

Правильный выбор метода доступа к данным не только делает код более читаемым и понятным, но и может значительно повысить производительность ваших аналитических скриптов, особенно при работе с большими объемами данных. 💪

Умение выбирать правильный метод доступа к данным в pandas — это не просто технический навык, а индикатор глубокого понимания принципов работы с данными. Различия между iloc и loc кажутся незначительными, пока не столкнешься с реальным проектом, где эти нюансы могут радикально влиять на корректность и эффективность анализа. Мастерство приходит с практикой: чем больше разнообразных задач вы решаете, тем интуитивнее становится выбор правильного инструмента. Цените время на изучение этих концепций — оно окупится многократно в виде отлаженного кода и точных результатов.