ProHoster > Blog > Administratioun > Wéi eng Sprooch ze wielen fir mat Daten ze schaffen - R oder Python? Souwuel! Migratioun vun pandas zu tidyverse an daten.Table an zréck

Wéi eng Sprooch ze wielen fir mat Daten ze schaffen - R oder Python? Souwuel! Migratioun vun pandas zu tidyverse an daten.Table an zréck

Andeems Dir no R oder Python um Internet sicht, fannt Dir Millioune Artikelen a Kilometer vun Diskussiounen iwwer d'Thema wéi eng besser, méi séier a méi bequem ass fir mat Daten ze schaffen. Awer leider sinn all dës Artikelen a Streidereien net besonnesch nëtzlech.

Wéi eng Sprooch ze wielen fir mat Daten ze schaffen - R oder Python? Souwuel! Migratioun vun pandas zu tidyverse an daten.Table an zréck

Den Zweck vun dësem Artikel ass d'Basisdatenveraarbechtungstechniken an de populärste Packagen vu béide Sprooche ze vergläichen. An hëlleft de Lieser séier eppes ze beherrschen wat se nach net wëssen. Fir déi, déi am Python schreiwen, erausfannen wéi een dat selwecht am R mécht, a vice versa.

Wärend dem Artikel wäerte mir d'Syntax vun de beléifste Packagen am R analyséieren. Dëst sinn d'Packagen déi an der Bibliothéik abegraff sinn. tidyversean och de Pak data.table. A vergläichen hir Syntax mat pandas, de populärste Dateanalysepaket am Python.

Mir wäerte Schrëtt fir Schrëtt duerch de ganze Wee vun der Datenanalyse goen, vun der Luede bis zur Ausféierung vun analytesche Fënsterfunktiounen mat Python a R.

Inhalt

Dësen Artikel kann als Cheat-Sheet benotzt ginn wann Dir vergiess hutt wéi Dir eng Datenveraarbechtungsoperatioun an engem vun de berécksiichtege Packagen ausféiert.

Wéi eng Sprooch ze wielen fir mat Daten ze schaffen - R oder Python? Souwuel! Migratioun vun pandas zu tidyverse an daten.Table an zréck

  1. Main Syntax Differenzen tëscht R a Python
    1.1. Zougang zu Package Funktiounen
    1.2. Aufgab
    1.3. Indexéierung
    1.4. Methoden an OOP
    1.5. Pipelines
    1.6. Daten Strukturen
  2. E puer Wierder iwwer d'Packagen déi mir benotzen
    2.1. uerdentlech
    2.2. data.tabell
    2.3. pandas
  3. Installatioun Pakete
  4. Lueden Daten
  5. Dateframes erstellen
  6. Auswiel vun de Kolonnen Dir braucht
  7. Filter Reihen
  8. Gruppéierung an Aggregatioun
  9. Vertikal Unioun vun Dëscher (UNION)
  10. Horizontal Verbindung vun Dëscher (JOIN)
  11. Basis Fënster Funktiounen a berechent Kolonnen
  12. Korrespondenztabell tëscht Datenveraarbechtungsmethoden am R a Python
  13. Konklusioun
  14. Eng kuerz Ëmfro iwwer wéi ee Package Dir benotzt

Wann Dir un Datenanalyse interesséiert sidd, fannt Dir meng Hëllefe profitéieren и YouTube Channels. De gréissten Deel vum Inhalt ass der R Sprooch gewidmet.

Main Syntax Differenzen tëscht R a Python

Fir e maachen et méi einfach fir Iech aus Python ze R ze wiesselen ugefaangen, oder Vize versa, Ech wäert e puer Haapt Punkten ginn, datt Dir oppassen muss.

Zougang zu Package Funktiounen

Wann e Package an R gelueden ass, musst Dir de Packagenumm net spezifizéieren fir op seng Funktiounen ze kommen. Am meeschte Fäll ass dëst net heefeg am R, awer et ass akzeptabel. Dir musst guer net e Package importéieren wann Dir eng vu senge Funktiounen an Ärem Code braucht, awer rufft et einfach un andeems Dir den Numm vum Package an den Numm vun der Funktioun uginn. De Separator tëscht Package- a Funktiounsnimm am R ass en Duebele Colon. package_name::function_name().

Am Python, am Géigendeel, gëtt et als klassesch ugesinn d'Funktioune vun engem Package ze nennen andeems se säin Numm explizit spezifizéieren. Wann e Package erofgeluede gëtt, gëtt et normalerweis e verkierzte Numm, z.B. pandas normalerweis gëtt e Pseudonym benotzt pd. Eng Package Funktioun gëtt iwwer e Punkt zougänglech gemaach package_name.function_name().

Aufgab

Am R ass et üblech fir e Pfeil ze benotzen fir e Wäert un en Objet ze ginn. obj_name <- value, obwuel en eenzegt Gläichzeechen erlaabt ass, gëtt dat eenzegt Gläichzeechen am R haaptsächlech benotzt fir Wäerter fir Argumenter ze funktionéieren.

Am Python gëtt d'Aufgab exklusiv mat engem eenzege Gläichzeechen gemaach obj_name = value.

Indexéierung

Et ginn och zimlech bedeitend Differenzen hei. Am R fänkt d'Indexéierung bei engem un an enthält all spezifizéiert Elementer am resultéierende Beräich,

am Python fänkt d'Indexéierung vun Null un an de gewielte Beräich enthält net dat lescht Element dat an der Indexéierung spezifizéiert ass. Also Design x[i:j] am Python wäert de j Element net enthalen.

Et ginn och Differenzen am negativen Indexéierung, an der R Notatioun x[-1] wäert all Elementer vum Vektor zréckginn ausser dee leschten. Am Python gëtt eng ähnlech Notatioun nëmmen dat lescht Element zréck.

Methoden an OOP

R implementéiert OOP op seng eege Manéier, ech hunn iwwer dëst am Artikel geschriwwen "OOP an der R Sprooch (Deel 1): S3 Klassen". Allgemeng ass R eng funktionell Sprooch, an alles dran ass op Funktiounen gebaut. Dofir, zum Beispill, fir Excel Benotzer, gitt op tydiverse et gëtt méi einfach wéi pandas. Obwuel dat vläicht meng subjektiv Meenung sinn.

Kuerz gesot, Objeten am R hunn keng Methoden (wa mir iwwer S3 Klassen schwätzen, awer et ginn aner OOP-Implementatiounen déi vill manner heefeg sinn). Et gi just generaliséiert Funktiounen déi se anescht veraarbecht ofhängeg vun der Klass vum Objet.

Pipelines

Vläicht ass dëst den Numm fir pandas Et wäert net ganz richteg sinn, awer ech probéieren d'Bedeitung z'erklären.

Fir net Zwësche Berechnungen ze retten an net onnéideg Objeten am Aarbechtsëmfeld ze produzéieren, kënnt Dir eng Zort Pipeline benotzen. Déi. Passe d'Resultat vun enger Berechnung vun enger Funktioun op déi nächst, a späichert keng Tëscheresultater.

Loosst d'folgend Code Beispill huelen, wou mir Tëschenzäit Berechnungen an getrennten Objete späicheren:

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

Mir hunn 3 Operatiounen sequenziell gemaach, an d'Resultat vun all gouf an engem separaten Objet gespäichert. Awer tatsächlech brauche mir dës Zwëschenobjekter net.

Oder nach méi schlëmm, awer méi vertraut fir Excel Benotzer.

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

An dësem Fall hu mir keng Zwëscherrechnungsresultater gespäichert, awer d'Liesen vum Code mat nestet Funktiounen ass extrem onbequem.

Mir wäerte verschidde Approche fir Datenveraarbechtung am R kucken, a si maachen ähnlech Operatiounen op verschidde Weeër.

Pipelines an der Bibliothéik tidyverse vum Bedreiwer ëmgesat %>%.

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

Sou huelen mir d'Resultat vun der Aarbecht func1() a gitt et als éischt Argument un func2(), da passéiere mir d'Resultat vun dëser Berechnung als éischt Argument func3(). A schlussendlech schreiwen mir all d'Berechnungen an den Objet obj <-.

All dat hei uewen ass besser illustréiert wéi Wierder vun dësem Meme:
Wéi eng Sprooch ze wielen fir mat Daten ze schaffen - R oder Python? Souwuel! Migratioun vun pandas zu tidyverse an daten.Table an zréck

В data.table Ketten ginn op eng ähnlech Manéier benotzt.

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

An jiddereng vun de véiereckege Klammeren kënnt Dir d'Resultat vun der viregter Operatioun benotzen.

В pandas esou Operatiounen sinn vun engem Punkt getrennt.

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

Déi. mir huelen eisen Dësch df a benotzen hir Method fun1(), da gëlle mir d'Methode op dat kritt Resultat fun2()duerno fun3(). Dat resultéierend Resultat gëtt an en Objet gespäichert Objet .

Daten Strukturen

Datestrukturen am R a Python sinn ähnlech, awer hunn verschidden Nimm.

Beschreiwung
Numm an R
Numm am Python / Pandas

Dësch Struktur
data.frame, daten.table, tibbel
DataFrame

Eendimensional Lëscht vu Wäerter
Vektor
Serie an pandas oder Lëscht am pure Python

Multi-Level Net-Tabulär Struktur
Lëscht
Wörterbuch (dict)

Mir kucken e puer aner Funktiounen an Differenzen an der Syntax hei ënnen.

E puer Wierder iwwer d'Packagen déi mir benotzen

Als éischt wäert ech Iech e bëssen iwwer d'Packagen soen, déi Dir während dësem Artikel kennt.

uerdentlech

Offiziell Websäit: tidyverse.org
Wéi eng Sprooch ze wielen fir mat Daten ze schaffen - R oder Python? Souwuel! Migratioun vun pandas zu tidyverse an daten.Table an zréck
Bibliothéik tidyverse geschriwwen vum Hedley Wickham, Senior Research Scientist bei RStudio. tidyverse besteet aus engem beandrockende Set vu Packagen déi d'Datenveraarbechtung vereinfachen, vun deenen 5 an den Top 10 Downloads vum CRAN Repository abegraff sinn.

De Kär vun der Bibliothéik besteet aus de folgende Packagen: ggplot2, dplyr, tidyr, readr, purrr, tibble, stringr, forcats. Jiddereng vun dëse Packagen zielt fir e spezifesche Problem ze léisen. Zum Beispill dplyr erstallt fir Datemanipulatioun, tidyr fir d'Donnéeën an eng ordentlech Form ze bréngen, stringr vereinfacht Aarbecht mat Saiten, an ggplot2 ass ee vun de populäersten Datevisualiséierungsinstrumenter.

Virdeel tidyverse ass d'Einfachheet an einfach ze liesen Syntax, déi op ville Weeër ähnlech wéi d'SQL Query Sprooch ass.

data.tabell

Wéi eng Sprooch ze wielen fir mat Daten ze schaffen - R oder Python? Souwuel! Migratioun vun pandas zu tidyverse an daten.Table an zréckOffiziell Websäit: r-datatable.com

Vun data.table ass de Matt Dole vun H2O.ai.

Déi éischt Verëffentlechung vun der Bibliothéik huet am Joer 2006 stattfonnt.

De Package Syntax ass net sou bequem wéi an tidyverse an erënnert méi u klassesch Datframes am R, awer gläichzäiteg däitlech an der Funktionalitéit erweidert.

All Manipulatioune mat der Tabell an dësem Package sinn a véiereckege Klammeren beschriwwen, a wann Dir d'Syntax iwwersetzt data.table an SQL kritt Dir eppes wéi dat: data.table[ WHERE, SELECT, GROUP BY ]

D'Kraaft vun dësem Package ass d'Geschwindegkeet vun der Veraarbechtung vu grousse Quantitéiten un Daten.

pandas

Offiziell Websäit: pandas.pydata.org Wéi eng Sprooch ze wielen fir mat Daten ze schaffen - R oder Python? Souwuel! Migratioun vun pandas zu tidyverse an daten.Table an zréck

Den Numm vun der Bibliothéik kënnt vum ekonometresche Begrëff "Paneldaten", benotzt fir multidimensional strukturéiert Sätz vun Informatioun ze beschreiwen.

Vun pandas ass den Amerikaner Wes McKinney.

Wann et drëms geet, fir Daten Analyse am Python, gläich pandas Nee. E ganz multifunktionnellen, héijen Niveau Package deen Iech erlaabt all Manipulatioun mat Daten auszeféieren, vun Daten aus all Quell ze lueden bis se visualiséieren.

Zousätzlech Packagen installéieren

D'Packagen, déi an dësem Artikel diskutéiert ginn, sinn net an de Basis R a Python Verdeelungen abegraff. Och wann et e klengen Opgepasst ass, wann Dir d'Anaconda Verdeelung installéiert hutt, installéiert dann zousätzlech pandas ass net néideg.

Installéiere vu Packagen am R

Wann Dir d'RStudio Entwécklungsëmfeld op d'mannst eemol opgemaach hutt, wësst Dir wahrscheinlech scho wéi Dir de erfuerderleche Package am R installéiert. Fir Packagen z'installéieren, benotzt de Standard Kommando install.packages() andeems se direkt an R selwer lafen.

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

No der Installatioun mussen d'Packagen verbonne sinn, fir déi meeschtens de Kommando benotzt gëtt library().

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

Installéiere Packagen am Python

Also, wann Dir pure Python installéiert hutt, dann pandas Dir musst et manuell installéieren. Öffnen eng Kommandozeil, oder Terminal, jee no Ärem Betribssystem a gitt de folgende Kommando.

pip install pandas

Da gi mir zréck op Python an importéiert de installéierte Package mam Kommando import.

import pandas as pd

Lueden Daten

Datemining ass ee vun de wichtegste Schrëtt an der Dateanalyse. Béid Python a R, wann Dir wëllt, bidden Iech extensiv Méiglechkeeten fir Daten aus all Quellen ze kréien: lokal Dateien, Dateien aus dem Internet, Websäiten, all Zort vun Datenbanken.

Wéi eng Sprooch ze wielen fir mat Daten ze schaffen - R oder Python? Souwuel! Migratioun vun pandas zu tidyverse an daten.Table an zréck

