Bevezetés

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)

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

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

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

Összetettebb függvények

In [11]:
sin(2) #szinusz
---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
<ipython-input-11-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 [12]:
import math
In [13]:
sin(2) # ez így továbbra sem létezik
---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
<ipython-input-13-a0912eaca942> in <module>
----> 1 sin(2) # ez így továbbra sem létezik

NameError: name 'sin' is not defined
In [14]:
math.sin(2)
Out[14]:
0.9092974268256817
In [15]:
# 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 [16]:
# 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 [17]:
a=2
b=3
c=4.0 # automatikus típusadás
In [18]:
(a+b*c)**a # a legáltalánosabb típus lesz a kimenet (int < float)
Out[18]:
196.0
In [19]:
# Fontos, hogy igyekezzük kerülni védett változó neveket! ILYET NE!
math.sqrt = 1
math.sqrt(2)

# KERNEL RESTART SZÜKSÉGES
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-19-e5b8c501aae6> in <module>
      1 # Fontos, hogy igyekezzük kerülni védett változó neveket! ILYET NE!
      2 math.sqrt = 1
----> 3 math.sqrt(2)
      4 
      5 # KERNEL RESTART SZÜKSÉGES

TypeError: 'int' object is not callable

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 [1]:
def foo(x):
    return 3*x

def bar(x,y):
    a = x+y**2
    return 2*a + 4
In [2]:
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 [3]:
double = lambda x : x*2
multiply = lambda x,y : x*y
In [4]:
print(double(3))
print(multiply(10,3))
6
30

Osztályok

In [5]:
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 [6]:
mcl=MyClass.createfrom_x(2)
In [7]:
mcl.return_stuff()
Out[7]:
38
In [8]:
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 [9]:
mcl=MyClass.createfrom_x(2)
In [10]:
mcl.return_stuff()
Out[10]:
38

Vezérlési szerkezetek (Control Flow) - csak a legfontosabbak

Listák

In [11]:
lista = [1,2,3,4,"valami",[1.0,4]]
In [12]:
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 [13]:
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 [14]:
lista = [2,3,64,89,1,4,9,0,1]

lista.sort()
lista
Out[14]:
[0, 1, 1, 2, 3, 4, 9, 64, 89]

if-then-else

if condition:
    instruction1
elif condition2:
    instruction2
else:
    intsturction3
In [15]:
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 [16]:
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 [17]:
lista2 = [3*i**2 for i in range(2,5)] # range: 2,3,4
lista2
Out[17]:
[12, 27, 48]
In [18]:
lista3 = list(range(10))
lista3
Out[18]:
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
In [19]:
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[19]:
[12, 48, 75, 147, 192]

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 [20]:
import math
import sympy as sp
import scipy as sc
sp.init_printing()
In [21]:
F, m, a, b, c, x = sp.symbols("F m a b c x")
In [22]:
F=m*a
In [23]:
F.subs([(a,7)])
Out[23]:
$$7 m$$
In [24]:
F.subs([(a,7),(m,1.1)])
Out[24]:
$$7.7$$
In [25]:
((a+b)**3).expand()
Out[25]:
$$a^{3} + 3 a^{2} b + 3 a b^{2} + b^{3}$$
In [26]:
((a+b)**7 - (b+2*a)**3).expand()
Out[26]:
$$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 [27]:
(a**2+b**2+2*a*b).factor()
Out[27]:
$$\left(a + b\right)^{2}$$
In [28]:
sp.factor(a**2+b**2+2*a*b)
Out[28]:
$$\left(a + b\right)^{2}$$
In [29]:
sp.factor(b**3 + 3*a*b**2 + 3*a**2*b + a**3)
Out[29]:
$$\left(a + b\right)^{3}$$
In [30]:
a/b+c/b+7/b
Out[30]:
$$\frac{a}{b} + \frac{c}{b} + \frac{7}{b}$$
In [31]:
sp.ratsimp(a/b+c/b+7/b)
Out[31]:
$$\frac{a + c + 7}{b}$$
In [32]:
(a/b+c/b+7/b).ratsimp()
Out[32]:
$$\frac{a + c + 7}{b}$$
In [33]:
(sp.sin(x)**2 + sp.cos(x)**2).simplify()
Out[33]:
$$1$$
In [34]:
(sp.cos(2*x)).expand()
Out[34]:
$$\cos{\left (2 x \right )}$$
In [35]:
sp.expand_trig(sp.cos(2*x))
Out[35]:
$$2 \cos^{2}{\left (x \right )} - 1$$
In [36]:
import scipy.constants
In [37]:
sc.constants.golden
Out[37]:
$$1.618033988749895$$
In [38]:
math.sqrt(-1+0j)
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-38-2f48549c8254> in <module>
----> 1 math.sqrt(-1+0j)

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

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 [41]:
sp.series(sp.sin(x),x,0,20)
Out[41]:
$$x - \frac{x^{3}}{6} + \frac{x^{5}}{120} - \frac{x^{7}}{5040} + \frac{x^{9}}{362880} - \frac{x^{11}}{39916800} + \frac{x^{13}}{6227020800} - \frac{x^{15}}{1307674368000} + \frac{x^{17}}{355687428096000} - \frac{x^{19}}{121645100408832000} + O\left(x^{20}\right)$$

