Работа с индексами — 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 студентов
Наши выпускники работают в компаниях:
Как добавить индекс и значения всей строки None к имеющемуся фрейму данных?
Есть фрейму данных df , нужно добавить последней строкой значения None с индексом «моя строка».
for ind in df2.index: if ind not in df1.index: df1.at[ind] = None # df1.loc[(ind),[None]] | df1 | Column1 | Column2 |
|---|---|---|
| index | 1 | 4 |
| First | 2 | 5 |
| Second | 3 | 6 |
| df2 | Column1 | Column2 |
|---|---|---|
| index | 1 | 5 |
| First | 2 | 6 |
| Second | 3 | 7 |
| Моя строка | 4 | 8 |
| df1 (после преобразования) | Column1 | Column2 |
|---|---|---|
| index | 1 | 4 |
| First | 2 | 5 |
| Second | 3 | 6 |
| Моя строка | None | None |
Отслеживать
51.6k 199 199 золотых знаков 59 59 серебряных знаков 242 242 бронзовых знака
задан 27 апр 2021 в 8:15
Elena Barbanova Elena Barbanova
605 4 4 серебряных знака 15 15 бронзовых знаков
@MaxU привела скрин, сейчас еще ссылку на файл добавлю
27 апр 2021 в 8:25
Плюс за пример данных текстом.
3 мая 2021 в 16:29
2 ответа 2
Сортировка: Сброс на вариант по умолчанию
In [5]: df = pd.DataFrame([[1,4], [2,5], [3,6]], columns=["Column1", "Column2"], index=["index", "First", "Second"]) In [6]: df Out[6]: Column1 Column2 index 1 4 First 2 5 Second 3 6 In [7]: df.loc["Моя строка"] = [np.nan] * df.shape[1] In [8]: df Out[8]: Column1 Column2 index 1.0 4.0 First 2.0 5.0 Second 3.0 6.0 Моя строка NaN NaN Отслеживать
ответ дан 27 апр 2021 в 8:39
MaxU — stand with Ukraine MaxU — stand with Ukraine
149k 12 12 золотых знаков 59 59 серебряных знаков 132 132 бронзовых знака
Спасибо огромное
27 апр 2021 в 9:14
к той же задаче, но немного другой вопрос. После того, как я добавила строки к первому дата фрейму и хочу их сшить, то применяю функцию concat. df_all = pd.concat([df1, df2],axis=’columns’, keys=[‘First’, ‘Second’], sort=False)/. Но выходит ошибка Shape of passed values is (113, 56), indices imply (110, 56).
27 апр 2021 в 9:29
@ElenaBarbanova задайте новый вопрос.
Как преобразовать индекс в столбец в Pandas (с примерами)
Вы можете использовать следующий базовый синтаксис для преобразования индекса кадра данных pandas в столбец:
#convert index to column df.reset_index(inplace= True ) Если у вас есть DataFrame MultiIndex pandas, вы можете использовать следующий синтаксис для преобразования определенного уровня индекса в столбец:
#convert specific level of MultiIndex to column df.reset_index(inplace= True , level = ['Level1']) В следующих примерах показано, как использовать этот синтаксис на практике.
Пример 1: преобразование индекса в столбец
Следующий код показывает, как преобразовать индекс pandas DataFrame в столбец:
import pandas as pd #create DataFrame df = pd.DataFrame() #view DataFrame df points assists rebounds 0 25 5 11 1 12 7 8 2 15 7 10 3 14 9 6 4 19 12 6 #convert index to column df.reset_index(inplace= True ) #view updated DataFrame df index points assists rebounds 0 0 25 5 11 1 1 12 7 8 2 2 15 7 10 3 3 14 9 6 4 4 19 12 6 Пример 2. Преобразование MultiIndex в столбцы
Предположим, у нас есть следующий DataFrame MultiIndex pandas:
import pandas as pd #create DataFrame index_names = pd.MultiIndex.from_tuples([('Level1','Lev1', 'L1'), ('Level2','Lev2', 'L2'), ('Level3','Lev3', 'L3'), ('Level4','Lev4', 'L4')], names=['Full','Partial', 'ID']) data = df = pd.DataFrame(data, columns = ['Store',' Sales'], index=index_names) #view DataFrame df Store Sales Full Partial ID Level1 Lev1 L1 A 17 Level2 Lev2 L2 B 22 Level3 Lev3 L3 C 29 Level4 Lev4 L4 D 35 В следующем коде показано, как преобразовать каждый уровень MultiIndex в столбцы в кадре данных pandas:
#convert all levels of index to columns df.reset_index(inplace= True ) #view updated DataFrame df Full Partial ID Store Sales 0 Level1 Lev1 L1 A 17 1 Level2 Lev2 L2 B 22 2 Level3 Lev3 L3 C 29 3 Level4 Lev4 L4 D 35 Мы также можем использовать следующий код для преобразования определенного уровня MultiIndex в столбец:
#convert just 'ID' index to column in DataFrame df.reset_index(inplace= True , level = ['ID']) #view updated DataFrame df ID Store Sales Full Partial Level1 Lev1 L1 A 17 Level2 Lev2 L2 B 22 Level3 Lev3 L3 C 29 Level4 Lev4 L4 D 35 Обратите внимание, что только уровень «ID» был преобразован в столбец в DataFrame.
Дополнительные ресурсы
В следующих руководствах объясняется, как выполнять другие распространенные функции в pandas:
Возможности объектов 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 |