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

Python bevezető¶

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

17 + 7 #Összeadás

24

1+1

2

333 - 7 #Kivonás

326

11 * 22 #Szorzás

242

9/7 #Osztás (ez nem egész (int) lesz: külön típus float)

1.2857142857142858

9//7

1

0.3-0.1-0.2 # float: számábrázolási hiba lehet!!

-2.7755575615628914e-17

9**2 # Hatványozás (** és NEM ^!)

81

2**(0.5) # Gyökvönás hatványozás segítségével

1.4142135623730951

5e-3 #normálalak e segítségével (vagy 5E-3)

0.005

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

'str1_' + 'str2_' #Összeadás

'str1_str2_'

2 * 'str2_' #Szorzás

'str2_str2_'

Összetettebb függvények ¶

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

import math

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

math.sin(2)

# 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

# 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

a=2
b=3
c=4.0 # automatikus típusadás

(a+b*c)**a # a legáltalánosabb típus lesz a kimenet (int < float)

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.

def foo(x):
    return 3*x

def bar(x,y):
    a = x+y**2
    return 2*a + 4

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.

double = lambda x : x*2
multiply = lambda x,y : x*y

print(double(3))
print(multiply(10,3))

6
30

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

Listák¶

lista = [1,2,3,4,"valami",[1.0,4]]

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

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]]

lista = [2,3,64,89,1,4,9,0,1]

lista.sort()
lista

if-then-else¶

if condition:
    instruction1
elif condition2:
    instruction2
else:
    intsturction3

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

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)¶

lista2 = [3*i**2 for i in range(2,5)] # range: 2,3,4
lista2

range(10000)

range(0, 10000)

lista3 = list(range(10))
lista3

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

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 ¶

import math
import sympy as sp
import scipy as sc
sp.init_printing()

F, m, a, b, c, x = sp.symbols("F m a b c x")

F=m*a

(a,7)

F.subs(a,7)

F.subs([(a,7),(m,1.1)])

((a+b)**3).expand()

((a+b)**7 - (b+2*a)**3).expand()

(a**2+b**2+2*a*b).factor()

sp.factor(a**2+b**2+2*a*b)

sp.factor(b**3 + 3*a*b**2 + 3*a**2*b + a**3)

a/b+c/b+7/b

sp.ratsimp(a/b+c/b+7/b)

(a/b+c/b+7/b).ratsimp()

(sp.sin(x)**2 + sp.cos(x)**2).simplify().expand()

(sp.cos(2*x)).expand()

sp.expand_trig(sp.cos(2*x))

import scipy.constants

sc.constants.golden

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

sc.sqrt(-1+0j)

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}$$

sp.series(sp.sin(x),x,0,20)

Deriválás/Integrálás ¶

a,Δt,x = sp.symbols('a,Δt,x')

Deriválás

sp.diff(sp.sin(x**3),x)

Többszöri deriválás

sp.diff(sp.sin(x**3),x,3)

Integrálás

sp.integrate(1/(1+x),x)

Határozott integrál

sp.integrate(1/(1+x),(x,1,2))

a = sp.Symbol('a')

sp.integrate(1/(x**2 + a),x)

Láncszabályt is ismeri a szoftver

y = sp.Symbol('y')
def f(x):
    return x**2
def g(y):
    return sp.sin(y)

f(g(y))

sp.diff(f(g(y)),y)

sp.diff(g(f(x)),x)

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:

sp.integrate(sp.sin(sp.cos(x)),x)

numerikus intágráls SymPy-vel

nem triviális

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

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

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

v1

v2

v2.multiply(v1)

mx2.multiply(v1)

v2.multiply(mx2)

EM

EVs=mx1.eigenvals() # sajátértékek és multiplicitásuk (racionális számokkal)

mx1.eigenvals(rational=False) # sajátértékek numerikusan

list(mx1.eigenvals(rational=False)) # sajátértékek numerikusan, listaként (multiplicitás nélkül)

mx1.det() # mx1 determinánsa

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()

 Sajátértékek, vektorok:

ev=mxSP.eigenvals()

mxSP=sp.Matrix([[Ix,0,0],[0,Ix,0],[0,0,Iy]])
display(mxSP)

print('\n Sajátértékek, vektorok: \n')
mxSP.eigenvects()

 Sajátértékek, vektorok:

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

import sympy as sp
import numpy as np
import numpy.linalg

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.]])

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.]

(λ,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 ¶

x, y, z = sp.symbols("x y z")

egy1=77*x+6 - 160

sp.solve(egy1,x)

sp.solve(x**2 - 5, x)

x

e1 = 3*z + 2*y + 1*x - 7
e2 = 4*z + 0*y + 2*x - 8
e3 = 1*z + 4*y + 3*x - 9

sp.solve([e1,e2,e3],[x,y,z])

def f(x):
    return x**2 - 4

# 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.

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

masodfoku_num = sp.lambdify(x,masodfoku_x.subs(adat))
masodfoku_num(1.)

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

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¶

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)

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

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()

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()

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()

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:¶

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¶

from mpl_toolkits.mplot3d import Axes3D

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)

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 ¶

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

mcl=MyClass.createfrom_x(2)