Combining Datasets: Merge and Join
One essential feature offered by Pandas is its high-performance, in-memory join and merge operations. If you have ever worked with databases, you should be familiar with this type of data interaction. The main interface for this is the pd.merge function, and we’ll see few examples of how this can work in practice.
For convenience, we will start by redefining the display() functionality from the previous section:
Relational Algebra¶
The behavior implemented in pd.merge() is a subset of what is known as relational algebra, which is a formal set of rules for manipulating relational data, and forms the conceptual foundation of operations available in most databases. The strength of the relational algebra approach is that it proposes several primitive operations, which become the building blocks of more complicated operations on any dataset. With this lexicon of fundamental operations implemented efficiently in a database or other program, a wide range of fairly complicated composite operations can be performed.
Pandas implements several of these fundamental building-blocks in the pd.merge() function and the related join() method of Series and Dataframe s. As we will see, these let you efficiently link data from different sources.
Categories of Joins¶
The pd.merge() function implements a number of types of joins: the one-to-one, many-to-one, and many-to-many joins. All three types of joins are accessed via an identical call to the pd.merge() interface; the type of join performed depends on the form of the input data. Here we will show simple examples of the three types of merges, and discuss detailed options further below.
One-to-one joins¶
Perhaps the simplest type of merge expresion is the one-to-one join, which is in many ways very similar to the column-wise concatenation seen in Combining Datasets: Concat & Append. As a concrete example, consider the following two DataFrames which contain information on several employees in a company:
5 Расширенных возможностей Pandas и как ими пользоваться
Pandas — это золотой стандарт в обработке данных. А функциональные возможности библиотеки по загрузке, фильтрации, обработке и изучению данных быстро сделали ее излюбленным инструментом аналитиков.
Конечно же, большинство из нас работает с самыми примитивными возможностями: загрузка данных из CSV -файла, фильтр нескольких столбцов и переход к визуализации данных. Однако в Pandas есть и малоизвестные, но от того не менее полезные функции, которые значительно упрощают обработку данных.
В данной статье мы рассмотрим 5 продвинутых функций, узнаем, для чего они нужны, и как ими пользоваться. Теперь обработка данных станет еще веселее!
(1) Настройка опций и параметров
Pandas идет в комплекте с набором настраиваемых опций и параметров. Они отлично повышают продуктивность аналитиков, поскольку позволяют им настроить Pandas-среду под себя.
Например, в настройках отображения можно задать количество показываемых строк и столбцов, а также настроить количество знаков после запятой.
В коде выше показывается, что Pandas может отображать не более 10 строк и 10 столбцов, а максимально допустимое количество знаков после запятой — 2. Таким образом, при добавлении большого DataFrame в терминал или Jupyter Notebook, он не превратится в мешанину из данных.
Это лишь базовый пример. Существует куда больше полезных возможностей Pandas. Почитать о других опциях можно в официальной документации.
(2) Объединение DataFrame
Мало кто знает, что DataFrame в Pandas можно объединить несколькими способами. Каждый из этих способов выдает разный результат, поэтому при выборе руководствуйтесь собственными целями. Кроме того, в оба способа заложены наборы параметров для более глубокой настройки слияния. Давайте поговорим о них подробнее.
Конкатенация
Конкатенация относится к самым известным методам объединения фреймов данных; ее можно рассматривать, как «стекинг». И этот самый стекинг бывает вертикальным или горизонтальным.
К примеру, у вас есть огромный набор данных в CSV -формате, и для упрощения обработки имеет смысл разделить его на несколько файлов. Это весьма распространенная практика для огромных наборов данных и довольно часто она называется «фрагментацией» или «шардингом».
При загрузке данных в Pandas вы можете создать единый DataFrame с помощью вертикальной пристыковки фрейма данных из каждого CSV -файла. Предположим, у нас есть 3 фрагмента по 5 миллионов строк в каждом. Тогда после вертикального стекинга наш итоговый фрейм данных будет содержать 15 миллионов строк.
В коде ниже показана вертикальная конкатенация DataFrame в Pandas.
Похожий результат можно получить при разделении набора данных не по строкам, а по столбцам. В таком случае, из каждого CSV -файла берется по нескольку столбцов со всеми строками. Это чем-то похоже на фрагментацию наборов данных по признакам. Далее выполняется горизонтальный стекинг для объединения столбцов/признаков.
Слияние
Слияние — это более сложный и мощный тип объединения DataFrame в стиле SQL . Фреймы данных объединяются по какому-то общему атрибуту.
Допустим, у вас есть два DataFrame с описанием YouTube-канала. Один из фреймов — это список ID пользователей и общее количество времени, которое каждый пользователь провел на канале. Другой фрейм содержит тот же список с ID и количество просмотренных роликов по каждому пользователю. Благодаря слиянию мы сможем объединить два фрейма данных в один по ID пользователя, а затем добавим туда единой строкой ID, затраченное время и количество просмотренных роликов.
Слияние двух DataFrame в Pandas делается через функцию merge . Пример ее использования можно найти ниже. Параметры left и right задают два DataFrame для объединения, а в on отмечается столбец для сопоставления данных.
Чтобы еще качественнее имитировать SQL -объединение, воспользуйтесь параметром how . Он позволяет выбрать тип SQL -объединения: внутреннее, внешнее, слева или справа. Подробнее об SQL -объединениях читайте на W3Schools.
(3) Изменение формы DataFrame
Существует несколько способов изменения формы и структуры фреймов данных в Pandas. От простых и легких до мощных и сложных. Давайте рассмотрим три наиболее популярные разновидности. Во всех примерах мы будем работать с набором данных о супергероях.
Транспонирование
Простейший способ. Здесь мы заменяем строки DataFrame на столбцы. Если у вас есть 5 000 строк и 10 столбцов, то после транспонирования вы получите 10 строк и 5 000 столбцов.
Groupby
Основное назначение Groupby — это разделение фреймов данных на части по определенным ключам. После разделения DataFrame вы сможете пройтись циклом по каждой из частей или выполнить дополнительные действия.
Например, в коде ниже мы создали фрейм данных по игрокам с их стажем ( Years ) и количеством очков ( Points ). Затем с помощью groupby мы разделили DataFrame на несколько частей по полю «игрок» ( Player ). Таким образом, каждый игрок оказался в собственной группе, показывающей, сколько очков данный игрок набрал за каждый год активности.
Стекинг
Стекинг в Pandas— это способ преобразования фреймов данных, при котором в DataFrame появляется многоуровневый индекс, т.е. каждая строка разбивается на несколько частей. Эти части создаются из столбцов DataFrame с дальнейшим сжатием их в мультииндекс. В общем и целом, стекинг можно рассматривать как сжатие столбцов в строки с мультииндексом.
Лучше всего все это показано в коде ниже.
(4) Работа с данными о дате и времени
Библиотека Datetime — это неотъемлемая часть Python. Всякий раз, встретив данные о дате или времени, вы обращаетесь к Datetime . К счастью для нас, Pandas придумала собственные возможности для использования объектов Datetime .
Давайте рассмотрим их на примере. В коде ниже мы создаем DataFrame с 4 столбцами (день, месяц, год, нужные данные), а затем сортируем их по году и месяцу. Как видите, получается слишком громоздко: для хранения данных используется целых 3 столбца, тогда как по факту календарная дата — это всего лишь одно значение.
Навести здесь порядок нам поможет datetime .
Pandas придумала отличную функцию to_datetime() , которая сжимает несколько столбцов DataFrame и преобразует их в единый объект Datetime . Сразу при задании нужного формата нам становятся доступны все гибкие возможности библиотеки Datetime .
Чтобы воспользоваться функцией to_datetime() , передадим ей все данные о дате из соответствующих столбцов ( Day , Month , Year ). После преобразования этих данных в формат Datetime , остальные столбцы нам больше не потребуются. Если хотите, можете от них избавиться. Вот, как все работает:
(5) Классификация элементов по группам
Классификация — это хитрый прием для организации категориальных данных. Предположим, что у нас есть огромный фрейм данных с тысячами строк, а один из столбцов содержит нужный нам элемент для классификации. Такое действие упростило бы процесс машинного обучения моделей и визуализации данных.
Взгляните на код ниже. Здесь приводится список продуктов, которые хотелось бы классифицировать:
Здесь мы выносим наш список в Series и создаем словарь с нужной нам классификацией Protein или Carbs . Это простейший пример. Но если бы эта Series была достаточно крупной (например, в 1 000 000 элементов длиной), то прохождение по ней циклом оказалось бы совершенно не разумным решением.
В таком случае, вместо обычного цикла for , лучше написать отдельную функцию, которая будет использовать встроенную Pandas-функцию map() для оптимизации процесса. В коде ниже все подробно расписано.
В этой функции мы проходимся циклом по всему словарю и создаем новый словарь, в котором ключами служат все вариации элементов из Series , а значениями являются признаки Protein или Carbs . Далее мы просто применяем встроенную функцию map() и классифицируем все значения из Series .
Вот, что у нас получается:
Заключение
Вот и все. Теперь вы узнали о 5 продвинутых возможностях Pandas и вариантах их применения.
Rukovodstvo
статьи и идеи для разработчиков программного обеспечения и веб-разработчиков.
Как объединить DataFrames в Pandas — merge (), join (), append (), concat () и update ()
Введение Pandas предоставляет огромный набор методов и функций для управления данными, включая слияние DataFrames. Слияние DataFrames позволяет вам создавать новый DataFrame без изменения исходного источника данных или изменения исходного источника данных. Если вы знакомы с SQL или аналогичным типом табличных данных, вы, вероятно, знакомы с термином соединение, которое означает объединение DataFrames для формирования нового DataFrame. Если вы новичок, может быть трудно полностью понять типы соединения (в
Время чтения: 14 мин.
Вступление
Pandas предоставляет огромный набор методов и функций для управления данными, включая слияние DataFrames. Слияние DataFrames позволяет вам создавать новый DataFrame без изменения исходного источника данных или изменения исходного источника данных.
Если вы знакомы с SQL или аналогичным типом табличных данных, вы, вероятно, знакомы с термином join , что означает объединение DataFrames для формирования нового DataFrame. Если вы новичок, может быть трудно полностью понять типы соединения ( внутреннее, внешнее, левое, правое ). В этом руководстве мы рассмотрим типы соединений с примерами.
Наше основное внимание будет сосредоточено на использовании функций merge() и concat() Однако мы обсудим другие методы слияния, чтобы дать вам как можно больше практических альтернатив.
В этом руководстве мы используем Pandas версии 1.1.4 и NumPy версии 1.19.4 .
Для вашего удобства вот содержание:
- Объединить фреймы данных с помощью merge ()
- Объединить фреймы данных с помощью join ()
- Объединить фреймы данных с помощью append ()
- Объединить фреймы данных с помощью concat ()
- Объединение фреймов данных с помощью comb_first () и update ()
Объединить фреймы данных с помощью merge ()
Начнем с настройки наших DataFrames, которые мы будем использовать в оставшейся части учебника.
df1 будет включать наш воображаемый список пользователей с именами, адресами электронной почты и идентификаторами.
При разработке баз данных считается хорошей практикой хранить настройки профиля (например, цвет фона, ссылку на изображение аватара, размер шрифта и т. Д.) В отдельной таблице от данных пользователя (электронная почта, дата добавления и т. Д.). Эти таблицы могут иметь взаимно-однозначное отношение.
Чтобы смоделировать этот сценарий, мы сделаем то же самое, создав df2 с URL-адресами изображений и идентификаторами пользователей:
Вот как выглядят наши DataFrames:
Давайте объединим эти DataFrames с функцией merge() . Во-первых, взгляните на все параметры, которые может принимать эта функция:
Большинство этих параметров имеют значения по умолчанию, за исключением левого и правого . Эти два параметра являются именами DataFrames, которые мы будем объединять. Сама функция вернет новый DataFrame, который мы сохраним в переменной df3_merged
Введите следующий код в оболочку Python:
Поскольку оба наших DataFrames имеют столбец user_id с одинаковым именем, merge() автоматически объединяет две таблицы, соответствующие этому ключу. Если бы у нас было два столбца с разными именами, мы могли бы использовать left_on=’left_column_name’ и right_on=’right_column_name’ чтобы явно указать ключи для обоих DataFrames.
df3_merged чтобы увидеть ее содержимое:
Вы заметите, что df3_merged имеет только 5 строк, в то время как исходный df1 имел 7. Почему?
Когда значение по умолчанию для how установлено на inner , новый DataFrame создается из пересечения левого и правого DataFrame. Следовательно, если user_id отсутствует в одной из таблиц, его не будет в объединенном DataFrame.
Это останется верным, даже если поменять местами левую и правую строки:
Пользователи с идентификаторами ‘id006’ и ‘id007’ не являются частью объединенных DataFrames, поскольку они не пересекаются в обеих таблицах.
Однако бывают случаи, когда мы хотим использовать один из DataFrames в качестве основного DataFrame и включать все строки из него, даже если они не все пересекаются друг с другом. То есть, чтобы иметь всех наших пользователей, в то время как image_url является обязательным.
Как? Используя merge() , мы можем передать аргумент ‘left’ how :
При левом соединении мы включили все элементы левого DataFrame ( df1 ) и каждый элемент правого DataFrame ( df2 ). Выполнение приведенного выше кода отобразит следующее:
Ячейки, которые не имеют совпадающих значений с левым DataFrame, заполняются NaN .
Почему бы нам не попробовать правильное соединение? Создайте следующий объединенный DataFrame:
Как вы могли ожидать, правое соединение вернет каждое значение из левого DataFrame, которое соответствует правому DataFrame:
Поскольку каждая строка в df2 имеет значение в df1 , в этом случае это right соединение аналогично inner
Давайте посмотрим на outer соединения. Чтобы лучше всего проиллюстрировать, как они работают, давайте поменяем местами наши DataFrames и создадим две новые переменные для левого и внешнего соединений:
Имейте в виду, что наш левый DataFrame — это df2 а правый DataFrame — это df1 . Использование how=’outer’ объединяет DataFrames, совпадающие по ключу, но также включает значения, которые отсутствуют или не совпадают.
Мы также добавили indicator и установили для него значение True чтобы Pandas добавил дополнительный столбец _merge в конец нашего DataFrame. Этот столбец сообщает нам, была ли найдена строка в левом, правом или обоих фреймах данных.
df_left выглядит так:
Однако в df_outer есть такие данные:
Обратите внимание, что в df_outer DataFrame id006 и id007 существует только в правом DataFrame (в данном случае это df1 ). Если мы попытаемся сравнить левое и внешнее соединения, не меняя местами, мы получим одинаковые результаты для них обоих.
Объединить фреймы данных с помощью join ()
В отличие от merge() который является методом экземпляра Pandas, join() является методом самого DataFrame. Это означает, что мы можем использовать его как статический метод в DataFrame: DataFrame.join(other, on=None, how=’left’, lsuffix=», rsuffix=», sort=False) .
DataFrame, из которого мы вызываем join() будет нашим левым DataFrame. DataFrame в other аргументе будет нашим правильным DataFrame.
Параметр on может принимать один или несколько [‘key1’, ‘key2’ . ] ) для определения соответствующего ключа, в то время how параметр how принимает один из аргументов дескриптора (левый, правый, внешний, внутренний), и он по умолчанию установлено left
Попробуем присоединить df2 к df1 :
Как и функция merge() join() автоматически пытается сопоставить ключи (столбцы) с тем же именем. В нашем случае это ключ user_id
Приведенный выше код распечатывает это:
Вы, наверное, заметили «повторяющийся столбец» под названием user_id_right . Если вы не хотите отображать этот столбец, вы можете установить user_id в качестве индекса для обоих столбцов, чтобы он присоединялся без суффикса:
Таким образом мы избавляемся от user_id и вместо этого устанавливаем его в качестве столбца индекса. Это дает нам более чистый результирующий DataFrame:
Объединить фреймы данных с помощью append ()
Как указывает официальная документация Pandas, поскольку concat() и append() возвращают новые копии DataFrames, чрезмерное использование этих методов может повлиять на производительность вашей программы.
Добавление очень полезно, когда вы хотите объединить два DataFrames только по оси строк. Это означает, что вместо сопоставления данных в их столбцах нам нужен новый DataFrame, содержащий все строки 2 DataFrame.
Давайте df2 к df1 и распечатаем результат:
Использование append() не приведет к сопоставлению DataFrames ни по каким ключам. Он просто добавит другой DataFrame к первому и вернет его копию. Если формы DataFrames не совпадают, Pandas заменит все несовпадающие ячейки на NaN.
Результат для добавления двух DataFrames выглядит следующим образом:
Большинство пользователей выбирают concat() append() поскольку он также предоставляет параметр сопоставления ключей и оси.
Объединить фреймы данных с помощью concat ()
Конкатенация немного более гибкая по сравнению с merge() и join() поскольку она позволяет нам комбинировать DataFrames по вертикали (по строкам) или по горизонтали (по столбцам).
Компромисс заключается в том, что любые несоответствующие данные будут отброшены. Вот полная функция с параметрами:
Вот наиболее часто используемые параметры функции concat() :
- objs — это список объектов DataFrame ([df1, df2, . ]) для объединения
- axis определяет направление конкатенации, 0 для строк и 1 для столбцов
- join может быть inner (пересечение) или outer (объединение)
- ignore_index по умолчанию установлен на False что позволяет значениям индекса оставаться такими, какими они были в исходных DataFrames, может привести к дублированию значений индекса. Если установлено значение True , он будет игнорировать исходные значения и повторно назначать значения индекса в последовательном порядке.
- keys позволяет нам построить иерархический индекс. Подумайте об этом как о другом уровне индекса, который добавлен слева от DataFrame, который помогает нам различать индексы, когда значения не уникальны.
Давайте создадим новый DataFrame с теми же типами столбцов с df2 , но этот включает image_url для id006 и id007 :
Чтобы объединить df2 и df2_addition строкам, мы можем передать их в списке в качестве objs и присвоить полученный DataFrame новой переменной:
Мы успешно заполнили недостающие значения:
Однако обратите внимание на индексы в крайнем левом столбце. Индексы 0 и 1 повторяются. Чтобы получить совершенно новые и уникальные значения индекса, мы передаем True параметру ignore_index
Теперь наш df_row_concat имеет уникальные значения индекса:
Как мы упоминали ранее, конкатенация может работать как по горизонтали, так и по вертикали. Чтобы объединить два DataFrames вместе по столбцам, нам нужно будет изменить значение axis 0 по 1 :
Вы заметите, что это не работает как слияние, сопоставление двух таблиц по ключу:
Если бы в нашем правом DataFrame даже не было user_id , эта конкатенация все равно вернула бы тот же результат. Функция concat() склеивает два DataFrames вместе, принимая во внимание значения индексов DataFrames и форму таблицы.
Он не выполняет сопоставление ключей, например merge() или join() . Попробуйте разные комбинации конкатенации, изменив join чтобы увидеть различия!
Объединение фреймов данных с помощью comb_first () и update ()
В некоторых случаях вы можете захотеть заполнить недостающие данные в вашем DataFrame, объединив их с другим DataFrame. Таким образом вы сохраните все не пропущенные значения в первом фрейме данных, заменив все NaN доступными не пропущенными значениями из второго фрейма данных (если они есть).
В этом примере мы импортируем NumPy, чтобы использовать значения NaN Если вы установили Pandas с помощью pip , NumPy уже должен быть установлен.
Введите следующий код в оболочку Python или файл сценария:
df_first df_first имеет 3 столбца и по 1 пропущенному значению в каждом из них:
В то время как df_second имеет только 2 столбца и одно отсутствующее значение в первом столбце:
Мы можем использовать df_second для исправления отсутствующих значений в df_first всеми соответствующими значениями:
Как упоминалось ранее, использование combine_first() заменит NaN только в порядке индексации и оставит все не пропущенные значения в первом DataFrame такими, какие они есть:
С другой стороны, если мы хотим перезаписать значения в df_first соответствующими значениями из df_second (независимо от того, являются они NaN или нет), мы бы использовали метод update() .
Давайте сначала добавим в наш код еще один DataFrame:
Форма (1, 3) — 1 строка и три столбца, не считая индекса:
Теперь давайте обновим df_first значениями из df_third :
Имейте в виду, что в отличие от combine_first() , update() не возвращает новый DataFrame. Он изменяет df_first на месте, изменяя соответствующие значения:
Для параметра overwrite update() по умолчанию установлено значение True Вот почему он изменяет все соответствующие значения, а не только значения NaN Мы можем изменить его на False чтобы заменить только значения NaN
Вот окончательное состояние нашего df_tictactoe df_tictactoe:
Мы не только успешно обновили значения, но и выиграли игру «Крестики-нолики»!
Заключение
Pandas предоставляет мощные инструменты для объединения DataFrames. Но бывает сложно решить, когда что использовать. Хотя в большинстве случаев функции merge() достаточно, в некоторых случаях вы можете использовать concat() для слияния по строкам, или использовать join() с суффиксами, или избавиться от отсутствующих значений с помощью combine_first() и update() . Вы даже можете добавлять строки данных с помощью append() .
Используйте ту функцию, которая вам удобна и лучше всего подходит для вашей задачи. Как эти функции помогут вам управлять данными в Pandas?
Merge, join, concatenate and compare#
pandas provides various facilities for easily combining together Series or DataFrame with various kinds of set logic for the indexes and relational algebra functionality in the case of join / merge-type operations.
In addition, pandas also provides utilities to compare two Series or DataFrame and summarize their differences.
Concatenating objects#
The concat() function (in the main pandas namespace) does all of the heavy lifting of performing concatenation operations along an axis while performing optional set logic (union or intersection) of the indexes (if any) on the other axes. Note that I say “if any” because there is only a single possible axis of concatenation for Series.
Before diving into all of the details of concat and what it can do, here is a simple example:
Like its sibling function on ndarrays, numpy.concatenate , pandas.concat takes a list or dict of homogeneously-typed objects and concatenates them with some configurable handling of “what to do with the other axes”:
objs : a sequence or mapping of Series or DataFrame objects. If a dict is passed, the sorted keys will be used as the keys argument, unless it is passed, in which case the values will be selected (see below). Any None objects will be dropped silently unless they are all None in which case a ValueError will be raised.
axis : <0, 1, …>, default 0. The axis to concatenate along.
join : <‘inner’, ‘outer’>, default ‘outer’. How to handle indexes on other axis(es). Outer for union and inner for intersection.
ignore_index : boolean, default False. If True, do not use the index values on the concatenation axis. The resulting axis will be labeled 0, …, n — 1. This is useful if you are concatenating objects where the concatenation axis does not have meaningful indexing information. Note the index values on the other axes are still respected in the join.
keys : sequence, default None. Construct hierarchical index using the passed keys as the outermost level. If multiple levels passed, should contain tuples.
levels : list of sequences, default None. Specific levels (unique values) to use for constructing a MultiIndex. Otherwise they will be inferred from the keys.
names : list, default None. Names for the levels in the resulting hierarchical index.
verify_integrity : boolean, default False. Check whether the new concatenated axis contains duplicates. This can be very expensive relative to the actual data concatenation.
copy : boolean, default True. If False, do not copy data unnecessarily.
Without a little bit of context many of these arguments don’t make much sense. Let’s revisit the above example. Suppose we wanted to associate specific keys with each of the pieces of the chopped up DataFrame. We can do this using the keys argument:
As you can see (if you’ve read the rest of the documentation), the resulting object’s index has a hierarchical index . This means that we can now select out each chunk by key:
It’s not a stretch to see how this can be very useful. More detail on this functionality below.
It is worth noting that concat() makes a full copy of the data, and that constantly reusing this function can create a significant performance hit. If you need to use the operation over several datasets, use a list comprehension.
When concatenating DataFrames with named axes, pandas will attempt to preserve these index/column names whenever possible. In the case where all inputs share a common name, this name will be assigned to the result. When the input names do not all agree, the result will be unnamed. The same is true for MultiIndex , but the logic is applied separately on a level-by-level basis.
Set logic on the other axes#
When gluing together multiple DataFrames, you have a choice of how to handle the other axes (other than the one being concatenated). This can be done in the following two ways:
Take the union of them all, join=’outer’ . This is the default option as it results in zero information loss.
Take the intersection, join=’inner’ .
Here is an example of each of these methods. First, the default join=’outer’ behavior:
Here is the same thing with join=’inner’ :
Lastly, suppose we just wanted to reuse the exact index from the original DataFrame:
Similarly, we could index before the concatenation:
Ignoring indexes on the concatenation axis#
For DataFrame objects which don’t have a meaningful index, you may wish to append them and ignore the fact that they may have overlapping indexes. To do this, use the ignore_index argument:
Concatenating with mixed ndims#
You can concatenate a mix of Series and DataFrame objects. The Series will be transformed to DataFrame with the column name as the name of the Series .
Since we’re concatenating a Series to a DataFrame , we could have achieved the same result with DataFrame.assign() . To concatenate an arbitrary number of pandas objects ( DataFrame or Series ), use concat .
If unnamed Series are passed they will be numbered consecutively.
Passing ignore_index=True will drop all name references.
More concatenating with group keys#
A fairly common use of the keys argument is to override the column names when creating a new DataFrame based on existing Series . Notice how the default behaviour consists on letting the resulting DataFrame inherit the parent Series ’ name, when these existed.
Through the keys argument we can override the existing column names.
Let’s consider a variation of the very first example presented:
You can also pass a dict to concat in which case the dict keys will be used for the keys argument (unless other keys are specified):
The MultiIndex created has levels that are constructed from the passed keys and the index of the DataFrame pieces:
If you wish to specify other levels (as will occasionally be the case), you can do so using the levels argument:
This is fairly esoteric, but it is actually necessary for implementing things like GroupBy where the order of a categorical variable is meaningful.
Appending rows to a DataFrame#
If you have a series that you want to append as a single row to a DataFrame , you can convert the row into a DataFrame and use concat
You should use ignore_index with this method to instruct DataFrame to discard its index. If you wish to preserve the index, you should construct an appropriately-indexed DataFrame and append or concatenate those objects.
Database-style DataFrame or named Series joining/merging#
pandas has full-featured, high performance in-memory join operations idiomatically very similar to relational databases like SQL. These methods perform significantly better (in some cases well over an order of magnitude better) than other open source implementations (like base::merge.data.frame in R). The reason for this is careful algorithmic design and the internal layout of the data in DataFrame .
See the cookbook for some advanced strategies.
Users who are familiar with SQL but new to pandas might be interested in a comparison with SQL .
pandas provides a single function, merge() , as the entry point for all standard database join operations between DataFrame or named Series objects:
left : A DataFrame or named Series object.
right : Another DataFrame or named Series object.
on : Column or index level names to join on. Must be found in both the left and right DataFrame and/or Series objects. If not passed and left_index and right_index are False , the intersection of the columns in the DataFrames and/or Series will be inferred to be the join keys.
left_on : Columns or index levels from the left DataFrame or Series to use as keys. Can either be column names, index level names, or arrays with length equal to the length of the DataFrame or Series.
right_on : Columns or index levels from the right DataFrame or Series to use as keys. Can either be column names, index level names, or arrays with length equal to the length of the DataFrame or Series.
left_index : If True , use the index (row labels) from the left DataFrame or Series as its join key(s). In the case of a DataFrame or Series with a MultiIndex (hierarchical), the number of levels must match the number of join keys from the right DataFrame or Series.
right_index : Same usage as left_index for the right DataFrame or Series
how : One of ‘left’ , ‘right’ , ‘outer’ , ‘inner’ , ‘cross’ . Defaults to inner . See below for more detailed description of each method.
sort : Sort the result DataFrame by the join keys in lexicographical order. Defaults to True , setting to False will improve performance substantially in many cases.
suffixes : A tuple of string suffixes to apply to overlapping columns. Defaults to (‘_x’, ‘_y’) .
copy : Always copy data (default True ) from the passed DataFrame or named Series objects, even when reindexing is not necessary. Cannot be avoided in many cases but may improve performance / memory usage. The cases where copying can be avoided are somewhat pathological but this option is provided nonetheless.
indicator : Add a column to the output DataFrame called _merge with information on the source of each row. _merge is Categorical-type and takes on a value of left_only for observations whose merge key only appears in ‘left’ DataFrame or Series, right_only for observations whose merge key only appears in ‘right’ DataFrame or Series, and both if the observation’s merge key is found in both.
validate : string, default None. If specified, checks if merge is of specified type.
-
“one_to_one” or “1:1”: checks if merge keys are unique in both left and right datasets.
-
“one_to_many” or “1:m”: checks if merge keys are unique in left dataset.
-
“many_to_one” or “m:1”: checks if merge keys are unique in right dataset.
-
“many_to_many” or “m:m”: allowed, but does not result in checks.
Support for specifying index levels as the on , left_on , and right_on parameters was added in version 0.23.0. Support for merging named Series objects was added in version 0.24.0.
The return type will be the same as left . If left is a DataFrame or named Series and right is a subclass of DataFrame , the return type will still be DataFrame .
merge is a function in the pandas namespace, and it is also available as a DataFrame instance method merge() , with the calling DataFrame being implicitly considered the left object in the join.
The related join() method, uses merge internally for the index-on-index (by default) and column(s)-on-index join. If you are joining on index only, you may wish to use DataFrame.join to save yourself some typing.
Brief primer on merge methods (relational algebra)#
Experienced users of relational databases like SQL will be familiar with the terminology used to describe join operations between two SQL-table like structures ( DataFrame objects). There are several cases to consider which are very important to understand:
one-to-one joins: for example when joining two DataFrame objects on their indexes (which must contain unique values).
many-to-one joins: for example when joining an index (unique) to one or more columns in a different DataFrame .
many-to-many joins: joining columns on columns.
When joining columns on columns (potentially a many-to-many join), any indexes on the passed DataFrame objects will be discarded.
It is worth spending some time understanding the result of the many-to-many join case. In SQL / standard relational algebra, if a key combination appears more than once in both tables, the resulting table will have the Cartesian product of the associated data. Here is a very basic example with one unique key combination:
Here is a more complicated example with multiple join keys. Only the keys appearing in left and right are present (the intersection), since how=’inner’ by default.
The how argument to merge specifies how to determine which keys are to be included in the resulting table. If a key combination does not appear in either the left or right tables, the values in the joined table will be NA . Here is a summary of the how options and their SQL equivalent names: