Tömbök (numpy)


Ebben a Notebookban bemutatjuk az tömböket illetve hogyan kell a pythonban adatfájlokat beolvasni.

In [1]:
%pylab inline 

Populating the interactive namespace from numpy and matplotlib

Adattömbök, matematikai eszközök, adatfájlok kezelése

A pythonban a numpy csomag felel az adatok beolvasásáért, matematikai operációk elvégezésért (mint a gyökvonás, szinusz ...)

Tömbök

A programozásban létrehozhatunk mátrixokat, melyeket adattömböknek hívunk. Ezek bármennyi dimenziósak lehetnek.

In [2]:
a = array([1, 2, 3])      # hozzunk létre egy 1 dimenziós tömböt
print(type(a))            # Írassuk ki "a" típusát: "<type 'numpy.ndarray'>"
print(a.shape)            # Nézzük meg a formáját: "(3,)"

<class 'numpy.ndarray'>
(3,)

A python és a legtöbb programozási nyelv nullától kezdi a tömbök indexelését. Azaz az első elem indexe 0, a másodiké 1 és így tovább. Egy 10 elemű tömbnek az utolsó eleme 9-es indexet visel (Elemszám-1)!

Így kell elképzelni az adattömböket:




In [3]:
print(a[0], a[1], a[2])   # Írassuk ki a tömb, első (0.-ik), második, ás harmadik elemét
a[0] = 5                  # Átírjuk az első (nulladik) elem értékét
print(a)                  # Nézzük meg a megváltozott "a" vektort

1 2 3
[5 2 3]
In [4]:
b = array([[1,2,3],[4,5,6]])    # Készítsünk 2 dimenziós tömböt
print(b.shape)                     # Kiíratjuk az alakját
print(b[0, 0], b[0, 1], b[1, 0])   # Írjunk ki pár elemet a tömbből

(2, 3)
1 2 4

"Almátrixok"

A pythonban ki tudunk egy tömbből venni résztömböket. De vigyázzunk, mert a résztömbön végzett művelet a szülőtömb adott elemein is elvégződik.

In [5]:
    # Készítsük els következő 2 dimenziós (3 sor, 4 oszlop) tömböt
    # [[ 1  2  3  4]
    #  [ 5  6  7  8]
    #  [ 9 10 11 12]]
a = array([[1,2,3,4], [5,6,7,8], [9,10,11,12]])
print(a[0, 1])   # Írassuk ki a 0. sor, 1. oszlopának elem(eit): 2

    # Hozzuk létre a mátrix következő almátrixát (ami 2*2 nagyságú)
    # [[2 3]
    #  [6 7]]
    # Azaz a mátrixból a 0-tól 2-ig levő adatsorok, illetve függőlegesen 1-tól 3-ig levő adatoszlopok kivétele
    # Vegyük észre, hogy a felső határ már nincs benne az adatsorban!
b = a[0:2, 1:3]

    # Változtassuk meg a b mátrix [0,0]-ás elemének értékét
b[0, 0] = 77

    # Ellenőrizzük az a mátrixban a "b[0,0]" helyen levő értéket (a[0,1]-as hely)
print(a[0, 1])   

2
77

Számsorok generálása és tömbbe rendezése

Lehetőség van adott hosszú sorokat gyártani, melyekből tömb készíthető. Nézzük néhány példát erre:

In [6]:
a = arange(15) # Készítsünk egy 15 elemű listát 
print(a)

[ 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14]
In [7]:
a = arange(15)   # Készítsünk egy 15 elemű listát 
a = a.reshape(3, 5) # Rendezzük a listát 3*5-s tömbbe
a                   # Nézzük meg az eredményt
Out[7]:
array([[ 0,  1,  2,  3,  4],
       [ 5,  6,  7,  8,  9],
       [10, 11, 12, 13, 14]])