Am ganzen Artikel wäerte mir e puer Datesätz benotzen:

  1. Zwee Downloads vu Google Analytics.
  2. Titanic Passagéier Datenset.

All d'Donnéeë sinn op meng GitHub a Form vun csv- an tsv-Dateien. Wou wäerte mir se froen?

Lueden Daten an R: tidyverse, vroom, readr

Fir Daten an eng Bibliothéik ze lueden tidyverse Et ginn zwee Packagen: vroom, readr. vroom méi modern, awer an Zukunft kënnen d'Packagen kombinéiert ginn.

Zitat vum offiziell Dokumentatioun vroom.

vroom vs Lieser
Wat mécht d'Verëffentlechung vun vroom heescht fir readr? Fir de Moment plangen mir déi zwee Packagen separat z'entwéckelen, awer wahrscheinlech wäerte mir d'Packagen an Zukunft vereenegen. Een Nodeel fir dem vroom seng faul Liesung ass bestëmmten Dateproblemer kënnen net virdru gemellt ginn, also wéi se am beschten ze vereenegen erfuerdert e puer Gedanken.

vroom vs Lieser
Wat heescht Verëffentlechung? vroom fir readr? Am Moment plangen mir béid Packagen separat z'entwéckelen, awer mir wäerte se wahrscheinlech an Zukunft kombinéieren. Ee vun den Nodeeler vun faul liesen vroom ass, datt e puer daten Problemer kann net am Viraus gemellt ginn, also du muss iwwer ze denken, wéi beschte hinnen ze kombinéieren.

An dësem Artikel wäerte mir op béid Daten Luede Pakete kucken:

Lueden Daten an R: vroom Package

# 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")

Lueden Daten an 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")

Am Pak vroom, onofhängeg vum csv / tsv Dateformat, d'Luede gëtt duerch d'Funktioun mam selwechten Numm duerchgefouert vroom(), am Package readr mir benotzen eng aner Funktioun fir all Format read_tsv() и read_csv().

Lueden Daten an R: data.table

В data.table et gëtt eng Funktioun fir Daten ze lueden fread().

Lueden Daten an R: data.table Package

# 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")

Lueden Daten am Python: pandas

Wa mir mat R Packagen vergläichen, dann ass an dësem Fall d'Syntax am nootsten pandas wäert readrwell pandas kann Daten iwwerall ufroen, an et gëtt eng ganz Famill vu Funktiounen an dësem Package read_*().

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

A vill aner Funktiounen entwéckelt fir Daten aus verschiddene Formater ze liesen. Awer fir eis Zwecker ass et genuch read_table() oder read_csv() Argument benotzt sept fir de Kolonnetrener ze spezifizéieren.

Lueden Daten am 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")

Dateframes erstellen

Dësch onheemlech, déi mir gelueden hunn, do ass e Feld Sex, déi dem Passagéier säi Geschlecht Identifizéierer späichert.

Awer fir eng méi praktesch Presentatioun vun Daten a punkto Passagéiergeschlecht, sollt Dir den Numm benotzen anstatt de Geschlechtcode.

Fir dëst ze maachen, wäerte mir e klengen Verzeechnes erstellen, en Dësch an deem et nëmmen 2 Kolonnen (Code a Geschlechtnumm) an 2 Reihen gëtt.

Erstellt en Dataframe am R: tidyverse, dplyr

Am Code Beispill hei drënner erstellen mir de gewënschten Dateframe mat der Funktioun tibble() .

Erstellt en Dataframe am R: dplyr

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

Schafen vun engem dataframe an R: data.table

Schafen vun engem dataframe an R: data.table

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

En Dateframe am Python erstellen: pandas

В pandas D'Schafe vu Frames gëtt an e puer Etappen duerchgefouert, als éischt erstellen mir e Wierderbuch, an dann konvertéiere mir d'Wierderbuch an en Dataframe.

En Dateframe am Python erstellen: pandas

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

Kolonnen auswielen

D'Tabellen, mat deenen Dir schafft, kënnen Dutzende oder souguer Honnerte vu Kolonnen vun Daten enthalen. Awer fir d'Analyse auszeféieren, brauch Dir als Regel net all d'Säulen, déi an der Quelltabell verfügbar sinn.

Wéi eng Sprooch ze wielen fir mat Daten ze schaffen - R oder Python? Souwuel! Migratioun vun pandas zu tidyverse an daten.Table an zréck

Dofir ass eng vun den éischten Operatiounen, déi Dir mat der Quelltabel ausféiert, et vun onnéideger Informatioun ze läschen an d'Erënnerung ze befreien, déi dës Informatioun besetzt.

Wielt Sailen an R: tidyverse, dplyr

Siwebiergen dplyr ass ganz ähnlech wéi d'SQL Query Sprooch, wann Dir mat deem vertraut sidd, wäert Dir dëse Package séier beherrschen.

Fir Spalten ze wielen, benotzt d'Funktioun select().

Drënner sinn Beispiller vu Code mat deem Dir Kolonnen op de folgende Weeër auswielen kënnt:

  • Oplëschtung vun den Nimm vun den erfuerderleche Kolonnen
  • Referéiert op Spaltennimm mat reguläre Ausdréck
  • No Datentyp oder all aner Eegeschafte vun den Donnéeën an der Kolonn

Auswahl Sailen an 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)

Auswiel vun Kolonnen an R: data.table

Déi selwecht Operatiounen an data.table ginn liicht anescht ausgeführt, am Ufank vum Artikel hunn ech eng Beschreiwung zur Verfügung gestallt vu wéi eng Argumenter an de Quadratklammern sinn data.table.

DT[i,j,by]

Wou:
ech - wou, d.h. Filteren no Reihen
j - select|update|do, d.h. Kolonnen auswielen an se konvertéieren
duerch - Dategruppéierung

Auswiel vun Kolonnen an 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$")]

Variabel .SD erlaabt Iech Zougang zu all Sailen, an .SDcols filtert déi erfuerderlech Kolonnen mat reguläre Ausdréck, oder aner Funktiounen fir d'Nimm vun de Kolonnen ze filteren déi Dir braucht.

Wielt Sailen am Python, pandas

Fir Spalten nom Numm ze wielen an pandas et ass genuch eng Lëscht vun hiren Nimm ze bidden. A fir Spalten mam Numm ze wielen oder auszeschléissen andeems Dir regulär Ausdréck benotzt, musst Dir d'Funktioune benotzen drop() и filter(), an Argument Achs = 1, mat deem Dir uginn datt et néideg ass Kolonnen ze veraarbecht anstatt Reien.

Fir e Feld no Datentyp ze wielen, benotzt d'Funktioun select_dtypes(), an Argumenter gehéiert oder ausgeschloss sinn passéiert eng Lëscht vun Datentypen entspriechend wéi eng Felder Dir musst auswielen.

Wielt Spalten am 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'])

Filter Reihen

Zum Beispill kann d'Quelltabell e puer Joer Daten enthalen, awer Dir musst nëmmen de leschte Mount analyséieren. Erëm, extra Linnen wäerten den Dateveraarbechtungsprozess verlangsamen an d'PC Memory verstoppen.

Wéi eng Sprooch ze wielen fir mat Daten ze schaffen - R oder Python? Souwuel! Migratioun vun pandas zu tidyverse an daten.Table an zréck

Filter Reihen an R: tydyverse, dplyr

В dplyr d'Funktioun gëtt benotzt fir Reihen ze filteren filter(). Et hëlt en Dateframe als dat éischt Argument, da lëscht Dir d'Filterbedéngungen.

Wann Dir logesch Ausdréck schreift fir en Dësch ze filteren, gitt an dësem Fall d'Kolonnnimm ouni Zitater an ouni den Dëschnumm ze deklaréieren.

Wann Dir verschidde logesch Ausdréck benotzt fir ze filteren, benotzt déi folgend Bedreiwer:

  • & oder Komma - logesch AN
  • | - logesch ODER

Filter Reihen an R: dplyr

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

Filter Reihen an R: data.table

Wéi ech schonn uewen geschriwwen, an data.table D'Syntax vun der Datenkonversioun ass a véiereckege Klammeren zougemaach.

DT[i,j,by]

Wou:
ech - wou, d.h. Filteren no Reihen
j - select|update|do, d.h. Kolonnen auswielen an se konvertéieren
duerch - Dategruppéierung

D'Argument gëtt benotzt fir Reihen ze filteren i, deen déi éischt Plaz a Klammern huet.

Spalten ginn a logeschen Ausdrock zougänglech ouni Zitatzeechen an ouni den Dëschnumm ze spezifizéieren.

Logesch Ausdréck si matenee verbonnen op déiselwecht Manéier wéi an dplyr duerch d' & an | Bedreiwer.

Filter Reihen an R: data.table

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

Filter Strings am Python: pandas

Filter no Reihen an pandas ähnlech wéi Filteren data.table, a gëtt an véiereckege Klammeren gemaach.

An dësem Fall gëtt den Zougang zu de Spalten onbedéngt duerchgefouert andeems den Numm vum Dateframe ugewise gëtt; da kann de Kolonnnumm och an Zitatzeechen a véiereckege Klammeren uginn ginn (Beispill df['col_name']), oder ouni Zitater no der Period (Beispill df.col_name).

Wann Dir en Dateframe no e puer Konditioune filtere musst, muss all Konditioun an Klammeren gesat ginn. Logesch Konditioune si matenee verbonne vu Betreiber & и |.

Filter Strings am 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)]

Gruppéierung an Aggregatioun vun Daten

Ee vun de meescht benotzt Operatiounen an der Datenanalyse ass Gruppéierung an Aggregatioun.

Wéi eng Sprooch ze wielen fir mat Daten ze schaffen - R oder Python? Souwuel! Migratioun vun pandas zu tidyverse an daten.Table an zréck

D'Syntax fir dës Operatiounen auszeféieren ass iwwer all Packagen verstreet déi mir iwwerpréiwen.

An dësem Fall wäerte mir en Dataframe als Beispill huelen onheemlech, a berechnen d'Zuel an d'Duerchschnëttskäschte vun Ticketen ofhängeg vun der Kabineklass.

Gruppéierung an Aggregatioun vun Daten am R: tidyverse, dplyr

В dplyr d'Funktioun gëtt fir Gruppéierung benotzt group_by(), a fir Aggregatioun summarise(). Tatsächlech, dplyr et gëtt eng ganz Famill vu Funktiounen summarise_*(), awer den Zweck vun dësem Artikel ass d'Basissyntax ze vergläichen, also wäerte mir net an esou Dschungel goen.

Basis Aggregatioun Funktiounen:

  • sum() - Zesummefaassung
  • min() / max() - Minimum a maximal Wäert
  • mean() - Moyenne
  • median() — median
  • length() - Quantitéit

Gruppéierung an Aggregatioun an R: dplyr

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

An Funktioun group_by() mir hunn den Dësch als éischt Argument passéiert onheemlech, an dann den Terrain uginn Pclass, duerch déi mir eisen Dësch gruppéiere wäerten. D'Resultat vun dëser Operatioun mam Bedreiwer %>% als éischt Argument fir d'Funktioun iwwerginn summarise(), an dobäi 2 weider Felder: Passagéier и avg_preis. Am éischten, benotzt d'Funktioun length() berechent d'Zuel vun Ticketen, an der zweeter benotzt d'Funktioun mean() krut den duerchschnëttleche Ticketpräis.

Gruppéierung an Aggregatioun vun Daten an R: data.table

В data.table d'Argument gëtt fir Aggregatioun benotzt j déi eng zweet Positioun am Klammern huet, a fir Gruppéierung by oder keyby, déi déi drëtt Positioun hunn.

D'Lëscht vun den Aggregatiounsfunktiounen an dësem Fall ass identesch mat deem beschriwwen an dplyr, well dës sinn Funktiounen aus der Basis R Syntax.

Gruppéierung an Aggregatioun an R: data.table

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

Gruppéierung an Aggregatioun vun Daten am Python: pandas

Gruppéieren an pandas ähnlech wéi dplyr, awer d'Aggregatioun ass net ähnlech wéi dplyr net op data.table.

Fir ze gruppéieren, benotzt d'Method groupby(), an deem Dir eng Lëscht vu Kolonnen passéiere musst, duerch déi den Dateframe gruppéiert gëtt.

Fir Aggregatioun kënnt Dir d'Methode benotzen agg()deen e Wierderbuch acceptéiert. D'Wörterbuchschlëssel sinn d'Säulen op deenen Dir d'Aggregatiounsfunktiounen applizéiert, an d'Wäerter sinn d'Nimm vun den Aggregatiounsfunktiounen.

Aggregatioun Funktiounen:

  • sum() - Zesummefaassung
  • min() / max() - Minimum a maximal Wäert
  • mean() - Moyenne
  • median() — median
  • count() - Quantitéit

Funktioun reset_index() am Beispill hei drënner gëtt et benotzt fir nestéiert Indizes zréckzesetzen déi pandas Default no Daten Aggregatioun.

Symbol erlaabt Iech op déi nächst Linn ze plënneren.

Gruppéierung an Aggregatioun am Python: pandas

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

Vertikal Verbindung vun Dëscher

Eng Operatioun an där Dir zwee oder méi Dëscher vun der selwechter Struktur verbënnt. D'Daten déi mir gelueden hunn enthalen Tabellen ga_nov и ga_dec. Dës Dëscher sinn identesch an Struktur, i.e. hunn déiselwecht Kolonnen, an d'Datentypen an dëse Kolonnen.

Wéi eng Sprooch ze wielen fir mat Daten ze schaffen - R oder Python? Souwuel! Migratioun vun pandas zu tidyverse an daten.Table an zréck

Dëst ass en Eroplueden vu Google Analytics fir de Mount November an Dezember, an dëser Rubrik kombinéiere mir dës Donnéeën an eng Tabell.

Vertikal verbannen Dëscher an R: tidyverse, dplyr

В dplyr Dir kënnt 2 Dëscher an een mat der Funktioun kombinéieren bind_rows(), laanschtgoungen Dëscher als seng Argumenter.

Filter Reihen an R: dplyr

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

Vertikal verbannen Dëscher an R: data.table

Et ass och näischt komplizéiert, loosst eis benotzen rbind().

Filter Reihen an R: data.table

## data.table
rbind(ga_nov, ga_dec)

Vertikal anzeschreiwen Dëscher am Python: pandas