Deriválás/Integrálás

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

Deriválás

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

Többszöri deriválás

In [44]:
sp.diff(sp.sin(x**3),x,3)
Out[44]:
$$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 [45]:
sp.integrate(1/(1+x),x)
Out[45]:
$$\log{\left (x + 1 \right )}$$

Határozott integrál

In [46]:
sp.integrate(1/(1+x),(x,1,2))
Out[46]:
$$- \log{\left (2 \right )} + \log{\left (3 \right )}$$
In [47]:
a = sp.Symbol('a')
In [48]:
sp.integrate(1/(x**2 + a),x)
Out[48]:
$$- \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 [49]:
y = sp.Symbol('y')
def f(x):
    return x**2
def g(y):
    return sp.sin(y)
In [50]:
f(g(y))
Out[50]:
$$\sin^{2}{\left (y \right )}$$
In [51]:
sp.diff(f(g(y)),y)
Out[51]:
$$2 \sin{\left (y \right )} \cos{\left (y \right )}$$
In [52]:
sp.diff(g(f(x)),x)
Out[52]:
$$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 [53]:
sp.integrate(sp.sin(sp.cos(x)),x)
Out[53]:
$$\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 [54]:
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 [55]:
v1
Out[55]:
$$\left[\begin{matrix}2.0\\3.0\\4.0\end{matrix}\right]$$
In [56]:
v2
Out[56]:
$$\left[\begin{matrix}3.0 & -2.0 & -7.0\end{matrix}\right]$$
In [57]:
v2.multiply(v1)
Out[57]:
$$\left[\begin{matrix}-28.0\end{matrix}\right]$$
In [58]:
mx2.multiply(v1)
Out[58]:
$$\left[\begin{matrix}20.0\\47.0\\74.0\end{matrix}\right]$$
In [59]:
v2.multiply(mx2)
Out[59]:
$$\left[\begin{matrix}-54.0 & -60.0 & -66.0\end{matrix}\right]$$
In [60]:
EM
Out[60]:
$$\left[\begin{matrix}1 & 0 & 0\\0 & 1 & 0\\0 & 0 & 1\end{matrix}\right]$$
In [61]:
mx1.eigenvals() # sajátértékek és multiplicitásuk (racionális számokkal)
Out[61]:
$$\left \{ \frac{2}{3} + \left(- \frac{1}{2} - \frac{\sqrt{3} i}{2}\right) \sqrt[3]{\frac{638}{27} + \frac{22 \sqrt{7} i}{3}} + \frac{88}{9 \left(- \frac{1}{2} - \frac{\sqrt{3} i}{2}\right) \sqrt[3]{\frac{638}{27} + \frac{22 \sqrt{7} i}{3}}} : 1, \quad \frac{2}{3} + \frac{88}{9 \left(- \frac{1}{2} + \frac{\sqrt{3} i}{2}\right) \sqrt[3]{\frac{638}{27} + \frac{22 \sqrt{7} i}{3}}} + \left(- \frac{1}{2} + \frac{\sqrt{3} i}{2}\right) \sqrt[3]{\frac{638}{27} + \frac{22 \sqrt{7} i}{3}} : 1, \quad \frac{2}{3} + \frac{88}{9 \sqrt[3]{\frac{638}{27} + \frac{22 \sqrt{7} i}{3}}} + \sqrt[3]{\frac{638}{27} + \frac{22 \sqrt{7} i}{3}} : 1\right \}$$
In [62]:
mx1.eigenvals(rational=False) # sajátértékek numerikusan
Out[62]:
$$\left \{ -3.6088213318864 : 1, \quad -1.14824478501694 : 1, \quad 6.75706611690333 : 1\right \}$$
In [63]:
mx1.eigenvects() # sajátvektorok numerikusan
Out[63]:
$$\left [ \left ( -1.14824478501694 - 4.0 \cdot 10^{-22} i, \quad 1, \quad \left [ \left[\begin{matrix}-2.97091106940601 + 8.63097165400352 \cdot 10^{-30} i\\1.69112210580027 + 2.15792503714448 \cdot 10^{-24} i\\1.0\end{matrix}\right]\right ]\right ), \quad \left ( -3.6088213318864 + 2.0 \cdot 10^{-22} i, \quad 1, \quad \left [ \left[\begin{matrix}-0.223746963816259 + 3.60331665052925 \cdot 10^{-31} i\\-0.984395110109405 + 1.30961555945332 \cdot 10^{-25} i\\1.0\end{matrix}\right]\right ]\right ), \quad \left ( 6.75706611690333 - 7.0 \cdot 10^{-21} i, \quad 1, \quad \left [ \left[\begin{matrix}0.810042648606886 + 4.63282092154982 \cdot 10^{-32} i\\0.831734542770669 + 4.74016880491627 \cdot 10^{-26} i\\1.0\end{matrix}\right]\right ]\right )\right ]$$
In [64]:
mx1.det() # mx1 determinánsa
Out[64]:
$$28.0$$
In [65]:
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()
$$\left[\begin{matrix}Ix & - Ixy\\- Ixy & Iy\end{matrix}\right]$$
 Sajátértékek, vektorok: 

