Как сбросить индекс в Pandas DataFrame(с примерами)
Вы можете использовать следующий синтаксис для сброса индекса в pandas DataFrame:
df.reset_index(drop= True , inplace= True ) Обратите внимание на следующие аргументы:
- drop : Указание True запрещает pandas сохранять исходный индекс в виде столбца в DataFrame.
- inplace : Указание True позволяет pandas заменить индекс в исходном DataFrame вместо создания копии DataFrame.
В следующих примерах показано, как использовать этот синтаксис на практике.
Пример 1: сбросить индекс и удалить старый индекс
Предположим, у нас есть следующие Pandas DataFrame:
import pandas as pd #define DataFrame df = pd.DataFrame(, index=[0, 4, 3, 5, 2, 1, 7, 6]) #view DataFrame print(df) points assists rebounds 0 25 5 11 4 12 7 8 3 15 7 10 5 14 9 6 2 19 12 6 1 23 9 5 7 25 9 9 6 29 4 12 В следующем коде показано, как сбросить индекс DataFrame и полностью удалить старый индекс:
#reset index df.reset_index(drop= True , inplace= True ) #view updated DataFrame print(df) points assists rebounds 0 25 5 11 1 12 7 8 2 15 7 10 3 14 9 6 4 19 12 6 5 23 9 5 6 25 9 9 7 29 4 12 Обратите внимание, что индекс был сброшен, и значения в индексе теперь находятся в диапазоне от 0 до 7.
Пример 2: сбросить индекс и сохранить старый индекс как столбец
Предположим, у нас есть следующие Pandas DataFrame:
import pandas as pd #define DataFrame df = pd.DataFrame(, index=['A', 'C', 'D', 'B', 'E', 'G', 'F', 'H']) #view DataFrame print(df) points assists rebounds A 25 5 11 C 12 7 8 D 15 7 10 B 14 9 6 E 19 12 6 G 23 9 5 F 25 9 9 H 29 4 12 В следующем коде показано, как сбросить индекс DataFrame и сохранить старый индекс в виде столбца в DataFrame:
#reset index and retain old index as a column df.reset_index(inplace= True ) #view updated DataFrame print(df) index points assists rebounds 0 A 25 5 11 1 C 12 7 8 2 D 15 7 10 3 B 14 9 6 4 E 19 12 6 5 G 23 9 5 6 F 25 9 9 7 H 29 4 12 Обратите внимание, что индекс был сброшен, и значения в индексе теперь находятся в диапазоне от 0 до 7.
Также обратите внимание, что старый индекс (с буквами) сохраняется как новый столбец в DataFrame под названием «индекс».
Дополнительные ресурсы
В следующих руководствах объясняется, как выполнять другие распространенные операции в pandas:
Как изменить индексы элементов при срезе DataFrame в Pandas?
Имеется DataFrame df_ab в который считывается 100.000 строк из файла csv . Делается срез чётных df_ab[0::2] и нечётных df_ab[1::2] элементов. Получается 2 DataFrame df_a и df_b , но индексы у них тоже чередуются.
import pandas as pd df_a = pd.DataFrame() df_b = pd.DataFrame() # пример из 1 столбца на 10 элементов (исходно 2 столбца) df_ab = pd.DataFrame() df_a = df_ab[0::2] df_b = df_ab[1::2] df_a = df_a.astype('int32') df_b = df_b.astype('int32') print('\na:\n', df_a) print('\nb:\n', df_b) a: AB 0 0 2 2 4 4 6 6 8 8 b: AB 1 1 3 3 5 5 7 7 9 9 Как сделать что бы индексы шли по порядку:
a: AB 0 0 1 2 2 4 3 6 4 8 b: AB 0 1 1 3 2 5 3 7 4 9 Возможности объектов Index в pandas / pd 3
В отличие от других структур данных в Python pandas не только пользуется преимуществами высокой производительности массивов NumPy, но и добавляет в них индексы.
Этот выбор оказался крайне удачным. Несмотря на и без того отличную гибкость, которая обеспечивается существующими динамическими структурами, внутренние ссылки на их элементы (а именно ими и являются метки) позволяют разработчикам еще сильнее упрощать операции.
В этом разделе речь пойдет о некоторых базовых функциях, использующих этот механизм:
- Переиндексирование
- Удаление
- Выравнивание
Переиндексирование df.reindex()
Вы уже знаете, что после объявления в структуре данных объект Index нельзя менять. Но с помощью операции переиндексирования это можно решить.
Существует даже возможность получить новую структуру из уже существующей, где правила индексирования заданы заново.
>>> ser = pd.Series([2,5,7,4], index=['one','two','three','four']) >>> ser one 2 two 5 three 7 four 4 dtype: int64 Для того чтобы провести переиндексирование объекта Series библиотека pandas предоставляет функцию reindex() . Она создает новый объект Series со значениями из другого Series , которые теперь переставлены в соответствии с новой последовательностью меток.
При операции переиндексирования можно поменять порядок индексов, удалить некоторые из них или добавить новые. Если метка новая, pandas добавит NaN на место соответствующего значения.
>>> ser.reindex(['three','four','five','one']) three 7.0 four 4.0 five NaN one 2.0 dtype: float64 Как видно по выводу, порядок меток можно поменять полностью. Значение, которое раньше соответствовало метке two , удалено, зато есть новое с меткой five .
Тем не менее в случае, например, с большим Dataframe , не совсем удобно будет указывать новый список меток. Вместо этого можно использовать метод, который заполняет или интерполирует значения автоматически.
Для лучшего понимания механизма работы этого режима автоматического индексирования создадим следующий объект Series .
>>> ser3 = pd.Series([1,5,6,3],index=[0,3,5,6]) >>> ser3 0 1 3 5 5 6 6 3 dtype: int64 В этом примере видно, что колонка с индексами — это не идеальная последовательность чисел. Здесь пропущены цифры 1, 2 и 4. В таком случае нужно выполнить операцию интерполяции и получить полную последовательность чисел. Для этого можно использовать reindex с параметром method равным ffill . Более того, необходимо задать диапазон значений для индексов. Тут можно использовать range(6) в качестве аргумента.
>>> ser3.reindex(range(6),method='ffill') 0 1 1 1 2 1 3 5 4 5 5 6 dtype: int64 Теперь в объекте есть элементы, которых не было в оригинальном объекте Series . Операция интерполяции сделала так, что наименьшие индексы стали значениями в объекте. Так, индексы 1 и 2 имеют значение 1, принадлежащее индексу 0.
Если нужно присваивать значения индексов при интерполяции, необходимо использовать метод bfill .
>>> ser3.reindex(range(6),method='bfill') 0 1 1 5 2 5 3 5 4 6 5 6 dtype: int64 В этом случае значения индексов 1 и 2 равны 5, которое принадлежит индексу 3.
Операция отлично работает не только с Series , но и с Dataframe . Переиндексирование можно проводить не только на индексах (строках), но также и на колонках или на обоих. Как уже отмечалось, добавлять новые индексы и колонки возможно, но поскольку в оригинальной структуре есть недостающие значения, на их месте будет NaN .
>>> frame.reindex(range(5), method='ffill',columns=['colors','price','new', 'object']) | item | colors | price | new | object |
|---|---|---|---|---|
| id | ||||
| 0 | blue | 1.2 | blue | ball |
| 1 | green | 1.0 | green | pen |
| 2 | yellow | 3.3 | yellow | pencil |
| 3 | red | 0.9 | red | paper |
| 4 | white | 1.7 | white | mug |
Удаление
Еще одна операция, связанная с объектами Index — удаление. Удалить строку или колонку не составит труда, потому что метки используются для обозначения индексов и названий колонок.
В этом случае pandas предоставляет специальную функцию для этой операции, которая называется drop() . Метод возвращает новый объект без элементов, которые необходимо было удалить.
Например, возьмем в качестве примера случай, где из объекта нужно удалить один элемент. Для этого определим базовый объект Series из четырех элементов с 4 отдельными метками.
>>> ser = pd.Series(np.arange(4.), index=['red','blue','yellow','white']) >>> ser red 0.0 blue 1.0 yellow 2.0 white 3.0 dtype: float64 Теперь, предположим, необходимо удалить объект с меткой yellow . Для этого нужно всего лишь указать ее в качестве аргумента функции drop() .
>>> ser.drop('yellow') red 0.0 blue 1.0 white 3.0 dtype: float64 Для удаления большего количества элементов, передайте массив с соответствующими индексами.
>>> ser.drop(['blue','white']) red 0.0 yellow 2.0 dtype: float64 Если речь идет об объекте Dataframe , значения могут быть удалены с помощью ссылок на метки обеих осей. Возьмем в качестве примера следующий объект.
>>> frame = pd.DataFrame(np.arange(16).reshape((4,4)), ... index=['red', 'blue', 'yellow', 'white'], ... columns=['ball', 'pen', 'pencil', 'paper']) >>> frame | ball | pen | pencil | paper | |
|---|---|---|---|---|
| red | 0 | 1 | 2 | 3 |
| blue | 4 | 5 | 6 | 7 |
| yellow | 8 | 9 | 10 | 11 |
| white | 12 | 13 | 14 | 15 |
Для удаления строк просто передайте индексы строк.
>>> frame.drop(['blue','yellow']) | ball | pen | pencil | paper | |
|---|---|---|---|---|
| red | 0 | 1 | 2 | 3 |
| white | 12 | 13 | 14 | 15 |
Для удаления колонок необходимо указывать индексы колонок, а также ось, с которой требуется удалить элементы. Для этого используется параметр axis . Чтобы сослаться на название колонки, нужно написать axis=1 .
>>> frame.drop(['pen','pencil'],axis=1) | ball | paper | |
|---|---|---|
| red | 0 | 3 |
| blue | 4 | 7 |
| yellow | 8 | 11 |
| white | 12 | 15 |
Арифметика и выравнивание данных
Наверное, самая важная особенность индексов в этой структуре данных — тот факт, что pandas может выравнивать индексы двух разных структур. Это особенно важно при выполнении арифметических операций на их значениях. В этом случае индексы могут быть не только в разном порядке, но и присутствовать лишь в одной из двух структур.
В качестве примера можно взять два объекта Series с разными метками.
>>> s1 = pd.Series([3,2,5,1],['white','yellow','green','blue']) >>> s2 = pd.Series([1,4,7,2,1],['white','yellow','black','blue','brown']) Теперь воспользуемся базовой операцией сложения. Как видно по примеру, некоторые метки есть в обоих структурах, а остальные — только в одной. Если они есть в обоих случаях, их значения складываются, а если только в одном — то значением будет NaN .
>>> s1 + s2 black NaN blue 3.0 brown NaN green NaN white 4.0 yellow 6.0 dtype: float64 При использовании Dataframe выравнивание работает по тому же принципу, но проводится и для рядов, и для колонок.
>>> frame1 = pd.DataFrame(np.arange(16).reshape((4,4)), ... index=['red','blue','yellow','white'], ... columns=['ball','pen','pencil','paper']) >>> frame2 = pd.DataFrame(np.arange(12).reshape((4,3)), ... index=['blue','green','white','yellow'], ... columns=['mug','pen','ball']) >>> frame1 | ball | pen | pencil | paper | |
|---|---|---|---|---|
| red | 0 | 1 | 2 | 3 |
| blue | 4 | 5 | 6 | 7 |
| yellow | 8 | 9 | 10 | 11 |
| white | 12 | 13 | 14 | 15 |
>>> frame2 | mug | pen | ball | |
|---|---|---|---|
| blue | 0 | 1 | 2 |
| green | 3 | 4 | 5 |
| white | 6 | 7 | 8 |
| yellow | 9 | 10 | 11 |
>>> frame1 + frame2 | ball | mug | paper | pen | pencil | |
|---|---|---|---|---|---|
| blue | 6.0 | NaN | NaN | 6.0 | NaN |
| green | NaN | NaN | NaN | NaN | NaN |
| red | NaN | NaN | NaN | NaN | NaN |
| white | 20.0 | NaN | NaN | 20.0 | NaN |
| yellow | 19.0 | NaN | NaN | 19.0 | NaN |
Работа с индексами — Python: Pandas
Фильтрация значений и оперирование с их подмножествами используются в задачах обработки, подготовки и анализа данных. В этом уроке мы познакомимся c правилами индексирования основных объектов Series и DataFrame , а также узнаем, как с их помощью осуществлять подвыборки нужных строк и столбцов в табличных данных.
Структура объекта DataFrame
Рассмотрим объект DataFrame . Он состоит из набора столбцов, каждый из которых является объектом Series :
import pandas as pd df_orders = pd.read_json('./data/Orders.xlsx') print(df_orders.head()) # => shop_1 shop_2 shop_3 shop4 # 0 7.0 1 7.0 8 # 1 4.0 2 4.0 5 # 2 3.0 5 NaN 3 # 3 8.0 12 8.0 7 # 4 15.0 11 13.0 9 Применим функцию type() к столбцу df_orders :
print(type(df_orders['shop_1'])) # => pandas.core.series.Series Объект Series спроектирован, чтобы хранить одномерные структуры данных. Он состоит из двух связанных между собой массивов: меток и значений:
print(df_orders.shop_1) # => 0 7.0 # 1 4.0 # 2 3.0 # 3 8.0 # 4 15.0 # 5 21.0 # 6 NaN # Name: shop_1, dtype: float64 Выбрать несколько столбцов можно следующим образом:
print(df_orders[['shop_1','shop_2']].head()) # => shop_1 shop_2 # 0 7.0 1 # 1 4.0 2 # 2 3.0 5 # 3 8.0 12 # 4 15.0 11 # При выборе нескольких столбцов мы будем снова получать тип данных DataFrame.
Иногда легче выбросить несколько столбцов, чем перечислять необходимые. В этом случае нужно использовать метод drop() :
print(df_orders.drop(['shop_4'], axis=1).head()) # => shop_1 shop_2 shop_3 # 0 7.0 1 7.0 # 1 4.0 2 4.0 # 2 3.0 5 NaN # 3 8.0 12 8.0 # 4 15.0 11 13.0 В методе drop() нужно задавать значение параметра axis . Значение 0 будет указывать, что нужно исключить некоторые строки. Значение 1 указывает на исключение столбцов.
Метод drop() возвращает новый объект DataFrame и оставляет без изменений исходный.
Индексы объектов DataFrame и Series
У каждой строки объекта DataFrame или значения у Series есть индекс. Индекс может быть как числом, так и строкой. Список индексов объектов DataFrame и Series можно получить с помощью атрибута index :
print(df_orders.index) # RangeIndex(start=0, stop=7, step=1) print(df_orders.shop_1.index) # RangeIndex(start=0, stop=7, step=1) Если нужно, можно изменить значение индексов и имя столбца с индексами:
df_orders.index = range(0,16,2) df_orders.index.name = 'New indexes' print(df_orders.head()) # => shop_1 shop_2 shop_3 shop4 # New indexes # 0 7.0 1 7.0 8 # 2 4.0 2 4.0 5 # 4 3.0 5 NaN 3 # 6 8.0 12 8.0 7 # 8 15.0 11 13.0 9 Строковые индексы обычно называют метки или ключи:
df_orders.index = ['a','b','c','d','e','f','g'] print(df_orders.head()) # => shop_1 shop_2 shop_3 shop_4 # a 7.0 1 7.0 8 # b 4.0 2 4.0 5 # c 3.0 5 NaN 3 # d 8.0 12 8.0 7 # e 15.0 11 13.0 9 Методы получения значений по индексу
Разберем следующие методы:
- loc() — метод выбора данных на основе меток строк
- iloc() — метод выбора строк согласно их числовой позиции
loc()
Выберем одну строку из объекта DataFrame по ее метке:
print(df_orders.loc['b']) # => shop_1 4.0 # shop_2 2.0 # shop_3 4.0 # shop_4 5.0 # Name: b, dtype: float64 Выберем несколько строк:
print(df_orders.loc[['b','c']]) # => shop_1 shop_2 shop_3 shop_4 # b 4.0 2 4.0 5 # c 3.0 5 NaN 3 iloc()
Выберем одну строку:
print(df_orders.iloc[1]) # => shop_1 4.0 # shop_2 2.0 # shop_3 4.0 # shop_4 5.0 # Name: b, dtype: float64 Выберем несколько строк:
print(df_orders.loc[[1,2]]) # => shop_1 shop_2 shop_3 shop_4 # b 4.0 2 4.0 5 # c 3.0 5 NaN 3 Фильтрация строк и столбцов одновременно
Методы loc() и iloc() позволяют выполнять фильтрацию по строкам и столбцам одновременно. Пример для loc() :
print(df_orders.loc[['b','c'],['shop_2','shop_4']]) # => shop_2 shop_4 # b 2 5 # c 5 3 Пример для iloc() :
print(df_orders.iloc[[2,4],[1,3]]) # => shop_2 shop4 # c 5 3 # e 11 9 Как и при использовании методов отдельно для строк и столбцов, метод loc() ожидает на вход метки, а iloc() — номера позиций строк и столбцов.
Срезы
Срезы позволяют получать совокупности строк в определенном диапазоне. Пример:
print(df_orders.loc['b':'d']) # => shop_1 shop_2 shop_3 shop_4 # b 4.0 2 4.0 5 # c 3.0 5 NaN 3 # d 8.0 12 8.0 7 В срез данных попали все строки между позициями 1 и 3 включительно. Позиции 1 и 3 соответствуют меткам ‘b’ и ‘d’. Можно строить более интересные срезы:
print(df_orders.loc['b':'f':2]) # => shop_1 shop_2 shop_3 shop_4 # b 4.0 2 4.0 5 # d 8.0 12 8.0 7 # f 21.0 18 17.0 21 В данный срез попала каждая вторая строка между строками с метками ‘b’ и ‘f’.
Можно получать срезы со строками и столбцами одновременно:
print(df_orders.loc['b':'f':2, 'shop_1':'shop_3']) # => shop_1 shop_2 shop_3 # b 4.0 2 4.0 # d 8.0 12 8.0 # f 21.0 18 17.0 В срез попала каждая вторая строка между строками с метками ‘b’ и ‘f’ и столбцы с метками от ‘shop_1’ до ‘shop_3’ включительно.
Аналогично получаются срезы с помощью метода iloc() . Приведем пример, который совпадает по результату с примером выше:
print(df_orders.iloc[1:6:2, 0:3]) # b 4.0 2 4.0 # d 8.0 12 8.0 # f 21.0 18 17.0 Открыть доступ
Курсы программирования для новичков и опытных разработчиков. Начните обучение бесплатно
- 130 курсов, 2000+ часов теории
- 1000 практических заданий в браузере
- 360 000 студентов
Наши выпускники работают в компаниях: