Bevezetés

Sykora Henrik - BME-GPK Műszaki Mechanikai Tanszék (sykora@mm.bme.hu)

Python programozási nyelv

A Python egy open-source (OS), interpretált, általános célú programozási nyelv (vagy script-nyelv).

Tulajdonságai:

  • Objektum orientált
  • Interpretált
    • Nem szükséges fordítani (mint a pl a C++-t), elég csak beírni a parancsot, és már futtatható is a kód
    • Alkalmas teszi számítások gyors-prototipizálására
    • Cserébe lassú
  • Open-source:
    • Ingyenes
    • Folyamatosan karban tartott
    • Széles körben felhasznált iparban és akadémiában is
    • Nagy "Community", sok segédlettel, fórummal (pl.: stackoverflow)
  • Moduláris:
    • Rengetek feladatra létezik "package" (pl.: numerikus számításokra numpy/scipy, szimbolikus számításokra sympy, táblázatfájl-kezelésre CSV)
    • Csak azt kell behívni, amire szükségünk van
    • Ismerni kell a package ekoszisztémát, mik léteznek, mi mire jó, stb...
  • Sok IDE (Integrated Development Environment) létezik:
    • Alapvetően shell (terminál) alapú
    • Notebook: jupyter notebook, jupyter lab
    • Szövegszerkesztő: Spyder, VS Code (ingyenes/open source - ezek tartalmaznak Debugger-t is)
    • Fizetős szövegszerkeszők (lista nem teljes): Visual Studio, PyCharm, stb...

Jupyter notebook működése (+ Python kernel):

Legfontosabb tudnivalók:

  • Csak egy front-end, ami kommunikál egy kernel-lel (ez a kernel menüben választható).
  • Két mód létezik:
    • Command mode (cellaműveleteket lehet végezni)
    • Edit mode (szövegbevitel cellába)
  • Command mode (ESC billentyű lenyomásával érhető el, kék csík a cella kijelölése esetén):
    • Notebook mentése: s
    • Cellák hozzáadása: b az aktuális cella alá, a az aktuális cella fölé
    • Cella törlése: kétszer egymás után a d billentyű lenyomása
    • Cella törlésének visszavonása: z
    • Cella másolás: c, kivágás: x, beillesztés az aktuális cella alá: v
    • Számozás bekapcsolása a cella soraira: l (kis L), vagy Shift + l az összes cellára
    • Cellamódok: futtatandó kód: y, nyers kód (nem futtatható): r, markdown (formázott szöveg): m
  • Edit mode (Enter billenytű lenyomásával érhető el, zöld szín):
    • Sor "kikommentelése"/"visszaállítása": Ctrl + /
    • Több kurzor lehelyezése: Ctrl + Bal egérgomb
    • Téglalap-szerű kijelölés (rectangular selection): Alt + Bal egérgomb "húzása" (dragging)
  • Közös
    • Cella futtatása, majd cellaléptetés: Shift + Enter (ez létrehoz egy új cellát, ha nincs hova lépnie)
    • Cella futtatása cellaléptetés nélkül: Ctrl + Enter

Jupyter notebook help-jének előhozása: Edit mode-ban h lenyomásával
Python help: Kurzorral a függvény nevén állva Shift + Tab vagy egy cellába ?"fv_név" beírása és futtatása

A bevezető felépítése:

Python bevezető

Alapműveletek (Shift/Ctrl + Enter-rel futtassuk)

In [1]:
17 + 7 #Összeadás
Out[1]:
24
In [2]:
1+1
Out[2]:
2
In [3]:
333 - 7 #Kivonás
Out[3]:
326
In [4]:
11 * 22 #Szorzás
Out[4]:
242
In [5]:
9/7 #Osztás (ez nem egész (int) lesz: külön típus float)
Out[5]:
1.2857142857142858
In [6]:
9//7
Out[6]:
1
In [7]:
0.3-0.1-0.2 # float: számábrázolási hiba lehet!!
Out[7]:
-2.7755575615628914e-17
In [8]:
9**2 # Hatványozás (** és NEM ^!)
Out[8]:
81
In [9]:
2**(0.5) # Gyökvönás hatványozás segítségével
Out[9]:
1.4142135623730951
In [10]:
5e-3 #normálalak e segítségével (vagy 5E-3)
Out[10]:
0.005

Néhány alapművelet működik szövegre is

In [11]:
'str1_' + 'str2_' #Összeadás
Out[11]:
'str1_str2_'
In [12]:
2 * 'str2_' #Szorzás
Out[12]:
'str2_str2_'

Összetettebb függvények

In [13]:
sin(2) #szinusz
---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
<ipython-input-13-f662c61863ec> in <module>
----> 1 sin(2) #szinusz

NameError: name 'sin' is not defined

Összetettebb függvények már nincsenek a python alapnyelvben - ilyenkor szükséges behívni külső csomagokat, pl a math csomagot

In [34]:
import math
In [35]:
sin(2) # ez így továbbra sem létezik
---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
<ipython-input-35-a0912eaca942> in <module>
----> 1 sin(2) # ez így továbbra sem létezik

NameError: name 'sin' is not defined
In [36]:
math.sin(2)
Out[36]:
$\displaystyle 0.9092974268256817$
In [37]:
# Több parancs együttes beírásakor nem látszik, csak az utolsó sor kimenete: print függvény alkalmazása!
print(math.sqrt(2))
print(math.tan(2))
print(math.atan(2))
1.4142135623730951
-2.185039863261519
1.1071487177940904
In [38]:
# Kimenet el is rejthető a ; segítségével ("suppress output")
1+1;

Amennyiben szükséges, definiálhatunk mi is saját változókat az = jellel.
Megjegyzés: a = értékadó függvénynek nincs kimenete

In [39]:
a=2
b=3
c=4.0 # automatikus típusadás
In [40]:
(a+b*c)**a # a legáltalánosabb típus lesz a kimenet (int < float)
Out[40]:
$\displaystyle 196.0$
# Fontos, hogy igyekezzük kerülni védett változó neveket! ILYET NE! math.sqrt = 1 math.sqrt(2) # KERNEL RESTART SZÜKSÉGES

Ha véletlenül ilyet teszünk, akkor érdemes újraindítani a kernel a fent látható körkörös nyíllal, vagy a Kernel $\rightarrow$ Restart segítségével

Saját függvények

Szerkezet:

def function(*arguments):
    instruction1
    instruction2
    ...
    return result

A függvény alá tartozó utasításokat tabulátoros behúzással (indent) kell beírni (nincs {} zárójel, vagy end). A függvény neve után jönnek az argumentumok majd kettősponttal : jelezzük, hogy hol kezdődik a függvény.

In [41]:
def foo(x):
    return 3*x

def bar(x,y):
    a = x+y**2
    return 2*a + 4
In [42]:
print(foo(3))
print(foo(3.))
print(foo('szöveg_'))

print(bar(3,4.))
9
9.0
szöveg_szöveg_szöveg_
42.0

Lehetséges úgynevezett anonim függvényeket (anonymous function vagy lambda function) is létrehozni, amely gyors módja az egyszerű, egysoros függvények létrehozására:

lambda arguments: instruction

Ez akár egy változóhoz is hozzárendelhető, mint egy szám vagy string.

In [43]:
double = lambda x : x*2
multiply = lambda x,y : x*y
In [44]:
print(double(3))
print(multiply(10,3))
6
30

Listák és vezérlési szerkezetek (Control Flow) - csak a legfontosabbak

Listák

In [45]:
lista = [1,2,3,4,"valami",[1.0,4]]
In [46]:
print(lista[0]) # lista 1. eleme
print(lista[3]) # lista 4. eleme
print(lista[-1]) # negatív számokkal hátulról indexeljük a listát, és (-1)-től indul
print(lista[-2]) # lista utolsó előtti eleme
1
4
[1.0, 4]
valami
In [47]:
print(lista[1:-1]) # egyszerre több elem [inkluzív:exklúzív módon]
print(lista[1:2]) # egyszerre több elem [inkluzív:exklúzív módon]
print(lista[2:]) # lista utolsó elemét is figyelembe vesszük
[2, 3, 4, 'valami']
[2]
[3, 4, 'valami', [1.0, 4]]
In [48]:
lista = [2,3,64,89,1,4,9,0,1]

lista.sort()
lista
Out[48]:
$\displaystyle \left[ 0, \ 1, \ 1, \ 2, \ 3, \ 4, \ 9, \ 64, \ 89\right]$

if-then-else

if condition:
    instruction1
elif condition2:
    instruction2
else:
    intsturction3
In [49]:
a=4
if a<=3:
    print('"a" nem nagyobb, mint 3')
elif a>=10:
    print('"a" nem kisebb, mint 10')
else:
    print('"a" nagyobb mint 3, de kisebb mint 10')
"a" nagyobb mint 3, de kisebb mint 10

for ciklus (for loop)

for i in array:
    instruction
In [50]:
for i in range(3):
    print(i)
    
print()

for (i,elem) in enumerate(lista):
    print('lista ',i,'. eleme: ',elem,sep='') # több elem printelése egyszerr, szeparátor = ''
0
1
2

lista 0. eleme: 0
lista 1. eleme: 1
lista 2. eleme: 1
lista 3. eleme: 2
lista 4. eleme: 3
lista 5. eleme: 4
lista 6. eleme: 9
lista 7. eleme: 64
lista 8. eleme: 89

Listák gyors létrehozása (List comprehension)

In [51]:
lista2 = [3*i**2 for i in range(2,5)] # range: 2,3,4
lista2
Out[51]:
$\displaystyle \left[ 12, \ 27, \ 48\right]$
In [52]:
range(10000)
Out[52]:
range(0, 10000)
In [53]:
lista3 = list(range(10))
lista3
Out[53]:
$\displaystyle \left[ 0, \ 1, \ 2, \ 3, \ 4, \ 5, \ 6, \ 7, \ 8, \ 9\right]$
In [54]:
myfun = lambda x: 3*x**2

lista4 = [myfun(i) for i in range(2,10) if i%3 != 0] # ha i nem osztható 3-al
lista4
Out[54]:
$\displaystyle \left[ 12, \ 48, \ 75, \ 147, \ 192\right]$

Külső függvénykönyvtárak:

A mérnöki gyakorlatban előforduló alapszámításokhoz 2 fő csomag importálása ajánlott:

  • sympy: szimbolikus számításokhoz
  • scipy/numpy: numerikus számításokhoz (pl mátrix algebra)
  • matplotlib.pyplot: Függvények ábrázolása A module-ok hívása az alábbi módokon történhet
  • import modulename : importálja az adott module-t. Ekkor a module-ban lévő függvények hívása a module.functionname(arguments) segítségével történik (Az 1_Alapok.ipynb-ben láthattunk erre példát a math module esetében).
  • import modulename as alias : hasonló az előzőhöz, de megválasztjuk, hogy milyen alias-ként hivatkozunk a module-unkra
  • from modulename import function1, function2, ... : csak bizonyos függvények importálása (nem szükséges a module-ra hivatkozni a függvények hívása során)
  • from modulename import * : a module összes függvényének importálása (nem szükséges a module-ra hivatkozni a függvények hívása során)

Szimbolikus matematikai műveletek

In [55]:
import math
import sympy as sp
import scipy as sc
sp.init_printing()
In [56]:
F, m, a, b, c, x = sp.symbols("F m a b c x")
In [57]:
F=m*a
In [58]:
(a,7)
Out[58]:
$\displaystyle \left( a, \ 7\right)$
In [59]:
F.subs(a,7)
Out[59]:
$\displaystyle 7 m$
In [60]:
F.subs([(a,7),(m,1.1)])
Out[60]:
$\displaystyle 7.7$
In [61]:
((a+b)**3).expand()
Out[61]:
$\displaystyle a^{3} + 3 a^{2} b + 3 a b^{2} + b^{3}$
In [62]:
((a+b)**7 - (b+2*a)**3).expand()
Out[62]:
$\displaystyle a^{7} + 7 a^{6} b + 21 a^{5} b^{2} + 35 a^{4} b^{3} + 35 a^{3} b^{4} - 8 a^{3} + 21 a^{2} b^{5} - 12 a^{2} b + 7 a b^{6} - 6 a b^{2} + b^{7} - b^{3}$
In [63]:
(a**2+b**2+2*a*b).factor()
Out[63]:
$\displaystyle \left(a + b\right)^{2}$
In [64]:
sp.factor(a**2+b**2+2*a*b)
Out[64]:
$\displaystyle \left(a + b\right)^{2}$
In [65]:
sp.factor(b**3 + 3*a*b**2 + 3*a**2*b + a**3)
Out[65]:
$\displaystyle \left(a + b\right)^{3}$
In [66]:
a/b+c/b+7/b
Out[66]:
$\displaystyle \frac{a}{b} + \frac{c}{b} + \frac{7}{b}$
In [67]:
sp.ratsimp(a/b+c/b+7/b)
Out[67]:
$\displaystyle \frac{a + c + 7}{b}$
In [68]:
(a/b+c/b+7/b).ratsimp()
Out[68]:
$\displaystyle \frac{a + c + 7}{b}$
In [69]:
(sp.sin(x)**2 + sp.cos(x)**2).simplify().expand()
Out[69]:
$\displaystyle 1$
In [70]:
(sp.cos(2*x)).expand()
Out[70]:
$\displaystyle \cos{\left(2 x \right)}$
In [71]:
sp.expand_trig(sp.cos(2*x))
Out[71]:
$\displaystyle 2 \cos^{2}{\left(x \right)} - 1$
In [72]:
import scipy.constants
In [73]:
sc.constants.golden
Out[73]:
$\displaystyle 1.618033988749895$
In [74]:
math.sqrt(-1+0j) # A math csomagban nincsenek implementálva a komplex számok!
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-74-f6807a18ccc0> in <module>
----> 1 math.sqrt(-1+0j) # A math csomagban nincsenek implementálva a komplex számok!

TypeError: can't convert complex to float
In [ ]:
sc.sqrt(-1+0j)
In [ ]:
sp.limit(sp.sin(x)/x,x,0)

Taylor-sor megadása. Első paraméter a függvény, második a változó, harmadik az érték ami körül akarjuk a sort kifejteni, negyedik pedig a fokszám:

$$f\left(x\right) \approx \sum\limits_{i=0}^{N} \dfrac{\left(x - x_0\right)^i}{i!} \left.\dfrac{\mathrm{d}^i f}{\mathrm{d} x^i}\right|_{x = x_0}$$
In [ ]:
sp.series(sp.sin(x),x,0,20)

Deriválás/Integrálás

In [75]:
a,Δt,x = sp.symbols('a,Δt,x')

Deriválás

In [76]:
sp.diff(sp.sin(x**3),x)
Out[76]:
$\displaystyle 3 x^{2} \cos{\left(x^{3} \right)}$

Többszöri deriválás

In [77]:
sp.diff(sp.sin(x**3),x,3)
Out[77]:
$\displaystyle 3 \left(- 9 x^{6} \cos{\left(x^{3} \right)} - 18 x^{3} \sin{\left(x^{3} \right)} + 2 \cos{\left(x^{3} \right)}\right)$

Integrálás

In [78]:
sp.integrate(1/(1+x),x)
Out[78]:
$\displaystyle \log{\left(x + 1 \right)}$

Határozott integrál

In [79]:
sp.integrate(1/(1+x),(x,1,2))
Out[79]:
$\displaystyle - \log{\left(2 \right)} + \log{\left(3 \right)}$
In [80]:
a = sp.Symbol('a')
In [81]:
sp.integrate(1/(x**2 + a),x)
Out[81]:
$\displaystyle - \frac{\sqrt{- \frac{1}{a}} \log{\left(- a \sqrt{- \frac{1}{a}} + x \right)}}{2} + \frac{\sqrt{- \frac{1}{a}} \log{\left(a \sqrt{- \frac{1}{a}} + x \right)}}{2}$

Láncszabályt is ismeri a szoftver

In [82]:
y = sp.Symbol('y')
def f(x):
    return x**2
def g(y):
    return sp.sin(y)
In [83]:
f(g(y))
Out[83]:
$\displaystyle \sin^{2}{\left(y \right)}$
In [84]:
sp.diff(f(g(y)),y)
Out[84]:
$\displaystyle 2 \sin{\left(y \right)} \cos{\left(y \right)}$
In [85]:
sp.diff(g(f(x)),x)
Out[85]:
$\displaystyle 2 x \cos{\left(x^{2} \right)}$

Sok esetben nem létezik zárt alakú kifejezés a határozatlan integrálhoz. Ebben az esetben használhatjuk a numerikus integrálást a határozott integrál számításához:

In [86]:
sp.integrate(sp.sin(sp.cos(x)),x)
Out[86]:
$\displaystyle \int \sin{\left(\cos{\left(x \right)} \right)}\, dx$

Vektor- és mátrixszámítások sympy-ban

Kisebb méretek esetén, amelyek akár szimbolikus számokat is tartalmaznak

In [87]:
v1= sp.Matrix([2.,3.,4.]) # oszlopvektor
v2= sp.Matrix([[3.,-2.,-7.]]) # sorvektor (még 1 szögletes zárójel)
mx1 = sp.Matrix([[1.,2.,3.],[2.,0.,4.],[3.,4.,1.]])
mx2 = sp.Matrix([[1.,2.,3.],[4.,5.,6.],[7.,8.,9.]])
EM = sp.eye(3) # egységmátrix
In [88]:
v1
Out[88]:
$\displaystyle \left[\begin{matrix}2.0\\3.0\\4.0\end{matrix}\right]$
In [89]:
v2
Out[89]:
$\displaystyle \left[\begin{matrix}3.0 & -2.0 & -7.0\end{matrix}\right]$
In [90]:
v2.multiply(v1)
Out[90]:
$\displaystyle \left[\begin{matrix}-28.0\end{matrix}\right]$
In [91]:
mx2.multiply(v1)
Out[91]:
$\displaystyle \left[\begin{matrix}20.0\\47.0\\74.0\end{matrix}\right]$
In [92]:
v2.multiply(mx2)
Out[92]:
$\displaystyle \left[\begin{matrix}-54.0 & -60.0 & -66.0\end{matrix}\right]$
In [93]:
EM
Out[93]:
$\displaystyle \left[\begin{matrix}1 & 0 & 0\\0 & 1 & 0\\0 & 0 & 1\end{matrix}\right]$
In [94]:
EVs=mx1.eigenvals() # sajátértékek és multiplicitásuk (racionális számokkal)
In [95]:
mx1.eigenvals(rational=False) # sajátértékek numerikusan
Out[95]:
$\displaystyle \left\{ -3.6088213318864 : 1, \ -1.14824478501694 : 1, \ 6.75706611690333 : 1\right\}$
In [96]:
list(mx1.eigenvals(rational=False)) # sajátértékek numerikusan, listaként (multiplicitás nélkül)
Out[96]:
$\displaystyle \left[ -3.6088213318864, \ -1.14824478501694, \ 6.75706611690333\right]$
In [97]:
mx1.det() # mx1 determinánsa
Out[97]:
$\displaystyle 28.0$
In [98]:
Ix,Iy,Ixy = sp.symbols('Ix,Iy,Ixy')
mxSP=sp.Matrix([[Ix,-Ixy],[-Ixy,Iy]])
display(mxSP)

print('\n Sajátértékek, vektorok: \n')
mxSP.eigenvects()
$\displaystyle \left[\begin{matrix}Ix & - Ixy\\- Ixy & Iy\end{matrix}\right]$
 Sajátértékek, vektorok: 

Out[98]:
$\displaystyle \left[ \left( \frac{Ix}{2} + \frac{Iy}{2} - \frac{\sqrt{Ix^{2} - 2 Ix Iy + 4 Ixy^{2} + Iy^{2}}}{2}, \ 1, \ \left[ \left[\begin{matrix}\frac{Ixy}{\frac{Ix}{2} - \frac{Iy}{2} + \frac{\sqrt{Ix^{2} - 2 Ix Iy + 4 Ixy^{2} + Iy^{2}}}{2}}\\1\end{matrix}\right]\right]\right), \ \left( \frac{Ix}{2} + \frac{Iy}{2} + \frac{\sqrt{Ix^{2} - 2 Ix Iy + 4 Ixy^{2} + Iy^{2}}}{2}, \ 1, \ \left[ \left[\begin{matrix}\frac{Ixy}{\frac{Ix}{2} - \frac{Iy}{2} - \frac{\sqrt{Ix^{2} - 2 Ix Iy + 4 Ixy^{2} + Iy^{2}}}{2}}\\1\end{matrix}\right]\right]\right)\right]$
In [99]:
ev=mxSP.eigenvals()
In [100]:
mxSP=sp.Matrix([[Ix,0,0],[0,Ix,0],[0,0,Iy]])
display(mxSP)

print('\n Sajátértékek, vektorok: \n')
mxSP.eigenvects()
$\displaystyle \left[\begin{matrix}Ix & 0 & 0\\0 & Ix & 0\\0 & 0 & Iy\end{matrix}\right]$
 Sajátértékek, vektorok: 

Out[100]:
$\displaystyle \left[ \left( Ix, \ 2, \ \left[ \left[\begin{matrix}1\\0\\0\end{matrix}\right], \ \left[\begin{matrix}0\\1\\0\end{matrix}\right]\right]\right), \ \left( Iy, \ 1, \ \left[ \left[\begin{matrix}0\\0\\1\end{matrix}\right]\right]\right)\right]$

Vektor- és mátrixszámítások numpy-ban

Nagy mátrixok és vektorok esetén érdemes ezt használni, vagy ha sok numerikus adattal dolgozik az ember. Továbbá a sajátérték-sajátvektor számítások is jobban megoldott ebben a csomagban

In [101]:
import sympy as sp
import numpy as np
import numpy.linalg
In [102]:
v1= np.array([2.,3.,4.])
v2= np.array([3.,-2.,-7.])
mx1 = np.array([[1.,2.,3.],[2.,0.,4.],[3.,4.,1.]])
mx2 = np.array([[1.,2.,3.],[4.,5.,6.],[7.,8.,9.]])
In [103]:
print( np.dot(mx2,v1) )  # skalár szorat mx2*v1
print( np.dot(v1,mx2) )  # skalár szorat transpose(v1)*mx2
print( np.cross(v1,v2) ) # keresztszorzat v1×v2
[20. 47. 74.]
[42. 51. 60.]
[-13.  26. -13.]
In [104]:
(λ,V) = np.linalg.eig(mx1) # Mátrix sajátértékei, sajátvektorai a λ és a V változókban

# kiíratás 2 értékes tizedes jeggyel és for ciklusra példa
for (i,v) in enumerate(V):
    print(i+1, '. sajátérték és -vektor:',sep='')
    print('λ = ', sp.N(λ[i],3), '; v = ', [sp.N(e,3) for e in v], sep='', end='\n\n')
1. sajátérték és -vektor:
λ = 6.76; v = [0.529, 0.834, -0.157]

2. sajátérték és -vektor:
λ = -1.15; v = [0.543, -0.475, -0.693]

3. sajátérték és -vektor:
λ = -3.61; v = [0.653, -0.281, 0.704]

Figyeljük meg, hogy a numpy a sajátvektorokat 1 hosszúre normálja!

Egyenletek megoldása

In [105]:
x, y, z = sp.symbols("x y z")
In [106]:
egy1=77*x+6 - 160
In [107]:
sp.solve(egy1,x)
Out[107]:
$\displaystyle \left[ 2\right]$
In [108]:
sp.solve(x**2 - 5, x)
Out[108]:
$\displaystyle \left[ - \sqrt{5}, \ \sqrt{5}\right]$
In [109]:
x
Out[109]:
$\displaystyle x$
In [110]:
e1 = 3*z + 2*y + 1*x - 7
e2 = 4*z + 0*y + 2*x - 8
e3 = 1*z + 4*y + 3*x - 9
In [111]:
sp.solve([e1,e2,e3],[x,y,z])
Out[111]:
$\displaystyle \left\{ x : \frac{10}{7}, \ y : \frac{6}{7}, \ z : \frac{9}{7}\right\}$
In [112]:
def f(x):
    return x**2 - 4
In [113]:
# Numerikus gyökkereséssel scipy segítségével
from scipy import optimize

gyok = optimize.brentq(f,0,10)
print(gyok)
2.0

Szimbolikus függvényekből numerikus függvények

Ezt a legegyszerűbben lambda function-ök segítségével tehetjük meg, de van más mód is rá: lásd ezt az összefoglalót.

In [114]:
a,b,c,x = sp.symbols('a,b,c,x')
adat = [(a, 3.0), (b,-2.), (c,1.0)]

masodfoku_x = a*x**2 + b*x + c

