You are on page 1of 100

Bevezets az R-be

Oktatsi segdlet VZLAT 0.2

Abari Klmn
DE, Pszicholgiai Intzet
abari.kalman@gmail.com

Bevezets az R-be - 2013.09.16.

Tartalomjegyzk
Tartalomjegyzk ......................................................................................................................... 2
Elsz ......................................................................................................................................... 4
1. Bevezets ................................................................................................................................ 5
1.1. Mi az R? .......................................................................................................................... 5
1.2. Az R teleptse ................................................................................................................ 5
1.3. Munkafolyamat (session) az R-ben ................................................................................. 5
1.4. Az R parancssoros hasznlata ......................................................................................... 6
1.5. Szkriptek vgrehajtsa..................................................................................................... 7
1.6 A csomagok hasznlata .................................................................................................... 8
1.7. Segtsg az R hasznlathoz ............................................................................................ 9
2. Az R alapjai .......................................................................................................................... 11
2.1. Szmols az R-ben ........................................................................................................ 11
2.2. Objektumok ................................................................................................................... 13
2.2.1. rtkads ................................................................................................................ 13
2.2.2. Objektumok elnevezse.......................................................................................... 14
2.3. Fggvnyek ................................................................................................................... 15
2.4. Adattpusok az R-ben .................................................................................................... 18
2.4.1. Karakteres adatok ................................................................................................... 18
2.4.2. Logikai adatok ........................................................................................................ 20
3. Adatszerkezetek ................................................................................................................... 22
3.1 Vektorok ......................................................................................................................... 22
3.1.1. Vektorok ltrehozsa .............................................................................................. 22
3.1.2. Mveletek vektorokkal ........................................................................................... 26
3.1.3. Fggvnyek vektorokkal ........................................................................................ 27
3.1.4. Az NA hinyz rtk .............................................................................................. 28
3.1.5. Az Inf s a NaN ...................................................................................................... 28
3.1.6. Objektumok attribtumai ....................................................................................... 29
3.1.7. Vektorok indexelse ............................................................................................... 30
3.1.8. Vektorok rendezse ................................................................................................ 33
3.1.9. Elre definilt objektumok, nevestett konstansok ................................................ 34
3.2. Faktorok ........................................................................................................................ 34
3.3. Mtrixok s tmbk ...................................................................................................... 36
3.3.1 Szmtsok a mtrix soraiban s oszlopaiban ......................................................... 40
3.3.2 Sorok s oszlopok kezelse ..................................................................................... 43
3.5 Listk .............................................................................................................................. 44
3.5 Adattblk (dataframes) ................................................................................................. 47
3.5 Idsorok .......................................................................................................................... 49
4. Adatok olvassa s rsa ....................................................................................................... 50
4.1. Adatok beolvassa ......................................................................................................... 50
4.1.1.A c() s a scan() fggvnyek ................................................................................... 50
4.1.2. A read.table() csald ............................................................................................... 52
4.1.3. A read.fwf() fggvny ............................................................................................ 52
4.1.4. Binris llomnyok olvassa .................................................................................. 53
4.1.5. Adatbzisok elrse ................................................................................................ 53
4.2. Adatok kirsa ............................................................................................................... 53
4.2.1. A cat() fggvny..................................................................................................... 54
4.2.2. A write.table() csald ............................................................................................. 54

Bevezets az R-be - 2013.09.16.

5. Adattblk kezelse .............................................................................................................. 55


5.1. Adattblk ltrehozsa .................................................................................................. 56
5.2. Adattblk indexelse.................................................................................................... 57
5.3. A with() s az attach() ................................................................................................... 59
5.4. Sorok s oszlopok nevei ................................................................................................ 60
5.5. Rendezs........................................................................................................................ 61
5.5. Adattbla szrse ........................................................................................................... 62
5.6. Hinyz rtkeket tatalmaz sorok eltvoltsa ............................................................ 63
5.7. Adattbla oszlopainak transzformlsa ......................................................................... 64
6. Grafika az R-ben .................................................................................................................. 67
6.1. Grafikus eszkzk ......................................................................................................... 67
6.2. Az eszkzfellet felosztsa ........................................................................................... 68
6.2. Az eszkzfellet rszei .................................................................................................. 70
6.3. Magas-szint rajzfggvnyek ....................................................................................... 74
6.3.1. A plot() fggvny ................................................................................................... 74
6.3.2. A curve() fggvny ................................................................................................ 78
6.3.3. A hist() fggvny ................................................................................................... 79
6.3.4. A boxplot() fggvny ............................................................................................. 81
6.3.5. A pie() fggvny .................................................................................................... 81
6.3.6. A barplot() fggvny .............................................................................................. 82
6.4. Alacsony-szint rajzfggvnyek ................................................................................... 83
6.4.1. Szveg elhelyezse ..................................................................................................... 83
6.4.2. Pontok, vonalak .......................................................................................................... 85
6.4.3. Tglalapok, poligonok, nyilak .................................................................................... 87
6.4.4. Egyb kiegsztk ...................................................................................................... 89
6.5. Interaktv grafikus fggvnyek ..................................................................................... 92
6.5. Trellis grafika ................................................................................................................ 94
6.6. A ggplot2 grafika .......................................................................................................... 94
7. Matematika az R-ben ........................................................................................................... 95
7.1. Eloszlsok...................................................................................................................... 95
Irodalomjegyzk ....................................................................................................................... 98
R feladatok ............................................................................................................................... 99
Alapok .................................................................................................................................. 99
Egyb adatszerkezetek ......................................................................................................... 99
Megoldsok ............................................................................................................................ 100
Alapok ................................................................................................................................ 100
Egyb adatszerkezetek ....................................................................................................... 100

Bevezets az R-be - 2013.09.16.

Elsz
E jegyzet clja az R nyelv s krnyezet elsajttsnak segtse. A jegyzetet elssorban a
kezd R felhasznlknak ajnljuk. A lertak megrtshez a kzpiskolai matematikn tl
semmilyen elzetes ismeret nem szksges.
A jegyzetben az R 2.6.2-es (2008-02-08) verzijnak Windows platformra sznt
vltozatt hasznljuk a pldk vgrehajtshoz. Ez semmifajta megszortst nem jelent, a
hasznlt parancsok a ksbbi verzikban s az egyb platformokon (Linux, Mac OS X) fut R
pldnyokban is ugyangy hasznlhatk.
rmmel
fogadjuk
az
Olvasink
abari.kalman@gmail.com cmre vrjuk.

szrevteleit,

amelyeket

az

Bevezets az R-be - 2013.09.16.

1. Bevezets
1.1. Mi az R?
Az R egy magas szint programozsi nyelv s krnyezet, melynek legfontosabb felhasznlsa
az adatelemzs s az ahhoz kapcsold grafikus megjelents.
Az R nyelv egy interpretlt szkript nyelv, azaz az utastsainkat nem fordthatjuk le futtathat
binris llomnny, hanem a vgrehajtand parancsokat az R egyesvel rtelmezi (ellenrzi a
parancs szablyossgt, ha megfelelnek tallja rgtn vgrehajtja). Az R program
legfontosabb rsze teht az R-rtelmez (interpreter), amely a parancsok vgrehajtsrt
felels.
Az R-interpreterhez ktfle mdon juttathatunk parancsot, vagy interaktvan, az egyes
parancsok begpelsvel, vagy ktegelten n. szkript mdban, elre sszegyjttt
parancsok formjban.
A parancsok eredmnye megjelenhet a terminlban, llomnyokban vagy adatbzisokban is,
de grafikus megjelentsre is van lehetsgnk.
A legegyszerbb alapmveletektl kezdve a bonyolult statisztikai eljrsokig nagyon sokfle
mvelet hajthat vgre az R-ben. Az egyes mveletek eredmnyeit n. objektumokban
trolhatjuk. A mveletek pedig n. opertorok s fggvnyek formjban jelennek meg az Rben.
Az R szmos beptett fggvnyt bocst a felhasznlk rendelkezsre, de szmos kiegszts
is kszlt az R-hez, melyeket n. csomagok (package) formjban rhetnk el. A csomag
fggvnyeket s objektumokat tartalmazhat, amelyeket a csomag teleptsvel s betltsvel
tehetnk elrhetv.

