Modulok és matematikai csomagok

Modulok használata

Egy Python modul nem más mint függvények és osztályok összessége, amelyet egy csomagban kapunk meg. Természetesen mi magunk is tudunk (egyelőre Python nyelven) írni modulokat, amelyeket mások aztán használhatnak.

Ha telepítettük a Pythont, a bépített modulokat is megkapjuk. Ezeket egyszerűen tudjuk importálni, sőt sokat közülük már használtunk is.

In [1]:
import sys
print sys.path

['', 'C:\\ProgramData\\Anaconda2\\python27.zip', 'C:\\ProgramData\\Anaconda2\\DLLs', 'C:\\ProgramData\\Anaconda2\\lib', 'C:\\ProgramData\\Anaconda2\\lib\\plat-win', 'C:\\ProgramData\\Anaconda2\\lib\\lib-tk', 'C:\\ProgramData\\Anaconda2', 'C:\\ProgramData\\Anaconda2\\lib\\site-packages', 'C:\\ProgramData\\Anaconda2\\lib\\site-packages\\win32', 'C:\\ProgramData\\Anaconda2\\lib\\site-packages\\win32\\lib', 'C:\\ProgramData\\Anaconda2\\lib\\site-packages\\Pythonwin', 'C:\\ProgramData\\Anaconda2\\lib\\site-packages\\IPython\\extensions', 'C:\\Users\\Gabor\\.ipython']

A sys egy beépített modul, a rendszerrel kapcsolatos információkat tudjuk lekérdezni és használni (pl. parancssori argumentumok). Fent a sys.path változót irattuk ki. Ez azért lényeges, mert az import valami sor végrehajtásakor a Python a valami nevű modult először a beépített modulok között keresi, majd egy valami.py nevű fájlt keres a sys.path helyek egyikén. A sys.path akár változtatható is.

Importálni lehet egy egész fájlt is, egy könyvtárat, a benne lévő fájlokkal, vagy akár egyetlen függvényt is.

In [2]:
from csv import reader
from itertools import permutations
for p in permutations(['A','B','C']):
    print p

('A', 'B', 'C')
('A', 'C', 'B')
('B', 'A', 'C')
('B', 'C', 'A')
('C', 'A', 'B')
('C', 'B', 'A')

Relatív import. Importálhatunk fájlokat abból a könyvtárból, ahol éppen vagyunk.

In [3]:
from lab11 import Node
print Node("3+4*5")

<lab11.Node object at 0x00000000083618D0>

numpy alapok

A numpy numerikus számításokra tervezett Python modul. Ha otthon szeretnénk használni, akkor az Anaconda telepítése után rendelkezésre áll. Telepítés után keressünk egy szimpatikus mappát, ahova dolgozni szeretnénk, majd adjuk ki a jupyter notebook parancsot a Windows command line-ban.

Először beimportáljuk a modult. Érdemes import numpy as np módon használni, hiszen ilyenkor nem kell minden alkalommal kiírni, hogy numpy, elég az np is.

In [4]:
sys.path.append('d:\\numpy-1.11.0')

A numpy legfontosabb összetevője az array. Ez olyan, mintha egy Python lista lenne szteroidokon. Nézzük meg, hogyan működik!

In [5]:
import numpy as np
x = np.arange(1,-1,-0.1)
y = np.array([[1,2,3],[1,2,4]])
In [6]:
print x.dtype
print y.dtype
print x.shape
print y.shape
print x.ndim
print y.ndim
print x
print y

float64
int32
(20L,)
(2L, 3L)
1
2
[ 1.00000000e+00  9.00000000e-01  8.00000000e-01  7.00000000e-01
  6.00000000e-01  5.00000000e-01  4.00000000e-01  3.00000000e-01
  2.00000000e-01  1.00000000e-01  2.22044605e-16 -1.00000000e-01
 -2.00000000e-01 -3.00000000e-01 -4.00000000e-01 -5.00000000e-01
 -6.00000000e-01 -7.00000000e-01 -8.00000000e-01 -9.00000000e-01]
[[1 2 3]
 [1 2 4]]

A numpy.array típusú változókon végezhetünk műveleteket, sőt, az alapműveletek többsége működik, de az ökölszabály az, hogy elemenként értelmezzük őket.

In [7]:
a = np.array( [20,30,40,50] )
b = np.arange( 4 )
print a+b
print a-b
print b / (b+1.0)

[20 31 42 53]
[20 29 38 47]
[0.         0.5        0.66666667 0.75      ]

Hasonlóan lista és egy elem között is értelmezzük az alapműveleteket. Ilyenkor a lista minden elemére elvégezzük a műveleteket és az eredmény ez a lista.

In [8]:
b = np.arange(10)
print b
print b ** 2
print b + 10
print b % 3 == 1

[0 1 2 3 4 5 6 7 8 9]
[ 0  1  4  9 16 25 36 49 64 81]
[10 11 12 13 14 15 16 17 18 19]
[False  True False False  True False False  True False False]

