Modulok¶
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 is használhatnak.
Import¶
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.
import sys
print(sys.path)
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, mely azon könyvtárak listája, ahol pl. a Python a modulokat keresi. 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. A következő betöltési módok a leggyakoribbak:
import <modul>
import <modul> as <name>
from <modul> import <identifier>
from <modul.identifier> import <identifier>
Például:
from csv import reader
from itertools import permutations
for p in permutations(['A', 'B', 'C']):
print(p)
Relatív import¶
Importálhatunk fájlokat abból a könyvtárból, ahol éppen vagyunk, ahonnan a Python, ill. a jupyter fut.
Írjuk a következő kódot egy myfns.py nevű fájlba:
def foo():
print("FoO")
def bar():
print("BaR")
Ezután, betölthetjük őket az
import myfns
paranccsal, de ha csak az egyik függvényre van szükségünk, betölthetjük a következőképp:
from myfns import foo
foo()
numpy alapok¶
A numpy numerikus számításokra tervezett Python modul. (Ha otthon szeretnénk használni, akkor az Anaconda ezt is tartalmazza mindhárom oprendszeren. Telepítés után keressünk egy szimpatikus mappát, ahova dolgozni szeretnénk, majd adjuk ki a jupyter notebook parancsot Windows command line-ban, illetve Linux parancssorban.)
Először importáljuk a numpy modult. Érdemes import numpy as np módon használni, hiszen ilyenkor numpy helyett elég az np.
A numpy legfontosabb összetevője az array, ami listák listájából 2D, listák listájánal listájából 3D... tömböt kreál (Python lista szteroidokon). A másik az arange, ami a range-hez hasonlóan működik, de azonnal tömböt hoz létre. Ez átméretezhető egy tömbbé a reshape függvénnyel:
import numpy as np
x = np.arange(1, -1, -0.2)
y = np.array([[1, 2, 3], [1, 2, 4]])
z = np.arange(8).reshape(2, 2, 2)
print(x)
print(y)
print(z)
print(x.dtype, y.dtype, z.dtype)
print(x.ndim, y.ndim, z.ndim)
print(x.shape, y.shape, z.shape)
A numpy.ndarray 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.
a = np.array([20, 30, 40, 50])
b = np.arange(4)
print(a + b)
print(a - b)
print(b / (b+1.0))
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.
b = np.arange(10)
print(b)
print(b ** 2)
print(b + 10)
print(b % 3 == 1)
Az előzőekből szinte kikövetkeztethető, hogy a mátrixszorzás sem a * művelettel történik, helyette a @ művelet vagy a .dot metódus használható:
A = np.arange(2, 6).reshape(2, 2)
B = np.arange(3, -1, -1).reshape(2, 2)
print(A)
print(B)
print(A * B) # elementwise
print(A @ B) # matrix product
print(A.dot(B)) # matrix product
A Python indexelési lehetőségei mellett további kényelmes megoldások is használhatók:
x = np.arange(15).reshape(3, 5)
print(x)
print(x[0:2])
Sőt, indexelhetünk oszlopszinten is.
print(x[2, :3])
print(x[:, 3])
print(x[:, [3]])
a = np.arange(12)**2
i = np.array([1, 5, 1, 3, 8])
print(a[i])
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.
x = np.log(np.arange(2, 10, 0.5))
print(x)
print(x.sum())
print(x.mean())
print(x.std())
A mátrixalapú nyelvek (Octave, Matlab) több parancsa itt is megjelenik: működik a zeros és a ones, az identikus mátrix az eye mögött rejtőzik (I, ejtsd áj, eye ejtsd áj).
print(np.zeros([2, 3]))
print(np.ones([3, 1])) # float type
print(np.eye(4, dtype=int)) # int type
Véletlen számokat, sőt véletlen vektorokat vagy mátrixokat is generálhatunk. Itt a $[0,1)$ intervallumból egyenletes eloszlás szerint:
np.random.rand(3,4)
Mindig ugyanazt a sorozatot generálja, ha előtte beállítjuk a seed értékét:
np.random.seed(2)
np.random.rand(2,3)
Egészek sorozata is generálható, például kockadobások:
np.random.randint(1,7,10)
Plot¶
Függvények ábrázolására a matplotlib csomagot használjuk. A matplotlib használatának módja változtatható a %matplotlib ún. magic függvénnyel. (A magic függvények az IPython függvényei, melyekkel a környezet viselkedése kezelhető, ezek egy részét a jupyter is használja.)
%matplotlib inline
import matplotlib
import matplotlib.pyplot as plt
Először egy egyszerű plot.
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. Itt az arange helyett inkább a linspace függvényt használjuk, mely adott intervallumon helyez el adott számú osztópontot:
np.linspace(0, 1, 5)
plt.plot(np.linspace(0, 2*np.pi, 11),
np.sin(np.linspace(0, 2*np.pi, 11)))
plt.show()
plt.plot(np.linspace(0, 2*np.pi, 101),
np.sin(np.linspace(0, 2*np.pi, 101)), 'k')
plt.show()
plt.plot(np.linspace(0, 2*np.pi, 101),
np.sin(np.linspace(0, 2*np.pi, 101)), 'g')
plt.axis([0, 2*np.pi, -2, 2])
plt.show()
plt.plot(np.linspace(0, 2*np.pi, 101),
np.sin(np.linspace(0, 2*np.pi, 101)), 'r')
plt.axis('equal')
plt.show()
És a végére egy kis Monte–Carlo-módszer. Generálunk véletlen pontokat a $[-2,2]\times[0,1]$ téglalapban. A $[0,1]$ intervallumon egyenletes eloszlás szerint generált véletlen számokból egyszerű transzformációval kaphatunk a $[-2,2]$ intervallumon egyenletes eloszlásúakat. 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 ponthalmazon belül, néggyel szorozva egy közelítést ad $\int_{-2}^2e^{-x^2}\,\mathrm{d}x$-re.
a = np.arange(4).reshape(2, 2)
print(a)
print((np.where(a % 2)))
b = np.arange(4)
print(b)
print((np.where(b % 2)))
n = 500000
X = np.random.rand(n, 2)
X[:, 0] = X[:, 0]*4-2
J = np.where(X[:, 1] < np.exp(-X[:, 0]**2))[0]
print(4 * len(J) / n)
Nézzük meg rajzon.
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], 'r.')
plt.show()