1.2. Az R teleptse
Els kzeltsben gondoljunk az R-re, mint egy tbbplatformos alkalmazsra, vagyis egy
olyan programra, amely futtathat Windows, Linux s Mac OS X opercis rendszereken is.
Az R szabad szoftver, teht btran letlthetjk a kedvenc opercis rendszernknek megfelel
telept pldnyt az R hivatalos oldalrl (http://www.R-project.org), majd, mint egy
kznsges alkalmazst, a szoksos mdon telepthetjk a szmtgpnkre.
A Windows opercis rendszerekre sznt verzi rszletes teleptse megtallhat [1]ben, a 80-84. oldalon.

1.3. Munkafolyamat (session) az R-ben


Az R program (rendszer) sikeres teleptse utn az R futtatsa, a megfelel platform binris
llomnynak elindtst jelenti. A Windows opercis rendszerekben ez tbbnyire az
Asztalon lv R ikon segtsgvel lehetsges.
Az R indtsa utn a terminl vagy konzol ablakban megjelenik a program
verziszma s a kiadsi dtuma. J gyakorlat lehet, ha rendszeresen elltogatunk az R
hivatalos oldalra, ahonnan az R aktulis pldnynak a letltsvel mindig az R legfrissebb
pldnyt hasznlhatjuk. rdemes az j pldny teleptse eltt, a rgi vltozatot eltvoltani a
szmtgpnkrl. gyeljnk arra, hogy az R frisstse utn a csomagokat jra kell telepteni.
Fontos lehet az R-el vgzett munkink publiklsnl, hogy hogyan hivatkozzunk erre
a programra. Az R indtsa utn, a megjelen fejrszbl ez is kiolvashat.

Bevezets az R-be - 2013.09.16.


> citation()

Az R indtsa s lelltsa kztti rsz egy munkafolyamatot (session) hatroz meg. A


munkafolyamat sorn ltrehozott objektumokat (lsd. ksbb) az R nv szerint trolja. A
ltrehozott objektumok egyttest munkaterletnek (workspace) nevezzk. A
munkafolyamathoz tartozik egy munkaknyvtr (working directory) is. Ez a knyvtr az
alaprtelmezett knyvtr abban az esetben, ha a parancsok megadsnl nem hasznlunk
knyvtrhivatkozst.
A Windows opercis rendszerekben az R ikonhoz tartoz Indts helye mez hatrozza
meg az alaprtelmezett munkaknyvtrt. A munkaknyvtr az R-ben lekrdezhet, ill.
bellthat a getwd() s a setwd() parancsok kiadsval.
> getwd()
[1] "C:/Documents and Settings/Abari Klmn/Dokumentumok"
> setwd("C:/Documents and Settings/Abari Klmn/Dokumentumok/peldak")

A munkaknyvtr jelentsgt tovbb nveli, hogy az R indtsakor ebben a knyvtrban 2


llomny ltezst figyeli:

.Rhistory (a visszahvhat parancsokat tartalmaz szveges llomny)

.RData (a trolt objektumokat tartalmaz binris llomny).

A fenti llomnyok ugyanis betltsre kerlnek az R indtsakor, ha azokat az R megtallja a


munkaknyvtrban. gy ezek utn az .Rhistory llomnybl jv parancsok kztt
vlogathatunk a parancssor hasznlata sorn, ill. az .RData llomnyban trolt objektumok
azonnal elrhetek, azaz lesz egy indul munkaterletnk.
Ezeket az llomnyokat legtbbszr az R-bl val kilps sorn, maga a rendszer hozza ltre,
ehhez csak igennel kell vlaszolnunk a munkaterlet mentsre vonatkoz krdsre.
Azonban a fentiekhez hasonl szerkezet llomnyokat mi is ltrehozhatunk a munknk
sorn. A parancsok trtnett tartalmaz szveges llomny a loadhistory() s a
savehistory() parancsokkal tlthet be s rhat ki. A trolt objektumokat a load() s a
save() vagy save.image() parancsok tltik be s rjk ki.
A munka(folyamat) befejezse a quit() vagy q() parancsok kiadsval lehetsges.

1.4. Az R parancssoros hasznlata


Az R program indtsa utn a terminlban vagy a konzol ablakban megjelen > (nagyobb
jel) jelzi szmunkra, hogy az R vrja a parancsainkat. Ez az n. prompt, amely utn egy
tetszleges karaktersorozat begpelsre van lehetsgnk. A begpelt parancsot az ENTER
billentyvel kldjk el az R rtelmeznek, amely ha mindent rendben tall a
parancsunkban, akkor vgrehajtja azt.
> 1+2
[1] 3

A parancssort piros sznezssel emeljk ki a jegyzetben, az R vlaszt a begpelt parancsra


kk sznnel jelljk.
Nem minden parancs ad vlaszt az R-ben.
> x<-0

Bevezets az R-be - 2013.09.16.

St, az is elfordulhat, hogy az R nem tallt valamit rendben a parancsban. Ekkor


termszetesen nem hajtja/hajthatja vgre a begpelt sort, helyette hibt (error) jelez.
> Ez nem lesz j.
Error: unexpected symbol in "Ez nem"

Hosszabb, bonyolult parancsok gpelsnl gyakran elfordul, hogy nem teljes a begpelt
parancs, valami mg hinyzik belle (pl. egy zr kerek zrjel). Ezt az R szreveszi s az
ENTER megnyomsa utn egy + prompt megjelentsvel jelzi ezt szmunkra. A +
prompt utn van lehetsgnk a hinyz rszek ptlsra, majd ha kszen vagyunk az
ENTER billentyvel az sszes eddig mg vgre nem hajtott sort elkldhetjk az
rtelmeznek.
> paste("Ez mr",
+ "j"
+ )
[1] "Ez mr j"

Ha nem talljuk a hinyz rszt a parancsunkban, akkor az R-nek ezen knyelmi funkcija
oda vezethet, hogy rkk + promptot kapjuk az ENTER megnyomsa utn. Ezt a helyzetet
hivatott megoldani az ESC billenty, mellyel megszakthatjuk az rtelmezt, azaz ebben a
szituciban egy j sort, immr egy > prompttal kezdd (res) sort kapunk a konzol
ablakban.
Az R parancssoros hasznlatt mg tovbbi 2 dolog teszi knyelmesebb. Egyrszt a
korbban vgrehajtott parancsainkat (history) visszahvhatjuk, lapozhatunk bennk elre,
htra. Erre a FEL/LE NYL billentykkel van lehetsgnk. Termszetesen, az gy
visszahvott parancsot tetszleges mdon tszerkeszthetjk: naviglhatunk a sorban elre
htra, beszrhatunk/trlhetnk karaktereket vagy hasznlhatjuk a vgasztal
billentyparancsait. A visszahvott s mdostott parancsot az ENTER segtsgvel jra
vgrehajthatjuk, s ehhez mg a sor vgre sem kell a szvegkurzort pozcionlni, az a sorban
tetszleges helyen llhat, az R mgis a teljes sort fogja rtelmezni.
A msik knyelmi lehetsg a TAB billenty hasznlata, amellyel az elkezdett, mg
be nem fejezett sorokat egszthetjk ki. Ha egy sort tbbflekppen is kiegszthet az R,
akkor egy listt kapunk a lehetsgekrl, amelyet tovbbgpelssel szkthetnk, ha pedig
csak egyetlen szba jhet befejezse van a begpelt karaktereknek, akkor a TAB
megnyomsa utn ezzel a rsszel kiegszl az elkezdett sorunk. gy nemcsak egyszeren
gpelst, ill. idt takarthatunk meg, hanem pl. tjkozdhatunk a korbban ltrehozott
objektumok nevrl vagy az elrhet fggvnyek nvrl s paramtereirl is.
Az objektum, a fggvnyek s az egyb ebben a fejezetben homlyosan hagyott
fogalmak definciit a jegyzet ksbbi rszeiben rszletesen trgyaljuk.

1.5. Szkriptek vgrehajtsa


Az R-t nemcsak interaktvan, parancsok egyms utni begpelsvel hasznlhatjuk, hanem
n. szkript mdban is. A vgrehajtand parancsokat sszegyjtjk s egy szveges
llomnyban eltroljuk (pl. parancsok.R), majd az sszes parancsot egyetlen sor
begpelsvel elkldjk az rtelmeznek.
> source("parancsok.R")

Bevezets az R-be - 2013.09.16.

A fenti parancs felttelezi, hogy a szkript llomny (parancsok.R) az R krnyezet


munkaknyvtrban van, ha esetleg ms knyvtrban tallhat, akkor az elrsi utat is meg
kell adnunk.

1.6 A csomagok hasznlata


Az R indtsa utn nhny csomag automatikusan betltsre kerl. Ezeket a csomagokat s az
egyb krnyezeteket listzhatjuk ki a search() fggvnnyel.
> search()
[1] ".GlobalEnv"
"package:stats"
[4] "package:grDevices" "package:utils"
[7] "package:methods"
"Autoloads"

"package:graphics"
"package:datasets"
"package:base"

A fenti eredmnyben a package karaktersorozattal kezdd elemek mutatjk, hogy melyek


az alaprtelmezs szerint betlttt csomagok. A korbban teleptett csomagok betltshez
hasznljuk a library() fggvnyt.
> library(foreign)
> search()
[1] ".GlobalEnv"
[4] "package:graphics"
[7] "package:datasets"
[10] "package:base"

"package:foreign"
"package:stats"
"package:grDevices" "package:utils"
"package:methods"
"Autoloads"

A fenti pldban a foriegn csomag betltst s annak hatst kvethetjk nyomon. Ezutn a
csomagban lv fggvnyeket s objektumokat a parancsainkban felhasznlhatjuk.
Egy adott csomagban (esetnkben a foreign csomagban) lv fggvnyek s objektumok a
> library(help=foreign)

vagy a
> help(package=foreign)

paranccsal krdezhetk le. Betlttt csomagok esetben hasznlhatjuk az


> ls("package:foreign")

parancsot is. Betlttt csomagot a


> detach(package:foreign)

paranccsal tvolthatunk el a krnyezetbl.


Szmtgpnkre az install.packages() fggvnnyel telepthetnk csomagokat. A grafikus
felhasznli felletet (is) tartalmaz Rcmdr csomagot az
> install.packages("Rcmdr")

paranccsal telepthetnk szmtgpnkre. A fggvny mkdshez Internet kapcsolatra van


szksg.

Bevezets az R-be - 2013.09.16.

1.7. Segtsg az R hasznlathoz


Az R hasznlathoz szmos segtsget tallunk az Interneten s a teleptett R pldnyunkban
egyarnt. Az online segtsgek kzl elssorban a http://cran.r-project.org cmen olvashat R
dokumentcikat emeljk ki, ahol tbb tucat, elssorban angol nyelv lerst tallunk az R
megismershez. Errl az oldalrl tlthet le, az Irodalomjegyzkben [1] alatt szerepl
magyar nyelv lers is. Az R npszersgnek ksznheten, nagyon sok tovbbi
dokumentcit, tutorilt s pldt tallhatunk, ha az internetes kereskhz fordulunk.
Az R krnyezetben tovbbi lehetsgek llnak rendelkezsre. Az R megismerst kezdhetjk
a
> help.start()

paranccsal, ahol szmos, az R nyelvet rszletesen trgyal dokumentum kzl vlaszthatunk.


Ha csak egyetlen fggvnnyel kapcsolatban szeretnnk segtsget krni, akkor
hasznlhatjuk a beptett sgrendszer parancsait. Adjuk ki a
> help(t.test)

vagy a rvidebb
> ?t.test

parancsot, ha a t.test() fggvnyrl szeretnnk rszletes lerst kapni. Abban az esetben ha


nem ismerjk teljesen a fggvny nevt, hasznlhatjuk a
> help.search("test")

parancsot, ekkor az sszes olyan fggvnyt kilistzhatjuk, amelynek a nevben vagy a


lersban a test karaktersorozat elfordul.
Hasznos lehet tovbb a find() parancs, amely elrulja, hogy az illet fggvny
melyik mr betlttt csomagban foglal helyet.
> find("aov")
[1] "package:stats"

A fenti pldbl kiolvashat, hogy az aov() fggvny a stats csomagban tallhat.


Ugyancsak a betlttt csomagokban vgez keresst az apropos() fggvny, amellyel
lehetsg van a parancssorbl elrhet fggvnyek vagy objektumok nevben keresni.
> apropos("aov")
[1] ".__C__aov"
[4] "eff.aovlist"
[7] "summary.aovlist"

".__C__maov"
"aov"
"model.frame.aovlist" "summary.aov"
"terms.aovlist"
"TukeyHSD.aov"

Tovbb segtheti az egyes fggvnyek hasznlatnak elsajttst az example() parancs,


amely az egyes fggvnyek hasznlatra mutat pldt.
> example(t.test)

Utols lehetsgknt ejtsnk szt a demo() fggvnyrl, amellyel olyan beptett szkripteket
futtathatunk, amelyek az R tudst, erejt hivatottak demonstrlni. Prbljuk ki a

Bevezets az R-be - 2013.09.16.


>
>
>
>

demo(graphics)
demo(persp)
demo(plotmath)
demo(Hershey)

parancsokat.
Kzssgi oldalakon tartalom alapjn kereshetnk az RSiteSearch() fggvny segtsgvel:
> RSiteSearch("repeated measures")

R-rel kapcsolatos webes tartalmat a http://www.rseek.org/ cmen kerestetnk.

10

Bevezets az R-be - 2013.09.16.

2. Az R alapjai
2.1. Szmols az R-ben
Kezdjk az R nyelv megismerst egy egyszer sor begpelsvel.
> 2+2
[1] 4

Az ENTER megnyomsa utn a konzolban lthatjuk az sszeads eredmnyt a 4-et. Az


eredmny eltt egy szgletes zrjelben lv sorszmot is lthatunk ([1]), amely bonyolultabb
eredmnyekben segt eligazodni. Ksbb visszatrnk ennek az rtelmezsre.
Ltjuk, ebben az esetben az R gy viselkedik, mint egy szmolgp. A parancssorba
gpelt algebrai kifejezs rtkt kiszmolja s a kpernyn megjelenti. Termszetesen az
sszeadson tl ms mveletet is hasznlhatunk.
> 4+6*2
[1] 16

A fenti pldbl lthat, hogy az R kveti a mveletek elvgzsnek matematikban


megszokott sorrendjt. Azaz a szorzs mvelet (*) hamarabb hajtdik vgre, ennek
eredmnye 12. Ezt kveti az sszeads (+) most mr a 4 s a 12 kztt. Ennek az sszeads
mveletnek az eredmnye (16), ami egyben a kifejezs rtke is, teht ez jelenik meg a
konzolban.
> (4+6)*2
[1] 20

Termszetesen a matematikban megszokott mdon vltoztathatunk a mveletek


vgrehajtsnak alaprtelmezett sorrendjn, hasznlhatunk kerek zrjeleket. Ezeket az R a
megszokott mdon rtelmezi: a zrjelben szerepl mveletek vgrehajtst elreveszi. A
fenti pldban teht az sszeads mvelet lesz az els, amelynek az eredmnye 10. Ezt kveti
a szorzs, gy kapjuk a kifejezs rtkeknt a 20-at.
Ezeket a matematikban megszokott algebrai kifejezseket, az R-ben egyszeren
kifejezsnek vagy utalva arra, hogy a kifejezs rtke szm aritmetikai kifejezsnek
neveznk. Az eddigiek alapjn az aritmetikai kifejezsek teht a kvetkez nyelvi elemeket
tartalmazhatjk:

szmok, amelyeket az R numerikus konstansnak nevez,


mveleti jelek, melyeket az R-ben aritmetikai opertornak neveznk,
s kerek zrjelek.

Az R a parancssorba rt kifejezsek rtkt kiszmolja kirtkeli a kifejezst s a kapott


rtket megjelenti.
A numerikus konstansok tbbfle alakban is megjelenhetnek az R-ben.
Numerikus konstans formja az Rben

rtke

1, -1, 2, 100, 3.5, .4

1, -1,
0.4

1L, -1L, 2L, 100L

1, -1, 2, 100

11

Lers
2,

100,

3.5,

pozitv s negatv egsz


s nem egsz szmok
pozitv s negatv egsz

Bevezets az R-be - 2013.09.16.

szmok az L suffix
hasznlatval
1.2e3, 3e+4, .6e-2, 4e1L

1200, 30000, 0.006, 40

exponencilis
alak
egsz s nem egsz
szmok

0xef, 0Xf01, 0xEf03, 0xd1L

239, 3841, 61187, 209

hexadecimlis (16-os
szmrendszerben felrt
szmok)

Az R-ben hasznlhat aritmetikai opertorokat a precedencia cskken sorrendjben a


kvetkez tblzat tartalmazza.
Opertor formja

Mvelet

Plda

Plda eredmnye

^ (vagy **)

hatvnyozs

+ - (unris)

eljelek

%% %/%
* /

maradkos oszts s egsz


oszts
szorzs s oszts

+ - (binr)

sszeads s kivons

2^3
2**3
+3.3
-.5
13%%4
15%/%4
2*3
4 / 2
2 + 3
2 - 3

8
8
3.3
-.5
1
3
6
2
5
-1

A fentiek alapjn sszetettebb aritmetikai kifejezseket is megfogalmazhatunk az R


parancssorban.
> 4^2-3*2
[1] 10
> (56-14)/6-4*7*10/(5**2-5)
[1] -7

Az aritmetikai kifejezsek hasznlata sorn ne felejtkezznk meg az opertorok


precedencijrl sem.
> -2^2
[1] -4
> (-2)^2
[1] 4

Itt a hatvnyozs s az eljel opertor kztti vgrehajtsi sorrend okozza az eltr


eredmnyeket.
Eddig lthattuk, hogy kifejezseinket opertorok, szmok s zrjelek segtsgvel
ptettk fel. Ezek a kifejezsek kt rszletkben is ltalnosthatk: (1) egyrszt a kifejezs
adat rszben, amelyet eddig a numerikus konstansok kpviseltek, (2) msrszt a kifejezs
mveleti rszben, amelyet eddig az opertorok jelentettek meg. Az adatrsz ltalnostsa az
objektum a mveletek pedig a fggvny. Ezeket tekintjk t a kvetkezkben.

12

Bevezets az R-be - 2013.09.16.

2.2. Objektumok
Ha egy kifejezs rtket nem egyszeren a kpernyn szeretnnk megjelenteni, hanem azt
ksbb is fel akarjuk hasznlni, akkor objektumokat kell ltrehoznunk. A memriban trolt
adatok elrsre az R-ben objektumokon keresztl lehetsges. (Ms nyelvekben ezt
vltoznak vagy szimblumnak nevezik, ha nem okoz flrertst, akkor mi is hasznlhatjuk
ezeket az elnevezseket.)
> 117/11+2^3
[1] 18.63636

Tudjuk, ha a fenti aritmetikai kifejezst a parancssorba rjuk, az R miutn kirtkelte a


kifejezst, a kifejezs rtkt a megjelenti a konzolban. Ez az rtk azonban a megjelents
utn rgtn el is vsz.
> x <- 117/11+2^3

Ha azonban ltrehozunk egy x nev objektumot a fenti mdon, akkor ezt az rtket tovbbi
kifejezsekben is szerepeltethetjk. Egyszeren azokon a helyeken, ahol eddig szmok
jelentek meg a kifejezsben, oda ez az x objektumnv is berhat.
rhatjuk teht a kvetkezket:
> x+2
[1] 20.63636
> 2*x^3+5
[1] 12950.34

Minden objektumnak van neve s tartozik hozz a memriban egy terlet, ahol a krdses
rtk trolsra kerl. Esetnkben az objektum neve x a hozz tartoz memriaterleten pedig
a 18.63636 rtket trolja az R.
Az objektumok kezelse az R-ben alapveten 3 dolgot jelent: (1) az objektum
ltrehozsa, (2) az objektum rtknek lekrdezse s (3) az objektum rtknek
megvltoztatsa. (Ksbb ltjuk, mi mindent tehetnk mg az objektumokkal.)

2.2.1. rtkads
Objektumot rtkadssal hozhatunk ltre. Az rtkads tartalmaz egy rtkads opertort,
melynek alakja <-, vagyis egy kisebb jel s egy mnusz eljel egyms utn rva szkz
nlkl. (Tovbbi rtkad opertorok a ->, <<-, ->> s a =. Ezekrl ksbb lesz sz.)
Az rtkads ltalnos alakja: objektumnv <- kifejezs. Ahol lehet a tovbbiakban
ezt a balra nyl alak rtkad opertort hasznljuk az rtkads sorn. Az egyszersg
kedvrt a balra nyl eltt lv objektumnevet az rtkads bal oldalnak, az utna lv
kifejezst az rtkads jobb oldalnak nevezzk.
Ha nem ltez objektumnevet szerepeltetnk az rtkadsban, akkor az R ltrehoz egy ilyen
nev j objektumot, a hozz tartoz memriaterleten pedig az rtkads jobb oldaln lv
kifejezs kirtkelse utn kapott rtket trolja el.
> a <- 1+2

13

Bevezets az R-be - 2013.09.16.

Fent, a korbban nem ltez a objektumot hoztuk ltre. Az rtkads utn a mr ltez
objektum, gy a munkafolyamatunk munkaterlethez tartozik.
Ha az rtkadsban hasznlt objektumnv mr ltezik, akkor a jobb oldali kifejezs
kirtkelse utn a kapott rtkkel fellrja a bal oldali objektumhoz tartoz memriaterletet.
Ezzel a mdszerrel teht korbban ltrehozott objektum rtkt mdosthatjuk.
> a <- 10/3

Most teht a mr ltez a objektum rtkt vltoztattuk meg.


Az objektum memriban trolt rtkt le is krdezhetjk. A legegyszerbb md erre, ha az
objektum nevt a parancssorba rjuk
> a
[1] 3.333333

Objektumot azonban kifejezsekben is felhasznlhatjuk, akr rtkads jobb oldaln lv


kifejezsben is.
> a*3
[1] 10
> a <- 4+a*3
> a
[1] 14

2.2.2. Objektumok elnevezse


Az objektumok elnevezsre az angol bc kis s nagy betit, a szmjegyeket s a pont (.)
illetve az alhzs (_) szimblumokat hasznlhatjuk. Az objektum neve csak betvel vagy
ponttal kezddhet, de ez utbbi esetben a kvetkez karakternek betnek kell lennie.
Hagyomnyosan a pont karaktert hasznlhatjuk az objektumnevek tagolsra. Az R a magyar
kezetes karakterek hasznlatt is megengedi az objektumnevekben, de csakgy mint az
llomnyok elnevezsben, rdemes ezek hasznlatt mellzni.
Az objektumoknak rdemes beszdes nevet vlasztani, mg ha ennek az ra nmi extra
gpels is. (Tudjuk, a TAB billenty ezen segthet.)
Az R kis- s nagybet rzkeny, vagyis az x s a X klnbz objektumoknak szmtanak.
Pldul a kvetkez
> pulzus.atlag <- 72.86

parancs utn a
> Pulzus.atlag
Error: object "Pulzus.atlag" not found

sor hibt jelez, azaz a Pulzus.atlag objektumot nem tallja az R. Minden olyan esetben, ha
nem ltez objektumra hivatkozunk, a fenti hibazenet jelenik meg a konzolban.
> Pulzus.atlag <- 69.37
> pulzus.atlag; Pulzus.atlag
[1] 72.86
[1] 69.37

# j objektumot hozunk ltre

14

Bevezets az R-be - 2013.09.16.

A fenti pldban mr gondoskodtunk a nagy P-vel kezdd objektumrl is, gy lehetsgnk


van hibazenet nlkl mindkt objektum rknek kiratsra.
Ez a plda kt tovbbi apr jdonsgot is tartalmaz.
Megjegyzst az R-ben a ketts kereszt (#) karakter hasznlatval vezetnk be, az R
rtelmez a ketts kereszttl a sor vgig tart rszt figyelmen kvl hagyja. Itt helyezhetjk
el a paranccsal kapcsolatos magyarzatainkat magunk vagy a kdot ksbb olvask szmra.
Tovbb, ha a parancssorban tbb utastst szeretnnk elhelyezni, akkor ezeket
pontosvesszvel (;) kell elvlasztanunk. Ezeket az utastsokat az R rtelmez egyms utn,
balrl jobbra haladva hajtja vgre, mintha kln sorba rtuk volna ket.

2.3. Fggvnyek
Az aritmetikai kifejezseinkben hasznlhat opertorok nem teszik lehetv minden
matematikai mvelet elvgzst. Mit tegynk, ha a 2 ngyzetgykt szeretnnk kiszmolni? A
ngyzetgykvons opertor nem ltezik az R-ben, de ebben a specilis esetben a hatvnyozs
opertor segtsgvel elrhetjk a clunkat.
> 2^0.5
[1] 1.414214

Az R azonban ms lehetsget is biztost a ngyzetgyk kiszmtsra s ez az sqrt()


fggvny hasznlata.
> sqrt(2)
[1] 1.414214

A fggvnyek valamilyen utastssorozatot hajtanak vgre s a szmts eredmnyt


szolgltatjk. Esetnkben az sqrt() fggvny egy szm ngyzetgykt szmolja ki,
mghozz annak a szmnak a ngyzetgykt, amely a kerek zrjelek kztt szerepel. Teht
az R a paramterben megadott 2 rtkre meghvja az sqrt() fggvnyt, ami visszatr a 2
ngyzetgykvel.
A R szmos beptett fggvny hvst teszi lehetv. A fggvnyhvs ltalnos alakja
fggvnynv(arg1, arg2, , argN).
A fggvny neve ugyanazoknak a szablyoknak engedelmeskedik, amelyeket az objektumok
nevnl megtrgyaltunk (lvn a fggvny is egy objektum, lsd. ksbb). A fggvny neve
utn kerek zrjelben kvetkeznek a fggvny argumentumai, amelyek a fggvny
utastsainak a bemen paramterei. A fggvny a bemen paramterek alapjn az
utastsainak megfelelen egy visszatrsi rtket fog szolgltatni.
Egy fggvny hvsainl elfordul argumentumok szma s azok sorrendje igen vltozatos
kpet mutathat. Elljrban elmondhatjuk, hogy a fggvnyek argumentumai alaprtelmezett
rtkkel rendelkezhetnek, gy ezek az argumentumok elhagyhatk. Tovbb, a fggvnyek
argumentumai nvvel is rendelkeznek, amelyeket ha a fggvny hvsnl felhasznljuk, az
argumentumok sorrendje hvsnl trendezhet.
Elszr tekintsk t az R alapvet matematikai fggvnyeit.
Fggvny

Lers

Plda

Plda rtke

abs(x)

abszoltrtk fggvny

abs(-1)

sign(x)

eljel fggvny

sign(pi)

15

Bevezets az R-be - 2013.09.16.

sqrt(x)

ngyzetgyk fggvny

sqrt(9+16)

exp(x)

exponencilis fggvny

exp(1)

2.718282

log(x)

termszetes alap logaritmus

log(exp(3))

log(x,base)

tetszleges alap logaritmus

log(100, 10)

log10(x)
log2(x)

10-es s 2-es alap logaritmus

log10(1000)
log2(256)

3
8

cos(x)

koszinusz fggvny (x radinban mrt)

cos(pi)

-1

sin(x)

szinusz fggvny (x radinban mrt)

sin(pi/2)

tan(x)

tangens fggvny (x radinban mrt)

tan(0)

acos(x)
asin(x)
atan(x)

inverz trigonometrikus
radinban mrt)

2*asin(1)
acos(-1)
atan(pi)

3.141593
3.141593
1.262627

cosh(x)
sinh(x)
tanh(x)

hiperbolikus trigonometrikus fggvnyek

cosh(0)
sinh(0)
tanh(0)

1
0
0

acosh(x)
asinh(x)
atanh(x)

inverz
hiperbolikus
fggvnyek

acosh(0)
asinh(0)
atanh(0)

NaN
0
0

round(x,
digits=0)

kerekts adott tizedesre

round(1.5)
round(-1.5)

2
-2

floor(x)

x-nl kisebb, legnagyobb egsz

floor(1.5)
floor(-1.5)

1
-2

ceiling(x)

x-nl nagyobb, legkisebb egsz

ceiling(1.5)
ceiling(-1.5)

2
-1

trunc(x)

az x-hez legkzelebbi egsz x s 0 kztt

trunc(1.5)
trunc(-1.5)

1
-1

fggvnyek

(x

trigonometrikus

Nzzk meg rszletesebben a log() fggvnyt. Ha kikrjk a sgjt a


> ?log

parancs begpelsvel, akkor megtudhatjuk, hogy ez a legltalnosabb logaritmus fggvny,


tetszleges alap esetn hvhat. Szmunkra most a legfontosabb a sgnak az sora, amely a
logaritmus fggvny hasznlatt mutatja:
log(x, base=exp(1)).

Ebbl kiolvashat, hogy a log() fggvnynek 2 paramtere van. Az elst x-nek, a msodikat
base-nek nevezik. A msodik paramter alaprtelmezett rtkkel is rendelkezik, teht ez a
paramter a hvsnl elhagyhat, mg az x argumentum megadsa ktelez. A base
paramter rtke knnyen kiderthet az
> exp(1)
[1] 2.718282

parancsbl. Ezt az irracionlis szmot a matematikban e-vel jelljk, s a termszetes alap


logaritmus alapjnak nevezzk.
Vagyis, ha nem hatrozzuk meg a msodik paramtert, akkor a log() fggvny, termszetes
alap estn szmtja az x logaritmust.

16

Bevezets az R-be - 2013.09.16.

Ezek alapjn 2 termszetes alap logaritmust a


> log(2)
[1] 0.6931472

fggvnyhvs adja meg. Azt is megtehetjk, hogy felhasznljuk hvsnl az argumentum


nevt (x), s egy egyenlsgjel (=) felhasznlsval ezt a 2 el szrjuk be. A
> log(x=2);
[1] 0.6931472

sor termszetesen ugyanazt az eredmnyt szolgltatja, csak most explicit mdon kzltk,
hogy az aktulis paramterben szerepl 2-es rtket az x nev formlis paramternek
feleltetjk meg. Ez most felesleges gpelst jelentett s ltalban is elmondhatjuk, hogy
matematikai fggvnyek esetben az oly gyakori x argumentumnevet szoks szerint nem
hasznljuk az aktulis paramterek elnevezsre.
Hvjuk most kt argumentummal a log() fggvnyt. A 100 szm 10-es alap logaritmust a
> log(100, 10)
[1] 2

parancsbl olvashatjuk ki. A fggvnyhvsnl az x formlis argumentum a 100, a base


pedig a 10 rtket kapja. Termszetesen ezt a hvsnl mi is rgzthetjk a vilgosabb
rtelmezs kedvrt sajz magunk szmra a
> log(100, base=10)
[1] 2

vagy akr
> log(x=100, base=10)
[1] 2

formban is.
Arra is lehetsg van, hogy ha az nem okoz flrertst az R szmra, megcserljk az aktulis
paramterek sorrendjt. A legbiztonsgosabb ekkor az sszes paramter nevestse
> log(base=10, x=100)
[1] 2

de kt argumentum esetn gy is egyrtelm a hozzrendels:


> log(base=10, 100); log(10, x=100)
[1] 2
[1] 2

Ha az argumentumok nevestse nlkl cserljk fel az aktulis paramtereket, akkor


termszetesen hibs eredmnyt kapunk, mert az a 10 szm 100-as alap logaritmusa lesz.
> log(10, 100)
[1] 0.5

Knyelmi lehetsg az aktulis paramterek elnevezsnl, hogy rvidtseket is


hasznlhatunk, addig csonkolhatjuk az argumentum nevt, amg az argumentumok

17

Bevezets az R-be - 2013.09.16.

egyrtelmen azonosthatk maradnak. gy a pldban akr a b-vel is helyettesthetjk a base


argumentumnevet:
> log(b=10, 100)
[1] 2

Mint korbban emltettk, az x argumentum nem rendelkezik alaprtelmezett rtkkel, gy


paramter nlkl nem hvhat a log() fggvny.
> log()
Error: 0 arguments passed to 'log' which requires 1 or 2

A fenti hibazenet lthatjuk, ha egy fggvnyt hibs paramterszmmal hvunk.


Eddig a fggvnyek aktulis paramtereiknt csak numerikus konstansokat hasznltunk,
pedig tetszleges kifejezseket is megadhatunk. A fggvny hvsa eltt ezek kirtkeldnek
s a hvs sorn ezek az rtkek rendeldnek a formlis paramterekhez.
> alap <- 10; log(exp(1)); log(exp(4), base=alap); log(2*exp(2), b=alap/2)
[1] 1
[1] 1.737178
[1] 1.673346

A fenti plda a kvetkez numerikus konstansokkal trtn hvsoknak felel meg:


> log(2.718282); log(54.59815, base=10); log(14.77811, base=5)
[1] 1
[1] 1.737178
[1] 1.673346

Mostanra rendelkeznk elg ismerettel, hogy a kifejezs fogalmt pontosthassuk. Egy


konstans, egy objektum vagy egy fggvnyhvs nmagban kifejezs, de ezek opertorokkal
s kerek zrjelekkel sszefztt sorozata is kifejezs.

2.4. Adattpusok az R-ben


Eddig numerikus rtkekkel vgeztnk mveleteket, de tekintsk t az R tbbi adattpust is.
A legalapvetbb numerikus adat mellet beszlnk karakteres s logikai adatokrl is.

2.4.1. Karakteres adatok


Az R-ben egy karakterkonstans (vagy ms nven sztring) idzjelekkel hatrolt, tetszleges
karaktereket tartalmaz sorozat.
> "Hell"
[1] "Hell"
> 'Itt vagyok'
[1] "Itt vagyok"

Az karakterkonstansokat hatrol idzjel lehet egyszeres s dupla is, de egy konstanson bell
nem keverhetjk ket. Az R a dupla idzjelet rszesti elnyben.
Egy karakterkonstans tetszleges karaktert (bett, szmjegyet, rsjeleket, szkzt, stb)
tartalmazhat, egyedl azt az idzjelet kell elkerlnnk, amelyet a konstans ltrehozsnl
hasznltuk.

18

Bevezets az R-be - 2013.09.16.

A karakterkonstansok tartalmazhatnak n. escape szekvencikat, olyan backslash jellel (\,


fordtott perjel) kezdd karaktersorozatokat, amelyeket specilisan kell rtelmezni. A
legfontosabb escape szekvencik a kvetkezk:
Escape szekvencia

Jelentse

(szimpla idzjel)

(dupla idzjel)

\n

j sor karakter

\r

kocsi vissza karakter

\t

tabulator

\\

\ (backslash) karakter

A fentiek alapjn a kvetkez idzjel-hasznlatok engedlyezettek a karakterkonstansokban:


> '\'alma\''; "'alma'"; "\"alma\""; '"alma"'
[1] "'alma'"
[1] "'alma'"
[1] "\"alma\""
[1] "\"alma\""

Karakteres objektumokat is ltrehozhatunk:


> neve<-'Zsolt'; foglalkozasa<-"fest"

Karakteres opertor az R-ben nincs, de szmos karakterkezel fggvny segti a sztringek


kezelst.
Fggvny

Lers

Plda

Plda rtke

paste(,sep)

paste(a, b, sep==)

a=b

nchar(x)

sztringek
sszefzse
karakterszrting
hossza

nchar(alma)

substr(x,start,stop)

sztring egy rsze

substr(alma, 3, 5)

ma

tolower(x)

kisbetsre konvertl

tolower("Kiss Gza")

"kiss
gza"

toupper(x)

nagybetsre
konvertl

toupper("Kiss Gza")

"KISS
GZA"

chartr(old,new,x)

karakterek cserje

chartr("it","l","titik")

"llk"

cat(, sep)

kirats

cat(alma,fa\n,sep=)

almafa

grep(),regexpr(),
gregexpr()

rszsztringek
keresse

sub(), gsub()

rszsztringek
cserje

19

Bevezets az R-be - 2013.09.16.

2.4.2. Logikai adatok


Az eddigiekben megismert numerikus s karakteres konstansok nagyon sokfle rtk
megjelentsre kpesek, de ugyangy a numerikus s karakteres objektumokhoz nagyon sok
lehetsges numerikus s karakteres rtk rendelhet. A logikai adattpus ezektl lnyegesen
egyszerbb trolsi szerkezet, mivel sszesen kt rtket trolsra van mdunk. Ezek a
logikai igaz s a logikai hamis rtk, amelyek az R nyelvben a TRUE s a FALSE logikai
konstansokat jelentik. Az R a logikai konstansok rst a T s F globlis vltozk
bevezetsvel segti, ezek indul rtke a TRUE s FALSE logikai konstans.
Ezeket a logikai konstansokat rtkadsban is szerepeltethetjk, gy logikai objektumokat
hozhatunk ltre.
> fiu<-TRUE; van.kocsija<-FALSE; hazas<-T;
> fiu; van.kocsija; hazas
[1] TRUE
[1] FALSE
[1] TRUE

Logikai rtkeket vagy objektumokat relcis opertorok segtsgvel is ltrehozhatunk.


Opertor formja

Mvelet

Plda

Plda eredmnye

<

kisebb

>

nagyobb

<=

kisebb egyenl

>=

nagyobb egyenl

==

egyenl

!=

nem egyenl

1<2
alma<krte
3<(1+2)
abc>ab
1<=-.3
l<=el
3/4>=7/9
aki>=gi
20==2e1
Len==len
exp(1)!=pi
Len!=len

TRUE
TRUE
FALSE
TRUE
FALSE
TRUE
FALSE
TRUE
TRUE
FALSE
TRUE
TRUE

Numerikus s karakteres adatok is lehetnek a relcis opertorok operandusai. Numerikus


adatok esetn a szmok nagysga, karakteres adatok esetn az bcben elfoglalt hely s a
sztringek hossza (lexikografikus sorrend) alapjn vgzi az R az sszehasonltst. A sztringek
lexikografikus sszehasonltsa, magyar terleti belltsok esetn, a magyar kezetes
karaktereket is helyesen kezeli. (Bvebben: ?locals ).
Az ilyen, logikai rtkkel visszatr kifejezseket (egyszer) logikai kifejezseknek nevezzk.
Ezekbl az egyszer logikai kifejezsekbl a logikai opertorok segtsgvel sszetett logikai
kifejezseket hozhatunk ltre.
Opertor formja

Mvelet

Plda

Plda eredmnye

logikai NEM

& s &&

logikai S

| s ||

logikai VAGY

!(1<2)
!TRUE
!FALSE
TRUE & TRUE
TRUE & FALSE
FALSE & TRUE
FALSE & FALSE
TRUE | TRUE
TRUE | FALSE

FALSE
FALSE
TRUE
TRUE
FALSE
FALSE
FALSE
TRUE
TRUE

20

Bevezets az R-be - 2013.09.16.

FALSE | TRUE
FALSE | FALSE

21

TRUE
FALSE

Bevezets az R-be - 2013.09.16.

3. Adatszerkezetek
Az elz fejezetben lttuk, hogy a konstansok s az objektumok alapveten 3 tpusba
sorolhat rtket vehetnek fel. Ezek a numerikus, karakteres s logikai tpusok voltak. Az
eddigi pldkban az objektumokhoz hozzrendelt rtk elemi volt. Egy numerikus vltoz a
hozzrendelt memriaterleten pl. a 12 rtket trolhatja, egy msik karakteres objektum a
janur rtket s egy logikai objektum pl. a TRUE rtket.
Az R azonban tmogatja az sszetettebb adatszerkezeteket is, st a fenti elemi
esetek az n. vektor adatszerkezet legegyszerbb, specilis vltozatnak tekinthetk. Az
sszetett adatszerkezetre gy gondolhatunk, hogy az objektum neve nem egyetlen szmra,
karaktersorozatra vagy logikai rtkre vonatkozik, hanem ezekbl tbbre: pl. kt szmra, vagy
hrom karaktersorozatra, vagy tz logikai rtkre, esetleg ezekre mind egytt.
Az R a kvetkez adatszerkezeteket tartalmazza: vektor (vector), faktor (factor),
mtrix (matrix), tmb (array), lista (list), adattbla (data frame), idsor (ts).

3.1 Vektorok
Az R legalapvetbb adatszerkezete a vektor. A vektort egyms melletti cellkban trolt
rtkek sorozataknt kpzelhetjk el, mely rtkek mindegyike azonos tpus. gy azt
mondhatjuk, hogy a vektor azonos tpus (egynem, homogn) adatok egydimenzis
egyttese. A vektor fontos jellemzje, hogy homogn, teht a vektort alkot rtkek vagy
kizrlag numerikus konstansok, vagy kizrlag karakteres konstansok, vagy kizrlag
logikai konstansok.

3.1.1. Vektorok ltrehozsa


Vektort legegyszerbben a c() fggvnnyel hozhatunk ltre, a paramterben sorban
felsoroljuk a vektort alkot rtkeket. Numerikus vektort hozhatunk ltre, ha a paramterben
numerikus konstansokat sorolunk fel:
> v1<-c(2,4,6,8)
> v1
[1] 2 4 6 8

A fenti pldban a v1 objektum egy 4 elem vektor. Az els eleme a 2 numerikus konstans, a
msodik eleme a 4, a harmadik a 6 s a negyedik egyben utols eleme a 8. A vektor elemei
kiratskor szkzkkel elvlasztva jelennek meg a konzolban.
Karakteres vektort hasonlan hozhatunk ltre:
> v2<-c("ers", 'kzepes', "gyenge")
> v2
[1] "ers"
"kzepes" "gyenge"

A fenti v2 vektor 3 elem.


Egy logikai vektor csak logikai konstansokat tartalmazhat (TRUE vagy FALSE):
> v3<-c(TRUE, FALSE, TRUE)
> v3
[1] TRUE FALSE TRUE

22

Bevezets az R-be - 2013.09.16.

A v1, v2 , v3 objektum egy-egy plda az R klnbz tpus vektoraira. Egy vektor tpust a
typeof() fggvnnyel krdezhetjk le:
> typeof(v1); typeof(v2); typeof(v3)
[1] "double"
[1] "character"
[1] "logical"

A v1 objektum double tpusa a numerikus tpusok egyik vltozata (nem egsz rtkeket is
trolhatunk benne), a v2 karakteres s a v3 logikai tpusa pedig a fenti pldbl knnyen
kiolvashat.
Az objektumok fontos jellemzje az objektum hossza, ami vektorok esetn a vektort alkot
elemek szmt jelenti. Ezt a length() fggvnnyel krdezhetjk le.
> length(v1); length(v2); length(v3)
[1] 4
[1] 3
[1] 3

Trjnk vissza a vektorok ltrehozshoz. A c() fggvny paramterbe termszetesen


konstansok helyett tetszleges kifejezseket is rhatunk:
> szamok<-c(1, (2+3)*4, 1/4, .5^3)
> szamok
[1] 1.000 20.000 0.250 0.125
> nevek<-c("Pter", paste('Zso', "lt", sep=""))
> nevek
[1] "Pter" "Zsolt"
> iteletek<-c(T, 1<2, 2==3)
> iteletek
[1] TRUE TRUE FALSE

A vektorok esetben a homogenits kzponti szerepet jtszik. Az R abban az esetben sem fog
klnbz tpus elemekbl vektort ltrehozni, ha ezeket egyetlen c() fggvnyhvsban
szerepeltetjk. Ekkor automatikus tpuskonverzi trtnik. Nzzk ezeknek az eseteit:
> eset1<-c(2,4,"6",8)
> eset1
[1] "2" "4" "6" "8"
> eset2<-c(T, FALSE,"6")
> eset2
[1] "TRUE" "FALSE" "6"
> eset3<-c(T, FALSE, 3)
> eset3
[1] 1 0 3

Amennyiben karakteres konstans szerepel az elemek kztt a vektor karakteres tpus lesz.
Ha numerikus s logikai rtket sorolunk fel, akkor a vektor numerikus lesz, azzal a
kiegsztssel, hogy a TRUE logikai rtk 1-re a FALSE pedig 0-ra konvertldik.
Tovbbi lehetsg a c() fggvny hasznlata sorn, hogy a paramterben vektort
szerepeltessnk. Ekkor ezek az elemek is szerepelni fognak az eredmnyvektorban:

23

Bevezets az R-be - 2013.09.16.


> elol<-c(1,2,3)
> hatul<-c(7,8,9)
> c(0,elol,4,5,6,hatul,10)
[1] 0 1 2 3 4 5 6 7

9 10

A fenti pldban ltrehozott (majd el is vesz) 11 elem vektor sszerakshoz felhasznltunk


kt 3 elem vektort is.
Szablyos numerikus vektorokat hozhatunk ltre a kettspont (:) opertorral, a seq() s a
sequence() fggvnnyel. Az gy ltrehozott vektorok ugyanis valamilyen szmtani sorozat
egymst kvet elemei, vagyis az egyms mellett lv elemek klnbsge lland.
A legegyszerbb vektorltrehozsi md a kettspont (:) opertor, ahol az egymst kvet
elemek tvolsga 1. ltalnos alakja: start:stop.
> 1:10
[1] 1

9 10

> 10:1
[1] 10

> -1.5:5
[1] -1.5 -0.5

0.5

1.5

2.5

3.5

4.5

Lthat, hogy az gy ltrejv sorozatok lehetnek cskken vagy nvekv rendezettsgek


valamint trt rtkeket is hasznlhatunk operandusknt. A sorozat nem felttlenl a kettspont
utni rtkig tart, annyi igaz, hogy a stop rtknl mindig kisebb egyenl.
A seq() fggvny nagyobb szabadsgot ad a numerikus sorozatok generlsra.
Legegyszerbb hasznlata esetn a kettspont (:) opertort kapjuk vissza:
> seq(1,10)
[1] 1 2 3

9 10

A seq() fggvny hasznlathoz 4 nevestett paramter jelentst kell megtanulnunk: a from


a sorozat els elemt hatrozza meg, a to az utols elemet, a by a lpskzt s a
length.out a ltrehozand vektor elemeinek a szmt. A ngy paramterbl 3 megadsa
mr egyrtelmen azonostja a kvnt vektort:
> seq(from=1, to=10, by=2)
[1] 1 3 5 7 9
> seq(from=1, to=10, length.out=5)
[1] 1.00 3.25 5.50 7.75 10.00
> seq(to=10, by=1.3, length.out=5)
[1] 4.8 6.1 7.4 8.7 10.0
> seq(from=1, by=1.3, length.out=5)
[1] 1.0 2.3 3.6 4.9 6.2

A sequence() fggvny a paramterben szerepl rtkig, mint vgpontig 1-tl kezdd 1


lpskz sorozatot hoz ltre. A fggvnyt pozitv rtkeket tartalmaz vektorral is hvhatjuk,
ekkor tbb, a fenti szablynak eleget tev szablyos vektor sorozata lesz az eredmnyvektor:
> sequence(4)
[1] 1 2 3 4

24

Bevezets az R-be - 2013.09.16.


> sequence(c(4,5))
[1] 1 2 3 4 1 2 3 4 5
> sequence(c(4,5,3))
[1] 1 2 3 4 1 2 3 4 5 1 2 3

Tetszleges tpus vektor ltrehozsra hasznlhatjuk a rep() fggvnyt, amely egy ltez
vektor rtkeit ismtli meg.
> rep(2, times=3)
[1] 2 2 2
> rep(c(2, 0, -2), times=3)
[1] 2 0 -2 2 0 -2 2 0 -2
> rep("t", times=3)
[1] "t" "t" "t"
> rep(c(F,T,T), times=3)
[1] FALSE TRUE TRUE FALSE

TRUE

TRUE FALSE

TRUE

TRUE

A fenti pldban mindenhol hromszor ismteltk meg az els paramtert, mghozz gy,
hogy az R egyms utn sorolta fel ket.
Egy meglv vektor ismtlsnek van egy msik esete is, amikor az elemeit sorban egyenknt
vve vgezzk el az ismtlst. Ekkor nem a times paramtert, hanem az each argumentumot
kell hasznlnunk a fggvny hvsnl.
> rep(2, each=3)
[1] 2 2 2
> rep(c(2, 0, -2), each=3)
[1] 2 2 2 0 0 0 -2 -2 -2
> rep("t", each=3)
[1] "t" "t" "t"
> rep(c(F,T,T), each=3)
[1] FALSE FALSE FALSE TRUE

TRUE

TRUE

TRUE

TRUE

TRUE

Ltjuk, hogy egy elem vektorok ismtlse esetn nincs klnbsg a times s az each
paramterek hasznlata kztt.
Utols esetknt vegyk azt az esetet, amikor elemenknt szeretnnk ismtelni, de mindegyiket
esetleg eltr mrtkben. Ekkor az each paramterben a bemen vektor elemszmval
azonos hossz vektort kell megadni. Ez a vektor tartalmazza az egyes elemek ismtlsi
szmt.
> rep(c(2,3,4), c(1,2,3))
[1] 2 3 3 4 4 4
> rep(c("t","part"), c(2,3))
[1] "t"
"t"
"part" "part" "part"
> rep(c(T,F,T), c(2,3,4))
[1] TRUE TRUE FALSE FALSE FALSE

TRUE

25

TRUE

TRUE

TRUE

Bevezets az R-be - 2013.09.16.

3.1.2. Mveletek vektorokkal


Amint azt az elzekben lttuk, az R rendszer legalapvetbb adattrolsi szerkezete a vektor.
Az egyik legnagyszerbb tulajdonsga pedig az, ahogyan a vektorokkal mveleteket
vgezhetnk. Korbban mr lttuk, hogyan tudunk sszeadni kt szmot az R-ben. Prbljunk
meg sszeadni kt 2 elem vektort:
> c(1,2)+c(3,4)
[1] 4 6

A kt fenti vektort a parancssorban hoztuk ltre a c() fggvnnyel. Az sszeads eredmnye


egy 2 elem vektor. Az eredmnyvektor az 1+3 s a 2+4 mveletek alapjn jtt ltre, vagyis
az sszeads operandusaiban szerepl vektor azonos sorszm elemeire hajtotta vgre a
kijellt mveletet az R.
Kt vektor sszeadsnl termszetesen hasznlhatunk objektumneveket is:
> x<-1:3; y<-2:4
> x+y
[1] 3 5 7

Itt az eredmnyvektor 3 elem, s a komponensenknti mvelet-vgrehajts szablyainak


megfelelen az 1+2, 2+3 s a 3+4 sszeadsok eredmnye.
Az sszeads mveletet tetszleges opertorral felcserlhetjk, vektor operandusokkal
hasznlhatjuk az sszes aritmetikai s logikai opertort.
> c(1,2)-c(2,3)
[1] -1 -1
> x<-1:3; y<-2:4
> x-y; x*y; x/y; x^y
[1] -1 -1 -1
[1] 2 6 12
[1] 0.5000000 0.6666667 0.7500000
[1] 1 8 81

A fenti mveletek kzl a hatvnyozs vgrehajtsa tnhet kicsit szokatlannak, itt ugyanis
egy 3 elem vektort, mint alapot egy 3 elem msik vektorra, mint kitevre emeljk. Ha
azonban a komponensenknti vgrehajts szablyt szben tartjuk, akkor vilgos, hogy az
eredmnyvektor az 12, 23 s a 34 eredmnye.
A komponensenknti vgrehajts szablya logikai opertorokra is rvnyes:
> !c(T,T,F,F)
[1] FALSE FALSE

TRUE

TRUE

> c(T,T,F,F) & c(T,F,T,F)


[1] TRUE FALSE FALSE FALSE
> c(T,T,F,F) | c(T,F,T,F)
[1] TRUE TRUE TRUE FALSE

Az opertorokon tl a matematikai fggvnyek is tmogatjk a vektor paramtert. Ekkor nem


egyetlen rtkkel trnek vissza, hanem a bemen vektor minden elemre kiszmolt
fggvnyrtkek vektorval:

26

Bevezets az R-be - 2013.09.16.


> sqrt(c(4,9,16))
[1] 2 3 4
> log(1:3)
[1] 0.0000000 0.6931472 1.0986123

A vektorok kztti mveletek legegyszerbb esett tekintettk t eddig, azaz kt azonos


elemszm vektort adtunk ssze, vontunk ki stb. Ha az opertor kt oldaln lv vektorok
elemszma eltr, akkor az ltalnos szably az, hogy a rvidebbik vektort az R megismtli
mindaddig, mg a hosszabbik vektor elemszmt el nem ri. Ha a rvidebbik vektort nem
egsz szmszor megismtelve kapjuk a hosszabb vektort, akkor figyelmeztetst kapunk az Rtl, melyben erre a tnyre felhvja a figyelmnket, de a kijellt mveletet az R ennek ellenre
vgrehajtja.
> c(1,2)+5
[1] 6 7

A fenti pldban egy 2 elem s egy 1 elem vektort adunk ssze. A rvidebb vektort mg
egyszer megismtelve mr az (5, 5) vektort kapjuk, gy a kijellt sszeads minden
fennakads nlkl vgrehajthat. Az eredmnyvektor az 1+5 s a 2+5 sszeadsok eredmnye
lesz.
> c(1,2)+c(3,4,5)
[1] 4 6 6
Warning message:
In c(1, 2) + c(3, 4, 5) :
longer object length is not a multiple of shorter object length

Itt egy 2 elem s egy 3 elem vektort adunk ssze. A rvidebbik vektort mg egyszer
megismtelve nem hasznljuk fel annak minden elemt, gy egy figyelmezet zenetet
kapunk. Az eredmnyvektor az 1+3, 2+4 s a 1+5 sszeadsok eredmnye. A kvetkez
pldban mr nincs figyelmeztets:
> c(1,2)+c(3,4,5,6)
[1] 4 6 6 8

3.1.3. Fggvnyek vektorokkal


Az R egyik legnagyobb erssge, hogy vektorok elemeivel ciklusok megadsa nlkl
klnbz mveleteket vgezhetnk. A legfontosabb vektor alap fggvnyeket a kvetkez
tblzat tartalmazza:
Fggvny

Lers

Plda

Plda rtke

max(x)

max(1:10)

10

min(x)

az x vektor legnagyobb
eleme
az x vektor legkisebb eleme

min(11:20)

11

sum(x)

x elemeinek sszege

sum(1:5)

15

prod(x)

x elemeinek szorzata

prod(1:5)

120

mean(x)

x szmtani kzepe
(mintatlag)

mean(1:10)

5.5

median(x)

x medinja

median(1:10)

5.5

27

Bevezets az R-be - 2013.09.16.

range(x)

x legkisebb s legnagyobb
eleme

range(1:10)

1 10

sd(x)

az x tapasztalati szrsa

sd(1:10)

3.027650

var(x)

az x tapasztalati variancija

var(1:10)

9.166667

cor(x,y)

korrelci x s y kztt

cor(1:10,11:20)

3.1.4. Az NA hinyz rtk


Gyakorlati esetekben sokszor elfordul, hogy a vektor adott rtkt nem ismerjk, de
jelentsge miatt mgis jellnnk kell. Az R-ben az NA rtkkel jellhetjk a hinyz adatot,
amely tetszleges tpus vektor esetben hasznlhat:
> x<-c(2,NA,4); x
[1] 2 NA 4
> x<-c("ers", NA, "gyenge"); x
[1] "ers"
NA
"gyenge"
> x<-c(T, NA, FALSE); x
[1] TRUE
NA FALSE

Az NA rtk tesztelsre az is.na() fggvnyt hasznlhatjuk, amelynek a visszatrsi


rtkben lv vektor ott tartalmaz TRUE rtket, ahol hinyz adatot tallunk.
> is.na(c(1, NA))
[1] FALSE TRUE

Hinyz rtkeket is tartalmaz vektor esetn nhny fggvny meglep eredmnyt adhat, pl:
> mean(c(1:10,NA))
[1] NA

Ha kvncsiak vagyunk az NA rtken kvli elemek tlagra, akkor egy msodik paramtert is
szerepeltetnnk kell a mean() fggvnyben:
> mean(c(1:10,NA), na.rm=T)
[1] 5.5

Az na.rm argumentum TRUE rtke biztostja, hogy az tlag szmtsa sorn a hinyz
rtkeket figyelmen kvl hagyjuk.

3.1.5. Az Inf s a NaN


Az R-ben a numerikus mveletek eredmnye a matematikai rtelmezstl sokszor eltren
vezethet a pozitv vagy negatv vgtelen eredmnyre. Ezeket az Inf s a -Inf
szimblumok jellik, amelyeket a kifejezsekben mi is felhasznlhatunk:
> 1/0
[1] Inf
> log(0)
[1] -Inf

28

Bevezets az R-be - 2013.09.16.


> exp(Inf)
[1] Inf
> mean(c(1,2,Inf))
[1] Inf

Ms esetekben a numerikus kifejezsek eredmnye nem rtelmezhet szmknt, ezt az R-ben


a NaN (Not a Number) jelli. Ilyen kifejezsek pldul:
> 0/0
[1] NaN
> Inf-Inf
[1] NaN
> Inf/Inf
[1] NaN

Egy kifejezs vges vagy vgtelen voltt az is.finite() vagy is.infinite() fggvnyekkel
tesztelhetjk. A NaN rtkre az is.nan() fggvnnyel krdezhetnk r. rdekes megfigyelni,
hogy a NaN rtkre mind az is.nan() mind az is.na() fggvny igazat ad:
> x<-c(1, 2, NA, NaN, Inf, -Inf)
> is.na(x); is.nan(x); is.infinite(x); is.finite(x)
[1] FALSE FALSE TRUE TRUE FALSE FALSE
[1] FALSE FALSE FALSE TRUE FALSE FALSE
[1] FALSE FALSE FALSE FALSE TRUE TRUE
[1] TRUE TRUE FALSE FALSE FALSE FALSE

3.1.6. Objektumok attribtumai


Az R-ben hasznlhat objektumok, pl. az eddig vizsglt vektorok, kt alapvet attribtummal
rendelkeznek. Ez a md (mode) s a hossz (length), melyek az objektum trolsi szerkezetrl
s az elemeinek a szmrl adnak tjkoztatst. Ezeket az attribtumokat a mode() s a
length() fggvnyek segtsgvel krdezhetjk le, ill. llthatjuk be:
> x<--1:1; x; mode(x); length(x)
[1] -1 0 1
[1] "numeric"
[1] 3
> mode(x)<-"logical"; length(x)<-5; x
[1] TRUE FALSE TRUE
NA
NA

Ms attribtumokat is rendelhetnk objektumokhoz, melyek specilis jelentssel brnak. A


names attribtummal pldul a vektor egyes rtkeit nevezhetjk el. (Ksbbiekben ltjuk a
dim, dimnames, row.names, level, class, tsp attribtumok jelentsgt is.)
A names attribtum lekrdezhet s bellthat a names() fggvnnyel:
> x<-1:5
> names(x)<-c("elgtelen", "elgsges", "kzepes", "j", "jeles")
> x
elgtelen elgsges
kzepes
j
jeles
1
2
3
4
5
> names(x)
[1] "elgtelen" "elgsges" "kzepes"

29

"j"

"jeles"

Bevezets az R-be - 2013.09.16.

A names attribtum egy karakteres vektor, a hozzrendels utn pl. az R egy kiratsban is
felhasznlja ezeket a cmkket. Tovbbi lehetsgek az attribtumok meghatrozsra az
attributes() s az attr() fggvnnyek. Az
> attributes(x)
$names
[1] "elgtelen" "elgsges" "kzepes"

"j"

"jeles"

parancs az sszes attribtumot (az elsdlegeseket nem) kirja a kpernyre, de ezt a fggvnyt
hasznlva tudjuk az sszes attribtumot trlni is (az elsdlegeseket nem trlhetjk):
> attributes(x)<-NULL
> attributes(x)
NULL

Az attr() fggvnyben meg kell adnunk az elrend attribtum nevt is:


> attr(x,"names")<-c("elgtelen", "elgsges", "kzepes", "j", "jeles")
> attr(x,"names")
[1] "elgtelen" "elgsges" "kzepes"
"j"
"jeles"

3.1.7. Vektorok indexelse


A vektorok rvn egyetlen vltoznv segtsgvel tetszleges szm konstans rtkre
hivatkozhattunk, gy pldul nagyon egyszeren mindegyik elemhez hozzadhattunk 1-et:
> x<-1:10
> x+1
[1] 2 3

9 10 11

Sokszor van szksg azonban arra is, hogy a vektor egyes elemeit kln tudjuk elrni,
lekrdezni vagy mdostani. A vektor egy tetszleges rszt, egy vagy tbb elemt az
indexels mvelettel rhetjk el. Az index opertor a szgletes zrjel ([]), amit a vektor utn
kell rnunk. Az index opertorban numerikus, karakteres s logikai vektorok is
szerepelhetnek. Nzzk ezeket sorban.
Ha ltrehozunk egy 10 elem x vektort a
> x<-11:20; x
[1] 11 12 13 14 15 16 17 18 19 20

paranccsal, akkor megfigyelhetjk, hogy az x vektor els eleme 11, a msodik 12, az utols,
a tizedik pedig ppen 20. Ebben a felsorolsban az elemek sorszmai (els, msodik, tizedik)
pontosan a vektor indexeit jelentik. A vektor indexelse teht 1-el kezddik, ez az els elem
indexe, a msodik elem indexe 2, az utols elem pedig 10.
Ha az index opertorba egy ilyen egyszer sorszmot runk, akkor a vektor adott index
elemt rhetjk el:
> x[1]
[1] 11
> x[2]
[1] 12
> x[10]
[1] 20

30

Bevezets az R-be - 2013.09.16.

De nem csak lekrdezhetjk, hanem az rtkad opertor segtsgvel fell is rhatjuk


valamelyik elem rtkt:
> x[2]<-100
> x[3]<-2*x[2]
> x
[1] 11 100 200

14

15

16

17

18

19

20

Itt elszr a msodik elemet 100-ra cserljk, majd a harmadikat a msodik ktszeresre. A
vltozst ltjuk a kpernyn. Ha az x vektort az elemszmnl nagyobb indexszel prbljuk
elrni, akkor NA rtket kapunk:
> x[11]
[1] NA

Ha negatv skalr rtkkel indexelnk, akkor a negatv eljellel megadott sorszmon kvl az
sszes tbbi elemet elrhetjk:
> x<-11:20; x[-3]
[1] 11 12 14 15 16 17 18 19 20
> x[-5]<-0; x
[1] 0 0 0 0 15

Vektorokat azonban nem csak numerikus skalrral, hanem kt vagy tbb elem numerikus
vektorokkal is indexelhetnk. Ebben az esetben az indexben felsorolt sorszmoknak
megfelel index elemeket rhetjk el:
> x<-11:20
> x[c(1,3,5)]; x[3:6]
[1] 11 13 15
[1] 13 14 15 16
> y<-c(3,7); x[y]<-c(100,200); x
[1] 11 12 100 14 15 16 200

18

19

20

Termszetesen indexelskor negatv rtkeket tartalmaz numerikus vektorokat is


hasznlhatunk:
> x<-11:20; x[-seq(from=0, to=10, by=3)]; x[-c(1,10)]; x[-(1:5)]
[1] 11 12 14 15 17 18 20
[1] 12 13 14 15 16 17 18 19
[1] 16 17 18 19 20

Egy vektor indexe mindig egsz szm, de az R megengedi, hogy trt rtkeket
szerepeltessnk az index opertorban, ekkor az egsz rszt veszi az indexeknek (csonkolja
ket):
> x<-11:20; x[2.3]; x[2.8]; x[-2.3]; x[-2.8]
[1] 12
[1] 12
[1] 11 13 14 15 16 17 18 19 20
[1] 11 13 14 15 16 17 18 19 20

Egy name attribtummal is rendelkez vektort indexelhetnk karakteres vektorral is:


> x<-1:5

31

Bevezets az R-be - 2013.09.16.


> names(x)<-c("elgtelen", "elgsges", "kzepes", "j", "jeles")
> x["kzepes"]; x[c("kzepes","j")]
kzepes
3
kzepes
j
3
4

Ha tekintnk egy msik pldt,


> x<-c(18,12,20); names(x)<-0:2; x
0 1 2
18 12 20

ahol a (0, 1, 2) rtkek elfordulsi gyakorisgait a (18, 12, 20) elemeket tartalmaz
vektorban rgztjk. Az elemek nevei most is karakteres konstansok, az automatikus
konverzirl az R gondoskodik:
> names(x)
[1] "0" "1" "2"

Az x vektor indexelsnl fontos, hogy megklnbztessk a numerikus s a karakteres


indexeket, az utbbiaknl mindig idzjelet kell hasznlnunk:
> x[1]; x["1"]
0
18
1
12
> x[c(1,3)]; x[c("0", "2")]
0 2
18 20
0 2
18 20

Az R-ben a vektorokat logikai vektorokkal is indexelhetjk, a TRUE logikai rtkkel jelezzk,


hogy az adott sorszm elemet el akarjuk rni:
> x<-11:15; x[c(TRUE, FALSE, T, T, F)]
[1] 11 13 14

A fenti pldban TRUE szerepel az els, a harmadik s a negyedik pozciban, gy az x vektor


1., 3. s 4. elemeit rhetjk el.
Az indexelsre hasznlt logikai vektor elemszma kisebb is lehet, mint az indexelt vektor
hossza, ekkor az R az indexvektor ismtlst hasznlja:
> x<-11:15; x[c(T,F)]; x[T]; x[F]
[1] 11 13 15
[1] 11 12 13 14 15
integer(0)

Ha a csupa TRUE rtk vektorral indexelnk, akkor az x vektor sszes elemt megkapjuk, ha
pedig a csupa FALSE rtkkel, akkor az res vektort kapjuk, az integer(0) az res, egsz
rtkeket tartalmaz vektort jelli.
A logikai index-rtkek lehetv teszik a vektor szrst is, bizonyos feltteleknek eleget tev
rtkek levlogatst. Tekintsk ehhez az x vektort:
32

Bevezets az R-be - 2013.09.16.


> x<-c(4,7,9,2,8)
> which(x<5)
[1] 1 4

A which() fggvny bemen paramterknt egy logikai vektort vr, visszatrsi rtke pedig
a TRUE logikai rtkek indexe lesz. Lthat, hogy az
> x<5
[1] TRUE FALSE FALSE

TRUE FALSE

logikai vektor az 1. s 4. pozciban tartalmaz logikai igaz rtket. Ha teht egy adott
felttelnek eleget tev vektorelemek indexre vagyunk kvncsiak, a which() fggvnyt
hasznlhatjuk. Ha a felttelnek eleget tev vektor elemeit is el akarjuk rni, akkor vagy a
which() ltal szolgltatott numerikus rtkekkel,
> x[which(x<5)]
[1] 4 2

vagy sokkal elegnsabb mdon kzvetlenl a logikai vektor rtkeivel indexelnk:


> x[x<5]
[1] 4 2

Termszetesen sszetett logikai kifejezsekkel is indexelhetnk, pl.:


> which(3<=x & x<=7)
[1] 1 2
> x[3<=x & x<=7]
[1] 4 7

A vektorok indexelse sorn az indexopertor resen is maradhat, ekkor a vektor sszes


elemt elrhetjk, tovbb az NA, NaN s NULL rtkekkel is indexelhetnk:
> x<-11:15; x[]; x[NA]; x[NaN]; x[NULL]
[1] 11 12 13 14 15
[1] NA NA NA NA NA
[1] NA
integer(0)

3.1.8. Vektorok rendezse


Sokszor szksg van egy vektor elemeit nvekv vagy cskken sorrendben ltni. Az R-ben a
vektor elemeit a sort() fggvnnyel rendezhetjk:
> x<-c(1:5,5:3); x
[1] 1 2 3 4 5 5 4 3
> sort(x); sort(x, decreasing=T); rev(sort(x))
[1] 1 2 3 3 4 4 5 5
[1] 5 5 4 4 3 3 2 1
[1] 5 5 4 4 3 3 2 1

A sort() fggvny alaprtelmezs szerint nvekv sorrendbe rendezi t a bemen vektort, ha


azonban a decreasing paramtert TRUE-ra lltjuk, cskken rendezst kapunk. A rev()

33

Bevezets az R-be - 2013.09.16.

fggvnnyel, amely a bementi vektor elemit fordtott sorrendben sorolja fel, szintn elrhetjk
a cskken rendezettsget.
Ha a sort() fggvnnyel trendezett vektort a tovbbiakban fel szeretnnk hasznlni, akkor
azt egy jabb objektumban troljuk. Rossz gyakorlat, ha fellrjuk a kiindul vektorunkat.
A vektor rendezsnek msik mdja az order() fggvnyhez kapcsoldik. A visszatrsi
rtk ekkor egy numerikus indexvektor, amellyel a bemen vektort indexelve rendezett
vektort kapunk.
> x<-c(1:5,5:3); order(x)
[1] 1 2 3 8 4 7 5 6
> x[order(x)]; x[order(x, decreasing=T)];
[1] 1 2 3 3 4 4 5 5
[1] 5 5 4 4 3 3 2 1

Az order() fggvny esetben is hasznlhatjuk a decreasing paramtert, amellyel cskken


sorrendbe rendezhetjk a vektorunkat.
A numerikus vektorokon tl karakteres s logikai vektorokat is sorba rendezhetjk a sort()
s az order() fggvnyekkel.

3.1.9. Elre definilt objektumok, nevestett konstansok


A R-ben a kvetkez globlis vltozkat hasznlhatjuk, amelyek a base csomagban
vektorokknt kerltek megvalstsra:
> pi; T; F
[1] 3.141593
[1] TRUE
[1] FALSE
> LETTERS; letters
[1] "A" "B" "C" "D"
[14] "N" "O" "P" "Q"
[1] "a" "b" "c" "d"
[14] "n" "o" "p" "q"

"E"
"R"
"e"
"r"

"F"
"S"
"f"
"s"

> month.abb; month.name


[1] "Jan" "Feb" "Mar" "Apr"
[9] "Sep" "Oct" "Nov" "Dec"
[1] "January"
"February"
[5] "May"
"June"
[9] "September" "October"

"G"
"T"
"g"
"t"

"H"
"U"
"h"
"u"

"I"
"V"
"i"
"v"

"J"
"W"
"j"
"w"

"K"
"X"
"k"
"x"

"L"
"Y"
"l"
"y"

"M"
"Z"
"m"
"z"

"May" "Jun" "Jul" "Aug"


"March"
"July"
"November"

"April"
"August"
"December"

3.2. Faktorok
A faktor a vektorhoz nagyon hasonl, homogn, egydimenzis adatszerkezet, amelyet
elssorban kategorikus vltozk rtkeinek trolsra hasznlunk. Faktorok esetben csak
numerikus s karakteres adattpusokat hasznlhatunk.
Numerikus vagy karakteres vektorbl a factor() fggvny segtsgvel hozhatunk ltre
faktort. A faktor az alaprtelmezett attribtumokon kvl egy levels attribtumot is tartalmaz,
amely a faktor klnbz rtkeit (szintjeit) sorolja fel. A faktorok class attribtumnak
rtke pedig factor.
> x<-c(rep("A",3), rep("B",4), rep("C",3)); x

34

Bevezets az R-be - 2013.09.16.


[1] "A" "A" "A" "B" "B" "B" "B" "C" "C" "C"
> xf<-factor(x); xf
[1] A A A B B B B C C C
Levels: A B C
> attributes(xf)
$levels
[1] "A" "B" "C"
$class
[1] "factor"

A fenti pldban hrom lehetsges rtket tartalmaz faktort hoztunk ltre, amelyek a
levels() fggvnnyel lekrdezhetk s trhatk:
> levels(xf)
[1] "A" "B" "C"
> levels(xf)<-c(0:2); xf
[1] 0 0 0 1 1 1 1 2 2 2
Levels: 0 1 2
> levels(xf)
[1] "0" "1" "2"

A szintek meghatrozsakor a faktorban eddig nem szerepl rtkeket is megadhatjuk:


> levels(xf)<-c("A","B","C","D"); xf
[1] A A A B B B B C C C
Levels: A B C D

A szintek szmrl s azok cmkjrl a factor() fggvnyben is gondoskodhatunk:


> factor(1:3, levels=1:5)
[1] 1 2 3
Levels: 1 2 3 4 5
> factor(1:3, levels=1:5, labels="L")
[1] L1 L2 L3
Levels: L1 L2 L3 L4 L5
> factor(1:3, levels=1:5, labels=c("A","B","C","D","E"))
[1] A B C
Levels: A B C D E

A faktor ltrehozsnl gondoskodhatunk bizonyos rtkek kizrsrl, olyan rtkekrl,


amelyeket nem szeretnnk a faktorban felsorolni:
> factor(c(1:5, NA, 3:6))
[1] 1
2
3
4
5
Levels: 1 2 3 4 5 6

<NA> 3

Alaprtelmezs szerint az NA rtket zrjuk ki a faktor szintjeibl, de ezt megvltoztathatjuk


az exclude paramter hasznlatval:
> factor(c(1:5, NA, 3:6), exclude=NULL)
[1] 1
2
3
4
5
<NA> 3
4
Levels: 1 2 3 4 5 6 <NA>

35

Bevezets az R-be - 2013.09.16.


> factor(c(1:5, NA, 3:6), exclude=c(4, NA))
[1] 1
2
3
<NA> 5
<NA> 3
<NA> 5
Levels: 1 2 3 5 6

Ahogy ltjuk a fenti pldban, akr az NA rtket is bevonhatjuk a faktor szintjeibe, akr ms
rtkeket is kizrhatunk.
Faktorokat a gl() fggvnnyel is ltrehozhatunk (generate levels), ahol a szintek szmt s
az ismtlsek szmt kell megadnunk.
> gl(3,2)
[1] 1 1 2 2 3 3
Levels: 1 2 3

Tovbbi paramterknt a faktor hosszt s cmkit is meghatrozhatjuk:


> gl(3,2,8)
[1] 1 1 2 2 3 3 1 1
Levels: 1 2 3
> gl(3,2,8,labels="F")
[1] F1 F1 F2 F2 F3 F3 F1 F1
Levels: F1 F2 F3
> gl(3,2,8,labels=c("gyenge", "kzepes", "ers"))
[1] gyenge gyenge kzepes kzepes ers
ers
Levels: gyenge kzepes ers

gyenge

gyenge

3.3. Mtrixok s tmbk


Az egydimenzis vektor tbbdimenzis megfelelje a tmb (array). A tmb a vektorhoz
hasonlan homogn adatszerkezet, amely az alapvet attribtumokon tl a dim attribtummal
is rendelkezik. Egy vektort knnyen talakthatunk pl. egy 3 dimenzis tmbb a dim()
fggvny segtsgvel:
> x<-1:8; is.vector(x)
[1] TRUE
> dim(x)<-c(2,2,2); is.vector(x); is.array(x)
[1] FALSE
[1] TRUE
> x
, , 1
[1,]
[2,]

[,1] [,2]
1
3
2
4

, , 2
[1,]
[2,]

[,1] [,2]
5
7
6
8

Az x vektorbl egy hromdimenzis tmbt hoztunk ltre. Az is.vector() s az is.array()


fggvnyek eligaztanak az objektum adatszerkezetvel kapcsolatban, vektor ill. tmb
paramter esetn logikai igaz rtket adnak. A tmb kiratsa sorn az indexopertorokban

36

Bevezets az R-be - 2013.09.16.

szerepl sorszmok segtsgvel igazodhatunk el az elemek kztt. A hromdimenzis x


tmb dimenzii a sorok, oszlopok s a lapok. A 8 elemet kt lapon a , , 1 s a , , 2
nev lapokon kt-kt sorba [1, ], [2, ] s kt-kt oszlopba [ ,1], [ ,2] rendezve
sorolja fel az R. A msodik lapon a 2. sor 1. elemhez meg kell tallnunk a , , 2 lapot, a
[2, ] sort s a [ ,1] oszlopot, ami esetnkben a 6.
Tmbket az array() fggvnnyel is ltrehozhatunk:
> x<-array(data=1:20, dim=c(4,5)); x
[,1] [,2] [,3] [,4] [,5]
[1,]
1
5
9
13
17
[2,]
2
6
10
14
18
[3,]
3
7
11
15
19
[4,]
4
8
12
16
20

A fenti x tmb dimenziinak szma 2, az ilyen tmbket mtrixnak is nevezhetjk. Mtrixok


ltrehozsra hasznlhatjuk a matrix() fggvnyt is:
> x<-matrix(data=1:20, nrow = 4); x
[,1] [,2] [,3] [,4] [,5]
[1,]
1
5
9
13
17
[2,]
2
6
10
14
18
[3,]
3
7
11
15
19
[4,]
4
8
12
16
20

Itt az nrow paramter segtsgvel irnytjuk az R-t, hogy a sorok s az oszlopok szmt
meghatrozhassa. A matrix() fggvnyben az ncol paramter is hasznlhat. Lthatjuk,
hogy a 20 elem vektorbl az oszlopok mentn hoztuk ltre a mtrixot. Ha sorfolytonosan
szeretnnk a bemen vektor elemeibl mtrixot kpezni, akkor a byrow paramtert igazra
kell lltanunk:
> matrix(1:12,ncol=4,byrow=T)
[,1] [,2] [,3] [,4]
[1,]
1
2
3
4
[2,]
5
6
7
8
[3,]
9
10
11
12

Mtrixok ltrehozshoz teht egy adott elemszm vektor szksges, de elfordul, hogy a
vektor elemeit ismtelni kell:
> matrix(3:5, nrow=2, ncol=3)
[,1] [,2] [,3]
[1,]
3
5
4
[2,]
4
3
5
> matrix(0, nrow=2, ncol=3)
[,1] [,2] [,3]
[1,]
0
0
0
[2,]
0
0
0

Mtrixot s tmbt karakteres vagy logikai rtkekbl is pthetnk:


> matrix(c("a","b"), nrow=2, ncol=3, byrow=T)
[,1] [,2] [,3]
[1,] "a" "b" "a"
[2,] "b" "a" "b"

37

Bevezets az R-be - 2013.09.16.


> matrix(c(T,F,T), nrow=2, ncol=3, byrow=T)
[,1] [,2] [,3]
[1,] TRUE FALSE TRUE
[2,] TRUE FALSE TRUE

A tmbk indexelse nagyon hasonl a vektorok indexelsre, itt is a szgletes zrjel ([])
opertort kell hasznlnunk a tmb egyes elemeinek elrsre. Az egyetlen klnbsg, hogy
mivel itt a dimenzik szma nagyobb mint egy, az egyes dimenziknak megfelelen, tbb
indexeket kell megadnunk s ezeket vesszvel vlasztjuk el az indexopertoron bell. Teht
ha x pldul 3 dimenzis, akkor az x[1,3,2] egy lehetsges plda indexelsre, ahol az els
sor, harmadik oszlopban lv elemre gondolunk, a msodik laprl. A kt dimenzis mtrixok
esetn csak a sor s oszlop azonost indexre van szksgnk (pl. x[2,3]), 4 vagy afeletti
dimenziszmok esetn termszetesen 4 vagy tbb, vesszvel elvlasztott indexre.
Az egyes dimenzipozcikban szerepl indexekre ugyanazok a szablyok rvnyesek, mint a
vektorokra. Hasznlhatunk pozitv vagy negatv numerikus skalrokat s vektorokat, de a
karakteres s logikai vektorokkal val indexels is megengedett. Ha egy dimenzipozcit
resen hagyunk, az tovbbra is az sszes elemet jelenti abbl a dimenzibl:
> x<-matrix(1:10,nrow=2, ncol=5,byrow=T); x
[,1] [,2] [,3] [,4] [,5]
[1,]
1
2
3
4
5
[2,]
6
7
8
9
10
> x[2,3]
[1] 8
> x[2,c(1,4)]
[1] 6 9
> x[,c(1,4)]
[,1] [,2]
[1,]
1
4
[2,]
6
9
> x[,-c(1,4)]
[,1] [,2] [,3]
[1,]
2
3
5
[2,]
7
8
10

A mtrix indexels sorn a kapott elemek elveszthetik a 2 dimenzijukat s egyszer vektor


lehet az eredmny. Ha ezt el akarjuk kerlni, hasznljuk a drop paramtert hamis rtkkel az
indexben:
> x[2,3,drop=F]
[,1]
[1,]
8
>

x[2,c(1,4), drop=F]
[,1] [,2]
[1,]
6
9
>

x[2,, drop=F]
[,1] [,2] [,3] [,4] [,5]
[1,]
6
7
8
9
10
>

x[,3, drop=F]
[,1]

38

Bevezets az R-be - 2013.09.16.


[1,]
[2,]

3
8

A mtrix sorait s oszlopait elnevezhetjk a rownames() s a colnames() fggvnyekkel,


amelyek mint az lthat, a dimnames attribtumot mdostjk:
> rownames(x)<-c("eset1", "eset2")
> colnames(x)<-paste("sz.", 1:5, sep="")
> x
sz.1 sz.2 sz.3 sz.4 sz.5
eset1
1
2
3
4
5
eset2
6
7
8
9
10
> attributes(x)
$dim
[1] 2 5
$dimnames
$dimnames[[1]]
[1] "eset1" "eset2"
$dimnames[[2]]
[1] "sz.1" "sz.2" "sz.3" "sz.4" "sz.5"

Amennyiben egy mtrixnak (vagy egy tetszleges tmbnek) az egyes dimenzi rtkeit
elnevezzk, akkor az R megjelentskor is hasznlja ket, st az indexels sorn is
felhasznlhatjuk:
> x["eset1","sz.2"]
[1] 2
> x["eset1",2]
[1] 2
> x["eset2",]
sz.1 sz.2 sz.3 sz.4 sz.5
6
7
8
9
10
> x["eset1", c(T,F)]
sz.1 sz.3 sz.5
1
3
5

Mtrixok (s tmbk) esetn megengedett a mtrixszal trtn indexels is:


> x<-matrix(1:9, nrow=3); x
[,1] [,2] [,3]
[1,]
1
4
7
[2,]
2
5
8
[3,]
3
6
9
> index.m<-matrix(c(1:3,3:1), nrow=3); index.m
[,1] [,2]
[1,]
1
3
[2,]
2
2
[3,]
3
1
> x[index.m]<-0
> x
[,1] [,2] [,3]
[1,]
1
4
0

39

Bevezets az R-be - 2013.09.16.


[2,]
[3,]

2
0

0
6

8
9

3.3.1 Szmtsok a mtrix soraiban s oszlopaiban


Ha resen hagyjuk a mtrix sor vagy oszlop pozcijt az indexels sorn, akkor a mtrix
teljes oszlopra vagy sorra tudunk hivatkozni, majd ezekkel, mint vektorokkal mveleteket
hajthatunk vgre:
> x<-matrix(1:10,nrow=2, ncol=5,byrow=T); x
[,1] [,2] [,3] [,4] [,5]
[1,]
1
2
3
4
5
[2,]
6
7
8
9
10
> mean(x[1,]); var(x[,4])
[1] 3
[1] 12.5

Ngy specilis fggvnnyel az oszlopok s sorok sszegt s tlagt szmthatjuk ki:


> rowSums(x); rowMeans(x)
[1] 15 40
[1] 3 8
> colSums(x); colMeans(x)
[1] 7 9 11 13 15
[1] 3.5 4.5 5.5 6.5 7.5

ltalnosabb megolds, ha az apply() fggvnyt hasznljuk, amelyben a mtrix soraira vagy


oszlopaira vonatkoz fggvnyt mi hatrozzuk meg. Az apply() els paramtere a mtrix, a
msodik helyen pedig 1 vagy 2 ll, attl fggen, hogy a mtrix soraira vagy oszlopaira
akarjuk a harmadik paramterben szerepl fggvnyt alkalmazni.
> apply(x, 1, mean); apply(x, 1, var); apply(x, 1, min)
[1] 3 8
[1] 2.5 2.5
[1] 1 6
> apply(x, 2, mean); apply(x, 2, var); apply(x, 2, min)
[1] 3.5 4.5 5.5 6.5 7.5
[1] 12.5 12.5 12.5 12.5 12.5
[1] 1 2 3 4 5

Lehetsg van a mtrix oszlopait gy sszegezni, hogy az egyes sorokat csoportokba soroljuk
s az sszegzst a csoportokon bell hajtjuk vgre. Ha pldul az
> x<-matrix(1:12,nrow=4, ncol=3); x
[,1] [,2] [,3]
[1,]
1
5
9
[2,]
2
6
10
[3,]
3
7
11
[4,]
4
8
12

mtrix els kt sora ill. a msodik kt sora kpez egy-egy csoportot, akkor ezt a sorok
szmval megegyez elemszm vektor ltrehozsval jelezhetjk a kvetkez mdon:
> csoportok<-c("A","A","B","B")

40

Bevezets az R-be - 2013.09.16.

Magt az oszlopok sszegzst az egyes csoportokon a rowsum() fggvny vgzi:


> rowsum(x, csoportok)
[,1] [,2] [,3]
A
3
11
19
B
7
15
23

Amennyiben nem sszegzs, hanem ms mvelet vgrehajtsa a cl kijellt csoportokon,


akkor a tapply() fggvnyt hasznlhatjuk. A csoportok meghatrozsa itt a bemen x
mtrixszal egyez elemszm faktorok listjn alapul, amit a msodik paramterben kell
meghatroznunk. A csoportok meghatrozsnl a row() s col() fggvnyeket is
hasznljuk, ezek az x mtrix szerkezett megtartva minden rtkben a sor ill. oszlopsorszmot
tartalmazzk:
> row(x)
[,1] [,2] [,3]
[1,]
1
1
1
[2,]
2
2
2
[3,]
3
3
3
[4,]
4
4
4
> col(x)
[,1] [,2] [,3]
[1,]
1
2
3
[2,]
1
2
3
[3,]
1
2
3
[4,]
1
2
3

Ezek alapjn rgtn alternatv lehetsget ltunk sorokra s oszlopokra trtn


mveletvgzsre, hisz a
> tapply(x, row(x), max)
1 2 3 4
9 10 11 12

minden sor maximumt, a


> tapply(x, col(x), max)
1 2 3
4 8 12

pedig minden oszlop maximumt szolgltatja. Ahhoz azonban, hogy az eredeti clunkat
elrjk, nevezetesen, az oszlopok sszegt vegyk, gy, hogy az els kt sor s a msodik kt
sor kln csoportba tartozik, mg a tapply() msodik paramterben jabb csoportost
vektort kell megadnunk. Ezt a vektort a list() fggvnnyel fzzk a col(x) csoportost
vektor el, hisz ez a sorokra fog vonatkozni. A tapply() msodik paramtere teht
csoportost vektorokat tartalmaz lista, amelynek az elemeit faktorokra konvertlja az R,
mieltt felhasznlja ket.
> cs.matrix<-matrix(c("A","A","B","B"), nrow=4, ncol=3); cs.matrix
[,1] [,2] [,3]
[1,] "A" "A" "A"
[2,] "A" "A" "A"
[3,] "B" "B" "B"
[4,] "B" "B" "B"
> tapply(x, list(cs.matrix,col(x)), sum)

41

Bevezets az R-be - 2013.09.16.


1 2 3
A 3 11 19
B 7 15 23

A fenti pldban a sorok csoportostsa miatt hoztuk ltre a cs.matrix mtrixot. Egyszerbb
azonban ha helyette a csoportok vektort hasznljuk fel, mghozz egy mtrixszal indexelt
alakjt:
> csoportok[row(x)]
[1] "A" "A" "B" "B" "A" "A" "B" "B" "A" "A" "B" "B"

Ekkor a row(x) mtrixot az alaprtelmezett oszlopfolytonos mdon vve, ppen a kvnt


csoportost vektort kapjuk, gy rhatjuk:
> tapply(x, list(csoportok[row(x)],col(x)), sum)
1 2 3
A 3 11 19
B 7 15 23

A sum() fggvny helyett most mr tetszlegeset vlaszthatunk ebben az ltalnos alakban:


> tapply(x, list(csoportok[row(x)],col(x)), mean)
1
2
3
A 1.5 5.5 9.5
B 3.5 7.5 11.5

Hasonl eredmnyt kapunk az aggregate() fggvny hasznlatval is:


> aggregate(x,list(csoportok),sum)
Group.1 V1 V2 V3
1
A 3 11 19
2
B 7 15 23

rdekes lehetsg az oszlopokban lv elemek vletlenszer trendezse a sample()


fggvny segtsgvel. A sample() fggvny a bemen vektor elemeibl egy vletlen mintt
llt el, alapesetben a bemenet egy permutcijt adja:
> sample(1:5)
[1] 1 2 5 3 4

Bellthatjuk az eredmnyvektor elemszmt is a msodik paramterben:


> sample(1:100,10)
[1] 77 13 68 47 36 99 90 29 16 38

Ha teht az oszlopok rtkeit egymstl fggetlenl fel akarjuk cserlni, rhatjuk a


kvetkezt:
> apply(x,2,sample)
[,1] [,2] [,3]
[1,]
2
6
11
[2,]
1
5
12
[3,]
3
8
9
[4,]
4
7
10

42

Bevezets az R-be - 2013.09.16.

3.3.2 Sorok s oszlopok kezelse


Ltez mtrixot jabb sorokkal s oszlopokkal egszthetnk ki az rbind() s a cbind()
fggvnyekkel, de vektorokbl is pthetnk segtsgkkel mtrixot.
> cbind(1,1:2,1:4)
[,1] [,2] [,3]
[1,]
1
1
1
[2,]
1
2
2
[3,]
1
1
3
[4,]
1
2
4
> rbind(1,1:2,1:4)
[,1] [,2] [,3] [,4]
[1,]
1
1
1
1
[2,]
1
2
1
2
[3,]
1
2
3
4

Vektor paramterek esetn, a felsorolt vektorok fogjk alkotni az j mtrix oszlopait (cbind()
esetn), ill. sorait (rbind() esetn), a rvidebb vektor, ha van ilyen, ismtldni fog.
j oszloppal vagy j sorral is kiegszthetjk a mtrixunkat:
>

x<-matrix(1:12,nrow=4, ncol=3); x
[,1] [,2] [,3]
[1,]
1
5
9
[2,]
2
6
10
[3,]
3
7
11
[4,]
4
8
12
> cbind(-3:0,x,13:16)
[,1] [,2] [,3] [,4] [,5]
[1,]
-3
1
5
9
13
[2,]
-2
2
6
10
14
[3,]
-1
3
7
11
15
[4,]
0
4
8
12
16
> rbind(-1,x,1)
[,1] [,2] [,3]
[1,]
-1
-1
-1
[2,]
1
5
9
[3,]
2
6
10
[4,]
3
7
11
[5,]
4
8
12
[6,]
1
1
1

Tetszleges pozciba beszrhatunk egy oszlopot vagy egy sort:


> cbind(x,13:16)[,c(1,2,4,3)]
[,1] [,2] [,3] [,4]
[1,]
1
5
13
9
[2,]
2
6
14
10
[3,]
3
7
15
11
[4,]
4
8
16
12
> rbind(x,-1)[c(1,2,3,5,4),]
[,1] [,2] [,3]
[1,]
1
5
9
[2,]
2
6
10
[3,]
3
7
11

43

Bevezets az R-be - 2013.09.16.


[4,]
[5,]

-1
4

-1
8

-1
12

Hasznos lehetsg sszest sorok vagy oszlopok mtrixhoz fzse s elnevezse:


> x<-rbind(x,apply(x,2,mean))
> rownames(x)<-c(1:4,"tlag")
> x
[,1] [,2] [,3]
1
1.0 5.0 9.0
2
2.0 6.0 10.0
3
3.0 7.0 11.0
4
4.0 8.0 12.0
tlag 2.5 6.5 10.5

A sorok vagy oszlopok sorrendjt is megcserlhetjk a mtrixban, valamint ezek trlsre is


van lehetsgnk:
> x<-matrix(1:12,nrow=4, ncol=3); x
[,1] [,2] [,3]
[1,]
1
5
9
[2,]
2
6
10
[3,]
3
7
11
[4,]
4
8
12
> cbind(x[,c(2,3,1)])
[,1] [,2] [,3]
[1,]
5
9
1
[2,]
6
10
2
[3,]
7
11
3
[4,]
8
12
4

# oszlopcsere

> rbind(x[c(3,2,4,1),])
[,1] [,2] [,3]
[1,]
3
7
11
[2,]
2
6
10
[3,]
4
8
12
[4,]
1
5
9

# sorcsere

> cbind(x[,c(1,3)])
[,1] [,2]
[1,]
1
9
[2,]
2
10
[3,]
3
11
[4,]
4
12

# a 2. oszlop trlse

> rbind(x[c(1,3),])
[,1] [,2] [,3]
[1,]
1
5
9
[2,]
3
7
11

# az 2. s a 4. sor trlse

3.5 Listk
Az eddig megismert vektor, faktor, mtrix s tmb adatszerkezet mindegyike homogn, csak
azonos tpus rtkeket trolhatunk el bennk. A lista adatszerkezetben egyms utn tbbfajta
adatot is felsorolhatunk, sem azok tpusra, sem azok mretre nincs megszorts. A list()
fggvnnyel hozhatunk ltre legegyszerbben listkat, melyben vesszvel elvlasztva kell
megadnunk a lista elemeit:
44

Bevezets az R-be - 2013.09.16.


> x<-list(1:10, c("A","B"), c=T); x
[[1]]
[1] 1 2 3 4 5 6 7 8 9 10
[[2]]
[1] "A" "B"
$c
[1] TRUE

A fenti pldban x egy 3 elem lista, az els eleme egy 10 elem numerikus vektor, a
msodik eleme egy 2 elem karakteres vektor, a harmadik eleme pedig egy 1 elem logikai
vektor. A harmadik elemnek a c nevet adtuk, ezt mindegyik listaelem esetn megtehettk
volna. Ha a lista rtkt megjelentjk a kpernyn, akkor a listaelemek egyms alatt jelennek
meg. Az els kt esetben a ketts szgletes zrjelben ([[]]) lv sorszm azonostja a lista
elemeit, a harmadik esetben pedig a listaelem ltalunk megadott neve a $ utn.
A listaelemek nevt az x lista names attribtuma tartalmazza, segtsgvel a tbbi elemnek is
adhatunk rtket:
> names(x)
[1] "" ""

"c"

> names(x)[c(1,2)]<-c("a","b")
> names(x)
[1] "a" "b" "c"
> x
$a
[1]

9 10

$b
[1] "A" "B"
$c
[1] TRUE

A lista elemeire a vektoroknl megszokott [ opertor segtsgvel hivatkozhatunk, ahol


numerikus, karakteres s logikai rtkeket is megadhatunk:
> x[1]
$a
[1] 1

9 10

9 10

> x[c(2,3)]
$b
[1] "A" "B"
$c
[1] TRUE
> x["a"]
$a
[1] 1 2

> x[c(T,F,T)]
$a

45

Bevezets az R-be - 2013.09.16.


[1]

9 10

$c
[1] TRUE

A [ opertorral kapott eredmny minden esetben lista, mg akkor is, ha egyetlen elemt
rjk el az x listnak. Nagyon fontos ettl megklnbztetni a [[ opertor eredmnyt,
amely a lista valamelyik elemvel, annak az rtkvel tr vissza. Itt nincs md tbb listaelem
elrsre sem, szoks szerint numerikus vagy karakteres rtkkel indexelhetnk.
> x[[1]]
[1] 1 2

9 10

> x[["b"]]
[1] "A" "B"
> x[[3]]
[1] TRUE

A [[ opertor alkalmazsa helyett a rvidebb $ opertort hasznlhatjuk azoknak a


listaelemeknek az elrsre, amelyeket korbban elneveztnk. A lista nevt s az elem nevt
fzzk ssze a $ opertorral:
> x$a
[1] 1

9 10

> x$b
[1] "A" "B"
> x$c
[1] TRUE

Ha a lista elemt valamelyik mdszer segtsgvel elrtk, akkor tovbbi indexels


segtsgvel az elem sszetevit is lekrdezhetjk:
> x[["a"]][3:4]; x$a[4:5]<-0; x$c<-F; x
[1] 3 4
$a
[1] 1 2 3 0 0 6 7 8 9 10
$b
[1] "A" "B"
$c
[1] FALSE

A lista mindem elemvel a lapply() vagy az sapply() fggvny segtsgvel hajthatunk


vgre mveletet:
> lapply(x,length)
$a
[1] 10
$b
[1] 2
$c
[1] 1

46

Bevezets az R-be - 2013.09.16.


> sapply(x,length)
a b c
10 2 1

Az lapply() a bemen lista elemszmval egyez mret listval tr vissza, melynek rtkei
a msodik paramterben szerepl fggvny visszatrsi rtkei. Az sapply() hasonlan jr
el, de a visszatrsi rtke egy vektor.

3.5 Adattblk (dataframes)


Az adattbla (dataframe) statisztikai feldolgozs szempontjbl az R legfontosabb
adatszerkezete. Inhomogn, ktdimenzis szerkezet, amely a lista s a mtrix adatszerkezetek
elnyeit hordozza. Sorok s oszlopok alkotjk, alapveten azonos hosszsg
(oszlop)vektorok listjnak tekinthet.
Adattblt legegyszerbben a data.frame() fggvnnyel hozhatunk ltre, a paramterben az
t alkot elemeket kell felsorolni. Ezek lehetnek vektorok, faktorok, mtrixok, listk vagy
adattblk is. Ha a paramterek hossza nem azonos, akkor a fggvny ismtli a rvidebb
elemeket, de ez csak egsz szmszor lehetsges:
> x<-c('A','B'); y<-6:9; z<-1:8
> d<-data.frame(x,y,z); d
x y z
1 A 6 1
2 B 7 2
3 A 8 3
4 B 9 4
5 A 6 5
6 B 7 6
7 A 8 7
8 B 9 8

A pldban egy 8 sorbl s 3 oszlopbl ll adattblt ksztettnk. A data.frame()


fggvnyben nem azonos hossz vektorokat hasznltunk az adattbla ltrehozsra, az
automatikus ismtlssel mgis eredmnyt rtnk el. Nzzk, hogyan tekint az R az
adattblra:
> typeof(d); mode(d); length(d)
[1] "list"
[1] "list"
[1] 3
> is.list(d); is.data.frame(d)
[1] TRUE
[1] TRUE

Az adattblk tpusa s mdja is list, a hossza pedig az alkot (oszlop)vektorok szma. Az


adattblra teht tekinthetnk gy, mint egy listra, melynek elemei az adattbla oszlopai
lesznek.
Az adattbla sorai s oszlopai nvvel is rendelkeznek, ezek attribtumokban foglalnak helyet:
> attributes(d)
$names
[1] "x" "y" "z"
$row.names
[1] 1 2 3 4 5 6 7 8

47

Bevezets az R-be - 2013.09.16.

$class
[1] "data.frame"

Az str() fggvny segtsgvel az adattbla szerkezetrl kapunk felvilgostst:


> str(d)
'data.frame':
8 obs. of 3 variables:
$ x: Factor w/ 2 levels "A","B": 1 2 1 2 1 2 1 2
$ y: int 6 7 8 9 6 7 8 9
$ z: int 1 2 3 4 5 6 7 8

Lthajuk, hogy a d adattblnk 8 sort (megfigyelst) s 3 vltozt (oszlopot) tartalmaz,


valamint leolvashatjuk az egyes oszlopok adattpust is. Megfigyelhetjk, hogy a d$x
oszlopot karakteres vektorbl faktor tpus vltozv konvertlta a data.frame() fggvny.
Ezt az alaprtelmezett s a statisztikban nagyon hasznos viselkedst az I() fggvnnyel
tudjuk megakadlyozni:
> str(data.frame(I(x),y,z))
'data.frame':
8 obs. of 3 variables:
$ x:Class 'AsIs' chr [1:8] "A" "B" "A" "B" ...
$ y: int 6 7 8 9 6 7 8 9
$ z: int 1 2 3 4 5 6 7 8

Az names attribtum az adattbla oszlopainak, a row.names pedig a sorainak a nevt


hatrozza meg. Ezeket az attribtumokat szmos fggvnnyel trhatjuk: a rownames() a
sorok nevt a colnames() vagy a names() az oszlopok nevt rja t, de hasznlhatjuk az
ltalnos attr() vagy attributes() fggvnyeket is. A sorok nevnek meghatrozsnl
gyeljnk arra, hogy azoknak egyedieknek kell lennik, kt azonos sornv nem fordulhat el.
> rownames(d)<-paste(1:8, ".szemely", sep="")
> names(d)<-c("X","Y","Z")
> d
X Y Z
1.szemely A 6 1
2.szemely B 7 2
3.szemely A 8 3
4.szemely B 9 4
5.szemely A 6 5
6.szemely B 7 6
7.szemely A 8 7
8.szemely B 9 8

Az adattblk indexelse a mtrixoknl s a listknl ltott mdokon is trtnhet. Ha az


adattblra, mint egy mtrixra tekintnk, hasznlhatjuk a kvetkez hivatkozsokat:
> d[2,3]
[1] 2
> d[c(2,3),3]
[1] 2 3
> d[c(2,3),]
X Y Z
2.szemely B 7 2
3.szemely A 8 3
> d[,3]

48

Bevezets az R-be - 2013.09.16.


[1] 1 2 3 4 5 6 7 8
> d[,3, drop=F]
Z
1.szemely 1
2.szemely 2
3.szemely 3
4.szemely 4
5.szemely 5
6.szemely 6
7.szemely 7
8.szemely 8

Ha az adattblt listaknt indexeljk, akkor rvnyesek a kvetkezk:


> d$X
[1] A B A B A B A B
Levels: A B
> d$Y
[1] 6 7 8 9 6 7 8 9
> d$Y[3:5]
[1] 8 9 6

Az adattbla indexelsnl logikai vektorokat is hasznlhatunk, melyek az adattbla


tartalmra vonatkoz relcis kifejezsek is lehetnek. Ezzel a mdszerrel rhetjk el, hogy az
adattbla sorait valamilyen szempont szerint megszrjk:
> d[d$Y < 8,]
X Y
1.szemely A 6
2.szemely B 7
5.szemely A 6
6.szemely B 7

Z
1
2
5
6

> d[d$Y < 8


X
5.szemely A
6.szemely B

d$Z > 2,]


Z
5
6

&
Y
6
7

3.5 Idsorok
[]

49

Bevezets az R-be - 2013.09.16.

4. Adatok olvassa s rsa


Az R-ben adatokkal dolgozunk, amelyek beolvassra s kirsra az R szmos eljrst knl.
Adatokat beolvashatunk a billentyzetrl, a vgasztalrl s kls adatforrsbl: llomnybl
vagy adatbzisbl is. Az R-ben feldolgozott adatokat a vgasztalra vagy llomnyba rhatjuk
ki.

4.1. Adatok beolvassa


4.1.1.A c() s a scan() fggvnyek
Leggyorsabban a c() fggvny hasznlatval hozhatunk ltre adatvektort, de nagyobb
elemszm, tipikusan 10 feletti esetekben, nem ez a legknyelmesebb megolds:
> x<-c(4,8,3,6,8,2)

Szintn a parancssort hasznlhatjuk adatbevitelre a scan() fggvny hasznlata sorn:


> x<-scan()
1:

A fggvnyhvs hatsra megjelen 1: utn az els vektorelemet gpelhetjk be, a bevitel


vgt az ENTER billenty lenyomsval jelezzk. A megjelen 2: utn a msodik elem
begpelsre van lehetsgnk, s gy tovbb. Ha 5 elem numerikus vektort akarunk
ltrehozni, akkor a 6: megjelense utn egy ENTER segtsgvel fejezhetjk be a vektor
ltrehozst. Ekkor kilpnk a scan() fggvnybl s ezutn az x vektor a begpelt elemeket
fogja tartalmazni.
> x<-scan()
1: 2
2: 14
3: 3.5
4: 4.9
5: 3
6:
Read 5 items
> x
[1]

2.0 14.0

3.5

4.9

3.0

A scan() fggvny hasznlata sorn az adatokat a vgasztalrl is beilleszthetjk (CTRL-V),


akr rgtn az 1: megjelense utn. A tipikusan szvegszerkesztbl vagy
tblzatkezelbl szrmaz adatokat rdemes gy elkszteni, hogy egyms alatt, egy
oszlopban soroljuk fel a szmokat, majd ezt msoljuk fel a vgasztalra. Az gy beillesztett
adatokat a fenti scan() fggvnyhvs helyesen fogja rtelmezni.
A szmok begpelse sorn lehetsgnk van szkzkkel, vagy esetleg ms karakterekkel
elvlasztani az egy sorban megadott numerikus konstansokat. Az alaprtelmezett szkz
elvlaszt karaktert a sep argumentum segtsgvel vltoztathatjuk meg. Az elz vektor
beolvasst gy is elvgezhetjk:
> x<-scan()
1: 2 14 3.5

50

Bevezets az R-be - 2013.09.16.


4: 4.9 3
6:
Read 5 items

Karakteres adatokat is beolvashatunk a what paramter belltsval. Az alaprtelmezett


rtke a double(0), amely, mint korbban lttuk, numerikus vektor ltrehozst tette
lehetv. Ha az res karaktersorozatot lltjuk be, akkor karakteres konstansokat is
begpelhetnk:
> x<-scan(what="", sep="\n")
1: Els sor
2: Ez a msodik sor
3: Utols...
4:
Read 3 items
> x
[1] "Els sor"

"Ez a msodik sor" "Utols..."

A fenti pldban a sep paramter rtke (\n) biztostja, hogy a vektor elemeit a sor vge
karakter s ne a szkz vlassza el.
A numerikus s karakteres adatokon kvl logikai s binris adatok beolvassa is lehetsges a
scan() fggvnnyel, st, egy lista elemeit is beolvashatjuk:
> x<-scan(what=list(nev="",kor=0,suly=0))
1: a 33 72
2: b 42 81
3: c 39 78
4:
Read 3 records
> x
$nev
[1] "a" "b" "c"
$kor
[1] 33 42 39
$suly
[1] 72 81 78
> as.data.frame(x)
nev kor suly
1
a 33
72
2
b 42
81
3
c 39
78

Az elemi adattpusok mellett a fenti pldban hasznlt lista is lehet a what paramter rtke,
ekkor minden listaelem tpust a szoksos elemi adattpus jelzsvel kell megadnunk. Ltjuk,
hogy adattblkat is megadhatunk ezzel a mdszerrel.
Vgasztalon lv informcit kzvetlenl a readClipboard() fggvny segtsgvel is
objektumhoz rendelhetnk. Tipikusan karakteres konstansok ltrehozsra hasznljuk
Windows krnyezetben:
x<-readClipboard()

51

Bevezets az R-be - 2013.09.16.

A dget() fggvny segtsgvel a dput() fggvnnyel kirt szveges llomnybl


olvashatunk vissza objektumokat.
x<- dget("adat.txt")

4.1.2. A read.table() csald


A leggyakoribb mdszer kls llomny beolvassra a read.table() fggvny hasznlata.
Az adatokat tblzatszeren tartalmaz, tagolt (adott karakterrel elvlasztott) szveges
llomnyok olvassra hasznlhatjuk. A paramterekben tbbek kztt gondoskodhatunk az
els sorban lv oszlopnevekrl (header), az elvlaszt karakterrl (sep), a tizedesvessz
alakjrl (dec) s a hinyz rtkek jellsrl (na.strings).
> d<-read.table("c:/temp/adat.txt",header=T,sep=";",dec=",")

A fenti sor egy els sorban oszlopneveket tartalmaz szveges llomny tartalmt helyezi el
a d adattblban. Az llomnyban az adatokat (s az oszlopneveket is) a pontosvessz (;)
vlasztja el, a numerikus rtkekben pedig vesszt hasznlunk a tizedesvessz jellsre.
A paramterekben lert feltteleknek megfelel szveges llomnyt egy egyszer
szvegszerkesztvel is ltrehozhatjuk, de sokszor egyszerbb tblzatkezelt hasznlni, s az
abban elkszlt, tblzatos formban lv adatokat megfelel formtumban exportlni. (Pl.
magyar Excel esetn vlaszthatjuk a CSV (pontosvesszvel tagolt) formtumot).
A read.table() fggvny helyett hasznlhatjuk a read.csv() s read.csv2() fggvnyeket
is, amelyek csak a paramterek alaprtelmezett rtkeiben trnek el az alapfggvnytl.
Ezekben a fggvnyekben a header alaprtelmezetten TRUE, az elvlaszt karakter pedig a
vessz (csv) ill. a pontosvessz (csv2), valamint a tizedesvessz alakja a pont (csv) ill. a
vessz (csv2). Ha tabultorral tagolt llomnyt szeretnnk beolvasni, akkor a read.delim()
ill. a read.delim2() fggvnyeket rdemes hasznlni, mert az elvlaszt karakter itt
alaprtelmezs szerint a tabultor karaktert (\t).

4.1.3. A read.fwf() fggvny


A legtbb beolvasand szveges llomny tabultorral vagy pontosvesszvel tagolt.
Ritkbban szksg lehet fix szles mezket tartalmaz llomnyok beolvassra is. A
read.fwf() fggvny width paramterben kell megadnunk az egyes mezk hosszt. A
fggvny a megadott mezhossz rtkek alapjn egy ideiglenes, tabultorral elvlasztott
szveges llomnyt hoz ltre, amely a read.table() fggvnnyel kerl tnylegesen
feldolgozsra.
> allomany.nev<-tempfile()
> cat(file=allomany.nev,"A;B;C","123456","987654",sep="\n")
> read.fwf(allomany.nev, widths=c(1,2,3),header=T,sep=";")
A B
C
1 1 23 456
2 9 87 654

A fenti pldban a tempfile() fggvnyt hasznljuk egy a rendszernkben rvnyes


ideiglenes llomny nevnek meghatrozsra. A cat() fggvnnyel egy 3 soros szveges
llomnyt hozunk ltre. Az els sor pontosvesszvel elvlasztott oszlopneveket tartalmaz, a
kvetkez kt sor pedig 3 fix szles adatmezt tartalmaz. Ezek hossza rendre 1, 2 s 3
karakternyi. A read.fwf() fggvnyben pontosan ezeket a mezhosszakat adjuk meg a
width paramterben. A header paramterrel jelezzk, hogy az els sor oszlopneveket
52

Bevezets az R-be - 2013.09.16.

tartalmaz, a sep paramter pedig az els sorban hasznlt elvlaszt karaktert jelli. A sep
paramterre csak akkor van szksg, ha oszlopneveket tartalmaz sort is be akarunk olvasni.
Lthatjuk, hogy a fggvny ltal visszaadott adattbla 2 sort s 3 oszlopot tartalmaz.

4.1.4. Binris llomnyok olvassa


Az R-ben szmos ms statisztikai programcsomag adatllomnyt is beolvashatjuk. Ezek a
foreign csomagban tallhat fggvnyek a
> library(foreign)

fggvnyhvs utn lesznek elrhetek, s segtsgkkel tbbek kztt SPSS, SAS, Minitab,
S-PLUS, Stata s Systat llomnyokat is beolvashatunk. Az sszes elrhet fggvny listjt
a
> ls("package:foreign")
[1] "data.restore" "lookup.xport"
[5] "read.dta"
"read.epiinfo"
[9] "read.S"
"read.spss"
[13] "read.xport"
"write.arff"
[17] "write.foreign"

"read.arff"
"read.mtp"
"read.ssd"
"write.dbf"

"read.dbf"
"read.octave"
"read.systat"
"write.dta"

paranccsal krdezhetjk le.

4.1.5. Adatbzisok elrse


A kis s kzepes nagysg adattblk megnyitsa s kezelse az R-ben nem jelent nehzsget.
Ugyan a read.table() fggvny a megfelel oszloptpusok kitallsa miatt, sokszor lassnak
bizonyul, kb. 100 Mb alatti szveges llomnyok kezelse nem okoz problmt. Mivel az R
az objektumokat a memriban trolja, az ennl nagyobb mret llomnyok esetn
adatbzis-kezelk hasznlata javasolt. Az adatokat teht nem az R-ben, hanem egy kls
adatforrsban troljuk, amit az R-bl elrhetnk, lekrdezhetnk.
Az R az RODBC csomag segtsgvel szmos adatbzis-kezelhz tud kapcsoldni (pl.
Microsoft SQL Server, Access, MySQL, Oracle), de nagymret llomnyokban trolt
informcikhoz is hozzfrhetnk (pl. Excel, DBase, szveges llomnyok).
Az RODBC csomagban lv fggvnyek segtsgvel kapcsoldhatunk egy ODBC
kapcsolattal rendelkez adatbzishoz. Ez lehet akr egy Excel llomny is:
> kapcsolat<-odbcConnect("Excel adatok")
> sqlTables(kapcsolat)
> minta<-sqlFetch(kapcsolat, "Munka1")
> odbcCloseAll()

Adatbzishoz az odbcConnect() fggvny segtsgvel kapcsoldhatunk, majd az


sqlTables() hvssal megkajuk az elrhet tblkat. Az sqlFetch() teljes tbla tartalmt
adja vissza.

4.2. Adatok kirsa


Az objektumok rtkeinek kirsa knnyebb feladat, mint az adatllomnyok beolvassa.
Egyszerbb objektumokat a cat() fggvnnyel, adattblkat s mtrixokat a write.table()
fggvnnyel rhatjuk ki.

53

Bevezets az R-be - 2013.09.16.

4.2.1. A cat() fggvny


A cat() fggvnnyel egyszer objektumokat rhatunk a kpernyre vagy llomnyba. A file
paramterben gondoskodhatunk a kimeneti llomny nevrl:
> cat("Hell vilg\n")
Hell vilg
> cat("Hell vilg\n", file="kiir.txt")

A sep paramterben az elemi adatokat elvlaszt karaktert hatrozzuk meg, az alaprtelmezs


a szkz.
> x<-1:5
> cat(x, "\n", sep="\t")
1
2
3
4

A pldban az x vektor rtkei jelennek meg a kpernyn, majd egy sortrs karakter. Az
adatokat a tabultor jel vlasztja el.

4.2.2. A write.table() csald


Adattblk s mtrixok kirsra a write.table() fggvnyt hasznlhatjuk. Az els
paramter a kirand objektum neve, a msodik pedig a kimenti llomny elrsi tja. A
row.names s a col.names logikai paramterek szablyozzk, hogy a sor s oszlopnevek
szerepeljenek-e a kimeneti llomnyban. Ezek alaprtelmezett rtke TRUE.
> xmat<-matrix(1:12,nrow=3)
> write.table(xmat,"table.txt",col.names=F,row.names=F)

Mtrixok kirsnl sokszor a sor- s oszlopnevek kirstl eltekintnk, adattblk esetben


azonban ez fontos lehet. Arra is van lehetsgnk, hogy az llomny helyett a vgasztalt
vlasszuk kimenetnek. Ekkor a
> write.table(women,"clipboard", sep="\t", col.names=NA)

sorral a vgasztalra helyezhetjk az adattblt, amit egy tblzatkezelbe azonnal


beilleszthetnk (CTRL+V). A fenti plda a sorneveket is kirja, gy a helyes beillesztshez az
els sorban, a sor elejn egy j oszlopnvre is szksg van. A col.names argumentum NA
rtke res oszlopnv mezt helyez el az els sorban.
A write.table() paramtereinek alaprtelmezett rtkn vltoztat a write.csv() s
write.csv2() fggvny.

54

Bevezets az R-be - 2013.09.16.

5. Adattblk kezelse
Az adatkezels szempontjbl legfontosabb R objektum az adattbla (dataframe). Mint
korbban lttuk, a mtrixhoz hasonlan sorokat s oszlopokat tartalmaz, illetve a listhoz
hasonlan elemekbl, mghozz azonos hosszsg oszlopvektorokbl, pl fel. Az adattbla
ketts eredete jelentsen megknnyti az ilyen adatok kezelst.
Az adattbla sorai egyedekre (szemlyek, trgyak, dolgok, stb.) vonatkoz
megfigyelsek, az oszlopok pedig a megfigyelt tulajdonsgok. A statisztikban gy
mondannk, hogy az adattblban az adatmtrixunkat/tbbdimenzis mintnkat rgzthetjk,
a sorok a mintaelemek, az oszlopok a megfigyelt vltozk.
Az adattbla inhomogn adatszerkezet, oszlopai klnbz tpus adatokat is
tartalmazhatnak. Jellemzen kvalitatv (nominlis s ordinlis skln mrt) adatok trolsra a
faktort hasznljuk, kvantitatv (intervallum s arnyskln mrt) adatok trolsra a
numerikus vektort. Termszetesen adattblban karakteres s logikai vektorok is
szerepelhetnek, st dtumokat s idpontokat is kezelhetnk az adattblban.
Az adatok adattblba szervezsnl vezrl elv, hogy az azonos vltozhoz tartoz
adatrtkek kerljenek azonos oszlopba. Tekintsnk egy egyszer ksrletet, ahol arra
keressk a vlaszt, hogy a tpllkozs mdja befolysolja-e a vr alvadsi idejt.
Vletlenszeren kivlasztunk 24 llatot az egyes ditkhoz (A, B, C, D) s adatainkat papron
a kvetkezkppen rendezzk:
A

62

63

68

56

60

67

66

62

63

71

71

60

59

64

67

61

65

68

63

66

68

64
63
59

Az egyes numerikus rtkek msodpercben mrt vralvadsi idket jelentenek. Ahhoz, hogy
helyesen hozhassuk ltre az adattblnkat, a kvetkezkppen kell talaktani a fenti
tblzatot.
A

62

60

63

59

63

67

55

Bevezets az R-be - 2013.09.16.

71

64

65

66

68

66

71

67

68

68

56

62

60

61

63

64

63

59

Ezt a tblzatot mr rgzthetjk az R egy adattbljba.

5.1. Adattblk ltrehozsa


Korbban mr lttuk, hogy a data.frame() fggvnnyel hogyan hozhatunk ltre adattblt
(3.5. fejezet): a fggvny argumentumban az adattblt alkot oszlopvektorokat kellett
felsorolnunk. llomnyban rgztett adattbla beolvassra is lttunk pldt a 4.1.2.
fejezetben: pl. a read.table() fggvnnyel adattblba olvashatjuk adatainkat.
Tovbbi lehetsg a fix() s az edit() fggvnyek hasznlata, melyekkel az Excel
munkalapjhoz hasonl, knyelmes felleten hozhatjuk ltre j, vagy mdosthatjuk meglv
adattblinkat. A fggvnyek a paramterkben vrjk a mdostand adattbla nevt, de az
edit() a fix()-szel ellenttben nem vltoztatja meg a paramter rtkt, hanem a
mdostott adattbla lesz a visszatrsi rtke.
> fix(d)
> d.uj<-edit(d)

# mdostja d-t
# d vltozatlan, a mdostsok d.uj-ba kerlnek

Az R szmos beptett dataset-tel (tbbnyire adattbla, mtrix, idsor) rendelkezik. A data()


fggvny segtsgvel fedezhetjk fel a parancssorbl mr is elrhet adattblk nevt s
rvid lerst. Tovbbi informcit is krhetnk egy kivlasztott adattblrl (pl. women):
> ?women

56

Bevezets az R-be - 2013.09.16.

Az alaprtelmezetten betlttt csomagok kzl a datasets tartalmaz adattblkat, de szmos


ms csomagban is tallhatk dataset-ek, pl: MASS, survival, nlme. A teleptett csomagban
lv sszes dataset is lekrdezhet kvetkez sorral:
> data(package = .packages(all.available = TRUE))

5.2. Adattblk indexelse


Az adattblk indexelsre a mtrixok s listk indexelsi eljrsait is hasznlhatjuk. A 3.5.
fejezetben mr ttekintettk ezeket a lehetsgeket.
A kvetkez pldkban a datasets csomag mtcars adattbljt hasznljuk, amely a
parancssorbl azonnal elrhet. Az 32 db rgi aut fogyasztst s 10 tovbbi jellemzjt
tartalmaz adattbla els 10 sort lthatjuk itt:
> mtcars[1:10,]
Mazda RX4
Mazda RX4 Wag
Datsun 710
Hornet 4 Drive
Hornet Sportabout
Valiant
Duster 360
Merc 240D
Merc 230
Merc 280

mpg cyl disp hp drat


wt qsec vs am gear carb
21.0
6 160.0 110 3.90 2.620 16.46 0 1
4
4
21.0
6 160.0 110 3.90 2.875 17.02 0 1
4
4
22.8
4 108.0 93 3.85 2.320 18.61 1 1
4
1
21.4
6 258.0 110 3.08 3.215 19.44 1 0
3
1
18.7
8 360.0 175 3.15 3.440 17.02 0 0
3
2
18.1
6 225.0 105 2.76 3.460 20.22 1 0
3
1
14.3
8 360.0 245 3.21 3.570 15.84 0 0
3
4
24.4
4 146.7 62 3.69 3.190 20.00 1 0
4
2
22.8
4 140.8 95 3.92 3.150 22.90 1 0
4
2
19.2
6 167.6 123 3.92 3.440 18.30 1 0
4
4

Az adattbla vltozinak rszletes lerst a kvetkez parancs szolgltatja:


> ?mtcars

Indexelssel elrhetjk adattbla tetszleges rtkt:


> mtcars[6,3]
[1] 225
> mtcars$disp[6]
[1] 225

vagy tetszleges sort:


> mtcars[6,]
mpg cyl disp hp drat
wt qsec vs am gear carb
Valiant 18.1
6 225 105 2.76 3.46 20.22 1 0
3
1

vagy oszlopt:
> mtcars[,8]
[1] 0 0 1 1 0 1 0 1 1 1 1 0 0 0 0 0 0 1 1 1 1 0 0 0 0 1 0
[28] 1 0 0 0 1
> mtcars$am
[1] 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 1 1
[28] 1 1 1 1 1

Az adattbla rtkeinek egy tetszleges tartomnya is elrhet, ha vektorokkal indexelnk:

57

Bevezets az R-be - 2013.09.16.


> mtcars[11:15,c(1,3,8)]
mpg disp vs
Merc 280C
17.8 167.6 1
Merc 450SE
16.4 275.8 0
Merc 450SL
17.3 275.8 0
Merc 450SLC
15.2 275.8 0
Cadillac Fleetwood 10.4 472.0 0

Ha az indexvektorban hasznlt numerikus rtkek sorrendjt felcserljk, akkor az adattbla


oszlopait, esetleg sorait cserlhetjk fel:
> mtcars[15:11,c(3,8,1)]
disp vs mpg
Cadillac Fleetwood 472.0 0 10.4
Merc 450SLC
275.8 0 15.2
Merc 450SL
275.8 0 17.3
Merc 450SE
275.8 0 16.4
Merc 280C
167.6 1 17.8

Amikor az adattbla egyetlen oszlopbl vlogatunk le adatot, akkor az eredmny nem


adattbla, hanem egy vektor lesz. Ezt elkerlhetjk, ha a drop=FALSE argumentumot
hasznljuk:
> mtcars[c(2,4,6),8]
[1] 0 1 1
> mtcars[c(2,4,6),8,drop=F]
vs
Mazda RX4 Wag
0
Hornet 4 Drive 1
Valiant
1

Bizonyos esetekben szksg lehet az adattbla sorainak vletlen kivlasztsra. Ekkor a


sample() fggvnyt hasznljuk:
> mtcars[sample(1:32,10),]
mpg cyl
Chrysler Imperial 14.7
8
Ford Pantera L
15.8
8
Merc 450SLC
15.2
8
Merc 280
19.2
6
Porsche 914-2
26.0
4
Hornet 4 Drive
21.4
6
Pontiac Firebird 19.2
8
Fiat 128
32.4
4
Merc 240D
24.4
4
Merc 230
22.8
4

disp
440.0
351.0
275.8
167.6
120.3
258.0
400.0
78.7
146.7
140.8

hp
230
264
180
123
91
110
175
66
62
95

drat
3.23
4.22
3.07
3.92
4.43
3.08
3.08
4.08
3.69
3.92

wt
5.345
3.170
3.780
3.440
2.140
3.215
3.845
2.200
3.190
3.150

qsec vs am gear carb


17.42 0 0
3
4
14.50 0 1
5
4
18.00 0 0
3
3
18.30 1 0
4
4
16.70 0 1
5
2
19.44 1 0
3
1
17.05 0 0
3
2
19.47 1 1
4
1
20.00 1 0
4
2
22.90 1 0
4
2

A sample() fggvny alaprtelmezs szerint visszatevs nlkli vlaszt vletlen rtkeket az


els paramterbl (esetnkben 32 szmbl 10-et), de ha a replace=TRUE argumentumot
hasznljuk, akkor visszatevssel fog vlasztani:
> d<-mtcars[sample(11:13,4,replace=T),];
mpg cyl disp hp drat
wt
Merc 280C
17.8
6 167.6 123 3.92 3.44
Merc 450SL 17.3
8 275.8 180 3.07 3.73
Merc 280C.1 17.8
6 167.6 123 3.92 3.44
Merc 450SE 16.4
8 275.8 180 3.07 4.07

58

d
qsec vs am gear carb
18.9 1 0
4
4
17.6 0 0
3
3
18.9 1 0
4
4
17.4 0 0
3
3

Bevezets az R-be - 2013.09.16.

A sample() fggvny fenti paramterezse mellett biztosan elfordul sorismtls az j d


adattblban. Most az 1. s a 3. sor azonos, de mivel a sorok nevnek az adattblban
klnbznek kell lennie a Merc 280C egy .1 rsszel egszlt ki a megismtelt 3.
sorban.
Az sorismtlseket tartalmaz adattblk kezelsre a duplicated() s a unique()
fggvnyeket hasznlhatjuk. A sorismtlsek feldertsre a duplicated() fggvnyt
hasznljuk:
> duplicated(d)
[1] FALSE FALSE

TRUE FALSE

> d[duplicated(d),]
mpg cyl disp hp drat
wt qsec vs am gear carb
Merc 280C.1 17.8
6 167.6 123 3.92 3.44 18.9 1 0
4
4

A sorismtlsek eltvoltsra a unique() fggvnyt hasznlhatjuk:


> unique(d)
mpg cyl disp hp drat
wt qsec vs am gear carb
Merc 280C 17.8
6 167.6 123 3.92 3.44 18.9 1 0
4
4
Merc 450SL 17.3
8 275.8 180 3.07 3.73 17.6 0 0
3
3
Merc 450SE 16.4
8 275.8 180 3.07 4.07 17.4 0 0
3
3

5.3. A with() s az attach()


Az adattblk vltozinak indexels nlkli elrsre tbb mdszert is nyjt az R. Egyrszt
szmos statisztikai fggvny rendelkezik data argumentummal, amelynek ha egy adattbla
nevt adjuk rtkl, akkor illet adattbla oszlopneveit mindenfajta indexels nlkl
hasznlhatjuk a statisztikai fggvny tbbi argumentumban.
> names(women)
[1] "height" "weight"
> lm(height~weight,data=women)

Tovbbi lehetsgnk a with() fggvny hasznlata, amelyben ha az els argumentumban az


adattbla nevt szerepeltetjk, a msodik argumentumban szerepl kifejezsben nem kell
indexelnnk az adattbla vltozit:
> with(women, lm(height~weight))

Ha tbb utastst szeretnnk vgrehajtani a with() fggvny hasznlata sorn, akkor a


msodik argumentumban hasznljunk kapcsos zrjelet ({}), az utastsokat pedig rjuk kln
sorba, vagy vlasszuk el pontosvesszvel ket.
> with(women, {plot(height~weight); abline(lm(height~weight))})

Az attach() fggvny hasznlatval is megtakarthatjuk a vltozk indexelst. A fggvny


argumentumban szerepl adattblt az elrsi tba helyezzk, gy a nvfelolds sorn az
adattblnkat is vgignzi az R.
> names(women)
[1] "height" "weight"
> height
Error: object "height" not found
> weight
Error: object "weight" not found

59

Bevezets az R-be - 2013.09.16.


> attach(women)
> height
[1] 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72
> weight
[1] 115 117 120 123 126 129 132 135 139 142 146 150 154 159 164

Az elrsi tbl a detach() fggvnnyel trlhetnk adattblt (vagy csomagot).


> detach(women)
> height
Error: object "height" not found
> weight
Error: object "weight" not found

Az attach() hasznlatval azonban vatosnak kell lennnk, mert a munkaterlet egyb


vltozival knnyen tkzhetnek az adattbla vltoznevei:
> height<-1:10
> attach(women)
The following object(s) are masked _by_ .GlobalEnv :
height
> height
[1] 1 2 3 4 5 6 7 8 9 10
> weight
[1] 115 117 120 123 126 129 132 135 139 142 146 150 154 159 164

5.4. Sorok s oszlopok nevei


Az adattbla sorait a row.names, az oszlopait a names attribtum hasznlatval
nevezhetjk el. A sornevek egymstl klnbz, karakteres vagy numerikus egsz rtkek
lehetnek, mg az oszlopnevek csak karakteres adatok. A sor- s oszlopnevek lekrdezsre s
belltsra korbban mr lttunk pldt (3.5. fejezet).
Sokszor elfordul, hogy egy adattbla valamely vltozjnak rtkeivel szeretnnk a sorokat
elnevezni, ill. fordtva, az adattbla sorneveit oszlopvektorban szeretnnk ltni. Az adattbla
llomnybl trtn beolvassa sorn a read.table() fggvnyben a row.names=n
argumentum megadsval a szveges llomny n. oszlopbl nyerjk a sorok neveit.
Az mtcars adattbla sorneveit a kvetkez parancs segtsgvel vihetjk be vltozba:
> mtcars2<-data.frame(name=rownames(mtcars),mtcars,row.names=1:32)
> mtcars2[1:10,]
name mpg cyl disp hp drat
wt qsec vs am gear carb
1
Mazda RX4 21.0
6 160.0 110 3.90 2.620 16.46 0 1
4
4
2
Mazda RX4 Wag 21.0
6 160.0 110 3.90 2.875 17.02 0 1
4
4
3
Datsun 710 22.8
4 108.0 93 3.85 2.320 18.61 1 1
4
1
4
Hornet 4 Drive 21.4
6 258.0 110 3.08 3.215 19.44 1 0
3
1
5 Hornet Sportabout 18.7
8 360.0 175 3.15 3.440 17.02 0 0
3
2
6
Valiant 18.1
6 225.0 105 2.76 3.460 20.22 1 0
3
1
7
Duster 360 14.3
8 360.0 245 3.21 3.570 15.84 0 0
3
4
8
Merc 240D 24.4
4 146.7 62 3.69 3.190 20.00 1 0
4
2
9
Merc 230 22.8
4 140.8 95 3.92 3.150 22.90 1 0
4
2
10
Merc 280 19.2
6 167.6 123 3.92 3.440 18.30 1 0
4
4

A fordtott irnyhoz a kvetkez parancsot kell hasznlnunk:

60

Bevezets az R-be - 2013.09.16.


> mtcars3<-mtcars2

# j adattbla

> rownames(mtcars3)<-mtcars3$name
# sornevek meghatrozsa
> mtcars3<-mtcars3[2:11]
# a felesleges els oszlop trlse
> mtcars3[1:10,]
mpg cyl disp hp drat
wt qsec vs am gear
Mazda RX4
21.0
6 160.0 110 3.90 2.620 16.46 0 1
4
Mazda RX4 Wag
21.0
6 160.0 110 3.90 2.875 17.02 0 1
4
Datsun 710
22.8
4 108.0 93 3.85 2.320 18.61 1 1
4
Hornet 4 Drive
21.4
6 258.0 110 3.08 3.215 19.44 1 0
3
Hornet Sportabout 18.7
8 360.0 175 3.15 3.440 17.02 0 0
3
Valiant
18.1
6 225.0 105 2.76 3.460 20.22 1 0
3
Duster 360
14.3
8 360.0 245 3.21 3.570 15.84 0 0
3
Merc 240D
24.4
4 146.7 62 3.69 3.190 20.00 1 0
4
Merc 230
22.8
4 140.8 95 3.92 3.150 22.90 1 0
4
Merc 280
19.2
6 167.6 123 3.92 3.440 18.30 1 0
4

5.5. Rendezs
A vektorok rendezsnl mr megismertk az order() fggvnyt (3.1.8. fejezet), amelyet
adattblk rendezsre is hasznlhatunk. Az mtcars adattbla sorait a fogyasztsi adatok
(mpg vltoz) alapjn nvekv sorrendbe rendezhetjk, ha a sorok indexelsre az order()
fggvny visszatrsi rtkt hasznljuk:
> order(mtcars$mpg)
[1] 15 16 24 7 17 31 14 23 22 29 12 13 11
[21] 4 32 21 3 9 8 27 26 19 28 18 20

5 10 25 30

A fenti indexeket a sorkoordinta helyre rva, megkapjuk a rendezett adattblt


(helytakarkossgbl az els 10 sort rjuk ki):
> mtcars[order(mtcars$mpg)[1:10],]
mpg cyl disp
Cadillac Fleetwood 10.4
8 472.0
Lincoln Continental 10.4
8 460.0
Camaro Z28
13.3
8 350.0
Duster 360
14.3
8 360.0
Chrysler Imperial
14.7
8 440.0
Maserati Bora
15.0
8 301.0
Merc 450SLC
15.2
8 275.8
AMC Javelin
15.2
8 304.0
Dodge Challenger
15.5
8 318.0
Ford Pantera L
15.8
8 351.0

hp
205
215
245
245
230
335
180
150
150
264

drat
2.93
3.00
3.73
3.21
3.23
3.54
3.07
3.15
2.76
4.22

wt
5.250
5.424
3.840
3.570
5.345
3.570
3.780
3.435
3.520
3.170

qsec vs am gear carb


17.98 0 0
3
4
17.82 0 0
3
4
15.41 0 0
3
4
15.84 0 0
3
4
17.42 0 0
3
4
14.60 0 1
5
8
18.00 0 0
3
3
17.30 0 0
3
2
16.87 0 0
3
2
14.50 0 1
5
4

Rendezsi szempontnak a sorneveket is hasznlhatjuk:


> mtcars[order(rownames(mtcars))[1:10],]
mpg cyl disp hp drat
AMC Javelin
15.2
8 304.0 150 3.15
Cadillac Fleetwood 10.4
8 472.0 205 2.93
Camaro Z28
13.3
8 350.0 245 3.73
Chrysler Imperial 14.7
8 440.0 230 3.23
Datsun 710
22.8
4 108.0 93 3.85
Dodge Challenger
15.5
8 318.0 150 2.76
Duster 360
14.3
8 360.0 245 3.21
Ferrari Dino
19.7
6 145.0 175 3.62
Fiat 128
32.4
4 78.7 66 4.08
Fiat X1-9
27.3
4 79.0 66 4.08

61

wt
3.435
5.250
3.840
5.345
2.320
3.520
3.570
2.770
2.200
1.935

qsec vs am gear carb


17.30 0 0
3
2
17.98 0 0
3
4
15.41 0 0
3
4
17.42 0 0
3
4
18.61 1 1
4
1
16.87 0 0
3
2
15.84 0 0
3
4
15.50 0 1
5
6
19.47 1 1
4
1
18.90 1 1
4
1

Bevezets az R-be - 2013.09.16.

Rendezsnl egynl tbb vltozt is figyelembe vehetnk, ekkor az order() fggvnyben


tbb vltoznevet kell felsorolnunk vesszvel elvlasztva:
> mtcars[order(mtcars$mpg,mtcars$disp)[1:10],c("mpg","disp")]
mpg disp
Lincoln Continental 10.4 460.0
Cadillac Fleetwood 10.4 472.0
Camaro Z28
13.3 350.0
Duster 360
14.3 360.0
Chrysler Imperial
14.7 440.0
Maserati Bora
15.0 301.0
Merc 450SLC
15.2 275.8
AMC Javelin
15.2 304.0
Dodge Challenger
15.5 318.0
Ford Pantera L
15.8 351.0

Cskken sorrend rendezshez hasznlhatjuk az order() fggvny decreasing=TRUE


argumentumt, vagy a rev() fggvnyt. Tbb rendezsi szempont esetn ha keverni
szeretnnk a rendezsi irnyokatt, akkor numerikus oszlopvektorok eltt a mnusz (-) jellel
fordthatjuk meg a rendezs irnyt cskkenre.
> mtcars[order(mtcars$mpg,-mtcars$disp)[1:10],c("mpg","disp")]
mpg disp
Cadillac Fleetwood 10.4 472.0
Lincoln Continental 10.4 460.0
Camaro Z28
13.3 350.0
Duster 360
14.3 360.0
Chrysler Imperial
14.7 440.0
Maserati Bora
15.0 301.0
AMC Javelin
15.2 304.0
Merc 450SLC
15.2 275.8
Dodge Challenger
15.5 318.0
Ford Pantera L
15.8 351.0

5.5. Adattbla szrse


Sokszor elfordul, hogy az adattbla sorait egy vagy tbb vltoz (oszlop) rtke szerint
szeretnnk levlogatni. Ekkor az adattbla indexelse sorn a sorkoordinta helyn logikai
kifejezst kell szerepeltetnk. Ha pldul le szeretnnk krdezni, azokat a sorokat,
amelyekben a fogyszts rtke kisebb mint 15 mrfld/gallon, akkor a kvetkez logikai
kifejezst hasznlhatjuk:
> mtcars$mpg<15
[1] FALSE FALSE FALSE FALSE FALSE FALSE TRUE FALSE FALSE FALSE
[11] FALSE FALSE FALSE FALSE TRUE TRUE TRUE FALSE FALSE FALSE
[21] FALSE FALSE FALSE TRUE FALSE FALSE FALSE FALSE FALSE FALSE
[31] FALSE FALSE

A fenti logikai vekorban pontosan azokban a pozcikban szerepel TRUE rtk, amelyik
sorban fogyszts rtke kisebb mint 15 mrfld/gallon. Ha ezt szerpeltetjk a sorkoordinta
helyn, a kvnt sorokhoz jutunk:
> mtcars[mtcars$mpg<15,]
mpg cyl disp hp drat
wt qsec vs am gear carb
Duster 360
14.3
8 360 245 3.21 3.570 15.84 0 0
3
4
Cadillac Fleetwood 10.4
8 472 205 2.93 5.250 17.98 0 0
3
4
Lincoln Continental 10.4
8 460 215 3.00 5.424 17.82 0 0
3
4
Chrysler Imperial
14.7
8 440 230 3.23 5.345 17.42 0 0
3
4

62

Bevezets az R-be - 2013.09.16.


Camaro Z28

13.3

350 245 3.73 3.840 15.41

Tbb vltzn alapul felttel megadshoz sszetett logikai kifejezst kell rnunk:
> mtcars[mtcars$mpg<15 & mtcars$disp>400,]
mpg cyl disp hp drat
wt qsec vs am gear carb
Cadillac Fleetwood 10.4
8 472 205 2.93 5.250 17.98 0 0
3
4
Lincoln Continental 10.4
8 460 215 3.00 5.424 17.82 0 0
3
4
Chrysler Imperial
14.7
8 440 230 3.23 5.345 17.42 0 0
3
4

Adattblk szrst egyszersti a subset() fggvny, amely az els paramterben egy


adattblt, msodik paramterben pedig a szrst jelent logikai kifejezst vrja. A fenti
szrs subset() fggvny hasznlatval:
> subset(mtcars, mpg<15 & disp>400)
mpg cyl disp hp
Cadillac Fleetwood 10.4
8 472 205
Lincoln Continental 10.4
8 460 215
Chrysler Imperial
14.7
8 440 230

drat
wt qsec vs am gear carb
2.93 5.250 17.98 0 0
3
4
3.00 5.424 17.82 0 0
3
4
3.23 5.345 17.42 0 0
3
4

A subset() fggvny egy select argumentumot is tartalmazhat, melynek segtsgvel a


szrs eredmnyben megjelen oszlopokat hatrozhatjuk meg:
> subset(mtcars, mpg<15 & disp>400, select=c("mpg","disp"))
mpg disp
Cadillac Fleetwood 10.4 472
Lincoln Continental 10.4 460
Chrysler Imperial
14.7 440

5.6. Hinyz rtkeket tatalmaz sorok eltvoltsa


Az NA rtket is tartalmaz adattblnkbl az na.omit() fggvny hasznlatval
tvolthatjuk el azokat a sorokat, amelyekben a hinyz rtk elfordul.
> data(mtcars)
> mtcars[c(2,5,7),1]<-NA
> mtcars[1:10,]
mpg cyl
Mazda RX4
21.0
6
Mazda RX4 Wag
NA
6
Datsun 710
22.8
4
Hornet 4 Drive
21.4
6
Hornet Sportabout
NA
8
Valiant
18.1
6
Duster 360
NA
8
Merc 240D
24.4
4
Merc 230
22.8
4
Merc 280
19.2
6

disp
160.0
160.0
108.0
258.0
360.0
225.0
360.0
146.7
140.8
167.6

> na.omit(mtcars)[1:10,]
mpg cyl disp
Mazda RX4
21.0
6 160.0
Datsun 710
22.8
4 108.0
Hornet 4 Drive 21.4
6 258.0
Valiant
18.1
6 225.0
Merc 240D
24.4
4 146.7
Merc 230
22.8
4 140.8
Merc 280
19.2
6 167.6
Merc 280C
17.8
6 167.6

hp
110
93
110
105
62
95
123
123

hp
110
110
93
110
175
105
245
62
95
123

drat
3.90
3.90
3.85
3.08
3.15
2.76
3.21
3.69
3.92
3.92

drat
3.90
3.85
3.08
2.76
3.69
3.92
3.92
3.92

63

wt
2.620
2.875
2.320
3.215
3.440
3.460
3.570
3.190
3.150
3.440

wt
2.620
2.320
3.215
3.460
3.190
3.150
3.440
3.440

qsec vs am gear carb


16.46 0 1
4
4
17.02 0 1
4
4
18.61 1 1
4
1
19.44 1 0
3
1
17.02 0 0
3
2
20.22 1 0
3
1
15.84 0 0
3
4
20.00 1 0
4
2
22.90 1 0
4
2
18.30 1 0
4
4

qsec vs am gear carb


16.46 0 1
4
4
18.61 1 1
4
1
19.44 1 0
3
1
20.22 1 0
3
1
20.00 1 0
4
2
22.90 1 0
4
2
18.30 1 0
4
4
18.90 1 0
4
4

Bevezets az R-be - 2013.09.16.


Merc 450SE
Merc 450SL

16.4
17.3

8 275.8 180 3.07 4.070 17.40


8 275.8 180 3.07 3.730 17.60

0
0

0
0

3
3

3
3

5.7. Adattbla oszlopainak transzformlsa


Szmos esetben szksg lehet az adattbla oszlopaiban lv rtkek talaktsra
(transzformlsra). Az rtkeket vagy helyben (ugyanabban az oszlopban) vltoztatjuk meg,
vagy j oszlopknt szrjuk be az adattblba.
Adatok transzformlshoz tekintsk a women adattblt, amely a weight vltozjban
font-ban mrt rtkeket tartalmaz. Ezt alaktsuk t kg-ban mrt adatokk egy j oszlopban:
> data(women); women
height weight
1
58
115
2
59
117
3
60
120
4
61
123
5
62
126
6
63
129
7
64
132
8
65
135
9
66
139
10
67
142
11
68
146
12
69
150
13
70
154
14
71
159
15
72
164
> women$suly<-round(women$weight*0.45)
> women
height weight suly
1
58
115
52
2
59
117
53
3
60
120
54
4
61
123
55
5
62
126
57
6
63
129
58
7
64
132
59
8
65
135
61
9
66
139
63
10
67
142
64
11
68
146
66
12
69
150
68
13
70
154
69
14
71
159
72
15
72
164
74

Ugyanezt az eredmnyt a transform() fggvny segtsgvel is elrhetjk, ahol a subset()hez hasonlan nmileg egyszerbben hivatkozhatunk az adattbla vltozira. Most alaktsuk
t height vltozt inch-rl cm-re.
> transform(women,magassag=round(height*2.45))
height weight suly magassag
1
58
115
52
142
2
59
117
53
145
3
60
120
54
147
4
61
123
55
149
5
62
126
57
152

64

Bevezets az R-be - 2013.09.16.


6
7
8
9
10
11
12
13
14
15

63
64
65
66
67
68
69
70
71
72

129
132
135
139
142
146
150
154
159
164

58
59
61
63
64
66
68
69
72
74

154
157
159
162
164
167
169
172
174
176

Amennyiben a fenti pldkban nem j vltoznevek az talakts clpontjai, hanem mr


ltez oszlopok, akkor helyben vgezzk a transzformcit:
> transform(women,height=height-10)
height weight suly
1
48
115
52
2
49
117
53
3
50
120
54
4
51
123
55
5
52
126
57
6
53
129
58
7
54
132
59
8
55
135
61
9
56
139
63
10
57
142
64
11
58
146
66
12
59
150
68
13
60
154
69
14
61
159
72
15
62
164
74

A vltozk talaktsnak msik gyakori esete, amikor az eredetileg folytonos vltozt


kategrikus vltozv alaktjuk. A cut() fggvny segtsgvel numerikus vektorbl faktort
llthatunk el.
> cut(1:10,3)
[1] (0.991,4] (0.991,4] (0.991,4] (4,7]
[8] (7,10]
(7,10]
(7,10]
Levels: (0.991,4] (4,7] (7,10]

(4,7]

(4,7]

(4,7]

A fenti pldban a 10 elem bemen vektortbl 3 szint faktort hoztunk ltre. Ha az


intervallumok hatrt magunk szeretnnk megadni, akkor a msodik (breaks)
argumentumban egy vektort kell megadnunk:
> cut(1:10,breaks=c(0,2,10))
[1] (0,2] (0,2] (2,10] (2,10] (2,10] (2,10] (2,10] (2,10] (2,10] (2,10]
Levels: (0,2] (2,10]

A ltrejv faktor szintjei az intervallumok lersaibl llnak, termszetesen ezeket


megvaltoztathatjuk, csak a labels paramtert kell hasznlnunk:
> cut(1:10,breaks=c(0,2,7,10),label=c("gyenge","kzepes","ers"))
[1] gyenge gyenge kzepes kzepes kzepes kzepes kzepes ers
[10] ers
Levels: gyenge kzepes ers

Adattblk esetben a cut() fggvny hasznlatra lthatunk egy pldt:

65

ers

Bevezets az R-be - 2013.09.16.


> transform(women,height=cut(height,breaks=c(0,60,70,100),
+ labels=c("alacsony","kzepes","magas")))
height weight suly
1 alacsony
115
52
2 alacsony
117
53
3 alacsony
120
54
4
kzepes
123
55
5
kzepes
126
57
6
kzepes
129
58
7
kzepes
132
59
8
kzepes
135
61
9
kzepes
139
63
10 kzepes
142
64
11 kzepes
146
66
12 kzepes
150
68
13 kzepes
154
69
14
magas
159
72
15
magas
164
74

66

Bevezets az R-be - 2013.09.16.

6. Grafika az R-ben
Az R szmos eljrst ad a grafikus brk ltrehozsra, st sajt bratpusokat is
ltrehozhatunk. A parancssorba gpelt demo(graphics) vagy demo(persp)
fggvnyhvsokkal kpet kaphatunk az R grafikus lehetsgeirl.
Az R segtsgvel grafikus eszkzre (graphical device) rajzolhatunk, amely alaprtelmezetten
a kperny, de egy adott tpus llomny is lehet. A grafikus (rajz)fggvnyeink kt alapvet
csoportba sorolhatk, az n. magas-szint (high-level) rajzfggvnyek s az alacsony-szint
(low-level) fggvnyek.

6.1. Grafikus eszkzk


Az R-ben megnyithatunk egy vagy tbb grafikus eszkzt, ezekbl mindig az egyik az aktulis
(aktv), amelyre a grafikus fggvnyeinkkel rajzolhatunk. Az alaprtelmezett grafikus
eszkznk az R-ben a kperny egy ablaka (windows), de tbb llomnytpus (pl. jpeg, pdf,
postscript) ll rendelkezsre, amelyekben ltrehozhatjuk brinkat. A grafikus eszkzk
lerst a
> ?device

paranccsal rhetjk el.


Grafikus eszkzt a tpusuknak megfelel fggvnyhvssal hozhatunk ltre. A kvetkez
sorban kt windows s egy jpeg tpus grafikus eszkzt hozunk ltre:
> windows(); windows(); jpeg("abra.jpg")
> dev.list()
windows
windows jpeg:75:abra.jpg
2
3
4

Az dev.list() fggvnnyel a megnyitott grafikus eszkzeink listjt kapjuk meg: az eszkz


tpust s azonostjt ltjuk a kpernyn. Az els megnyitott eszkznk 2-es azonostt
kapja.
A megnyitott eszkzeink egyike az aktulis grafikus eszkz, az utoljra megnyitott eszkz
lesz az aktulis. Az aktulis eszkzt a dev.cur() fggvnnyel krdezhetjk le, belltsa a
dev.set() fggvnnyel lehetsges:
> dev.cur()
jpeg:75:abra.jpg
4
> dev.set(3)
windows
3
> dev.cur()
windows
3

A grafikus eszkzk bezrst a dev.off() fggvny vgzi. Paramter nlkl az aktulis


eszkzt zrhatjuk be, numerikus paramterrel pedig az adott sorszm eszkzt. A visszatrsi
rtke az aktulis grafikus eszkz. A graphics.off() az sszes nyitott eszkzt bezrja:
> dev.off()

67

Bevezets az R-be - 2013.09.16.


jpeg:75:abra.jpg
4
> dev.off(2)
jpeg:75:abra.jpg
4
> graphics.off()

6.2. Az eszkzfellet felosztsa


Nagyon hasznos lehetsg az R-ben, hogy a rajzterlet feloszthat klnll rszekre
(ablakokra), melyek mindegyikre a tbbitl fggetlenl rajzolhatunk. A felosztsra tbb
lehetsgnk is van, ezek nem minden esetben kompatibilisek egymssal.
A legegyszerbben a mfrow vagy mfcol grafikus paramtereket hasznlhatjuk a felosztsra,
egy ktelem numerikus vektor lehet az rtkk, amelyek a felosztott ablakok sorainak s
oszlopainak a szmt hatrozzk meg.
> par(mfrow=c(3,2))

A fenti sor hatsra egy 3 sorbl s 2 oszlopbl ll, 6 elklnlt ablakot tartalmaz
rajzterletet kapunk. Az mfrow esetn a feloszts soronknt, az mfcol esetn pedig
oszloponknt trtnik.
Az aktulis felosztsrl a layout.show() fggvny ad tjkoztatst:
> par(mfrow=c(3,2)); layout.show(6)

A fggvny sorszmokkal azonostja a klnbz rajzterleteket, gy azok beazonosthatk,


nagysguk s elhelyezkedsk az brrl leolvashat:

A fenti feloszts az mfcol paramter belltsval is elrhet, de ekkor a rajzterletek


kiosztsa oszloponknt trtnik:
> par(mfcol=c(3,2)); layout.show(6)

A felosztott rajzterletekre az brk rajzolsa az azonostk sorrendjben trtnik, elszr az


1-es sorszm rajzterletre rajzolunk, majd a kvetkez magas-szint fggvnyhvs a 2-es
sorszm rajzterletre rajzol, s gy tovbb.
Ritkn elfordul, hogy a fenti sorrendet fell szeretnnk brlni s azt szeretnnk, hogy a
kvetkez magas-szint fggvnynk egy adott (nem a sorrendben kvetkez) rajzterletre
vonatkozzon. Ekkor az mfg paramtert hasznlhatjuk az aktulis rajzterlet belltsra:
> par(mfg=c(2,1,3,2))

68

Bevezets az R-be - 2013.09.16.

A fenti pldban arrl rendelkeznk, hogy a 2. sor 1. oszlopba kerljn a kvetkez bra. A
4 elem numerikus vektor utols kt rtke csak megismtli a feloszts tnyt, miszerint a
rajzterlet 3 sor s 2 oszlop mentn lett felosztva.
A rajzterlet rugalmasabb felosztst teszi lehetv layout() fggvny, amely a
paramterben szerepl mtrix rtkei mentn vgzi a felosztst. A rajzterlet rszei eltr
mretek is lehetnek, valamint gondoskodhatunk az egyms melletti rszek egyestsrl is.
A mfcol paramter hasznlatnl szerepl felosztst a kvetkez layout() fggvnyhvs
hajtja vgre:
> layout(matrix(1:6,ncol=2)); layout.show(6)

Ha eltr nagysg terletekre szeretnnk felosztani a rajzunkat, akkor a widths s a


heights paramterekkel llthatjuk be az oszlopok s a sorok egymshoz viszonytott
arnyt.
> layout(matrix(1:4,ncol=2), widths=c(1,2), heights=c(1,2))
> layout.show(4)

A feloszts itt egy 2x2-es mtrix alapjn trtnik, ahol a widths paramter a kt oszlop
szlessgt lltja be: a msodik oszlop az els oszlop szlessgnek ktszerese. A heights
paramter hasonlan hatrozza meg a sorok magassgt.
A layout() fggvny els paramterben szerepl mtrix azonos rtkeket is tartalmazhat,
ekkor egyms melletti rajzterletek sszevonsra van lehetsgnk:
> layout(matrix(c(1:3,3),ncol=2), widths=c(1,2), heights=c(1,2))
> layout.show(3)

A fenti kt felosztsi mdszertl alapjaiban eltr a split.screen() fggvnnyel trtn


feloszts.
> split.screen(c(2,1))
[1] 1 2

A pldban 2 sor s 1 oszlop mentn a rajzterletet egy fels s als rszre osztottuk. Ezek
azonostja a visszatrsi rtknek megfelelen 1 s 2. Az azonostkat felhasznlhatjuk az
adott rajzterlet tovbbosztshoz:

69

Bevezets az R-be - 2013.09.16.


> split.screen(c(1,3), screen=2)
[1] 3 4 5

A 2-es rajzterletet osztjuk 1 sor s 3 oszlop mentn hrom egyenl rszre, ezek j
azonostival tr vissza a fggvny. A rajzterlet kivlasztst a screen() fggvnnyel
vgezzk, paramterben egy rajzterlet azonostjt kell megadnunk. Rajzterlet tartalmt az
erase.screen() fggvnnyel trlhetjk, a rajzterlet felosztsbl a close.screen()
fggvnnyel lphetnk ki.

6.2. Az eszkzfellet rszei


Az eszkzfelleten egyetlen bra ltrehozsakor a kvetkez rszeket klnbztethetjk meg:
kls marg, braterlet, bels marg, rajzterlet. A 6.1. brn bellrl kifel haladva a
rajzterlet s a bels marg lthat, melyek egytt egy olyan braterletet alkotnak, amely
teljesen kitlti az eszkzfelletet. Kls marg alaprtelmezs szerint nincs, ezt magunknak
kell belltani.

6.1. bra
A rajzterletre kerlnek az brzoland pontok, vonalak, grbk, 2 s 3 dimenzis alakzatok.
A bels margn foglal helyet az bra cme s alcme, a tengelyek feliratai, a beosztsok
cmki s maguk a beosztsok is. A rajzterlet s a bels marg hatrn helyezkedik el a kt
tengely, valamint a rajzterletet krbevev szegly is.
A bels margk a mai (inch-ben mrt) s mar (szvegsorokban mrt) paramterek
segtsgvel krdezhetk le s llthatk be.
> par(c("mai", "mar"))
$mai
[1] 0.95625 0.76875 0.76875 0.39375
$mar
[1] 5.1 4.1 4.1 2.1

70

Bevezets az R-be - 2013.09.16.

A kapott rtkek rendre az als, bal oldali, fels s jobb oldali margkat jelentik.
A kls margk az omi s az oma paramterek segtsgvel kezelhetk s mint lttuk
alaprtelmezetten nem kerlnek belltsra:
> par(c("omi", "oma"))
$omi
[1] 0 0 0 0
$oma
[1] 0 0 0 0

Az omi az inch-ben mrt, az oma pedig a szvegsorban mrt margnagysgot hatrozza


meg. Ha 2 szvegsornyira lltjuk mindegyik kls margt
> par(oma=c(2,2,2,2))
> par(c("omi", "oma"))
$omi
[1] 0.375 0.375 0.375 0.375
$oma
[1] 2 2 2 2

akkor az eszkzfellet a 6.2. brnak megfelelen pl fel.

6.2. bra
A margkban (kls vagy bels) szveges informcit az mtext() fggvnnyel helyezhetnk
el. Az side paramter a marg kivlasztst jelenti (1=als, 2=bal, 3=fels, 4=jobb), a line
paramterrel a marg szvegsort adjuk meg (0-val kezddik), az outer paramter pedig a
kls vagy bels marg kztti vlasztsrl gondoskodik (TRUE=kls marg,
FALSE=bels marg). A kls s bels margba rhatunk a kvetkez parancsokkal:
> mtext("Kls marg", outer=T, line=2)

71

Bevezets az R-be - 2013.09.16.


> mtext("Bels marg", outer=F, line=1)

A bels s kls margba rhat szvegsorokrl a 6.3. bra tjkoztatst. Az mtext()


fggvny line paramtere hatrozza meg a szveg helyt, az adj paramter a szveg
igaztst (a tengelyekkel prhuzamos irnyban az adj=0 balra igazt, adj=1 jobbra igazt).

6.3. bra
Amennyiben az eszkzfelletnket tbb ablakra osztjuk az alaprtelmezett felosztsban az
ablakokban egy-egy braterlet tallhat, amelyek bels margval s rajzterlettel
rendelkeznek (6.4. bra).

6.4. bra

72

Bevezets az R-be - 2013.09.16.

A kls marg most is hinyzik, de a szoksos grafikus paramterek segtsgvel


bellthatjuk, ekkor a 6.5. brnak megfelel felosztst kapjuk.

6.5. bra
Termszetesen a margkba most is rhatunk tetszleges szveget az mtext() fggvny
segtsgvel a 6.6. brnak megfelelen.

6.6. bra

73

Bevezets az R-be - 2013.09.16.

6.3. Magas-szint rajzfggvnyek


A magas-szint rajzfggvnyek az aktv grafikai eszkzn hoznak ltre j brt, ami a
legtbbszr a rgi tartalom trlsvel jr. Az brhoz tbbek kztt tengelyek, cmkk s
feliratok tartoznak, amelyek megjelentsrl a grafikai paramterekkel gondoskodhatunk.
A legtbbszr hasznlt magas-szint fggvnyek a plot(), hist(), barplot(), boxplot(),
pie() s a curve().

6.3.1. A plot() fggvny


A plot() az R legalapvetbb fggvnye brk ltrehozsra. Egyik legegyszerbb
felhasznlsa, hogy az x s y tengelyek mentn a fggvny bemeneti paramtereiben
meghatrozott rtkprokhoz (mint x s y rtkekhez) egy-egy pontot jelentsen meg az brn
(6.7. bra):
> x<-21:30
> y<-51:60
> plot(x,y)

6.7. bra
Az x s y numerikus vektorok 10-10 elemek, a 6.7. brn is 10 pontot ltunk. Az els
pontnak megfelel karika a (21, 51) koordintj pontban rajzoldik ki, ezek a koordintk
az x s y vektor els elemei. A msodik kis karika rajzolshoz a numerikus vektorok 2.
elemeit hasznlja a plot(), ez a (22, 52) koordintj pont lesz. A tbbi 8 pont is hasonlan,
az azonos pozcin lv vektorelemeknek megfelel rtkprok alapjn jelenik meg az brn.
A plot() fggvny egyetlen vektorral is hvhat:
> x<-21:30

74

Bevezets az R-be - 2013.09.16.


> plot(x)

6.8 bra
A 6.8. brn a plot() fggvny a bemeneti x vektor alapjn jelent meg 10 pontot. A pontok
megjelentshez szksges kt koordinta kzl most csak az egyik az y koordinta ll
rendelkezsre, ezt ppen az x vektor elemei alkotjk. Az x koordintk az x vektor indexeibl
llnak, amely egy 10 elem vektor esetn az 1,2, ,10 elemeket jelenti. Az els brzolt pont
koordinti ennek megfelelen az (1, 21), a msodik (2, 22) s gy tovbb, az utols (10, 30).
A plot() fggvny paramterben a numerikus vektorok helyett faktorok is szerepelhetnek.
Ha egyetlen faktorral hvjuk, akkor oszlopdiagramot kapunk, ha faktorral s numerikus
vektorral, akkor dobozdiagramot kapunk. Ezeket az eseteket foglalja ssze a 6.9. bra.
>
>
>
>
>
>
+
>
>
+

layout(matrix(1:4,ncol=2, byrow=T))
x<-rnorm(10)
y<-rnorm(10)
f<-gl(2,3,10)
plot(x, main="Egy vltoz", xlab="Az x vektor indexei")
plot(f, main="Egy vltoz", sub="Kategorikus vltoz",
las=1, col="red", pch=16, , ylim=c(0, 8))
plot(cbind(x,y), main="Kt vltoz", ylim=c(-3,3), bty="l")
plot(y~f, main="Kt vltoz", xlab="Kategrikus vltoz",
ylab="Kvantitatv vltoz", ylim=c(-3,3))

75

Bevezets az R-be - 2013.09.16.

6.9. bra
A 6.9. bra megjelentshez a plot() fggvnyekben klnbz paramtereket
hasznlhatunk. Nzzk a legfontosabbakat sorban:
main

Az bra cme, fell, kzpen, kielmelten fog megjelenni.

sub

Az bra alcme, az bra aljn jelenik meg.

xlab, ylab

Az x s y tengely felirata, ha elhagyjuk, akkor az brzolt


objektum nevt olvashatjuk.

axes

A tengelyek s a rajzterletet szeglyeinek megjelentst


szablyozzuk. Alaprtelmezett rtke a TRUE. Ha FALSE
rtket adunk, akkor az axis() s a box() fggvnyekkel a
tengelyeket s a szeglyt ksbb is megrajzolhatjuk.

bty

A rajzterlet szeglyezst llthatjuk be. rtke egy karakter


lehet, melyek jelentse a kvetkez:
o

teljes keretet rajzol

bal oldalt s lent lesz csak szegly

fent s jobboldalt rajzol keretet

"c",

alul, baloldalt s fell lesz rajzol szeglyt

"u",

baloldalt, alul s jobboldalt kapunk keretet

"]"

fell, jobboldalt s alul jelenik meg szegly

nem jelent meg szeglyt

76

Bevezets az R-be - 2013.09.16.


xlim, ylim

Az x s y tengelyek brzolsi tartomnyt hatrozzuk meg.


rtkeik egy-egy ktelem numerikus vektor, melyek az
brzolt intervallum als s fels hatrait adjk.

fg, bg,

Az bra szneinek megadsra hasznlt paramterek.

col,
col.axis,
col.lab,
col.main,
col.sub
las

pch

Az x s y tengelyek cmki lehetnek prhuzamosak s


merlegesek a tengelyeikre nzve. A lehetsges eseteknek
megfelelen a paramter rtke lehet:
0

prhuzamosak a tengelykkel (alaprtelmezs)

x-re prhuzamos, y-ra merleges

merlegesek a tengelykre

x-re merleges, y-ra prhuzamos

A kirajzolt pont hatrozza meg. rtke vagy egy karakter s


ekkor az lesz a megjelentett pont alakja, vagy tipikusan egy
skalr 0 s 25 kztt.

lty
cex,
cex.axis,
cex.lab,
cex.main,
cex.sub
family,
font, font.axis,
font.lab,
font.main,
font.sub

A plot() fggvny fontos argumentuma a type, amelyikkel jelentsen mdosthatjuk azonos


adatok esetn is a megjelentst. A lehetsges rtkeket s a hozzjuk tartoz megjelentst a
6.10. bra tartalmazza.
>
>
>
>
>
>
>
>
>
>
>

layout(matrix(1:9,ncol=3, byrow=T))
x<-1:10; y<-rpois(10,lambda=5); m<-cbind(x=x,y=y-5)
plot(m,type="p",main='type="p"')
plot(m,type="l",main='type="l"')
plot(m,type="b",main='type="b"')
plot(m,type="c",main='type="c"')
plot(m,type="o",main='type="o"')
plot(m,type="h",main='type="h"')
plot(m,type="s",main='type="s"')
plot(m,type="S",main='type="S"')
plot(m,type="n",main='type="n"')

77

Bevezets az R-be - 2013.09.16.

6.10. bra

6.3.2. A curve() fggvny


A curve() fggvny segtsgvel egy x-ben vltoz fggvny grafikonjt rajzolhatjuk meg.
Az els argumentum kifejezse rja le az brzoland fggvnyt, amely R-beli matematikai
fggvnyek nevt is tartalmazhatja. A from s to paramterek hatrozzk meg a megjelents
rtelmezsi tartomnyt, az n paramter pedig, hogy sszesen hny behelyettests trtnjen a
fggvnybe. A 6.11. bra tartalmaz nhny pldt a curve() fggvny hasznlatra.
>
>
>
>
>

par(mfrow=c(2,2))
curve(12*x**2+3*x-1, from=-10, to=10)
curve(sin, from=-5, to=5)
curve(sin(x)/x, from=-20, to=20, n=200)
curve(dnorm(x,mean=5,sd=2),from=-1, to=11)

78

Bevezets az R-be - 2013.09.16.

6.11. bra

6.3.3. A hist() fggvny


A hist() fggvny segtsgvel hisztogramot rajzolhatunk, azaz bizonyos
osztlyintervallumokhoz tartoz tglalapokat lthatunk egyms mellet, melyek terletkkel
jelzik az osztlyintervallum (relatv)gyakorisgt. Az osztlyintervallumok ltrehozst a
bemen adatvektor alapjn a hist() fggvny is vgezheti, de tipikusabb a breaks
paramterrel vezrelni az intervallumok ltrehozst. A hist() fggvny legfontosabb
argumentumai a kvetkezk:
breaks

Az rtke lehet: (1) skalr (ekkor az osztlyintervallumok


szmt jelenti), (2) numerikus vektor (az osztlyintervallumok
hatrai), (3) karaktersorozat (az osztlyhatrok megllaptsra
hasznlt algoritmus neve ("Sturges", "Scott", "FD" /
"Freedman-Diaconis") vagy (4) egy sajt fggvny neve,
amely az osztlyokat ltrehozza.

freq

Gyakorisg (TRUE) vagy relatv gyakorisg (FALSE)


megjelentse kztt vlaszthatunk a paramter segtsgvel.
Alaprtelmezetten TRUE, de ha nem azonos nagysgk az
osztlyintervallumok, akkor FALSE lesz az rtke.

right

Az osztlyintervallumok bal vagy jobb oldali zrtsgt


szablyozhatjuk vele. Alaprtelmezett rtke a TRUE, ami jobb
oldali zrtsgot jelent, azaz ezek az rtkek mg az osztlyhoz

79

Bevezets az R-be - 2013.09.16.

tartoznak.

>
>
>
>
>
+
>
+
>
+

include.lowest

Amennyiben a right rtke TRUE s a legkisebb rtk az els


osztlyintervallum bal szls rtke, akkor az argumentum
TRUE
rtke
esetn
(ez
az
alaprtelmezett)
az
osztlyintervallumhoz sorolja a fggvny ezt az elemet. Ha a
right rtke FALSE (jobb oldali nyitottsg), akkor mindez a
legnagyobb rtkre s az utols osztly jobb szls rtkre
rtend.

plot

Ha megvltoztatjuk az alaprtelmezett TRUE rtket FALSE-ra,


akkor nem trtnik meg a hisztogram kirajzolsa, hanem a
visszatrsi rtkkel (ami egy lista) dolgozhatunk tovbb.

labels

Az oszlopok tetejn (relatv)gyakorisgot jelent meg.

par(mfrow=c(2,2))
x<-c(1,1,1,2,2,3)
rx<-rpois(120, lambda=5)
hist(x,ylim=c(0,4),labels=T)
hist(x,breaks=c(.5,1.5,2.5,3.5),right=TRUE,ylim=c(0,4),
labels=T,ylab="gyakorisg")
hist(x,freq=F,breaks=c(.5,1.5,2.5,3.5),right=TRUE,ylim=c(0,.6),
labels=T,ylab="relatv gyakorisg",col=rainbow(12))
hist(rx,freq=F,breaks=seq(0,20,3),ylab="relatv gyakorisg",
col=rainbow(10),main="Hisztogram",ylim=c(0,.2))

80

Bevezets az R-be - 2013.09.16.

6.12. bra

6.3.4. A boxplot() fggvny


A boxplot() fggvny a hisztogramhoz hasonlan az adatmegtekints vizualizlst segti
n. dobozdiagramok megjelentsvel. A dobozdiagramrl a minta terjedelme (legkisebb s
legnagyobb rtke), az als- s felskvartilis, illetve a medin olvashat le. ltalban tbb
csoport adatait hasonltjuk ssze a dobozdiagram segtsgvel.
A boxplot() fggvny range paramtervel a kiugr rtkek kezelst befolysolhatjuk.
>
>
>
>
>
>

par(mfrow=c(2,2))
rx<-rchisq(100,10)
boxplot(rx)
boxplot(rx,range=0)
boxplot(count~spray, data=InsectSprays, col="lightgray")
boxplot(decrease~treatment, data=OrchardSprays, col="bisque")

6.13. bra

6.3.5. A pie() fggvny


A krdiagramot a pie() fggvnnyel kszthetnk. A radius argumentum a kr sugart adja
meg, a clockwise a krcikkek krbejrsi irnyt adja meg.
> par(mfrow=c(2,2))

81

Bevezets az R-be - 2013.09.16.


> pie(rep(1,12), col = rainbow(20))
> pie(c(2,3,2,3,5), radius=0.9, clockwise = T)
> pie.sales <- c(0.12, 0.3, 0.26, 0.16, 0.04, 0.12)
> names(pie.sales) <- c("Honda", "Toyota", "Mazda", "Volkswagen", "Egyb",
"Skoda")
> pie(pie.sales)
> pie(pie.sales, col = gray(seq(0.4,1.0,length=6)))

6.14. bra

6.3.6. A barplot() fggvny


A barplot() fggvny oszlopdiagram ltrehozst teszi lehetv. Numerikus vektorbl vagy
mtrixbl hozhatunk ltre oszlopdiagramot. Hasznlhatjuk a horiz argumentumot, amellyel
fekv vagy ll oszlopdiagramot hozhatunk ltre vagy a space-t, amellyel az oszlopok
egyms kztti tvolsgt adhatjuk meg. Mtrix bemen paramter esetn az egy oszlopban
lv elemeket egy csoportpa sorolja a box() fggvny. A beside argumentum FALSE rtke
mellett a csoportok egyms mellett, a csoportok elemei pedig egyms felett jelennek meg. A
beside TRUE rtke mellett a csoportok elemei egyms mellett szerepelnek, de a csoportok
kztt nagyobb lesz a tvolsg. A fentieket szemllteti a 6.15. bra.
>
>
>
+
>

par(mfrow=c(2,2))
barplot(c(1:5,5:1),main="Vektor argumentum\nhoriz=F",col=heat.colors(10))
barplot(rpois(12, lambda=5),main="Vektor argumentum\nhoriz=T",
col=heat.colors(12),horiz=T)
m<-matrix(1:12,ncol=3); m
[,1] [,2] [,3]
[1,]
1
5
9
[2,]
2
6
10
[3,]
3
7
11

82

Bevezets az R-be - 2013.09.16.


[4,]
4
8
12
> barplot(m,main="Mtrix argumentum\nbeside=F",col=rainbow(4))
> barplot(m,main="Mtrix argumentum\nbeside=T, space=c(1,4)",
+
beside=T, space=c(1,4), col=rainbow(4))

6.15. bra

6.4. Alacsony-szint rajzfggvnyek


Az alacsony-szint fggvnyek segtsgvel meglv brinkhoz adhatunk hozz elemeket.
Szveget rhatunk a kls vagy bels margra az mtext(), az braterletre pedig a text()
fggvnnyel. Az braterltre pontokat helyezhetnk el points(), vonalakat a lines() s az
abline() fggvnnyel. Tovbb rajzolhatunk tglalapot a rect(), sokszget a polygon()
fggvnnyel. Az brnkra tengelyeket rajzolhatunk az axis(), szeglyeket a box(),
jelmagyarzatot a legend(), cmet s alcmet a title() fggvnnyel.

6.4.1. Szveg elhelyezse


Az mtext() fggvnyben a szveg helyt a line argumentum hatrozza meg: az
alaprtelmezett 0 segtsgvel a margra tudunk rni , de kintebb vagy beljebb is tudunk rni
a marghoz kpest pozitv vagy negatv rtk megadsa esetn. A text() fggvnyben a
szveg helyt a felhasznl koordintarendszerben rtend x s y argumentum rtkei
hatrozzk meg.
Mindkt fggvny esetben az adj argumentum hatrozza meg a szveg igaztst, ami
tipikusan 0 s 1 kztti numerikus rtk, de a legtbb grafikus eszkzn kibvthetjk ezt a
tartomnyt. A text() fggvny esetben ez a paramter ktelem vektor is lehet, az els rtk

83

Bevezets az R-be - 2013.09.16.

az x a msodik az y irnyban hatrozza meg az igaztst. Az mtext() fggvny esetben


egyetlen rtk is elegend igaztsra, a msik pozcit a line argumentum rtkbl
kvetkezik. Mindezt a 6.16. brrl is leolvashatjuk.
>
>
>
>
>
>
>
>
>
>
>

plot(1:10,xlab=expression(x[y]),ylab=expression(x^y), type="n")
mtext("mtext(line= -1,side=3)",line=-1,side=3)
mtext("mtext(line=1,side=3,adj=0.2)",line=1,side=3,adj=0.2)
mtext("mtext(line=0,side=4,adj=1)",line=0,side=4,adj=1)
points(2:7,2:7,pch=3, cex=4,col="red")
text(2,2,"text(2,2)")
text(3,3,"text(6,6,adj=c(0,0))",adj=c(0,0))
text(4,4,"text(4,4,adj=c(1,0))",adj=c(1,0))
text(5,5,"text(5,5,adj=c(0,1))",adj=c(0,1))
text(6,6,"text(6,6,adj=c(1,1))",adj=c(1,1))
text(7,7,"text(7,7,adj=c(0.5,0.5))",adj=c(.5,.5))

6.16. bra
Az x s y tengely feliratban als s fels indexet is hasznlhatunk. Ehhez az expression()
fggvnyt hasznljuk fel, amellyel kifejezseket hozhatunk ltre az R-ben. Als indexek
rsra a szgletes zrjelet (pl. x[y]), fels indexre a hatvnyozs jelt (pl. x^y)
hasznlhatjuk.
A megjelentend szveg bettpust is megvltoztathatjuk a font s a family argumentumok
segtsgvel. A font rtkei: 1=norml, 2=flkvr,3=dlt s 4=flkvr/dlt. A family
argumentum egy betcsald nevt tartalmazhatja, alaprtelmezett rtkei a serif, sans,
mono s symbol lehetnek. A szmtgpen egyb betcsaldok a windowsFonts() s a
windowFont() fggvnyek hasznlata utn lesznek elrhetek az R-ben.
> windowsFonts( font.comic = windowsFont("Comic Sans MS"),

84

Bevezets az R-be - 2013.09.16.


+
+
+
>
>
>
>
>
>
>
>
>
>

font.verdana = windowsFont("Verdana"),
font.trebuchet = windowsFont("Trebuchet MS"),
font.book.antiqua = windowsFont("Book Antiqua"))
plot(1:10,type="n",xlab="",ylab="")
par(cex=1.4)
text(2,8,"serif",family="serif",font=1)
text(2,6,"sans",family="sans",font=2)
text(2,4,"mono",family="mono",font=3)
text(2,2,"symbol",family="symbol",font=4)
text(8,8,"Comic Sans MS",family="font.comic",font=1)
text(8,6,"Verdana",family="font.verdana",font=2)
text(8,4,"Trebuchet MS",family="font.trebuchet",font=3)
text(8,2,"Book Antiqua",family="font.book.antiqua",font=4)

6.17. bra

6.4.2. Pontok, vonalak


A points() fggvny x s y paramtere a megjelentend pontok koordintit tartalmazzk,
mg a lines() fggvny ugyanezen paramterek mellett egyenes szakaszokkal kti ssze
pontokat. A megjelentend pontok alakjt a pch, a vonalak tpust pedig a lty paramter
hatrozza meg.
>
>
>
>
>
>
>
>
>

plot(1:10, type="n")
x<-c(1,2,3,1,2,1,3,2,1,2)
points(1:10,x+7, pch="*",cex=2)
lines(1:10,x+4.4,lty=1)
lines(1:10,x+4, lty=2, lwd=1.5)
lines(1:10,x+3.6,lty=3, lwd=2)
lines(1:10,x+3.2,lty=4, lwd=2.5)
lines(1:10,x+2.8,lty=5, lwd=3)
lines(1:10,x+2.2,lty=6, lwd=3.5)

85

Bevezets az R-be - 2013.09.16.


> points(1:10,x,
> lines(1:10,x,

pch=16)
lty=5)

6.18. bra
Egyeneseket az abline() segtsgvel is ltrehozhatunk. Legfontosabb argumentumok az a s
a b, amelyek az y tengellyel val metszspontot s az egyenes meredeksget adjk meg.
Fggleges s vzszintes egyeneseket is rajzolhatunk a v s h paramterek megadsval.
>
>
>
>
>
>
>
>
>

plot(-4:5,-4:5, type="n",xlab="",ylab="")
abline(h=0, v=0, col = "gray60")
text(0.1,0, "abline ( h = 0 )",col="gray60",adj=c(0,-0.1))
text(0,0.1, "abline ( v = 0 )",col="gray60",adj=c(0,-0.1),srt=90)
abline(h = -3:4, v = -3:4, col = "lightgray", lty=3)
abline(a=1, b=2, col="blue")
text(1,3,"abline( 1, 2 )", col="blue",adj=c(-.1,-.1))
abline(a=-2, b=-1, col="blue")
text(1,-3,"abline( -2, -1 )", col="blue",adj=c(-.1,-.1))

86

Bevezets az R-be - 2013.09.16.

6.19. bra

6.4.3. Tglalapok, poligonok, nyilak


A rect() fggvnnyel tglalapot rajzolhatunk az braterletre. A tglalapok bal als s jobb
fels sarknak x s y koordintjt kell megadnunk, ezek rendre: xleft, ybottom, xright,
ytop.
>
>
>
>
+

plot(100:500,100:500, type="n",xlab="",ylab="")
x<-runif(50)*350
y<-runif(50)*330
rect(100+x, 100+y, 150+x, 170+y, col=rainbow(11,start=.7,end=.1),
border=gray(x/400),lwd=x%%10)

87

Bevezets az R-be - 2013.09.16.

6.20. bra
A polygon() fggvny tetszleges egyenesekkel hatrolt skidomok ltrehozsrt felels.
Az x s y paramterben vrja a cscspontok koordintit. A lenti pldban a vonalak
rajzolsra hasznlatos segments() fggvny is bemutatsra kerl, azt lthatjuk, hogy a
polygon() fggvny argumentuma, hogyan feleltethet meg a segments() fggvny
bemen paramternek.

my_segments<-function(x,y) {
i<-1:(length(x)-1)
segments(x[i],y[i],x[i+1],y[i+1])
segments(x[length(x)],y[length(x)],x[1],y[1])
}
plot(-4:5,-4:5, type="n",xlab="",ylab="")
abline(h=0, v=0, col = "gray60")
abline(h = -4:5, v = -4:5, col = "lightgray", lty=3)
x<-c(-4,-1,0)
y<-c(1,2,1)
polygon(x,y,col="gray")
y<-y+2
my_segments(x,y)
x<-c(1,2,3,4)
y<-c(1,2,2,1)
polygon(x,y,col="gray")
y<-y+2
my_segments(x,y)
my_func<-function(x) {

88

Bevezets az R-be - 2013.09.16.


return (5*dnorm(x,mean=-2,sd=.6)-4)
}
curve(my_func,from=-4,to=0, add=T)
xp<-seq(-4,-2.5,.01)
polygon(c(xp,-2.5),c(my_func(xp),-4),col="red")
curve(my_func(x-5),from=1,to=5, add=T)
xp<-seq(2,4,.01)
polygon(c(2,xp,4),c(-4,my_func(xp-5),-4),col="red")

6.21. bra

6.4.4. Egyb kiegsztk


Ha brnk ltrehozsa sorn korbban nem gondoskodtunk cm/alcm, tengelyek, szegly
vagy jelmagyarzat megrajzolsrl, akkor alacsony-szint rajzfggvnyekkel utlag is
hozzadhatjuk ezeket a grafiknkhoz.
A tilte() fggvny fontosabb argumentumai a kvetkezk:
main, sub

Az bra cmnek s alcmnek meghatrozsra hasznljuk.

xlab, ylab

Tengelyfeliratok hozzadsa.

line

Az alaprtelmezett szvegpozcit
meghatrozzuk a szvegsor sorszmt.

outer

Az bra cmt a kls margra rhatjuk ha TRUE rtket adunk


meg.

89

rhatjuk

fell,

ha

Bevezets az R-be - 2013.09.16.

A box() fggvny legfontosabb argumentuma:


which

A bekeretezend terlet meghatrozsa. rtkei lehetnek:


plot

rajzterlet szeglyezse

figure braterlet szeglyezse


inner

tbb bra esetn az braterleteket fogja ssze

outer

az eszkzfellet szeglyezse

A tengelyek megjelentst szablyz grafikai paramterek, az axis() fggvny hasznlata


sorn:
xaxt, yaxt

Az x s y tengely kirajzolst tilthatjuk meg, ha n rtkkel


ltjuk el. Alaprtelmezett az s, ekkor megrajzolja az illet
tengelyt. (Hasonl a szerepe, mint az axes argumentumnak.)

mgp=c(3,1,0)

A tengely egyes rszeinek a rajzterlet szltl mrt tvolsgt


meghatroz 3 elem vektor. Az els rtk a tengelyfelirat, a
msodik a tengelycmkk, a harmadik magnak a tengely
vonalnak a margjt adja meg.

lab

Hromelem numerikus vektor, amelynek az els kt elemvel


az x s az y tengely beosztsainak a szmt hatrozhatjuk meg.
A tnyleges osztsszm az ltalunk megadott rtktl eltrhet.
A harmadik elemet nem veszi figyelembe az R.

xaxp, yaxp

Leginkbb lekrdezsre sznt 3 elem numerikus vektor. Az


els s msodik elem a kt szls beoszts rtket adja, a
harmadik elem pedig az osztlyok szmt.

xaxs, yaxs

Az alaprtelmezett r rtk mellett a tengelyek ltal tfogott


intervallum az brzoland adatokbl kiszmolt vagy az xlim,
ylim paramterekbl kapott intervallumnl 4%-al nagyobb lesz.
Pontos egyezshez az i rtket kell megadnunk.

tck,
tcl,
las,
xlim, ylim, log,
xlog, ylog

Korbban mr szerepletek.

Az axis() fggvny fontos argumentumai:


side

A rajzoland tengely helye: 1=lennt, 2=balra, 3=fennt,


4=jobbra..

at=NULL

A beosztsok helyt hatrozza meg. Ha az rtke NULL, akkor


automatikusan szmolja az R, egybknt a megadott numerikus
vektor elemeinek megfelel helyre kerl beoszts.

labels

A beosztsok cmkit hatrozza meg.

Jelmagyarzat tbbnyire a rajzterleten bell foglal helyet, a pozcijt is a felhasznli


koordintkban kell megadni. A jelmagyarzat ltrehozst szmos paramter segti, de az

90

Bevezets az R-be - 2013.09.16.

brn szerepl s a jelmagyarzatban hasznlt jelek kztti sszhangot neknk kell


megteremteni, az R semmilyen ellenrzst nem vgez ezzel kapcsolatban.
A legend() fggvny argumentumai:
x, y

A jelmagyarzat bal fels sarknak a koordinti a rajzterlet


koordintiban mrve.
Az x argumentum karakteres rtkvel az igaztst adhatjuk
meg: "bottomright", "bottom", "bottomleft", "left",
"topleft", "top", "topright", "right" and "center"

legend
fill,
pch

lty,

A jelmagyarzat szvegt tartalmaz karakteres vektor.


lwd,

A jelmagyarzat szvegt s az brn hasznlt jeleket sszekt


szimblumok ltrehozsra hasznlhat argumentumok.

inset=0

Ha kulcsszavakat hasznlunk az igaztsra, akkor a margtl


mrt tvolsgot itt adhatjuk meg.

merge

Ha pontokat s vonalakat is hasznlunk a jelmagyarzatban,


akkor TRUE rtk mellett ezeket kombinlja a megjelentskor.

horiz=FALSE

A jelmagyarzat tjolst befolysol logikai paramter.

ncol=1

A jelmagyarzat oszlopainak a szmt hatrozza meg.

text.col, bg

A szveg szne s a httrszn jelmagyarzatban.

>
>
>
>

op<-par()
par(oma=c(.5,.5,2,.5))
par(mfrow=c(2,2))
x<-rnorm(10)

>
>
>
>
>
>
>
>
>
>
>

plot(x,main="",axes=F,xlab="",ylab="",col=gray(0.7))
text(5.5,0,"Alaprtelmezett",font=2)
title(main="Cm a kls margn",outer=T,line=0.2)
title(main="Cm a bels margn")
title(sub="ALCM")
title(xlab="x",ylab="y")
box("outer",lty=1,col=grey(.2))
box("inner",lty=2,col=grey(.4))
box("figure",lty=3,col=grey(.6))
box("plot",lty=4,col=grey(.8))
axis(1, at=1:10);axis(2)

>
>
>
>

par(xaxs="i")
par(yaxs="i")
par(mgp=c(2,.5,0))
plot(x,main='xaxs="i",yaxs="i",mgp=c(2,.5,0)',axes=F,
+
xlab="axis(1,at=1:10,tcl=.3)",ylab="")
> box("plot",lty=4,col=grey(.8))
> axis(1,at=1:10,tcl=.3)
>
> par(xaxs="r")
> par(yaxs="r")
>
> par(mgp=c(3,1,-.2))
> plot(x,main='xaxs="r",yaxs="r",mgp=c(3,1,.2)',axes=F,xlab="axis(1,at=3:8,labels=LETTERS[1:6])",ylab="")

91

Bevezets az R-be - 2013.09.16.


>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>

box("plot",lty=4,col=grey(.8))
axis(1,at=3:8,labels=LETTERS[1:6])
axis(2)
axis(4)
par(mgp=c(3,1,0))
par(mar=c(1,1,1,1))
plot(1:10,main="",axes=F,xlab="",ylab="",type="n")
box("figure",lty=3,col=grey(.6))
box("plot",lty=4,col=grey(.8))
legend("topleft",LETTERS[1:3],lw=1:3,inset=.1)
legend("top",LETTERS[1:3],lty=1:3,inset=.1)
legend("topright",LETTERS[1:3],lty=1:3,pch=0:3,inset=.05)
legend("right",LETTERS[1:3],lw=1:3,pch=0:3)
legend("bottomright",LETTERS[1:3],fill=2:4,text.col=2:4)
legend(1,7, as.character(0:25), pch = 0:25,ncol=4,cex=1.2)
par(op)

6.22. bra

6.5. Interaktv grafikus fggvnyek


Az R hagyomnyos grafikus rendszere elssorban statikus brk ltrehozst tmogatja, a
ksz grafikn tovbbi interaktv mveletekre csak korltozottan van lehetsg. Ezek kzl
most a locator() s az identify() fggvnyeket tekintjk t.

92

Bevezets az R-be - 2013.09.16.

A locator() fggvny lehetv teszi, hogy a felhasznl a rajzterleten az egr bal


gombjval kijelljn egy vagy tbb pontot. A fggvny visszatrsi rtke egy lista, amely a
megjellt pontok x s y koordintit sorolja fel.
> legend(locator(1), as.character(0:25), pch = 0:25)

A locator() fggvny fontosabb argumentumai:


n

A meghatrozand pontok maximlis szmt adhatjuk meg.


Alaprtelmezetten 512 pont helyt kaphatjuk meg.

type

rtke az n, p, l vagy o karakter valamelyike lehet.


Az alaprtelmezett n esetben az egrkattints utn nem
trtnik megjelents, mg p s o hatsra egy pont fog
megjelenni, l vagy o estn pedig vonal fogja sszektni a
megjellt helyeket.

Az identify() fggvny a rajzterleten megjelen adatpontokhoz rendel cmkt. A locator()


fggvnyhez hasonlan az egr bal gombjval itt is ki kell jellni egy pontot a rajzterleten,
majd a fggvny a megjellt ponthoz legkzelebb lv adatponthoz rendel egy cmkt. Az
indentify() fggvny visszatrsi rtke az azonostott adatpontok indexe.
> library(MASS)
> attach(mammals)
> plot(body,brain,log="xy")
> identify(body,brain,row.names(mammals),n=10)
[1] 2 7 32 35 36 44 46 48 52 58

Az identify() fggvny fontosabb argumentumai:


x, y

Numerikus vektorok, amelyek az bra adatpontjainak x s y


koordintit hatrozzk meg.

labels

Karakteres vektor, amely egyes adatpontok cmkit tartalmazza.


Az x s y argumentumokkal azonos hossz vektor,
alaprtelmezetten sorszmokat tartalmaz.

pos=FALSE

Ha FALSE az rtke, akkor a fggvny az azonostott


adatpontok indexvel fog visszatrni. Ha TRUE, akkor egy
listval, amely az ind elemben az indexeket, pos elemben
pedig a cmke adatponthoz viszonytott helyt tartalmazza
(1=lennt, 2=balra, 3=fennt, 4=jobbra, ill. 0=ekkor az
atpen=TRUE volt)

A megjelellend pontok szma.

plot=TRUE

Logikai rtk, amely ha TRUE (ez az alaprtelmezett), akkor


megjelent cmkket, egybknt nem.

atpen=FALSE

A cmke pozcija TRUE rtk esetn az egrkattints helye lesz,


FALSE esetn automatikusan kerl meghatrozsra.

offset=0.5

A cmke s az adatpont tvolsga. A numerikus rtk a


karakterszlessghez mrt. Az atpen=FALSE esetn nem
hasznlja az R.

93

Bevezets az R-be - 2013.09.16.

tolarence=0.25

Inch-ben mrt numerikus rtk, amely az egrkattints s a


kzeli adatpont kztti maximlis tvolsgot jelenti.

6.5. Trellis grafika


Az elz fejezetekben megismert rajfggvnyek az R hagyomnyos grafikus lehetsgei kz
tartoznak.

6.6. A ggplot2 grafika

94

Bevezets az R-be - 2013.09.16.

7. Matematika az R-ben
7.1. Eloszlsok
Elre definilt eloszlsok szles krt biztostja szmunkra az R. Mindegyik eloszlshoz ngy
fggvny tartozik, amelyek csak az egy bets eltagban (prefix) klnbznek. A prefixknt
hasznlhat d, p, q s r jelentse a kvetkez:

d az eloszls rtkeire krdezhetnk r: diszkrt esetben az adott rtk elfordulsi


valsznsgt kapjuk, folytonos esetben a srsgfggvny adott pontbeli rtkt,

p a kommulatv eloszls, azaz az eloszlsfggvny adott pontbeli rtkt kapjuk,

q az eloszls kvantilisei, azaz egy adott valsznsghez tartoz rtket kapunk,

r adott szm vletlen szmot generlhatunk az adott eloszlsbl.

A kvetkez tblzat foglalja ssze az R-ben hasznlhat legfontosabb eloszlsokat. Ha


kivlasztjuk pldul a normlis eloszls norm() fggvnyvget, akkor az eltagok
hasznlatval megkaphatjuk a mr vals dnorm(), pnorm(), qnorm() s rnorm()
fggvnyeket.
Eloszls (*-diszkrt)
bta
binomilis*
Cauchy
2
exponencilis
Fisher F
gamma
geometriai*
hipergeometrikus*
logisztikus
lognormlis
negatv binomilis*
normlis
Poisson*
Wilcoxon*
Student t
egyenletes
Weilbull
Wilcoxon*

Fggvny vge

Eloszls paramterei
shape1, shape2
size, prob
location, scale

beta()
binom()
cauchy()
chisq()
exp()
f()
gamma()
geom()
hyper()
logis()
lnorm()
nbinom()
norm()
pois()
signrank()
t()
unif()
weibull()
wilcox()

df
rate
df1, df2
shape
prob
m, n, k
location, scale
meanlog, sdlog
size, prob
mean, sd
lambda
n
df
min, max
shape, scale
m, n

A folytonos normlis eloszls s a diszkrt binomilis eloszls segtsgvel bemutatjuk a fenti


fggvnyek hasznlatt. A normlis eloszlshoz tartoz ngy fggvny hasznlatra ltunk
pldt a 7.1. brn.
>
>
>
>
>
>

# Elkszts
par(mfrow=c(2,2)); x<-seq(-3,3,0.1); p<-seq(0,1,0.01)
# 1. bra: dnorm()
plot(x,dnorm(x),type="l",main="dnorm()")
polygon(c(x[x<=-1],-1),c(dnorm(x[x<=-1]),dnorm(-3)),col="grey")
text(-2.2,.2,paste("p=",round(pnorm(-1),3),sep=""),adj=c(.5,0))

95

Bevezets az R-be - 2013.09.16.


>
>
>
>
>
>
>
>
>
>
>
>
>
>
>

arrows(-2.2,.18,-1.5,.05,length=0.1)
# 2. bra: pnorm()
plot(x,pnorm(x),type="l",main="pnorm()")
arrows(-1,0,-1,pnorm(-1),col="red",length=0.1)
arrows(-1,pnorm(-1),-3,pnorm(-1),col="green",length=0.1)
text(-2,.4,paste("( -1,", round(pnorm(-1),3),")"),adj=c(.5,0))
arrows(-2,.38,-1,pnorm(-1),length=0.1)
# 3. bra: qnorm()
plot(p,qnorm(p),type="l",main="qnorm()")
arrows(pnorm(-1),-3,pnorm(-1),-1,col="red",length=0.1)
arrows(pnorm(-1),-1,0,-1,col="green",length=0.1)
text(.2,1,paste("( ", round(pnorm(-1),3),", -1 )",sep=""),adj=c(.5,0))
arrows(.2,0.8,pnorm(-1),-1,length=0.1)
# 4. bra: rnorm()
plot(rnorm(50),type="h",main="rnorm(50)")

7.1. bra
A dnorm() fggvny alaprtelmezs szerint a standard normlis eloszls
srsgfggvnynek rtkeit szolgltatja. A mean s az sd argumentumokkal tetszleges
paramter normlis eloszlst definilhatunk.
A binomilis eloszlshoz tartoz ngy fggvnyre a 7.2. brn ltunk pldt.
>
>
>
>
+
>

# Elkszts
par(mfrow=c(2,2)); x<-0:10; p<-seq(0,1,0.01)
# 1. bra: dbinom()
barplot(dbinom(x,size=10,prob=.3),main="dbinom(size=10,prob=.3)",
names.arg=0:10,col=c(rep("gray",5),rep("white",5)),ylim=c(0,.3))
text(9,.2,paste("p=",round(pbinom(4,size=10,prob=.3),3),sep=""))

96

Bevezets az R-be - 2013.09.16.


>
>
+
>
>
+
>
+
+
>
>
>
>
>
>

# 2. bra: pbinom()
plot(x,pbinom(x,size=10,prob=.3),type="h",main="pbinom()",
axes=F,col=gray(.4))
box(); axis(1,at=0:10); axis(2)
segments(4, pbinom(4,size=10,prob=.3),
-1,pbinom(4,size=10,prob=.3),lty=2,col="red")
text(2,pbinom(4,size=10,prob=.3),
paste("p=",round(pbinom(4,size=10,prob=.3),3),sep=""),
adj=c(.5,-.3))
# 3. bra: qbinom()
plot(p,qbinom(p,size=10,prob=.3),type="s",main="qbinom()")
segments(.85,-1,.85,4,lty=2,col="red")
segments(pbinom(3,size=10,prob=.3),4,-1,4,lty=2,col="red")
# 4. bra: rbinom()
plot(rbinom(25,size=10,prob=.3),type="h",main="rbinom(25)")

7.2. bra

97

Bevezets az R-be - 2013.09.16.

Irodalomjegyzk
[1] R <-...erre, erre...! (Bevezets az R-nyelv s krnyezet hasznlatba) (szerz: Solymosi
Norbert)
[2] Crawley, Michael J. The R Book. John Wiley & Sons Ltd, England. 2007.

98

Bevezets az R-be - 2013.09.16.

R feladatok
Alapok
Hatrozzuk meg az els szz termszetes szm sszegt!
Hatrozzuk meg a szznl kisebb pratlan termszetes szmok sszegt!
Hatrozzuk meg az els szz pros termszetes szm sszegt!
Hatrozzuk meg az els szz, 3-mal oszthat termszetes szm sszegt!
Hatrozzuk meg a szznl kisebb, 3-mal oszthat termszetes szmok sszegt!
Hatrozzuk meg az els tz ngyzetszm sszegt!
Ksztsnk egy olyan 10 elem vektort, amelynek elemei egy szmtani sorozat
egymst kvet elemei! Legyen az utols elem 120, a szomszdos elemek kztti
tvolsg pedig 3!
8. Ksztsnk egy olyan 10 elem vektort, amelynek elemei egy szmtani sorozat
egymst kvet elemei! Legyen az els elem a hexadecimlis E01, a szomszdos
elemek kztti tvolsg pedig 12!

9. Ksztsnk egy 10 elem vektort, mely a sin i , i=1,,10 rtkeket tartalmazza!
2
(gyeljnk a kerektsre, hasznljuk a round() fggvnyt!)
10. Ksztsnk egy olyan 10 elem vektort, amelynek elemei egy mrtani sorozat egymst
kvet elemei! Legyen az els elem 20, a szomszdos elemek kztti hnyados pedig
3!
11. Hozzunk ltre egy y vektort, mely egy tetszleges x vektor elemeit 2-szer egyms utn
felsorolva tartalmazza!
12. Hozzunk ltre egy y vektort, melynek els s utols eleme legyen 0, valamint a
kzbls rtkek egy tetszleges x vektor elemeit 2-szer egyms utn felsorolva
tartalmazzk!
13. Hozzunk ltre egy y vektort, mely egy tetszleges x vektor elemeit 12-szer egyms
utn felsorolva tartalmazza!
14. Hozzunk ltre egy y vektort, mely egy tetszleges x vektor elemeinek mindegyikt 12szer rendre megismtli!
15. Hozzunk ltre egy y vektort, mely egy tetszleges x vektor els elemt 12-szer
megismtli, az sszes tbbi x elemet pedig 1-szer felsorolva tartalmazza!
16. Tltsk fel 0-val a 10 elem x vektor pros index elemeit!
17. Tltsk fel 0-val a 10 elem x vektor pratlan index elemeit!
18. Tltsk fel 0-val a tetszleges elemszm x vektor pros index elemeit!
19. Hozzunk ltre egy y vektort, mely egy tetszleges x vektor elemeit fordtott
sorrendben tartalmazza!
20. Hozzunk ltre egy y vektort, mely egy tetszleges x vektor elemeinek als felt
tartalmazza! (Pratlan elemszm x esetn az als kisebbik felt. Hasznljuk a
floor() fggvnyt!)
21. Hozzunk ltre egy y vektort, mely egy tetszleges x vektor elemeinek fels felt
tartalmazza! (Pratlan elemszm x esetn a fels nagyobbik felt. Hasznljuk a
ceiling() fggvnyt!)
1.
2.
3.
4.
5.
6.
7.

Egyb adatszerkezetek
1. Ksztsnk egy csupa 0 elemeket tartalmaz, 3 sorbl s 4 oszlopbl ll mtrixot!
2. Ksztsnk egy 3 sorbl s 5 oszlopbl ll mtrixot, amelynek elemei a sor- s
oszlopindexek szorzatait tartalmazza!

99

Bevezets az R-be - 2013.09.16.

Megoldsok
Alapok
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.

sum(1:100)
[1] 5050
sum(seq(from=1, to=99, by=2))
[1] 2500
sum(seq(from=2, by=2, length.out=100))
[1] 10100
sum(seq(from=3, by=3, length.out=100))
[1] 15150
sum(seq(from=3, to=99, by=3))
[1] 1683
sum((1:10)^2)
[1] 385
seq(to=120, by=3, length.out=10)
[1] 93 96 99 102 105 108 111 114 117 120
seq(from=0xE01, by=12, length.out=10)
[1] 3585 3597 3609 3621 3633 3645 3657 3669 3681 3693
round(sin((pi/2)*(1:10)))
[1] 1 0 -1 0 1 0 -1 0 1 0
20*3^(0:9)
[1]
20
60
180
540
1620
4860 14580
43740 131220 393660
y<-c(x,x)
y<-c(0,x,x,0)
y<-rep(x, times=12)
y<-rep(x, each=12)
y<-rep(x, times=c(12,rep(1,length(x)-1)))
x[(1:5)*2]<-0
x[(0:4)*2+1]<-0
x[c(F,T)]<-0
y<-x[length(x):1]
y<-x[1:floor((length(x)/2))]
y<-x[ceiling((length(x)/2)):length(x)]

Egyb adatszerkezetek
1. m<-matrix(0,nrow=3, ncol=4)
2. m<-matrix(c(1:5,(1:5)*2,(1:5)*3),nrow=3,ncol=5,byrow=T)

100