Sådan køres Python i R

Så meget som jeg elsker R, er det klart, at Python også er et godt sprog - både til datavidenskab og almindelig computing. Og der kan være gode grunde til, at en R-bruger ønsker at gøre nogle ting i Python. Måske er det et fantastisk bibliotek, der endnu ikke har en R-ækvivalent. Eller en API, som du vil have adgang til, der har eksempelkode i Python, men ikke R.

Takket være R reticulate-pakken kan du køre Python-kode lige inden for et R-script - og videregive data frem og tilbage mellem Python og R.

Ud over reticulate skal du have Python installeret på dit system. Du har også brug for alle Python-moduler, pakker og filer, din Python-kode afhænger af.

Hvis du gerne vil følge med, skal du installere og indlæse netnet medinstall.packages ("reticulate") og bibliotek (reticulate).

For at holde tingene enkle, lad os starte med kun to linjer Python-kode for at importere NumPy-pakken til grundlæggende videnskabelig computing og oprette en matrix med fire tal. Python-koden ser sådan ud:

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

Og her er en måde at gøre det rigtigt på i et R-script:

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

Det py_run_string () funktion udfører uanset Python-kode inden for parenteser og anførselstegn.

Hvis du kører denne kode i R, kan det se ud som om der ikke skete noget. Intet vises i din RStudio-miljørude, og ingen værdi returneres. Hvis du løber udskriv (my_python_array) i R får du en fejl der min_python_array eksisterer ikke.

Men hvis du kører enPython udskriv kommando inde i py_run_string () funktion som f.eks

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

du skulle se et resultat.

Det bliver irriterende at køre Python-kode linje for linje som denne, hvis du har mere end et par linjer kode. Så der er et par andre måder at køre Python i R og reticulate.

Den ene er at placere al Python-koden i en almindelig .py-fil og bruge py_run_file () fungere. En anden måde, jeg kan lide, er at bruge et R Markdown-dokument.

R Markdown giver dig mulighed for at kombinere tekst, kode, koderesultater og visualiseringer i et enkelt dokument. Du kan oprette et nyt R Markdown-dokument i RStudio ved at vælge Filer> Ny fil> R Markdown.

Kodestykker starter med tre backticks (```) og slutter med tre backticks, og de har som standard en grå baggrund i RStudio.

Denne første del er til R-kode - det kan du se med r efter åbningsbeslaget. Det indlæser netværkspakken, og derefter angiver du den version af Python, du vil bruge. (Hvis du ikke angiver, bruger den din systemstandard.)

`` {r opsætning, inkluderer = FALSK, ekko = SAND}
bibliotek (reticulate)
use_python ("/ usr / bin / python")
```

Denne anden del nedenfor er til Python-kode. Du kan skrive Python, som du ville i en Python-fil. Koden nedenfor importerer NumPy, opretter en matrix og udskriver arrayet.

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

Her er den seje del: Du kan bruge den matrix i R ved at henvise til den som py $ my_python_array (generelt, py $ objektnavn).

I denne næste kodebit gemmer jeg det Python-array i en R-variabel kaldet min_r_array. Og så kontrollerer jeg klassen for den matrix.

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

Det er en klasse "array", som ikke er nøjagtigt, hvad du ville forvente for et R-objekt som dette. Men jeg kan gøre det til en almindelig vektor med as.vector (min_r_array) og kør de R-operationer, jeg gerne vil have på den, f.eks. gang hver artikel med 2.

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

Næste seje del: Jeg kan bruge den R-variabel tilbage i Python, som r.my_r_array (mere generelt, r.variablename), såsom

`` {python}
my_python_array2 = r.my_r_vector
udskriv (my_python_array2)
```

Hvis du gerne vil se, hvordan dette ser ud uden at konfigurere Python på dit system, skal du tjekke videoen øverst i denne historie.