En recherchant R ou Python sur Internet, vous trouverez des millions d'articles et des kilomètres de discussions sur le thème de celui qui est le meilleur, le plus rapide et le plus pratique pour travailler avec des données. Mais malheureusement, tous ces articles et disputes ne sont pas particulièrement utiles.

Le but de cet article est de comparer les techniques de base de traitement des données dans les packages les plus populaires des deux langues. Et aidez les lecteurs à maîtriser rapidement quelque chose qu’ils ne connaissent pas encore. Pour ceux qui écrivent en Python, découvrez comment faire la même chose en R, et vice versa.

Au cours de l'article, nous analyserons la syntaxe des packages les plus populaires dans R. Ce sont les packages inclus dans la bibliothèque tidyverseet aussi le colis data.table. Et comparez leur syntaxe avec pandas, le package d'analyse de données le plus populaire en Python.

Nous allons parcourir étape par étape tout le chemin de l'analyse des données, depuis leur chargement jusqu'à l'exécution des fonctions de fenêtre analytique à l'aide de Python et R.

Teneur

Cet article peut être utilisé comme aide-mémoire si vous avez oublié comment effectuer une opération de traitement de données dans l'un des packages considérés.

1. Principales différences de syntaxe entre R et Python
   1.1. Accès aux fonctions du package
   1.2. Affectation
   1.3. Indexation
   1.4. Méthodes et POO
   1.5. Pipelines
   1.6. Structures de données
2. Quelques mots sur les packages que nous utiliserons
   2.1. Tidyverse
   2.2. données.table
   2.3. pandas
3. Installation de packages
4. Chargement des données
5. Création de trames de données
6. Sélection des colonnes dont vous avez besoin
7. Filtrage des lignes
8. Regroupement et agrégation
9. Union verticale des tables (UNION)
10. Jointure horizontale de tables (JOIN)
11. Fonctions de fenêtre de base et colonnes calculées
12. Table de correspondance entre les méthodes de traitement de données en R et Python
13. Conclusion
14. Une brève enquête sur le package que vous utilisez

Si vous êtes intéressé par l'analyse des données, vous trouverez peut-être mon télégramme и Youtube canaux. La plupart du contenu est dédié au langage R.

Principales différences de syntaxe entre R et Python

Pour vous faciliter le passage de Python à R, ou vice versa, je vais vous donner quelques points principaux auxquels vous devez prêter attention.

Accès aux fonctions du package

Une fois qu'un package est chargé dans R, vous n'avez pas besoin de spécifier le nom du package pour accéder à ses fonctions. Dans la plupart des cas, ce n’est pas courant dans R, mais c’est acceptable. Vous n'êtes pas du tout obligé d'importer un package si vous avez besoin d'une de ses fonctions dans votre code, mais appelez-le simplement en spécifiant le nom du package et le nom de la fonction. Le séparateur entre les noms de packages et de fonctions dans R est un double deux-points. package_name::function_name().

En Python, au contraire, il est considéré comme classique d’appeler les fonctions d’un package en précisant explicitement son nom. Lorsqu'un package est téléchargé, il reçoit généralement un nom abrégé, par ex. pandas généralement un pseudonyme est utilisé pd. Une fonction de package est accessible via un point package_name.function_name().

Affectation

En R, il est courant d'utiliser une flèche pour attribuer une valeur à un objet. obj_name <- value, bien qu'un seul signe égal soit autorisé, le seul signe égal dans R est principalement utilisé pour transmettre des valeurs aux arguments de la fonction.

En Python, l'affectation se fait exclusivement avec un seul signe égal obj_name = value.

Indexation

Il existe également ici des différences assez significatives. Dans R, l'indexation commence à un et inclut tous les éléments spécifiés dans la plage résultante,

En Python, l'indexation commence à zéro et la plage sélectionnée n'inclut pas le dernier élément spécifié dans l'index. Donc concevoir x[i:j] en Python n'inclura pas l'élément j.

Il existe également des différences dans l'indexation négative, en notation R x[-1] renverra tous les éléments du vecteur sauf le dernier. En Python, une notation similaire ne renverra que le dernier élément.

Méthodes et POO

R implémente la POO à sa manière, j'en ai parlé dans l'article "POO en langage R (partie 1) : classes S3". En général, R est un langage fonctionnel et tout ce qu'il contient est construit sur des fonctions. Ainsi, par exemple, pour les utilisateurs d'Excel, accédez à tydiverse ce sera plus facile que pandas. Bien que cela puisse être mon opinion subjective.

En bref, les objets dans R n'ont pas de méthodes (si l'on parle de classes S3, mais il existe d'autres implémentations POO qui sont beaucoup moins courantes). Il n'existe que des fonctions généralisées qui les traitent différemment selon la classe de l'objet.

Pipelines

C'est peut-être le nom de pandas Ce ne sera pas tout à fait exact, mais je vais essayer d'expliquer le sens.

Afin de ne pas enregistrer de calculs intermédiaires et de ne pas produire d'objets inutiles dans l'environnement de travail, vous pouvez utiliser une sorte de pipeline. Ceux. transmettre le résultat d'un calcul d'une fonction à la suivante, et ne pas enregistrer les résultats intermédiaires.

Prenons l'exemple de code suivant, dans lequel nous stockons les calculs intermédiaires dans des objets séparés :

temp_object <- func1()
temp_object2 <- func2(temp_object )
obj <- func3(temp_object2 )

Nous avons effectué 3 opérations séquentiellement et le résultat de chacune a été enregistré dans un objet distinct. Mais en réalité, nous n’avons pas besoin de ces objets intermédiaires.

Ou pire encore, mais plus familier aux utilisateurs d'Excel.

obj  <- func3(func2(func1()))

Dans ce cas, nous n'avons pas enregistré les résultats de calcul intermédiaires, mais la lecture de code avec des fonctions imbriquées est extrêmement gênante.

Nous examinerons plusieurs approches du traitement des données dans R, et elles effectuent des opérations similaires de différentes manières.

Pipelines dans la bibliothèque tidyverse mis en œuvre par l'opérateur %>%.

obj <- func1() %>% 
            func2() %>%
            func3()

On prend donc le résultat du travail func1() et transmettez-le comme premier argument à func2(), puis on passe le résultat de ce calcul comme premier argument func3(). Et au final, on écrit tous les calculs effectués dans l'objet obj <-.

Tout ce qui précède est mieux illustré que les mots par ce mème :

В data.table les chaînes sont utilisées de la même manière.

newDT <- DT[where, select|update|do, by][where, select|update|do, by][where, select|update|do, by]

Dans chacun des crochets, vous pouvez utiliser le résultat de l’opération précédente.

В pandas ces opérations sont séparées par un point.

obj = df.fun1().fun2().fun3()

Ceux. nous prenons notre table df et utilise sa méthode fun1(), puis on applique la méthode au résultat obtenu fun2(), après fun3(). Le résultat obtenu est enregistré dans un objet obj .

Structures de données

Les structures de données en R et Python sont similaires, mais portent des noms différents.

description
Nom en R
Nom en Python/pandas

Structure du tableau
data.frame, data.table, tibble
Trame de données

Liste de valeurs unidimensionnelle
Vecteur
Série en pandas ou liste en Python pur

Structure non tabulaire à plusieurs niveaux
Liste
Dictionnaire (dict)

Nous examinerons ci-dessous quelques autres fonctionnalités et différences de syntaxe.

Quelques mots sur les packages que nous utiliserons

Tout d’abord, je vais vous parler un peu des packages avec lesquels vous vous familiariserez au cours de cet article.

Tidyverse

Site officiel: Tidyverse.org

bibliothèque tidyverse écrit par Hedley Wickham, chercheur scientifique principal chez RStudio. tidyverse se compose d'un ensemble impressionnant de packages qui simplifient le traitement des données, dont 5 sont inclus dans les 10 meilleurs téléchargements du référentiel CRAN.

Le noyau de la bibliothèque se compose des packages suivants : ggplot2, dplyr, tidyr, readr, purrr, tibble, stringr, forcats. Chacun de ces packages vise à résoudre un problème spécifique. Par exemple dplyr créé pour la manipulation de données, tidyr pour mettre les données sous une forme soignée, stringr simplifie le travail avec des chaînes, et ggplot2 est l'un des outils de visualisation de données les plus populaires.

L'avantage tidyverse est la simplicité et la syntaxe facile à lire, qui est à bien des égards similaire au langage de requête SQL.

données.table

Site officiel: r-datatable.com

Auteur data.table est Matt Dole de H2O.ai.

La première version de la bibliothèque a eu lieu en 2006.

La syntaxe du package n'est pas aussi pratique que dans tidyverse et rappelle davantage les dataframes classiques de R, mais en même temps ses fonctionnalités sont considérablement étendues.

Toutes les manipulations avec le tableau de ce package sont décrites entre crochets, et si vous traduisez la syntaxe data.table en SQL, vous obtenez quelque chose comme ceci : data.table[ WHERE, SELECT, GROUP BY ]

La force de ce package réside dans la rapidité de traitement de grandes quantités de données.

pandas

Site officiel: pandas.pydata.org

Le nom de la bibliothèque vient du terme économétrique « données de panel », utilisé pour décrire des ensembles d’informations structurés multidimensionnels.

Auteur pandas est l'Américain Wes McKinney.

Lorsqu'il s'agit d'analyse de données en Python, c'est égal pandas Non. Un package très multifonctionnel de haut niveau qui vous permet d'effectuer n'importe quelle manipulation avec des données, du chargement de données depuis n'importe quelle source jusqu'à leur visualisation.

Installation de packages supplémentaires

Les packages abordés dans cet article ne sont pas inclus dans les distributions de base R et Python. Bien qu'il y ait une petite mise en garde, si vous avez installé la distribution Anaconda, installez-la en plus pandas n'est pas nécessaire.

Installer des packages dans R

Si vous avez ouvert l'environnement de développement RStudio au moins une fois, vous savez probablement déjà comment installer le package requis dans R. Pour installer les packages, utilisez la commande standard install.packages() en l'exécutant directement dans R lui-même.

# установка пакетов
install.packages("vroom")
install.packages("readr")
install.packages("dplyr")
install.packages("data.table")

Après l'installation, les packages doivent être connectés, pour lesquels dans la plupart des cas la commande est utilisée library().

# подключение или импорт пакетов в рабочее окружение
library(vroom)
library(readr)
library(dplyr)
library(data.table)

Installation de packages en Python

Donc, si Python pur est installé, alors pandas vous devez l'installer manuellement. Ouvrez une ligne de commande ou un terminal, en fonction de votre système d'exploitation et entrez la commande suivante.

pip install pandas

Ensuite, nous retournons à Python et importons le package installé avec la commande import.

import pandas as pd

Chargement des données

L'exploration de données est l'une des étapes les plus importantes de l'analyse des données. Python et R, si vous le souhaitez, vous offrent de nombreuses possibilités d'obtenir des données à partir de n'importe quelle source : fichiers locaux, fichiers provenant d'Internet, sites Web, toutes sortes de bases de données.

Tout au long de l'article, nous utiliserons plusieurs ensembles de données :

1. Deux téléchargements depuis Google Analytics.
2. Ensemble de données sur les passagers du Titanic.

Toutes les données sont sur mon GitHub sous forme de fichiers csv et tsv. Où allons-nous les demander ?

Chargement de données dans R : Tidyverse, Vroom, Readr

Pour charger des données dans une bibliothèque tidyverse Il existe deux forfaits : vroom, readr. vroom plus moderne, mais à l'avenir, les packages pourront être combinés.

Citation de documents officiels vroom.

vroom contre lecteur
Qu'est-ce que la sortie de vroom signifie pour readr? Pour l'instant, nous prévoyons de laisser les deux packages évoluer séparément, mais nous les unirons probablement à l'avenir. Un inconvénient de la lecture paresseuse de vroom est que certains problèmes de données ne peuvent pas être signalés à l'avance, donc la meilleure façon de les unifier nécessite une réflexion.

vroom contre lecteur
Que signifie la libération ? vroom pour readr? Pour le moment, nous prévoyons de développer les deux packages séparément, mais nous les combinerons probablement à l'avenir. L'un des inconvénients de la lecture paresseuse vroom est que certains problèmes liés aux données ne peuvent pas être signalés à l'avance, vous devez donc réfléchir à la meilleure façon de les combiner.

Dans cet article, nous examinerons les deux packages de chargement de données :

Chargement de données dans R : package vroom

# install.packages("vroom")
library(vroom)

# Чтение данных
## vroom
ga_nov  <- vroom("https://raw.githubusercontent.com/selesnow/publications/master/data_example/r_python_data/ga_nowember.csv")
ga_dec  <- vroom("https://raw.githubusercontent.com/selesnow/publications/master/data_example/r_python_data/ga_december.csv")
titanic <- vroom("https://raw.githubusercontent.com/selesnow/publications/master/data_example/r_python_data/titanic.csv")

Chargement de données dans R : readr

# install.packages("readr")
library(readr)

# Чтение данных
## readr
ga_nov  <- read_tsv("https://raw.githubusercontent.com/selesnow/publications/master/data_example/r_python_data/ga_nowember.csv")
ga_dec  <- read_tsv("https://raw.githubusercontent.com/selesnow/publications/master/data_example/r_python_data/ga_december.csv")
titanic <- read_csv("https://raw.githubusercontent.com/selesnow/publications/master/data_example/r_python_data/titanic.csv")

Dans le paquet vroom, quel que soit le format de données csv/tsv, le chargement s'effectue par la fonction du même nom vroom(), dans le paquet readr nous utilisons une fonction différente pour chaque format read_tsv() и read_csv().

Chargement de données dans R : data.table

В data.table il y a une fonction pour charger les données fread().

Chargement de données dans R : package data.table

# install.packages("data.table")
library(data.table)

## data.table
ga_nov  <- fread("https://raw.githubusercontent.com/selesnow/publications/master/data_example/r_python_data/ga_nowember.csv")
ga_dec  <- fread("https://raw.githubusercontent.com/selesnow/publications/master/data_example/r_python_data/ga_december.csv")
titanic <- fread("https://raw.githubusercontent.com/selesnow/publications/master/data_example/r_python_data/titanic.csv")

Chargement de données en Python : pandas

Si nous comparons avec les packages R, alors dans ce cas, la syntaxe est la plus proche de pandas volonté readrParce que pandas peut demander des données de n'importe où, et il y a toute une famille de fonctions dans ce package read_*().

• read_csv()
• read_excel()
• read_sql()
• read_json()
• read_html()

Et bien d'autres fonctions conçues pour lire des données sous différents formats. Mais pour nos besoins, c'est suffisant read_table() ou read_csv() utiliser des arguments sep pour spécifier le séparateur de colonnes.

Chargement de données en Python : pandas

import pandas as pd

ga_nov  = pd.read_csv("https://raw.githubusercontent.com/selesnow/publications/master/data_example/russian_text_in_r/ga_nowember.csv", sep = "t")
ga_dec  = pd.read_csv("https://raw.githubusercontent.com/selesnow/publications/master/data_example/russian_text_in_r/ga_december.csv", sep = "t")
titanic = pd.read_csv("https://raw.githubusercontent.com/selesnow/publications/master/data_example/russian_text_in_r/titanic.csv")

Création de trames de données

Dans la table titanesque, que nous avons chargé, il y a un champ Relations sexuelles, qui stocke l'identifiant de genre du passager.

Mais pour une présentation plus pratique des données en termes de sexe du passager, vous devez utiliser le nom plutôt que le code de genre.

Pour ce faire, nous allons créer un petit répertoire, un tableau dans lequel il n'y aura que 2 colonnes (code et genre nom) et 2 lignes, respectivement.

Création d'un dataframe dans R : Tidyverse, dplyr

Dans l'exemple de code ci-dessous, nous créons la trame de données souhaitée à l'aide de la fonction tibble() .

Création d'un dataframe dans R : dplyr

## dplyr
### создаём справочник
gender <- tibble(id = c(1, 2),
                 gender = c("female", "male"))

Création d'un dataframe dans R : data.table

Création d'un dataframe dans R : data.table

## data.table
### создаём справочник
gender <- data.table(id = c(1, 2),
                    gender = c("female", "male"))

Créer un dataframe en Python : pandas

В pandas La création des frames s'effectue en plusieurs étapes, on crée d'abord un dictionnaire, puis on convertit le dictionnaire en dataframe.

Créer un dataframe en Python : pandas

# создаём дата фрейм
gender_dict = {'id': [1, 2],
               'gender': ["female", "male"]}
# преобразуем словарь в датафрейм
gender = pd.DataFrame.from_dict(gender_dict)

Sélection de colonnes

Les tables avec lesquelles vous travaillez peuvent contenir des dizaines, voire des centaines de colonnes de données. Mais pour effectuer une analyse, en règle générale, vous n'avez pas besoin de toutes les colonnes disponibles dans la table source.

Par conséquent, l’une des premières opérations que vous effectuerez avec la table source est de la supprimer des informations inutiles et de libérer la mémoire occupée par ces informations.

Sélection de colonnes dans R : Tidyverse, dplyr

syntaxe dplyr est très similaire au langage de requête SQL, si vous le connaissez vous maîtriserez rapidement ce package.

Pour sélectionner des colonnes, utilisez la fonction select().

Vous trouverez ci-dessous des exemples de code avec lesquels vous pouvez sélectionner des colonnes des manières suivantes :

• Liste des noms des colonnes requises
• Faites référence aux noms de colonnes à l'aide d'expressions régulières
• Par type de données ou toute autre propriété des données contenues dans la colonne

Sélection de colonnes dans R : dplyr

# Выбор нужных столбцов
## dplyr
### выбрать по названию столбцов
select(ga_nov, date, source, sessions)
### исключь по названию столбцов
select(ga_nov, -medium, -bounces)
### выбрать по регулярному выражению, стобцы имена которых заканчиваются на s
select(ga_nov, matches("s$"))
### выбрать по условию, выбираем только целочисленные столбцы
select_if(ga_nov, is.integer)

