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))
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()
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__
__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
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()
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]))
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()
class repulo_tuzokado_sarkany(repulo_sarkany,tuzokado_sarkany):
def __init__(self, nev, szarnyfesztav):
self.nev=nev
self.szarnyfesztav=szarnyfesztav
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.
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])
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)
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")
import os, sys
from sys import stdin, stderr, stdout
from argparse import ArgumentParser
import inspect
inspect.isclass(ArgumentParser)
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
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.
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 modulnev
Modul instalálása pip uninstall modulnev
Modul törlésepip list
Instalá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
Részletek: https://docs.python.org/3/library/
Numeric and Mathematical Modules
Functional Programming Modules
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.")