Az előzőekből szinte kikövetkeztethető, hogy a mátrixszorzás sem a * művelettel történik.

In [9]:
A=np.arange(2,6).reshape(2,2)
B=np.arange(3,-1,-1).reshape(2,2)
print A
print B
print A*B
print A.dot(B)

[[2 3]
 [4 5]]
[[3 2]
 [1 0]]
[[6 6]
 [4 0]]
[[ 9  4]
 [17  8]]

Első észrevétel a reshape használatához kapcsolódik. A (4,1) alakú array-ből (2,2) alakút tudunk csinálni. A dot bármikor hívható, ha a bal oldal szorozható a jobb oldallal.

Természetesen az indexelés is kényelmes. Először is megjegyezzük, hogy a klasszikus Python indexelés működik.

In [10]:
x = np.arange(15).reshape(3,5)
print x
print x[0:2]

[[ 0  1  2  3  4]
 [ 5  6  7  8  9]
 [10 11 12 13 14]]
[[0 1 2 3 4]
 [5 6 7 8 9]]

Sőt, indexelhetünk oszlopszinten is.

In [11]:
print x[:,3]
print x[2,:3]

[ 3  8 13]
[10 11 12]

Megadhatunk indexek listáját is.

In [12]:
a = np.arange(12)**2
i = np.array( [ 1,1,3,8,5 ] ) 
print a[i]

[ 1  1  9 64 25]

Függvényeket is hívhatunk elemenként. Sőt, a listaműveletek is elérhetők, persze np előtaggal, hiszen array típusra a normál Python függvények nem működnek. Átlagot, szórást is egy sorban számolhatunk.

In [13]:
x = np.log(np.arange(2,10,0.5))
print x
print x.sum()
print x.mean()
print x.std()

[0.69314718 0.91629073 1.09861229 1.25276297 1.38629436 1.5040774
 1.60943791 1.70474809 1.79175947 1.87180218 1.94591015 2.01490302
 2.07944154 2.14006616 2.19722458 2.2512918 ]
26.457769829012314
1.6536106143132696
0.4600673068044455

Amit még tud a numpy. Működik a zeros és a ones. Az identitásmátrix az eye mögött rejtőzik.

In [14]:
print np.zeros([4,3])
print np.ones([4,1])
print np.eye(4)

[[0. 0. 0.]
 [0. 0. 0.]
 [0. 0. 0.]
 [0. 0. 0.]]
[[1.]
 [1.]
 [1.]
 [1.]]
[[1. 0. 0. 0.]
 [0. 1. 0. 0.]
 [0. 0. 1. 0.]
 [0. 0. 0. 1.]]

Véletlen számokat, sőt véletlen vektorokat is generálhatunk.

In [15]:
np.random.rand(3,4)
Out[15]:
array([[0.36251805, 0.70458436, 0.5751368 , 0.51236362],
       [0.01072853, 0.00493258, 0.222462  , 0.53738111],
       [0.07768957, 0.72038115, 0.02521082, 0.4503569 ]])

Plot

Függvények ábrázolására a matplotlib csomagot használjuk.

In [16]:
%matplotlib inline
import matplotlib
import matplotlib.pyplot as plt

Először egy egyszerű plot.

In [17]:
plt.plot([1,2,4])
plt.ylabel('some numbers')
plt.show()

Látjuk, hogy nem szinbolikusan számol, hanem egyszerűen összeköti a számokat vonalakkal. Szinuszgörbét is hasonlóan rajzolunk. Az np.sin a lista minden elemére számol szinuszt.

In [18]:
plt.plot(np.arange(0,2*np.pi,0.05), np.sin(np.arange(0,2*np.pi,0.05)), 'g')
plt.axis([0,2*np.pi,-1,1])
plt.show()

És a végére egy kis Monte-Carlo. Generálunk véletlen pontokat a $[-2,2]\times[0,1]$ téglában. Először is, véletlen számokat csak 0 és 1 között tudunk generálni, de egy kis transzformáció nem árt senkinek. A J tömbben azon $(x,y)$ pontok indexeit tároljuk, ahol $e^{-x^2} > y$. Mivel a téglalap területe 4, az ilyen pontok aránya az teljes populáción belül, néggyel szorozva egy közelítést ad $\int_{-2}^2e^{-x^2}\,\mathrm{d}x$-re.

In [19]:
X = np.random.rand(500000,2)
X[:,0] = X[:,0]*4-2
J = np.where(X[:,1] < np.exp(-X[:,0]**2))[0]
print len(J) / 500000.0 * 4

1.761416

Nézzük meg rajzon.

In [20]:
Xp = X[:2000]
Ip = [i for i in range(2000) if i in J]
Inp = [i for i in range(2000) if i not in J]
plt.plot(Xp[Ip,0],Xp[Ip,1], 'bd', Xp[Inp,0],Xp[Inp,1], 'rd')
plt.show()