Sélection de colonnes dans R : data.table

Les mêmes opérations dans data.table sont exécutés légèrement différemment, au début de l'article, j'ai fourni une description des arguments qui se trouvent entre crochets dans data.table.

DT[i,j,by]

Où:
je - où, c'est-à-dire filtrage par lignes
j - sélectionner | mettre à jour | faire, c'est-à-dire sélectionner des colonnes et les convertir
par - regroupement de données

Sélection de colonnes dans R : data.table

## data.table
### выбрать по названию столбцов
ga_nov[ , .(date, source, sessions) ]
### исключь по названию столбцов
ga_nov[ , .SD, .SDcols = ! names(ga_nov) %like% "medium|bounces" ]
### выбрать по регулярному выражению
ga_nov[, .SD, .SDcols = patterns("s$")]

Variable .SD vous permet d'accéder à toutes les colonnes, et .SDcols filtrez les colonnes requises à l'aide d'expressions régulières ou d'autres fonctions pour filtrer les noms des colonnes dont vous avez besoin.

Sélection de colonnes en Python, pandas

Pour sélectionner des colonnes par nom dans pandas il suffit de fournir une liste de leurs noms. Et pour sélectionner ou exclure des colonnes par nom à l'aide d'expressions régulières, vous devez utiliser les fonctions drop() и filter(), et argumentation axe = 1, avec lequel vous indiquez qu'il est nécessaire de traiter les colonnes plutôt que les lignes.

Pour sélectionner un champ par type de données, utilisez la fonction select_dtypes(), et dans les arguments comprendre ou exclure transmettez une liste de types de données correspondant aux champs que vous devez sélectionner.

Sélection de colonnes en Python : pandas

# Выбор полей по названию
ga_nov[['date', 'source', 'sessions']]
# Исключить по названию
ga_nov.drop(['medium', 'bounces'], axis=1)
# Выбрать по регулярному выражению
ga_nov.filter(regex="s$", axis=1)
# Выбрать числовые поля
ga_nov.select_dtypes(include=['number'])
# Выбрать текстовые поля
ga_nov.select_dtypes(include=['object'])

Filtrage des lignes

Par exemple, la table source peut contenir plusieurs années de données, mais vous ne devez analyser que le dernier mois. Encore une fois, des lignes supplémentaires ralentiront le processus de traitement des données et obstrueront la mémoire du PC.

Filtrage des lignes dans R : tydyverse, dplyr

В dplyr la fonction est utilisée pour filtrer les lignes filter(). Il prend une trame de données comme premier argument, puis vous répertoriez les conditions de filtrage.

Lors de l'écriture d'expressions logiques pour filtrer une table, dans ce cas, spécifiez les noms de colonnes sans guillemets et sans déclarer le nom de la table.

Lorsque vous utilisez plusieurs expressions logiques pour filtrer, utilisez les opérateurs suivants :

• & ou virgule - ET logique
• | - OU logique

Filtrage des lignes dans R : dplyr

# фильтрация строк
## dplyr
### фильтрация строк по одному условию
filter(ga_nov, source == "google")
### фильтр по двум условиям соединённым логическим и
filter(ga_nov, source == "google" & sessions >= 10)
### фильтр по двум условиям соединённым логическим или
filter(ga_nov, source == "google" | sessions >= 10)

Filtrage des lignes dans R : data.table

Comme je l'ai déjà écrit plus haut, dans data.table la syntaxe de conversion des données est placée entre crochets.

DT[i,j,by]

Où:
je - où, c'est-à-dire filtrage par lignes
j - sélectionner | mettre à jour | faire, c'est-à-dire sélectionner des colonnes et les convertir
par - regroupement de données

L'argument est utilisé pour filtrer les lignes i, dont la première position est entre crochets.

Les colonnes sont accessibles dans des expressions logiques sans guillemets et sans spécifier le nom de la table.

Les expressions logiques sont liées les unes aux autres de la même manière que dans dplyr via les opérateurs & et |.

Filtrage des lignes dans R : data.table

## data.table
### фильтрация строк по одному условию
ga_nov[source == "google"]
### фильтр по двум условиям соединённым логическим и
ga_nov[source == "google" & sessions >= 10]
### фильтр по двум условиям соединённым логическим или
ga_nov[source == "google" | sessions >= 10]

Filtrage de chaînes en Python : pandas

Filtrer par lignes dans pandas similaire au filtrage dans data.table, et est fait entre crochets.

