Abari Kálmán Bevezetés Az R-Be

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
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
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
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.

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

>
>
>
>
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
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
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
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
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
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
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
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
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
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
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
FALSE | TRUE
FALSE | FALSE
21
TRUE
FALSE
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
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

> 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

> 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
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

> 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
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

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

> 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

> 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
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

[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

> 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
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

> 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

[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

[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
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

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
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

[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

> 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

[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

> 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
$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

[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
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

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
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
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
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
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
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
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,]
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

> 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),];
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
18.9 1 0
4
4
17.6 0 0
3
3
18.9 1 0
4
4
17.4 0 0
3
3
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),]
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)
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

> 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
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

> mtcars3<-mtcars2
# j adattbla
> rownames(mtcars3)<-mtcars3$name
# sornevek meghatrozsa
> mtcars3<-mtcars3[2:11]
# a felesleges els oszlop trlse
> mtcars3[1:10,]
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

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],]
AMC Javelin
15.2
8 304.0 150 3.15
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

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
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,]
Duster 360
14.3
8 360 245 3.21 3.570 15.84 0 0
3
4
8 472 205 2.93 5.250 17.98 0 0
3
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

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,]
8 472 205 2.93 5.250 17.98 0 0
3
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
8 472 205
8 460 215
Chrysler Imperial
14.7
8 440 230
drat
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

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

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

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

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

> 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
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

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
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

> 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
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

> 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
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
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

> 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
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

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
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
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
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
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

> 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

[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
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(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

+
+
+
>
>
>
>
>
>
>
>
>
>
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

> 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
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
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

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
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
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

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

>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
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

>
>
+
>
>
+
>
+
+
>
>
>
>
>
>
# 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
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
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
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

Abari Kálmán Bevezetés Az R-Be

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Abari Kálmán Bevezetés Az R-Be

Uploaded by

Copyright:

Available Formats

Bevezets az R-be

Oktatsi segdlet VZLAT 0.2

Bevezets az R-be - 2013.09.16.

Bevezets az R-be - 2013.09.16.

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

Bevezets az R-be - 2013.09.16.

Bevezets az R-be - 2013.09.16.

1.3. Munkafolyamat (session) az R-ben

Bevezets az R-be - 2013.09.16.

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

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

.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

1.4. Az R parancssoros hasznlata

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

Bevezets az R-be - 2013.09.16.

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

1.5. Szkriptek vgrehajtsa

Bevezets az R-be - 2013.09.16.

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

1.6 A csomagok hasznlata

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

paranccsal krdezhetk le. Betlttt csomagok esetben hasznlhatjuk az

parancsot is. Betlttt csomagot a

paranccsal tvolthatunk el a krnyezetbl.

paranccsal telepthetnk szmtgpnkre. A fggvny mkdshez Internet kapcsolatra van

Bevezets az R-be - 2013.09.16.

1.7. Segtsg az R hasznlathoz

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

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

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

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

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

Bevezets az R-be - 2013.09.16.

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

Bevezets az R-be - 2013.09.16.

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

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

Termszetesen a matematikban megszokott mdon vltoztathatunk a mveletek

szmok, amelyeket az R numerikus konstansnak nevez,

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

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

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

pozitv s negatv egsz

Bevezets az R-be - 2013.09.16.

1200, 30000, 0.006, 40

0xef, 0Xf01, 0xEf03, 0xd1L

239, 3841, 61187, 209

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

maradkos oszts s egsz

A fentiek alapjn sszetettebb aritmetikai kifejezseket is megfogalmazhatunk az R

Az aritmetikai kifejezsek hasznlata sorn ne felejtkezznk meg az opertorok

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

Bevezets az R-be - 2013.09.16.

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

Bevezets az R-be - 2013.09.16.

Most teht a mr ltez a objektum rtkt vltoztattuk meg.

Objektumot azonban kifejezsekben is felhasznlhatjuk, akr rtkads jobb oldaln lv

2.2.2. Objektumok elnevezse

# j objektumot hozunk ltre

Bevezets az R-be - 2013.09.16.

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