Hvordan kjøre Python i R

Så mye som jeg elsker R, er det klart at Python også er et flott språk - både for datavitenskap og databehandling. Og det kan være gode grunner til at en R-bruker ønsker å gjøre noen ting i Python. Kanskje det er et flott bibliotek som ikke har en R-ekvivalent (ennå). Eller et API du vil ha tilgang til som har eksempelkode i Python, men ikke R.

Takket være R reticulate-pakken kan du kjøre Python-kode rett i et R-skript - og sende data frem og tilbake mellom Python og R.

I tillegg til retikulering trenger du Python installert på systemet ditt. Du trenger også Python-moduler, pakker og filer som Python-koden din er avhengig av.

Hvis du vil følge med, kan du installere og laste nettkorn medinstall.packages ("reticulate") og bibliotek (nettform).

For å holde ting enkelt, la oss starte med bare to linjer Python-kode for å importere NumPy-pakken for grunnleggende vitenskapelig databehandling og lage en matrise med fire tall. Python-koden ser slik ut:

importer nummen som np
my_python_array = np.array ([2,4,6,8])

Og her er en måte å gjøre det riktig i et R-skript:

py_run_string ("importer numpy som np")
py_run_string ("my_python_array = np.array ([2,4,6,8])")

De py_run_string () funksjon utfører hva Python-koden er innenfor parenteser og anførselstegn.

Hvis du kjører den koden i R, kan det se ut som ingenting skjedde. Ingenting vises i RStudio-miljøruten, og ingen verdi returneres. Hvis du løper skriv ut (my_python_array) i R får du en feil som my_python_array eksisterer ikke.

Men hvis du kjører enPython utskriftskommando inne i py_run_string () funksjon som

py_run_string ("for vare i min_python_array: utskrift (vare)")

du burde se et resultat.

Det kommer til å bli irriterende å kjøre Python-kode linje for linje som dette, skjønt, hvis du har mer enn et par linjer med kode. Så det er noen andre måter å kjøre Python i R og retikulere.

Den ene er å sette all Python-koden i en vanlig .py-fil, og bruke py_run_file () funksjon. En annen måte jeg liker er å bruke et R Markdown-dokument.

R Markdown lar deg kombinere tekst, kode, koderesultater og visualiseringer i et enkelt dokument. Du kan opprette et nytt R Markdown-dokument i RStudio ved å velge File> New File> R Markdown.

Kodebiter starter med tre backticks (```) og avsluttes med tre backticks, og de har som standard en grå bakgrunn i RStudio.

Denne første delen er for R-kode - du kan se det med r etter åpningsbraketten. Den laster retikulatpakken, og deretter spesifiserer du versjonen av Python du vil bruke. (Hvis du ikke spesifiserer det, bruker det systemets standard.)

`` {r setup, include = FALSE, echo = TRUE}
bibliotek (nettform)
use_python ("/ usr / bin / python")
```

Denne andre delen nedenfor er for Python-kode. Du kan skrive Python som du ville gjort i en Python-fil. Koden nedenfor importerer NumPy, oppretter en matrise og skriver ut matrisen.

`` {python}
importer nummen som np
my_python_array = np.array ([2,4,6,8])
for varen i my_python_array:
skrive ut (vare)
```

Her er den kule delen: Du kan bruke den matrisen i R ved å referere til den som py $ my_python_array (generelt, py $ objektnavn).

I denne neste kodebiten lagrer jeg den Python-matrisen i en R-variabel kalt min_r_array. Og så sjekker jeg klassen til den matrisen.

`` {r}
my_r_array <- py $ my_python_array
klasse (min_r_array)
``

Det er en klasse "array", som ikke er akkurat hva du forventer for et R-objekt som dette. Men jeg kan gjøre det om til en vanlig vektor med as.vector (min_r_array) og kjør hvilke R-operasjoner jeg ønsker på den, for eksempel å multiplisere hvert element med 2.

`` {r}
my_r_vector <- as.vector (py $ my_python_array)
klasse (min_r_vektor)
min_r_vector <- min_r_vector * 2
```

Neste kule del: Jeg kan bruke den R-variabelen tilbake i Python, som r.my_r_array (mer generelt, r.variablename), som for eksempel

`` {python}
my_python_array2 = r.my_r_vector
skriv ut (my_python_array2)
```

Hvis du vil se hvordan dette ser ut uten å konfigurere Python på systemet ditt, kan du sjekke ut videoen øverst i denne historien.