Legtöbbször a legjobb ábrák a legegyszerűbb ábrák! Az alábbiakban áttekintünk néhány egyszerű ábrakészítési módot, amelyek segíségével a leggyakrabban előforduló ábrázolási problémáinkat orvosolhatjuk. Fontos megjegyezni, hogy ábrát a matplotlib
segítségével több hasonló módon is elő lehet állítani. Az alábbiakban törekedünk a lehető legegyszerűbb módszer bemutatására. Fontos azt is megjegyezni, hogy az alábbi példákban előforduló függvényopciók (kulcsszavas argumentumok) lehetséges értékeinek csak egy szűk halmazára térünk ki. A megfelelő paraméterek lehetséges értékei után vagy a matplotlib mintapáldái vagy a megfelelő függvények, pl. plot
,hist
,pcolor
, contour
és contourf
docstring-jében érdemes kutatni!
In [1]:
#a már megszokott betöltési parancs
%pylab inline
Sok esetben a feladat egy ismert adathalmaz, netán egy analitikus függvény ábrázolása. Ha analitikus fügvénnyel van dolgunk, akkor az ábrázoláshoz először legyártunk kiértékelési pontokat, ezután ezekben a pontokban kiértékeljük az adott függvényt. Az alábbi példában a $\sin(x)$ függvényt fogjuk kiértékelni a $[-\pi,\pi]$ intervallumban 25 pontban.
In [2]:
x=linspace(-pi,pi,25);
y=sin(x);
Az ábrázolás (ahogy azt már korábban is láttuk) a plot
paranccsal történik.
In [3]:
plot(x,y)
Out[3]:
Vizsgáljunk meg néhány kulcsszavas argumentumot, amely segítségével a plot
parancs kimenetelét tudjuk változtatni.
A color
kulcsszó az ábrázolt adat színeit változtatja meg. Ez az ábra tartalmazza a matpotlib
-ben néven nevezett színek nevét. Változtassuk meg a fenti ábrában a görbe színét pirosra!
In [4]:
plot(x,sin(x),color='red')
Out[4]:
A linewidth
kulcsszó segítségével a vonalszélességen változtathatunk.
In [5]:
plot(x,sin(x),linewidth=3)
Out[5]:
A linestyle
kulcscszó a vonalstílust állítja be. Ez lehet megnevezett kulcsszó (mint az alábbi példában) vagy szimbólum is.
In [6]:
plot(x,sin(x),linestyle='dashed') # szaggatott vonal (angolul: dashed line)
Out[6]:
Ha üres stringet adunk vonalstílusnak, és a marker
kulcsszót használjuk, akkor az ábrán csak pontok jelennek meg. Így például ábrázolhatunk olyan adatokat, amik nincsenek szépen sorbarendezve.
In [7]:
plot(x,sin(x),linestyle='',marker='o')
Out[7]:
Ha a linestyle
és a marker
kulcsszavakat egyszerre alkalmazzuk, akkor a markereket a kért vonalstílussal köti össze a matplotlib
.
In [8]:
plot(x,sin(x),linestyle='dashed',marker='s')
Out[8]:
Természetesen ahogy már megszoktuk, kulcsszavas argumentumokból egyszerre többet is beadhatunk (vajon mit jelenthetnek azok a kulcsszók, amiről eddig nem volt szó?):
In [9]:
jellemzok=dict(color='green', linestyle='dashed', marker='o', markerfacecolor='blue',
markeredgecolor='red',markeredgewidth=2, markersize=12 )
plot(x, sin(x), **jellemzok)
Out[9]:
Az ábra tengelyeinek tartományát az xlim()
, illetve ylim()
függvények segítségével tudjuk beállítani, melyeket a plot
függvény után hívunk meg:
In [10]:
plot(x,sin(x))
xlim(-pi,pi);
A plot függvény számos más kulcsszavas argumentummal rendelkezik. A docstring-jében mindezek jól le vannak dokumentálva!
In [11]:
?plot
Ha két (vagy több) plot
parancsot adunk ki egymás után, akkor az ábrán egyszerre két (vagy több) függvény is megjelenik.
In [12]:
plot(x,sin(x))
plot(x,cos(x))
Out[12]:
Speciális esete ennek az, amikor az egyik plot
csak egyetlen pontot tartalmaz. Ezzel a módszerrel jelölhetünk érdekes pontokat a függvény görbéjén.
In [13]:
plot(x,sin(x))
plot(1,sin(1),'o')
Out[13]:
Ha több függvényt ábrázolunk, akkor a label
kulcsszó és a legend()
függvény segítségével tudjuk egyszerűen jelölni, hogy melyik görbe melyik függvényt ábrázolja.
In [14]:
plot(x,sin(x),label='sin(x)',color='red',linestyle='-',linewidth=3)
plot(x,cos(x),label='cos(x)',color='blue',linestyle='--',linewidth=3)
legend()
Out[14]:
Az xlabel()
és az ylabel()
függvények segítségével tengelyfeliratokat készíthetünk.
In [15]:
plot(x,sin(x))
xlabel(r'ido',fontsize=20)
ylabel('kiteres',fontsize=20)
Out[15]:
Az xticks()
és yticks()
függvények a a tengelybeosztások formázásáért felelősek. Segítségükkel tudjuk a beosztásokat saját igényeink szerint beállítani. Ezen függvények dockstringjeit is érdemes megvizsgálni!
In [16]:
plot(x,sin(x))
xticks([-pi,-pi/2,0,pi/2,pi],[r'$-\pi$',r'$-\pi/2$',r'$0$',r'$\pi/2$',r'$\pi$'],fontsize=20);
yticks(linspace(-1,1,9));
#Vajon mi válltozott a fenti ábrához képest ?
Out[16]:
Végül nézzünk meg egy példát, amely a fent tanult trükköket egyszerre alkalmazva egy publikációs minőségű ábrát készít.
In [17]:
plot(x,sin(x),label='sin(x)',color='red',linestyle='-',linewidth=3)
plot(x,cos(x),label='cos(x)',color='blue',linestyle='--',linewidth=3)
xticks([-pi,-pi/2,0,pi/2,pi],[r'$-\pi$',r'$-\pi/2$',r'$0$',r'$\pi/2$',r'$\pi$'],fontsize=20);
yticks(linspace(-1,1,3),fontsize=20);
xlabel('ido',fontsize=20)
ylabel('kiteres',fontsize=20)
legend(loc='upper left',fontsize=20)
xlim(-pi,pi)
grid(True) #Vajon ez a függvény mit csinál ?
Fontos megjegyezni, hogy a vonal- és pontábrázolások kulcsszavas paraméterezését sok másik függvény is megörökölte. Így például 3D-s ábra készítésnél is hasonlóan használhatóak mint itt. Továbbá a tengelyfeliratozás és -beosztás kezelése is hasonlóan általánosabban használható, nem csak a plot()
parancssal egyetemben!
Láttuk, hogy a plot függvény segítségével akár mérési adatpontokat is tudunk ábrázolni. Sokszor azonban a mérések során a mérési hiba is rendelkezésünkre áll! Vizsgáljunk meg erre egy példát!
Az alábbiakban a történelmi napfoltadatok ábrázolásán keresztül igazi mérési adatokat fogunk ábrázolni. Az adatok a data
könyvtárban található SN_m_tot_V2.0.txt
file-ban vannak. Ahhoz hogy az adatok a rendelkezésünkre álljanak, először be kell tölteni a file tartalmát. Ezt legegyszerűbben a numpy
modul loadtxt
függvénye segítségével tehetjük meg. Ez a függvény egyszerűen strukturált adatfileokat olvas be egy array
-be.
In [18]:
dat=loadtxt('data/SN_m_tot_V2.0.txt'); # a napfolt adatok betöltése.
A fenti parancs tehát a dat
tömbbe beolvasta a file-ban található adatokat. A file 3. oszlopa tartalmazza a megfigyelés idejét években mérve, a 4. oszlop pedig a napfoltok számát.
Ábrázoljuk az utolsó 100 pontot az adatfile-ból:
In [19]:
plot(dat[-100:,2],dat[-100:,3],linestyle='',marker='o')
Out[19]:
Az 5. oszlop viszont a megfigyelések statisztikus hibáit tartalmazza. Ha a mérési pontokat és a hibát egy ábrán szeretnénk látni, akkor ezt az errorbar()
függvény segítségével megtehetjük.
In [20]:
errorbar(dat[-100:,2],dat[-100:,3],dat[-100:,4],linestyle='',marker='o')
Out[20]:
Az errorbar()
függvény tehát három bemenő oszlopot vár, amelyekből az első kettő a mérési pontok, illetve a mért értékek, a harmadik pedig a hiba. Ezeken felül, hasonlóan a plot()
-hoz kulcsszavakkal vezérelhetjük a megjelenést. Az alábbi példa illusztrál néhány kulcsszót.
In [21]:
jellemzok=dict(linestyle='',marker='o',ecolor='green',capsize=4,capthick=2)
errorbar(dat[-100:,2],dat[-100:,3],dat[-100:,4],**jellemzok)
Out[21]:
További opciókról a docstringben kaphatunk némi felvilágosítást:
In [22]:
?errorbar
Természetesen két különféle ábrázolást is lehet egy képen megjeleníteni! Az alábbi példában egy plot()
és egy errorbar()
függvényt kombinálunk.
In [23]:
errorbar(dat[-300:,2],dat[-300:,3],dat[-300:,4],linestyle='',marker='o')
plot(dat[-300:,2],70*cos(2*pi/11*dat[-300:,2]-pi*0.25)+70,color='red',linewidth=3)
Out[23]:
A hisztogramok a statisztikai elemzések fontos eszközei.
A múlt órán már láttunk pár példát hisztogram készítésére a hist
parancs segítségével. Ismerkedjünk most meg a hist()
hisztogramgyártó-rutin néhány kulcsszavas argumentumával. Először is gyártsunk néhány véletlen számot!
In [24]:
meres1=randn(10000);
meres2=random.normal(2,0.5,10000);
Amint már korábban láttuk, ez a legegyszerűbb módja a hisztogramgyártásnak.
In [25]:
hist(meres1)
Out[25]:
Ha növelni akarjuk a hisztogram felbontását, akkor azt a bins
argumentummal tehetjük meg. Ha a bins
egy számot kap a bemenetre, akkor annyi automatikusan legenerált beosztás szerint gyártódik le a hisztogramm.
In [26]:
hist(meres1,bins=100);
A beosztások széleit önkényesen is megadhatjuk!
In [27]:
hist(meres1,bins=[-2,0,1,2,3]);
Ha oszlopok helyett egy folytonos vonallal szeretnénk elkészíteni a hisztogramot, akkor a histtype
kulcsszó segít!
In [28]:
hist(meres1,histtype='step');
Természetesen ahogy a plot parancsnál, úgy a hist parancsnál is lehet egyszerre több hisztogramot egy képen ábrázolni.
In [29]:
hist(meres1,bins=100,linewidth=0);
hist(meres2,bins=100,linewidth=0);
Ha nagyon eltakarná a két eloszlás egymást, akkor az alpha
kulcsszó segítségével némileg áttetszővé tehetjük őket!
In [30]:
hist(meres1,bins=100,linewidth=0,alpha=0.5);
hist(meres2,bins=100,linewidth=0,alpha=0.5);
Kétváltozós függvények megjelenítése az egy változósokéhoz hasonlóan, adatgyűjtéssel vagy mintavételezéssel kezdődik. A már ismert linspace()
függvényt kombinálva a meshgrid()
függvénnyel a múlt órán megismert módon mintavételezünk egy kétváltozós paraméterteret:
In [31]:
x2,y2 = meshgrid(linspace(-4,4,50),linspace(-3,3,50)) #mintavételezési pontok legyártása
z2 = sin(x2) ** 10 + cos(10 + y2 * x2) * cos(x2) #függvény kiértékelés
A fenti kódsor tehát legyártott három tömböt. Az első kettő tartalmazza a (2 indexes array formájában) a mintavételezési pontok $x$ és $y$ koordinátáját. A z2
változó pedig a kiértékelt függvényt. Most már csak ábrázolni kell! Ezt legegyszerűbben - ahogy már láttuk - a pcolor()
függvény teszi meg:
In [32]:
pcolor(x2,y2,z2)
Out[32]:
Hogy egy adott szín mit jelent, azt a colorbar()
függvény segítségével tudhatjuk meg.
In [33]:
pcolor(x2,y2,z2)
colorbar()
Out[33]:
Sok színsála létezik. Mindegyiknek megvan a maga előnye és hátránya. A matplotlib színskálák oldalán néhány megnevezett színsála közzül a cmap
kulcsszó segítségével tudunk válogatni.
In [34]:
pcolor(x2,y2,z2,cmap='viridis')
colorbar()
Out[34]:
Kétváltozós függvényeket szokás kontúrok segítségével is ábrázolni. Egy kontúrvonal azokat a pontokat tartalmazza, ahol az adott két változós függvény ugyanazt az értéket veszi fel. A contour()
függvény segítségével tudunk kontúrábrákat generálni:
In [35]:
contour(x2,y2,z2)
Out[35]:
Ha csak megadott kontúrértékekre vagyunk kíváncsiak, akkor azt a levels
kulcsszó használatával tehetjük meg.
In [36]:
contour(x2,y2,z2,levels=[-0.5,0,0.5])
Out[36]:
A clabel()
függvény segítségével a kontúr vonalakat a megfelelő értékek szerint tudjuk feliratozni.
In [37]:
cs=contour(x2,y2,z2,levels=[-0.5,0,0.5])
clabel(cs)
Out[37]:
A contourf()
függvény a pcolor()
és a contour()
függvények jó tulajdonságait ötvözi. Segítségével kitöltött szines ábrákat tudunk generálni, amelyek jobban illeszkednek a megjelenítendő függvény alakjához.
In [38]:
contourf(x2,y2,z2)
Out[38]:
A levels
kulcsszó segítségével feljebb vehetjük a felbontást.
In [39]:
contourf(x2,y2,z2,levels=linspace(-1.5,1.5,100))
colorbar()
Out[39]:
Előfordulhat, hogy a mintavételezés valamilyen oknál fogva nem volt egyenletes. Ekkor az adatpontok háromszögelésének segítségével lehet ábrázolni a kérdéses függvényt. Az alábbiakban erre látunk példát.
Gyártsunk le először is véletlenszerűen síkbeli pontokat!
In [40]:
tx,ty = [8*rand(50*50)-4,6*rand(50*50)-3] #mintavételezési pontok legyártása
Értékeljük ki ezekben a véletlen mintavételezési pontokban az ábrázolni kívánt függvényt!
In [41]:
tz = sin(tx) ** 10 + cos(10 + ty * tx) * cos(tx) #függvény kiértékelés
Ha az adatpontok rendezetlenek, akkor a tripcolor()
, tricontour()
és tricontourf()
függvényeket használhatjuk a pcolor()
, contour()
, illetve a contourf()
függvényekkel teljesen analóg módon!
In [42]:
tripcolor(tx,ty,tz)
Out[42]:
In [43]:
tricontourf(tx,ty,tz,linspace(-1.5,1.5,100))
Out[43]:
In [44]:
u=-y2*sin(x2*y2 + 10)*cos(x2) + 10*sin(x2)**9*cos(x2) - sin(x2)*cos(x2*y2 + 10)
v=-x2*sin(x2*y2 + 10)*cos(x2)
A quiver()
függvény segítségével a sík minden pontjához, amelyet az x2
és y2
tömbök definiálnak, egy az u
és v
tömbök által definiált vektort tudunk rendelni. Azaz a tér (x2[i],y2[i])
pontjába egy (u[i],v[i])
vektor kerül!
In [45]:
quiver(x2,y2,u,v)
Out[45]:
Rajzoljuk csak minden harmadik vektort ki, piros színnel és kicsit vastagabban.
In [46]:
quiver(x2[::3, ::3], y2[::3, ::3], u[::3, ::3], v[::3, ::3],
color='red',width=0.005)
Out[46]: