Edukien aurkibidea[Ezkutatu][Erakutsi]
Hitzaldi honetan, python-en klaseak, eraikitzaileak eta herentzia ezagutuko ditugu.
Kontzeptu hauek oso garrantzitsuak dira programa handi batean, non mota desberdinak definitu behar diren.
Eskolak
Klaseak ezinbestekoak dira programazioan eta ez dira python-en espezifikoak. Beste asko programazio hizkuntzak klaseen nozioa onartzen. Klaseak erabiltzen ditugu datu mota berriak definitzeko.
Orain arte, Python-en oinarrizko datu motei buruz ikasi dugu, hala nola, zenbakiak, kateak eta boolearrak. Hauek dira Python-en oinarrizko datu-motak edo sinpleak. Datu mota konplexu batzuk ere ikusi ditugu zerrendak eta hiztegiak adibidez.
Mota hauek oso erabilgarriak diren arren, ezin dira beti kontzeptu konplexuak modelatzeko erabili. Adibidez, pentsa puntu baten ideian, edo erosketa-gurdi baten ideian. Erosketa saskia ez da boolearra edo zerrenda bat. Beste datu mota bat da. Beraz, klaseak erabil ditzakegu mota berriak definitzeko benetako kontzeptuak modelatzeko.
Orain, defini dezagun puntu izeneko datu mota berri bat. Mota berri honek metodoak izango ditu aurretik egiaztatu genuen bezala.
Honela egingo duzu:
Klase bat definitzen hasten gara "class" gako-hitza erabiliz eta horren ondoren gure klaseari izena ematen diogu.
class Point
Orain, begiratu hemen erabili dudan izendapen-konbentzioa. Lehen letra larriz idatzi dut hemen, hau da pascal izendatzeko konbentzioa deitzen dioguna. Konbentzio hau gure aldagaiak eta funtzioak izendatzeko erabiltzen dugunaren desberdina da, horretarako beti letra xeheak erabiltzen ditugu eta hainbat hitz bereizten ditugu azpimarra erabiliz. Baina klaseak izendatzerakoan, ez dugu azpimarrarik erabiltzen hainbat hitz bereizteko, hitz bakoitzaren lehen letra larriz idazten dugu.
Gure klasea definitu ondoren, bi puntu bat erabiltzen da eta horrek esan nahi du orain bloke bat definitu dela.
class Point:
def move (self):
Bloke honetan, puntuei dagozkien funtzio edo metodo guztiak defini ditzakegu. Adibidez, puntu bat mugitzeko "mugitu" izeneko funtzio bat defini dezakegu. Kontuan izan parentesi irekiak idatzi bezain laster, PyCharm-ek automatikoki gehitzen duela hemen "auto". Hau gako-hitz berezi bat da eta laster itzul nazazu. Inprima dezagun "mugitu" terminalean.
print("move")
Definitu dezagun “marraztu” bezalako beste metodo bat eta inprima dezagun terminalean.
def draw(self):
print("draw")
Gure "puntu" klasearen definizioarekin amaitu dugu. Mota berri honekin, objektu berriak sor ditzakegu. Klase batek plano horretan oinarritutako benetako instantziak diren objektuak sortzeko planoa edo txantiloia besterik ez du definitzen. Objektu bat sortzeko, gure klasearen izena idazten dugu eta gero funtzio bat bezala deitzen diogu. Honek objektu berri bat sortzen du eta gero itzultzen du. Ondoren, objektu hori aldagai batean gorde dezakegu. Erakutsi dezadan:
Hemen hiru dimentsioko puntu bat den “point1” definitu dugu. Hori ikusi dezakezu, terminalean koordenatu indibidualak inprima ditzakegu.
Puntu honekin "marraztu" eta "mugitu" bi metodoak erabil ditzakegu.
Beraz, laburbiltzeko, klaseak erabiltzen ditugu mota berriak definitzeko eta mota hauek klasearen gorputzean definitzen ditugun metodoak izan ditzakete. Klaseek gure programetan edozein lekutan ezar ditzakegun atributuak izan ditzakete.
eraikitzaileak
Orain arte, klaseak erabiliz mota berriak sortzen ikasi dugu. Orain arazo txiki bat dago ezarpen honekin. X edo y koordenaturik gabeko objektu puntu bat sor dezakegu klaseak erabiliz eta hori ez da ideala. Utzidazu erakusten.
Sortu dezagun puntu bat eta inprima dezagun x koordenatua ezarri aurretik. Gure programa exekutatzeak honelako atributu errore bat sortzen du:
Esan nahi du puntu objektuak ez duela x izeneko atributurik. Orain arazoa da posible dela x edo y koordenaturik gabeko objektu puntual bat izatea. Horrek ez du zentzurik puntu bati buruz hitz egiten dugunean puntu hori non dagoen jakin behar baitugu. Arazo hau konpontzeko, eraikitzaile bat erabiltzen dugu. Eraikitzailea objektu bat sortzeko unean deitzen zaion funtzio bat da.
Hona hemen eraikitzailea nola erabiltzen dugun. Lehenik eta behin, pasa ditzagun x eta y koordenatuen balioak goiko programan.
point = Point(10, 20)
print(point.x)
Orain, konstruktore izeneko klase honetan metodo berezi bat gehitu behar dugu. Bere sintaxia honelakoa da:
def __init__(self, x, y):
init
hasierako laburra da, eta puntu-objektu berri bat sortzen denean deitzen den funtzioa edo metodoa da. X eta y berehala gehitzen dira self
bi parametro gehigarri gehitzeko.
Horren ondoren, x eta y-ak pasatako balioekin mapatu beharko genituzke, hau da, 10 eta 20
self.x = x
self.y = y
Erabiltzen dugu self
uneko objektuari erreferentzia egiteko eta gero x atributua “x” funtzioari pasatako x argumentari ezarriko diogu. Modu honetan, erabiliz init
metodoa, gure objektuak hasieratu ditzakegu. Metodo honi eraikitzaile gisa esaten zaio. Exekutatu dezagun gure programa.
Orain, x eta y koordenatuak geroago alda ditzakegu. Eguneratu dezagun x koordenatua:
point = Point(10, 20)
point.x = 11
print(point.x)
Orain, x koordenatua 11 baliora eguneratzen da.
Ariketa
Hemen duzue ariketa interesgarri bat.
Pertsona izeneko mota berri bat definitzea nahi dut. "Pertsona" objektu hauek "" bat izan behar dutename
” atributua eta “talk()
”Metodoa.
Zeregin sinplea da eta ez luke minutu pare bat baino gehiago behar.
Irtenbidea
Hasi "Pertsona" klasea honela definitzen:
class Person:
self.name = name
Aurrerago definituko dugu eraikitzailea. Orain, "Pertsona" objektua sor dezakegu. Dei diezaiogun John
john = Person("John Smith")
print(john.name)
john.talk()
Orain, joan kodearen lehen zatira eta sortu eraikitzaile bat.
def __init__(self, name):
Azken kodea honela izango da:
Formateatutako kateak eta beste kontzeptu batzuk ere erabil ditzakezu klaseekin eta eraikitzaileekin batera.
herentzia
Kode bat berrerabiltzeko aukera ematen dizuten klaseekin lotutako beste kontzeptu bat da herentzia.
Demagun kode zati hau.
class Dog:
def walk(self):
print("walk")
“Txakurra” klase bat sortu dugu “ibiltzea” metodoarekin. Metodo honetan, oinezko mezua terminalean inprimatzen ari gara. Demagun, benetako programa batean, 10 kode lerro daude hemen lerro bakarra izan beharrean. Etorkizunean, “walk” metodoa izateko beste klase bat behar bada, kode hori guztia errepikatu beharko dugu. Hau ez da ideala.
Programazioan, DRY izeneko printzipioa dugu, ez errepikatu. Demagun etorkizunean, gure "ibilaldi" metodoarekin arazo bat aurkitzen dugula eta metodo hau beste leku askotan errepikatu edo bikoiztu badugu, itzuli egin beharko dugula arazo hori bikoiztu dugun toki guztietan. kodea. Horregatik, programazioan ez dugu zerbait bi aldiz definitu behar.
Arazo hau konpontzeko planteamendu desberdinak daude baina hemen hasiberrientzat errazagoa dena eta herentzia deitzen dena ikasiko dugu. Kasu honetan, beste "ugaztun" klase bat sortuko dugu eta gure "ibilaldi" atributua definituko dugu klase horretan.
class Mammal:
def walk(self):
print("walk")
Gure "Ugaztun" klasea definitu ondoren, herentzia erabil dezakegu atributuak honela pasatzeko:
Bi txakur eta katu klaseak bere guraso klasean definitutako klase-metodo guztiak heredatzen ari dira. Orain, honelako txakurrentzat espezifikoak diren metodoak gehi ditzakegu:
class Dog:
def bark(self):
print("bark")
Bilatu!
Hau guztia klaseei, eraikitzaileei eta herentzia kontzeptuak dituzten klaseetan kodea berrerabiltzeari buruzkoa zen. Orain gure seriearen amaierara iristen ari gara. Une honetan, kode onak, irakurgarriak eta zehatzak sortzeko gai izan beharko zenuke Python-en.
Moduluen eta paketeen kontzeptua hurrengo hitzaldian ikusiko dugu.
Utzi erantzun bat