masodfoku_x
Out[114]:
$\displaystyle a x^{2} + b x + c$
In [115]:
masodfoku_num = sp.lambdify(x,masodfoku_x.subs(adat))
masodfoku_num(1.)
Out[115]:
$\displaystyle 2.0$

Egyszerű ábrák készítése

In [116]:
import numpy as np # Ez egyszerűsíti a sok függvénnyel való munkát
import matplotlib.pyplot as plt # matplotlib csomag python rajzolójának behívása

Függvények ábrázolása egyszerű diagramokon

In [117]:
def f(x):
    return np.sin(x)*(1-4*np.exp(0.7*x)/(x**3))

x1 = np.linspace(2,10,30)
y1 = f(x1)
In [118]:
plt.figure(figsize=(20/2.54,12/2.54)) #inch-ben lehet megadni az ábra méretét - nem kötelező de érdemes, ha dokumentációba szánjuk

#plot objektum létrehozása
plt.plot(x1,y1)

# tengelyfeliratok
plt.xlabel('x',fontsize=12)
plt.ylabel('f(x)',fontsize=12)

# rácsozás
plt.grid()

# ábra mentés (még azelőtt kell, mielőtt kirajzolunk)
# plt.savefig("abra1.png", bbox_inches="tight") 
# plt.savefig("abra1.pdf", bbox_inches="tight")

# plot kirajzolása
# plt.show()

# plot mentése
plt.savefig('abra1.png')  # lehet .pdf, .svg formátumokban is menteni
In [119]:
plt.plot(x1,y1,linewidth=3,color='k',linestyle='-.') # vonalvastagság, -szín, és -stílus módosítása
plt.xlabel('x')
plt.ylabel('f(x)')
# megjelenítési határ
plt.ylim(-0.5,0.5) #-0.5...0.5
plt.xlim(None,8) # xmin...8
plt.grid()
 
plt.show()
In [120]:
def g(x):
    return np.sqrt(x)
def h(x):
    return x**2

x2 = np.linspace(0.,1.,100) 

plt.plot(x2,g(x2))
plt.plot(x2,h(x2))

plt.xlabel('x',fontsize=12)
# felirat
plt.legend((r'$\sqrt{x}$',r'$x^2$'), fontsize=12, loc = 5) # loc: 1:jobbfenn, 2: balfent, 3:ballent,...10
plt.grid()


plt.show()
In [121]:
x3 = np.arange(1,14+1)
y3 = np.exp(x3)/(1.4e4)
plt.plot(x3, y3, linestyle = '', marker = 'o')
plt.xlabel('szorgalmi hét sorszáma')
plt.ylabel('hallgatók terheltsége [%]-ban')
plt.grid()
plt.show()
In [122]:
plt.plot(x3, y3, linestyle = '-', marker = 'o')
plt.yscale('log')
plt.xlabel('szorgalmi hét sorszáma')
plt.ylabel(r'hallgatók terheltsége [%]-ban')
plt.grid()
plt.show()

Parametrikus függvényábrázolás:

In [123]:
t = np.linspace(0,2*sc.pi,100)
x = np.sin(t)
y = np.cos(t)

plt.plot(x, y, linestyle = '--')
plt.grid()
plt.axis('equal')
plt.show()

3D függvényábrázolás

In [124]:
from mpl_toolkits.mplot3d import Axes3D
In [125]:
def f(x, y):
    return np.sin(np.exp( - x ** 2 - y ** 2))

x = np.linspace(-2, 2, 30)
y = np.linspace(-2, 2, 30)

X, Y = np.meshgrid(x, y)
Z = f(X, Y)
In [126]:
fig = plt.figure(figsize=(16/2.54,10/2.54)) # itt manuálisan létre kell hozni a plot (figure) objektumot
ax = fig.add_subplot(111, projection='3d')
ax.plot_surface(X, Y, Z, cmap='viridis')
plt.show()

+ Osztályok

In [129]:
def foo(x):
    return x**2

class MyClass:
    def __init__(self,x,y,z):
        self.square = foo(x)-z
        self.cubic = y**3+foo(y)

    @classmethod
    def createfrom_x(cls,x):
        return MyClass(x,x,x)
    
    def return_stuff(self):
        return self.square+3*self.cubic
In [130]:
mcl=MyClass.createfrom_x(2)