In [8]:
a.shape
Out[8]:
(3, 5)
In [9]:
a.size # Megadja mekkora a tömb mérete (mennyi adat van benne)
Out[9]:
15
In [10]:
a.ndim
Out[10]:
2
In [11]:
type(a)
Out[11]:
numpy.ndarray
In [12]:
a.dtype.name # Megnézi milyen tipusú adatok vannak a tömbben
Out[12]:
'int64'
In [13]:
b = array([6.25, -0.25, 8.])
b
Out[13]:
array([ 6.25, -0.25,  8.  ])
In [14]:
type(b)
Out[14]:
numpy.ndarray
In [15]:
b.dtype.name
Out[15]:
'float64'
In [16]:
c = array( [ [1,2], [3,4] ], dtype=complex )
c
Out[16]:
array([[ 1.+0.j,  2.+0.j],
       [ 3.+0.j,  4.+0.j]])
In [17]:
c.dtype.name
Out[17]:
'complex128'
In [18]:
zeros( (3,4) ) #Készítsünk egy 3*4-es tömböt, mely tele van nullával
Out[18]:
array([[ 0.,  0.,  0.,  0.],
       [ 0.,  0.,  0.,  0.],
       [ 0.,  0.,  0.,  0.]])
In [19]:
ones( (2,3,4), dtype=int16 ) # Készítsünk egy 3 dimenziós tömböt, csupa egyesből
Out[19]:
array([[[1, 1, 1, 1],
        [1, 1, 1, 1],
        [1, 1, 1, 1]],

       [[1, 1, 1, 1],
        [1, 1, 1, 1],
        [1, 1, 1, 1]]], dtype=int16)
In [20]:
a = arange(15, 100, 5) # Készítsünk egy listát 15-től, 100-ig, 5-sével 
print(a)

[15 20 25 30 35 40 45 50 55 60 65 70 75 80 85 90 95]
In [21]:
arange( 30, 10, -5 )
Out[21]:
array([30, 25, 20, 15])
In [22]:
arange( 10, 30, -5 ) #Ez üres lista, de NINCS hibaüzenet!!!
Out[22]:
array([], dtype=int64)
In [23]:
arange( 0, 2, 0.3 )
Out[23]:
array([ 0. ,  0.3,  0.6,  0.9,  1.2,  1.5,  1.8])
In [24]:
linspace( 0, 2, 9 ) # Készítsünk egy 9 elemű listát 0 és 2 között. Egyenlő lépésközzel.
Out[24]:
array([ 0.  ,  0.25,  0.5 ,  0.75,  1.  ,  1.25,  1.5 ,  1.75,  2.  ])

Matematikai függvények

Bővebb leírás itt található: https://docs.scipy.org/doc/numpy/reference/routines.math.html

In [25]:
x = linspace( 0, 2*pi, 100 ) # A pi-nek a neve "pi"
x
Out[25]:
array([ 0.        ,  0.06346652,  0.12693304,  0.19039955,  0.25386607,
        0.31733259,  0.38079911,  0.44426563,  0.50773215,  0.57119866,
        0.63466518,  0.6981317 ,  0.76159822,  0.82506474,  0.88853126,
        0.95199777,  1.01546429,  1.07893081,  1.14239733,  1.20586385,
        1.26933037,  1.33279688,  1.3962634 ,  1.45972992,  1.52319644,
        1.58666296,  1.65012947,  1.71359599,  1.77706251,  1.84052903,
        1.90399555,  1.96746207,  2.03092858,  2.0943951 ,  2.15786162,
        2.22132814,  2.28479466,  2.34826118,  2.41172769,  2.47519421,
        2.53866073,  2.60212725,  2.66559377,  2.72906028,  2.7925268 ,
        2.85599332,  2.91945984,  2.98292636,  3.04639288,  3.10985939,
        3.17332591,  3.23679243,  3.30025895,  3.36372547,  3.42719199,
        3.4906585 ,  3.55412502,  3.61759154,  3.68105806,  3.74452458,
        3.8079911 ,  3.87145761,  3.93492413,  3.99839065,  4.06185717,
        4.12532369,  4.1887902 ,  4.25225672,  4.31572324,  4.37918976,
        4.44265628,  4.5061228 ,  4.56958931,  4.63305583,  4.69652235,
        4.75998887,  4.82345539,  4.88692191,  4.95038842,  5.01385494,
        5.07732146,  5.14078798,  5.2042545 ,  5.26772102,  5.33118753,
        5.39465405,  5.45812057,  5.52158709,  5.58505361,  5.64852012,
        5.71198664,  5.77545316,  5.83891968,  5.9023862 ,  5.96585272,
        6.02931923,  6.09278575,  6.15625227,  6.21971879,  6.28318531])
In [26]:
f = sin(x) # vegyük az előbb generált adatsornak a szinuszát
plot(f)   # majd ábárzoljuk
Out[26]:
[<matplotlib.lines.Line2D at 0x7f5b48d6b240>]
In [27]:
plot(cos(x))
Out[27]:
[<matplotlib.lines.Line2D at 0x7f5b47836240>]
In [28]:
plot(tan(x))
Out[28]:
[<matplotlib.lines.Line2D at 0x7f5b48b45278>]
In [29]:
plot(tanh(x))
Out[29]:
[<matplotlib.lines.Line2D at 0x7f5b45f704e0>]
In [30]:
plot(arctan(x))
Out[30]:
[<matplotlib.lines.Line2D at 0x7f5b48724320>]
In [31]:
B = arange(3)
B
Out[31]:
array([0, 1, 2])
In [32]:
exp(B) # Emeljük "e"-adra a B elemeit
Out[32]:
array([ 1.        ,  2.71828183,  7.3890561 ])
In [33]:
sqrt(B) # Gyökvonás neve 'sqrt'
Out[33]:
array([ 0.        ,  1.        ,  1.41421356])
In [34]:
C = array([2., -1., 4.])
add(B, C) # Össze is adhatunk elemenként 2 tömböt
Out[34]:
array([ 2.,  0.,  6.])

Kétváltozós függvények ábrázolása (felületi ábrák)

Ha kétváltozós függvényt szeretnénk ábrázolni, akkor ahhoz a mintavételezést a numpy csomag meshgrid() függvényével tehetjük meg az alábbi szintaxis szerint:

In [35]:
xrange=linspace(-3,3,100)   # határok és pontok száma az x irányba
yrange=linspace(-3,3,100)   # határok és pontok száma az y irányba
x,y=meshgrid(xrange,yrange) # mintavételezés az x és y síkban

Két változós függvényt a pcolormesh() matplotlib függvény segítségével tudunk ábrázolni.

A fent definiált x és y tömbök segítségével például az $ f(x,y)=e^{-(x^2+y^2)} $ kétdimenziós Gauss-görbét az alábbi módon ábrázolhatjuk:

In [36]:
pcolormesh(x,y,exp(-(x**2+y**2)))
Out[36]:
<matplotlib.collections.QuadMesh at 0x7f5b477edfd0>

Hogy egy adott szín mit jelent, azt a colorbar() függvény segítségével tudhatjuk meg.

In [37]:
pcolormesh(x,y,exp(-(x**2+y**2)))
colorbar()
Out[37]:
<matplotlib.colorbar.Colorbar at 0x7f5b45efbe80>

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 [38]:
contour(x,y,exp(-(x**2+y**2)))
Out[38]:
<matplotlib.contour.QuadContourSet at 0x7f5b45ee7fd0>

Ha csak megadott kontúrértékekre vagyunk kíváncsiak, akkor azt a levels kulcsszó használatával tehetjük meg.

In [39]:
contour(x,y,exp(-(x**2+y**2)), levels=linspace(0,1,20))
Out[39]:
<matplotlib.contour.QuadContourSet at 0x7f5b4393f908>

Ábra mentése

A legenerált ábrákat a savefig() paranccsal tudjuk kimenteni képfile-okba.

In [40]:
plot(x,y)
savefig('az_en_abram.pdf')