В pandas d'Funktioun gëtt benotzt fir Dëscher matzemaachen concat(), an déi Dir musst eng Lëscht vu Rummen passéieren fir se ze kombinéieren.

Filter Strings am Python: pandas

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

Horizontal Verbindung vun Dëscher

Eng Operatioun an där Spalten vun der zweeter mam Schlëssel an den éischten Dësch bäigefüügt ginn. Et gëtt dacks benotzt wann Dir eng Faktentabell beräichert (zum Beispill en Dësch mat Verkafsdaten) mat e puer Referenzdaten (zum Beispill d'Käschte vun engem Produkt).

Wéi eng Sprooch ze wielen fir mat Daten ze schaffen - R oder Python? Souwuel! Migratioun vun pandas zu tidyverse an daten.Table an zréck

Et gi verschidden Aarte vu Joint:

Wéi eng Sprooch ze wielen fir mat Daten ze schaffen - R oder Python? Souwuel! Migratioun vun pandas zu tidyverse an daten.Table an zréck

Am virdrun gelueden Dësch onheemlech mir hunn eng Kolonn Sex, wat dem Passagéier säi Geschlechtscode entsprécht:

1 - weiblech
2 - männlech

Och hu mir en Dësch erstallt - e Referenzbuch Geschlecht. Fir eng méi praktesch Presentatioun vun Daten iwwer d'Geschlecht vun de Passagéier, musse mir den Numm vum Geschlecht aus dem Verzeechnes derbäisetzen Geschlecht op den Dësch onheemlech.

Horizontal Dësch matmaachen an R: tidyverse, dplyr

В dplyr Et gëtt eng ganz Famill vu Funktiounen fir horizontale Verbindung:

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

Déi meescht benotzt a menger Praxis ass left_join().

Als déi éischt zwee Argumenter, huelen d'Funktiounen uewen opgezielt zwee Dëscher fir matzemaachen, an als drëtt Argument by Dir musst d'Kolonn uginn fir matzemaachen.

Horizontal Dësch matmaachen an R: dplyr

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

Horizontal Verbindung vun Dëscher an R: data.table

В data.table Dir musst Dëscher mat Schlëssel mat der Funktioun matmaachen merge().

Argumenter ze fusionéieren () Funktioun an data.table

  • x, y - Dëscher fir matzemaachen
  • vun - Kolonn dat ass de Schlëssel fir matzemaachen wann et deeselwechten Numm a béid Dëscher huet
  • by.x, by.y - Spaltennimm fir ze fusionéieren, wa se verschidden Nimm an den Dëscher hunn
  • all, all.x, all.y - Join Typ, all wäert all Zeilen aus béiden Dëscher zréckginn, all.x entsprécht der LEFT JOIN Operatioun (verléisst all d'Reihen vum éischten Dësch), all.y - entsprécht der RIGHT JOIN Operatioun (gëtt all d'Zeile vun der zweeter Dësch verloossen).

Horizontal Verbindung vun Dëscher an R: data.table

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

Horizontal Dësch matmaachen an Python: pandas

Wéi och an data.table, an pandas d'Funktioun gëtt benotzt fir Dëscher matzemaachen merge().

Argumenter vun der Fusioun () Funktioun an pandas

  • wéi - Verbindung Typ: lénks, riets, baussenzegen, bannen
  • op - Kolonn dat ass e Schlëssel wann et dee selwechten Numm a béid Dëscher huet
  • left_on, right_on - Nimm vu Schlësselkolonnen, wa se verschidden Nimm an Tabellen hunn

Horizontal Dësch matmaachen an Python: pandas

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

Basis Fënster Funktiounen a berechent Kolonnen

Fënsterfunktiounen sinn ähnlech a Bedeitung wéi Aggregatiounsfunktiounen, a ginn och dacks an der Datenanalyse benotzt. Awer am Géigesaz zu Aggregatiounsfunktiounen änneren d'Fënsterfunktiounen net d'Zuel vun de Reihen vum erausginn Dateframe.

Wéi eng Sprooch ze wielen fir mat Daten ze schaffen - R oder Python? Souwuel! Migratioun vun pandas zu tidyverse an daten.Table an zréck

Am Wesentlechen, mat der Fënsterfunktioun, hu mir den erakommende Dateframe an Deeler opgedeelt no e puer Critère, d.h. duerch de Wäert vun engem Feld, oder e puer Felder. A mir maachen arithmetesch Operatiounen op all Fënster. D'Resultat vun dësen Operatiounen ginn an all Linn zréck, d.h. ouni d'Gesamtzuel vun de Reihen an der Tabell z'änneren.

Zum Beispill, loosst eis den Dësch huelen onheemlech. Mir kënnen berechent wéi engem Prozentsaz d'Käschte vun all Ticket bannent senger Kabine Klass war.

Fir dëst ze maachen, musse mir an all Linn d'Gesamtkäschte vun engem Ticket fir déi aktuell Kabineklass kréien, zu där den Ticket an dëser Linn gehéiert, dann deelt d'Käschte vun all Ticket duerch d'Gesamtkäschte vun all Ticketen vun der selwechter Kabineklass .

Fënster Funktiounen an R: tidyverse, dplyr

Fir nei Kolonnen derbäizefügen, ouni Zeilengruppéierung ze benotzen, an dplyr déngt Funktioun mutate().

Dir kënnt de Problem hei uewen beschriwwen léisen andeems Dir Daten no Feld gruppéiere kënnt Pclass a summéiert d'Feld an enger neier Kolonn Fueren. Als nächst, degruppéiert den Dësch an deelt d'Feldwäerter Fueren zu deem wat am virege Schrëtt geschitt ass.

Fënster Funktiounen an R: dplyr

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

Fënster Funktiounen an R: data.table

D'Léisung Algorithmus bleift déi selwecht wéi an dplyr, mir mussen den Dësch a Fënsteren no Feld opzedeelen Pclass. Ausgab an enger neier Kolonn de Betrag fir de Grupp, deen all Zeil entsprécht, a füügt eng Kolonn un an där mir den Undeel vun de Käschte vun all Ticket a senger Grupp berechnen.

Fir nei Sailen ze addéieren data.table Bedreiwer presentéieren :=. Drënner ass e Beispill fir e Problem mat dem Package ze léisen data.table

Fënster Funktiounen an R: data.table

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

Fënster Funktiounen am Python: pandas

Ee Wee fir eng nei Kolonn ze addéieren pandas - benotzt d'Funktioun assign(). Fir d'Käschte vun Ticketen no Kabineklass ze resuméieren, ouni Zeile ze gruppéieren, wäerte mir d'Funktioun benotzen transform().

Drënner ass e Beispill vun enger Léisung, an där mir un den Dësch bäidroen onheemlech déi selwecht 2 Saile.

Fënster Funktiounen am Python: pandas

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

Fonctiounen a Methoden Korrespondenz Dësch

Drënner ass eng Tabell vun der Korrespondenz tëscht Methoden fir verschidden Operatiounen mat Daten an de Packagen ze maachen déi mir berücksichtegt hunn.

Beschreiwung
uerdentlech
data.tabell
pandas

Lueden Daten
vroom()/ readr::read_csv() / readr::read_tsv()
fread()
read_csv()

Dateframes erstellen
tibble()
data.table()
dict() + from_dict()

Kolonnen auswielen
select()
Argument j, zweeter Positioun am Klammern
mir passéieren d'Lëscht vun erfuerderleche Spalten a véiereckege Klammeren / drop() / filter() / select_dtypes()

Filter Reihen
filter()
Argument i, éischt Positioun an véiereckege Klammeren
Mir lëschten d'Filterbedéngungen a véiereckege Klammeren / filter()

Gruppéierung an Aggregatioun
group_by() + summarise()
Argumenter j + by
groupby() + agg()

Vertikal Unioun vun Dëscher (UNION)
bind_rows()
rbind()
concat()

Horizontal Verbindung vun Dëscher (JOIN)
left_join() / *_join()
merge()
merge()

Basis Fënster Funktiounen an dobäi berechent Kolonnen
group_by() + mutate()
Argument j de Bedreiwer benotzen := + Argument by
transform() + assign()

Konklusioun

Vläicht am Artikel hunn ech beschriwwen net déi optimal Implementatioune vun der Dateveraarbechtung, also wäert ech frou sinn wann Dir meng Feeler an de Kommentarer korrigéiert oder einfach d'Informatioun am Artikel ergänzt mat aneren Techniken fir mat Daten am R / Python ze schaffen.

Wéi ech uewe geschriwwen hunn, war den Zweck vum Artikel net d'Meenung opzesetzen, wéi eng Sprooch besser ass, mee d'Méiglechkeet ze vereinfachen, béid Sproochen ze léieren, oder, wann néideg, tëscht hinnen ze migréieren.

Wann Dir den Artikel gär hutt, wäert ech frou sinn nei Abonnente op meng ze hunn YouTube и Telegramm Channels.

Poll

Wéi eng vun de folgende Packagen benotzt Dir an Ärer Aarbecht?

An de Kommentarer kënnt Dir de Grond fir Äre Choix schreiwen.

Nëmme registréiert Benotzer kënnen un der Ëmfro deelhuelen. Umellen, wann ech glift.

Wéi eng Dateveraarbechtungspaket benotzt Dir (Dir kënnt verschidden Optiounen auswielen)

  • 45,2%uerdentlech 19

  • 33,3%data.table14

  • 54,8%pandas 23

42 Benotzer hunn gestëmmt. 9 Benotzer hu sech enthalen.

Source: will.com

Setzt e Commentaire