Out[65]:
$$\left [ \left ( \frac{Ix}{2} + \frac{Iy}{2} - \frac{\sqrt{Ix^{2} - 2 Ix Iy + 4 Ixy^{2} + Iy^{2}}}{2}, \quad 1, \quad \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 ), \quad \left ( \frac{Ix}{2} + \frac{Iy}{2} + \frac{\sqrt{Ix^{2} - 2 Ix Iy + 4 Ixy^{2} + Iy^{2}}}{2}, \quad 1, \quad \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 [66]:
mxSP=sp.Matrix([[Ix,0],[0,Iy]])
display(mxSP)

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

Out[66]:
$$\left [ \left ( Ix, \quad 1, \quad \left [ \left[\begin{matrix}1\\0\end{matrix}\right]\right ]\right ), \quad \left ( Iy, \quad 1, \quad \left [ \left[\begin{matrix}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 [67]:
import sympy as sp
import scipy as sc
import scipy.linalg
In [68]:
v1= sc.array([2.,3.,4.])
v2= sc.array([3.,-2.,-7.])
mx1 = sc.array([[1.,2.,3.],[2.,0.,4.],[3.,4.,1.]])
mx2 = sc.array([[1.,2.,3.],[4.,5.,6.],[7.,8.,9.]])
In [69]:
print( sc.dot(mx2,v1) )  # skalár szorat mx2*v1
print( sc.dot(v1,mx2) )  # skalár szorat transpose(v1)*mx2
print( sc.cross(v1,v2) ) # keresztszorzat v1×v2
[20. 47. 74.]
[42. 51. 60.]
[-13.  26. -13.]
In [70]:
(λ,V) = sc.linalg.eig(mx1) # Mátrix sajátértékei, sajátvektorai a \lambda é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 míg a sympy a sajátvektor utolsó koordinátáját 1-nek választja, addig a scipy a sajátvektorokat 1-re normálja!

Egyenletek megoldása

In [71]:
import scipy.optimize
In [72]:
x, y, z = sp.symbols("x y z")
In [73]:
egy1=77*x+6 - 160
In [74]:
sp.solve(egy1,x)
Out[74]:
$$\left [ 2\right ]$$
In [75]:
sp.solve(x**2 - 5, x)
Out[75]:
$$\left [ - \sqrt{5}, \quad \sqrt{5}\right ]$$
In [76]:
x
Out[76]:
$$x$$
In [77]:
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 [78]:
sp.solve([e1,e2,e3],[x,y,z])
Out[78]:
$$\left \{ x : \frac{10}{7}, \quad y : \frac{6}{7}, \quad z : \frac{9}{7}\right \}$$
In [79]:
def f(x):
    return x**2 - 4
In [80]:
gyok = scipy.optimize.brentq(f,0,10)
print(gyok)
2.0

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

In [81]:
import scipy as sc # 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 [82]:
def f(x):
    return sc.sin(x)*(1-4*sc.exp(0.7*x)/(x**3))

x1 = sc.linspace(2,10,30)
y1 = f(x1)
In [83]:
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()
In [84]:
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 [85]:
def g(x):
    return sc.sqrt(x)
def h(x):
    return x**2

x2 = sc.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 [86]:
x3 = sc.arange(1,14+1)
y3 = sc.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 [87]:
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 [88]:
t = sc.linspace(0,2*sc.pi,100)
x = sc.sin(t)
y = sc.cos(t)

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

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

In [89]:
from mpl_toolkits.mplot3d import Axes3D
In [90]:
def f(x, y):
    return sc.sin(sc.exp( - x ** 2 - y ** 2))

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

X, Y = sc.meshgrid(x, y)
Z = f(X, Y)
In [91]:
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()