Öröklődés¶
class Ember:
pass
class Matematikus(Ember):
pass
e = Ember()
m = Matematikus()
print(isinstance(e, Matematikus))
print(isinstance(m, Ember))
print(issubclass(Ember, Matematikus))
print(issubclass(Matematikus,Ember))
Ha nem írunk semmilyen osztályt, automatikusan az object osztály a szülő osztály:
o=object()
class A: pass
class B(object): pass
print(issubclass(A, object))
print(issubclass(B, object))
Metódus öröklődés¶
A metódusok öröklődnek, de felülírhatóak.
class A(object):
def foo(self):
print("A.foo függvény")
def bar(self):
print("A.bar függvény")
class B(A):
def foo(self):
print("B.foo függvény")
b = B()
b.foo()
b.bar()
Attribútum öröklődés¶
Mivel az adat attribútumok bárhol létrehozhatóak, nem öröklődnek!
class A(object):
def foo(self):
self.value = 42
class B(A):
pass
b = B()
a = A()
print('a',a.__dict__,'b',b.__dict__) # a __dict__ kiírja az összes attribútumot
a.foo()
print('a',a.__dict__,'b',b.__dict__)
b.foo()
print('a',a.__dict__,'b',b.__dict__)
dir(a)
a.__dict__
A szülő osztály konstruktora¶
- meghívódik az szülő osztály
__init__függvénye. Viszont mivel az__init__nem egy szokásos konstruktor, így nem hívódik meg automatikusan a szülő osztály init függvénye, ha felülírja a gyerek osztály.
class A(object):
def __init__(self):
print("A.__init__ called")
class B(A):
#pass
def __init__(self):
print("B.__init__ called")
class C(A):
pass
b = B()
print("c létrehozása")
c = C()
A szülő osztály metódusai kétféleképpen is elérhetőek
- a már tanult módon, az osztály nevével
- vagy pedig a super függvény segítségével
class A(object):
def __init__(self):
print("A.__init__ ")
class B(A):
def __init__(self):
A.__init__(self)
print("B.__init__ ")
class C(A):
def __init__(self):
super().__init__()
print("C.__init__ ")
print("B")
b = B()
print("C")
c = C()
1. Példa: polinomok¶
class Polinom:
def __init__(self, lista):
self.ehlista=lista
def __str__(self):
szoveg=""
for i,eh in enumerate(self.ehlista):
szoveg=szoveg+str(eh)+"x^"+str(i)+"+"
szoveg=szoveg.rstrip("+")
return szoveg
def deri(self):
l=[i*eh for i,eh in enumerate(self.ehlista) if i!=0]
return Polinom(l)
a=Polinom([1,2,4,5])
print(a)
print(a.deri())
class Masodfoku(Polinom):
def egyikgyok(self):
a=self.ehlista[2]
b=self.ehlista[1]
c=self.ehlista[0]
return (-b+(b**2-4*a*c)**(1/2))/(2*a)
p=Masodfoku([2,3,1])
print(p)
p.egyikgyok()
#print(p.deri())
class Polinom:
def __init__(self, lista):
self.ehlista=lista
def __str__(self):
szoveg="".join([str(eh)+"x^"+str(i)+"+" for i,eh in enumerate(self.ehlista)][::-1])
szoveg=szoveg.rstrip("+")
return szoveg
def deri(self):
l=[i*eh for i,eh in enumerate(self.ehlista) if i!=0]
return Polinom(l)
def beh(self,x):
valasz=sum([eh*x**i for i,eh in enumerate(self.ehlista)])
return valasz
def __add__(self, other):
l=max(len(self.ehlista),len(other.ehlista))
bovitett_eh1=self.ehlista + [0]*(l - len(self.ehlista))
bovitett_eh2=other.ehlista + [0]*(l - len(other.ehlista))
uj_ehlista=[bovitett_eh1[i]+bovitett_eh2[i] for i in range(l) ]
while uj_ehlista[-1]==0:
del uj_ehlista[-1]
return Polinom( uj_ehlista )
p=Polinom([1,2])
print(p,p.beh(5))
print(p.deri())
Mi lesz az eredmény?
m=Masodfoku([1,2,7])
print(m.beh(m.egyikgyok()))
print(p+p)
print(Polinom([1,2,0])+Polinom([2,1]))
print(Polinom([-1,2,3])+Polinom([1,2,-3]))
2. Példa: Sárkányok¶
class sarkany:
def __init__(self, nev):
self.nev=nev
class repulo_sarkany(sarkany):
def __init__(self, nev, szarnyfesztav):
super().__init__(nev)
self.szarnyfesztav=szarnyfesztav
def tamadas(self):
print("A", self.nev, "nevű sárkány a levegőből rád vetette magát", )
def repules(self):
print("A", self.nev, "nevű sárkány repül", )
smaug=repulo_sarkany("Smaug",12)
smaug.repules()
smaug.tamadas()
smaug.szarnyfesztav
class tuzokado_sarkany(sarkany):
def __init__(self, nev):
super().__init__(nev)
def tamadas(self):
print("A", self.nev, "nevű sárkány szénné égetett", )
def tuzokadas(self):
print("A", self.nev, "nevű sárkány a tüzet okád", )
susu=tuzokado_sarkany("Süsü")
susu.tuzokadas()
susu.tamadas()
Többszörös öröklődés¶
- mindegyik osztály metódusai öröklődnek
class repulo_tuzokado_sarkany(repulo_sarkany,tuzokado_sarkany):
def __init__(self, nev, szarnyfesztav):
self.nev=nev
self.szarnyfesztav=szarnyfesztav
Vajon mi lesz az eredmény?¶
viserion=repulo_tuzokado_sarkany("Viserion",25)
viserion.repules()
viserion.tuzokadas()
viserion.tamadas()
Azt, hogy melyik hívódik meg, az MRO (Method Resolution Order) határozza meg. Ez egy sorrend az osztályokon, és egy metódus hívásnál addig megy a sorrendben még meg nem találja valamelyik osztályban a metódust. Nem pontosan így működik, de ökölszabálynak jó, hogy felfelé mélységi kersést végez, balról jobbra sorrendben.
import sys
", ".join(dir(sys)) # a dir függvény megadja az objektum attribútumait és metódusait.
Példák dokumentációra¶
import random
type(random)
importálás után modulnev.attribútum alakban érjük el a modul tartalmát.
random.choice([3,4,5])
Saját modult is készíthetünk¶
A notebookal azonos mappában készítsünk egy mod.py fájlt.
import mod
dir(mod)
print(mod.a)
mod.foo(1)
print(mod.s)
almodulok importálása¶
from modulnév import almodul
Az almodult ezután almodul néven érjük el és nem modulnév.almodul néven.
from os import path
try:
os
except NameError:
print("os nincs definiálva")
try:
path
print("path megtalálva")
except NameError:
print("path nincs definiálva")
try:
os.path
print("os.path megtalálva")
except NameError:
print("os.path nincs definiálva")
Az as kulcssszó segítségével megadhatunk egy másik nevet is:
import numpy as np
import os as os_module
try:
os
except NameError:
print("os nincs definiálva")
try:
os_module
print("os_module megtalálva")
except NameError:
print("os_module nincs definiálva")
Egyszerre több mindent is importálhatunk¶
import os, sys
from sys import stdin, stderr, stdout
Konkrét függvényeket és osztályokat is importálhatunk¶
from argparse import ArgumentParser
import inspect
inspect.isclass(ArgumentParser)
Minden importálása egy modulból¶
from modulnév import * után a modul tartalma elérhető a modulnév. nélkül.
NAGYON NEM AJÁNLOTT mert tudtunkon kívül felülírhatunk dolgokat.
def stat():
print("Én egy statisztika vagyok")
stat()
from os import *
stat()
stat
Modulok instalálása¶
import wikipedia
Ha ModuleNotFoundError-t kapunk, akkor a Python nem találta meg a számítógépünkön a modult. Ekkor általában az a gond, hogy tényleg nincs is a gépünkön, így instalálni kell.
pip (pip installs packages)¶
A pip program automatikusan telepítődik az Anaconda keretében. Windowson az Anaconda Promptból érjük el, Linuxon pedig a terminálból. Használat:
pip install modulnevModul instalálásapip uninstall modulnevModul törlésepip listInstalált modulok listája
Olyan packageket tudunk installálni amik megtalálhatóak a PyPi-ben. (https://pypi.org/)
!pip list # a ! a mögötte lévő parancsot lefuttatja a terminálban
Hasznos beépített packagek, standard library¶
Részletek: https://docs.python.org/3/library/
Numeric and Mathematical Modules
- numbers — Numeric abstract base classes
- math — Mathematical functions
- cmath — Mathematical functions for complex numbers
- decimal — Decimal fixed point and floating point arithmetic
- fractions — Rational numbers
- random — Generate pseudo-random numbers
- statistics — Mathematical statistics functions
Functional Programming Modules
- itertools — Functions creating iterators for efficient looping
- functools — Higher-order functions and operations on callable objects
- operator — Standard operators as functions
- matek és tudományos modulok
- numpy
- scipy
- sympy
- vizualizáció
- Matplotlib
- bokeh
- deep, machine és mindenféle learning, adatbányászat
- Keras
- TensorFlow
- PyTorch
- Pandas
- nyelvi feldolgozás
- NLTK
Kiegészítő anyagok¶
- Saját package létrehozása https://packaging.python.org/tutorials/distributing-packages/
- Virtualenv: Komolyabb Python használat esetén különböző projektekhez különböző verizói lehetnek szükségesek egy adott packagenek. A Virtualenv ennek kezelésében (is) segít.
String formatálás¶
Több módszer van arra, hogy kényelmesebben generáljunk szöveges kimenetet. Az egyik a format() függvény. Ez egy stringből egy másik stringet készít úgy, hogy hogy a megadott paramétereket behelyettesíti a kapcsos zárójelek közé. A függvényekhez hasonlóan több féle paraméter átadás működik:
# default argumentumok
print("Kedves {}, az ön egyenlege {}.".format("Ádám", 230.2346))
# pozíció szerintei argumentumok
print("Kedves {1}, az ön egyenlege {0}.".format("Ádám", 230.2346))
# kucsszavas argumentumok
print("Kedves {nev}, az ön egyenlege {egyen}.".format(nev="Ádám", egyen=230.2346))
# vegyes
print("Kedves {0}, az ön egyenlege {egyen}.".format("Ádám",egyen= 230.2346))
Ha az adatok egy dicitionaryben vannak, azt is használhatjuk.
person = {'eletkor': 23, 'nev': 'Ádam'}
print("{p[nev]} életkora: {p[eletkor]}".format(p=person))
szam1 = 12
szam2 = 1
nev="Paprika Jancsi"
print(f"{nev}nak {szam1} almája és {szam2} kutyája van.")