Dans ce cas, l'accès aux colonnes s'effectue obligatoirement en indiquant le nom de la dataframe ; puis le nom de la colonne peut également être indiqué entre guillemets entre crochets (exemple df['col_name']), ou sans guillemets après le point (exemple df.col_name).

Si vous devez filtrer un dataframe selon plusieurs conditions, chaque condition doit être placée entre parenthèses. Les conditions logiques sont reliées entre elles par des opérateurs & и |.

Filtrage de chaînes en Python : pandas

# Фильтрация строк таблицы
### фильтрация строк по одному условию
ga_nov[ ga_nov['source'] == "google" ]
### фильтр по двум условиям соединённым логическим и
ga_nov[(ga_nov['source'] == "google") & (ga_nov['sessions'] >= 10)]
### фильтр по двум условиям соединённым логическим или
ga_nov[(ga_nov['source'] == "google") | (ga_nov['sessions'] >= 10)]

Regroupement et agrégation de données

L'une des opérations les plus couramment utilisées dans l'analyse des données est le regroupement et l'agrégation.

La syntaxe permettant d'effectuer ces opérations est dispersée dans tous les packages que nous examinons.

Dans ce cas, nous prendrons comme exemple une dataframe titanesque, et calculez le nombre et le coût moyen des billets en fonction de la classe de cabine.

Regroupement et agrégation de données dans R : Tidyverse, dplyr

В dplyr la fonction est utilisée pour le regroupement group_by(), et pour l'agrégation summarise(). En fait, dplyr il y a toute une famille de fonctions summarise_*(), mais le but de cet article est de comparer la syntaxe de base, nous n'entrerons donc pas dans une telle jungle.

Fonctions d'agrégation de base :

• sum() — résumé
• min() / max() – valeur minimale et maximale
• mean() - moyenne
• median() — médiane
• length() - quantité

Regroupement et agrégation dans R : dplyr

## dplyr
### группировка и агрегация строк
group_by(titanic, Pclass) %>%
  summarise(passangers = length(PassengerId),
            avg_price  = mean(Fare))

En fonction group_by() nous avons passé la table comme premier argument titanesque, puis a indiqué le champ Pclasse, par lequel nous regrouperons notre table. Le résultat de cette opération utilisant l'opérateur %>% passé comme premier argument à la fonction summarise(), et j'ai ajouté 2 champs supplémentaires : passagers и prix_moy. Dans le premier, en utilisant la fonction length() calculé le nombre de tickets, et dans le second en utilisant la fonction mean() reçu le prix moyen du billet.

Regroupement et agrégation de données dans R : data.table

В data.table l'argument est utilisé pour l'agrégation j qui a une deuxième position entre crochets, et pour le regroupement by ou keyby, qui occupent la troisième position.

La liste des fonctions d'agrégation dans ce cas est identique à celle décrite dans dplyr, parce que ce sont des fonctions de la syntaxe de base de R.

Regroupement et agrégation dans R : data.table

## data.table
### фильтрация строк по одному условию
titanic[, .(passangers = length(PassengerId),
            avg_price  = mean(Fare)),
        by = Pclass]

Regroupement et agrégation de données en Python : pandas

Regroupement en pandas semblable à dplyr, mais l'agrégation n'est pas similaire à dplyr pas sur data.table.

Pour regrouper, utilisez la méthode groupby(), dans lequel vous devez transmettre une liste de colonnes par lesquelles le dataframe sera regroupé.

Pour l'agrégation, vous pouvez utiliser la méthode agg()qui accepte un dictionnaire. Les clés du dictionnaire sont les colonnes sur lesquelles vous allez appliquer les fonctions d'agrégation, et les valeurs sont les noms des fonctions d'agrégation.

Fonctions d'agrégation :

• sum() — résumé
• min() / max() – valeur minimale et maximale
• mean() - moyenne
• median() — médiane
• count() - quantité

Fonction reset_index() dans l'exemple ci-dessous, il est utilisé pour réinitialiser les index imbriqués qui pandas la valeur par défaut est après l'agrégation des données.

Symbole permet de passer à la ligne suivante.

Regroupement et agrégation en Python : pandas

# группировка и агрегация данных
titanic.groupby(["Pclass"]).
    agg({'PassengerId': 'count', 'Fare': 'mean'}).
        reset_index()

Jointure verticale de tables

Opération dans laquelle vous joignez deux ou plusieurs tables de la même structure. Les données que nous avons chargées contiennent des tableaux ga_nov и ga_dec. Ces tableaux sont de structure identique, c'est-à-dire ont les mêmes colonnes et les types de données dans ces colonnes.

Il s'agit d'un téléchargement de Google Analytics pour les mois de novembre et décembre. Dans cette section, nous combinerons ces données en un seul tableau.

Joindre verticalement des tables dans R : Tidyverse, dplyr

В dplyr Vous pouvez combiner 2 tables en une seule grâce à la fonction bind_rows(), en passant des tables comme arguments.

Filtrage des lignes dans R : dplyr

# Вертикальное объединение таблиц
## dplyr
bind_rows(ga_nov, ga_dec)

Joindre verticalement des tables dans R : data.table

Ce n’est pas compliqué non plus, utilisons rbind().

Filtrage des lignes dans R : data.table

## data.table
rbind(ga_nov, ga_dec)

Joindre verticalement des tables en Python : pandas

В pandas la fonction est utilisée pour joindre des tables concat(), dans lequel vous devez transmettre une liste de cadres pour les combiner.

Filtrage de chaînes en Python : pandas

# вертикальное объединение таблиц
pd.concat([ga_nov, ga_dec])

Jointure horizontale de tables

Une opération dans laquelle les colonnes de la seconde sont ajoutées à la première table par clé. Il est souvent utilisé pour enrichir une table de faits (par exemple, une table avec des données de ventes) avec des données de référence (par exemple, le coût d'un produit).

Il existe plusieurs types de jointures :

Dans le tableau précédemment chargé titanesque nous avons une colonne Relations sexuelles, qui correspond au code de sexe du passager :

1 - femelle
2 - mâle

Nous avons également créé un tableau - un ouvrage de référence le sexe. Pour une présentation plus pratique des données sur le sexe des passagers, nous devons ajouter le nom du sexe du répertoire le sexe à la table titanesque.

Jointure de table horizontale dans R : Tidyverse, dplyr

В dplyr Il existe toute une famille de fonctions pour la jointure horizontale :

• inner_join()
• left_join()
• right_join()
• full_join()
• semi_join()
• nest_join()
• anti_join()

Le plus couramment utilisé dans ma pratique est left_join().

Comme deux premiers arguments, les fonctions répertoriées ci-dessus nécessitent deux tables à joindre, et comme troisième argument by vous devez spécifier les colonnes à joindre.

Jointure de table horizontale dans R : dplyr

# объединяем таблицы
left_join(titanic, gender,
          by = c("Sex" = "id"))

Jointure horizontale de tables dans R : data.table

В data.table Vous devez joindre les tables par clé en utilisant la fonction merge().

Arguments pour la fonction merge() dans data.table

• x, y — Tables à joindre
• by — Colonne qui est la clé à joindre si elle porte le même nom dans les deux tables
• by.x, by.y — Noms de colonnes à fusionner, s'ils ont des noms différents dans les tableaux
• all, all.x, all.y — Type de jointure, all renverra toutes les lignes des deux tables, all.x correspond à l'opération LEFT JOIN (quittera toutes les lignes de la première table), all.y — correspond à l'opération LEFT JOIN (quittera toutes les lignes de la première table). Opération RIGHT JOIN (quittera toutes les lignes de la deuxième table).

Jointure horizontale de tables dans R : data.table

# объединяем таблицы
merge(titanic, gender, by.x = "Sex", by.y = "id", all.x = T)

Jointure de table horizontale en Python : pandas

Aussi bien que dedans data.tabledans pandas la fonction est utilisée pour joindre des tables merge().

Arguments de la fonction merge() dans les pandas

• comment — Type de connexion : gauche, droite, externe, interne
• on — Colonne qui est une clé si elle porte le même nom dans les deux tables
• left_on, right_on — Noms des colonnes clés, si elles ont des noms différents dans les tableaux

Jointure de table horizontale en Python : pandas

# объединяем по ключу
titanic.merge(gender, how = "left", left_on = "Sex", right_on = "id")

Fonctions de fenêtre de base et colonnes calculées

Les fonctions de fenêtre ont une signification similaire aux fonctions d'agrégation et sont également souvent utilisées dans l'analyse des données. Mais contrairement aux fonctions d'agrégation, les fonctions de fenêtre ne modifient pas le nombre de lignes de la trame de données sortante.

Essentiellement, en utilisant la fonction window, nous divisons la trame de données entrante en parties selon certains critères, c'est-à-dire par la valeur d'un champ, ou de plusieurs champs. Et nous effectuons des opérations arithmétiques sur chaque fenêtre. Le résultat de ces opérations sera renvoyé dans chaque ligne, c'est-à-dire sans modifier le nombre total de lignes du tableau.

Par exemple, prenons la table titanesque. Nous pouvons calculer le pourcentage du coût de chaque billet dans sa classe de cabine.

Pour ce faire, nous devons obtenir dans chaque ligne le coût total d'un billet pour la classe de cabine actuelle à laquelle appartient le billet de cette ligne, puis diviser le coût de chaque billet par le coût total de tous les billets de la même classe de cabine. .

Fonctions de fenêtre dans R : Tidyverse, dplyr

Pour ajouter de nouvelles colonnes, sans utiliser le regroupement de lignes, dans dplyr remplit une fonction mutate().

Vous pouvez résoudre le problème décrit ci-dessus en regroupant les données par champ Pclasse et additionner le champ dans une nouvelle colonne Réussir. Ensuite, dissociez la table et divisez les valeurs des champs Réussir à ce qui s'est passé à l'étape précédente.

Fonctions de fenêtre dans R : dplyr

group_by(titanic, Pclass) %>%
  mutate(Pclass_cost = sum(Fare)) %>%
  ungroup() %>%
  mutate(ticket_fare_rate = Fare / Pclass_cost)

Fonctions de fenêtre dans R : data.table

L'algorithme de solution reste le même que dans dplyr, nous devons diviser la table en fenêtres par champ Pclasse. Sortez dans une nouvelle colonne le montant pour le groupe correspondant à chaque ligne, et ajoutez une colonne dans laquelle on calcule la part du coût de chaque billet dans son groupe.

Pour ajouter de nouvelles colonnes à data.table opérateur présent :=. Vous trouverez ci-dessous un exemple de résolution d'un problème à l'aide du package data.table

Fonctions de fenêtre dans R : data.table

titanic[,c("Pclass_cost","ticket_fare_rate") := .(sum(Fare), Fare / Pclass_cost), 
        by = Pclass]

Fonctions de fenêtre en Python : pandas

Une façon d'ajouter une nouvelle colonne à pandas - utiliser la fonction assign(). Pour résumer le coût des billets par classe de cabine, sans regrouper les lignes, nous utiliserons la fonction transform().

Ci-dessous un exemple de solution dans laquelle nous ajoutons au tableau titanesque les mêmes 2 colonnes.

Fonctions de fenêtre en Python : pandas

titanic.assign(Pclass_cost      =  titanic.groupby('Pclass').Fare.transform(sum),
               ticket_fare_rate = lambda x: x['Fare'] / x['Pclass_cost'])

Table de correspondance des fonctions et méthodes

Vous trouverez ci-dessous un tableau de correspondance entre les méthodes permettant d'effectuer diverses opérations avec les données des packages que nous avons considérés.

description
Tidyverse
données.table
pandas

Chargement des données
vroom()/ readr::read_csv() / readr::read_tsv()
fread()
read_csv()

Création de trames de données
tibble()
data.table()
dict() + from_dict()

Sélection de colonnes
select()
argument j, deuxième position entre crochets
on passe la liste des colonnes obligatoires entre crochets / drop() / filter() / select_dtypes()

Filtrage des lignes
filter()
argument i, première position entre crochets
Nous listons les conditions de filtrage entre crochets / filter()

Regroupement et agrégation
group_by() + summarise()
arguments j + by
groupby() + agg()

Union verticale des tables (UNION)
bind_rows()
rbind()
concat()

Jointure horizontale de tables (JOIN)
left_join() / *_join()
merge()
merge()

Fonctions de fenêtre de base et ajout de colonnes calculées
group_by() + mutate()
argument j en utilisant l'opérateur := +argumentation by
transform() + assign()

Conclusion

Peut-être que dans l'article je n'ai pas décrit les implémentations les plus optimales du traitement des données, je serai donc heureux si vous corrigez mes erreurs dans les commentaires, ou complétez simplement les informations données dans l'article avec d'autres techniques pour travailler avec des données en R/Python.

Comme je l’ai écrit plus haut, le but de l’article n’était pas d’imposer son opinion sur la meilleure langue, mais de simplifier la possibilité d’apprendre les deux langues ou, si nécessaire, de migrer entre elles.

Si vous avez aimé l'article, je serai heureux d'avoir de nouveaux abonnés à mon Youtube и télégramme canaux.

Interview

Parmi les packages suivants, lesquels utilisez-vous dans votre travail ?

Dans les commentaires, vous pouvez écrire la raison de votre choix.

Seuls les utilisateurs enregistrés peuvent participer à l'enquête. se connecters'il te plait.

Quel logiciel de traitement de données utilisez-vous (vous pouvez sélectionner plusieurs options)

• 45,2%Tidyverse19

• 33,3%données.table14

• 54,8%pandas23

42 utilisateurs ont voté. 9 utilisateurs se sont abstenus.

Source: habr.com