Sa lecture na ito, malalaman natin ang tungkol sa mga klase, constructor at inheritance sa python.
Ang mga konseptong ito ay talagang mahalaga sa isang malaking programa kung saan kailangang tukuyin ang iba't ibang uri.
Klase
Ang mga klase ay mahalaga sa programming at hindi sila partikular sa python. Maraming iba programming languages suportahan ang paniwala ng mga klase. Gumagamit kami ng mga klase upang tukuyin ang mga bagong uri ng data.
Sa ngayon, natutunan namin ang tungkol sa mga pangunahing uri ng data sa Python tulad ng mga numero, string, at boolean. Ito ang mga pangunahing o simpleng uri ng data sa Python. Nakakita rin kami ng ilang kumplikadong uri ng data tulad ng mga listahan at diksyunaryo.
Bagama't lubhang kapaki-pakinabang ang mga uri na ito, hindi sila palaging magagamit upang magmodelo ng mga kumplikadong konsepto. Halimbawa, isipin ang ideya ng isang punto, o isang shopping cart. Ang shopping cart ay hindi isang boolean o isang listahan. Ito ay ibang uri ng data. Kaya't maaari tayong gumamit ng mga klase upang tukuyin ang mga bagong uri upang magmodelo ng mga tunay na konsepto.
Ngayon, tukuyin natin ang isang bagong uri ng data na tinatawag na point. Ang bagong uri na ito ay magkakaroon ng mga pamamaraan tulad ng sinuri namin dati.
Ito ay kung paano mo ito gagawin:
Nagsisimula kami sa pamamagitan ng pagtukoy ng isang klase sa pamamagitan ng paggamit ng keyword na "klase" at pagkatapos nito ay binibigyan namin ng pangalan ang aming klase.
class Point
Ngayon, tingnan ang kombensiyon ng pagbibigay ng pangalan na ginamit ko dito. Na-capitalize ko ang unang titik dito, ito ang tinatawag nating pascal naming convention. Ang convention na ito ay iba sa ginagamit namin para sa pagbibigay ng pangalan sa aming mga variable at function kung saan palagi kaming gumagamit ng maliliit na titik at pinaghihiwalay ang maraming salita gamit ang underscore. Ngunit kapag pinangalanan ang mga klase, hindi kami gumagamit ng underscore upang paghiwalayin ang maraming salita sa halip, ginagamit namin ang unang titik ng bawat salita.
Pagkatapos tukuyin ang aming klase, isang colon ang ginagamit na nangangahulugan na ngayon ay isang bloke ang tinukoy.
class Point:
def move (self):
Sa block na ito, maaari nating tukuyin ang lahat ng mga function o pamamaraan na kabilang sa mga puntos. Halimbawa, maaari naming tukuyin ang isang function na tinatawag na "move" para sa paglipat ng isang punto. Tandaan na sa sandaling mag-type kami ng bukas na panaklong, awtomatikong idaragdag ng PyCharm ang "sarili" dito. Ito ay isang espesyal na keyword at hayaan akong bumalik dito sa ilang sandali. I-print natin ang "move" sa terminal.
print("move")
Tukuyin natin ang isa pang paraan tulad ng “draw” at i-print ito sa terminal.
def draw(self):
print("draw")
Tapos na kami sa kahulugan ng aming "punto" na klase. Gamit ang bagong uri na ito, maaari tayong lumikha ng mga bagong bagay. Tinutukoy lamang ng isang klase ang blueprint o ang template para sa paglikha ng mga bagay na aktwal na mga pagkakataon batay sa blueprint na iyon. Upang lumikha ng isang bagay, itina-type namin ang pangalan ng aming klase at pagkatapos ay tinatawag itong tulad ng isang function. Lumilikha ito ng isang bagong bagay at pagkatapos ay ibabalik ito. Pagkatapos ay maiimbak natin ang bagay na iyon sa isang variable. Hayaan mo akong ipakita sa iyo:
Dito namin tinukoy ang isang "point1" na isang three-dimensional na punto. Makikita mo iyon, maaari kaming mag-print ng mga indibidwal na coordinate sa terminal.
Maari nating gamitin ang dalawang paraan na "draw" at "move" sa puntong ito.
Kaya't sa pagbabalik-tanaw, gumagamit kami ng mga klase upang tukuyin ang mga bagong uri at ang mga uri na ito ay maaaring magkaroon ng mga pamamaraan na aming tinukoy sa katawan ng klase. Ang mga klase ay maaaring magkaroon ng mga katangian na maaari naming itakda saanman sa aming mga programa.
Mga tagapagbuo
Sa ngayon, natutunan namin kung paano lumikha ng mga bagong uri gamit ang mga klase. Ngayon ay may maliit na problema sa pagpapatupad na ito. Maaari tayong lumikha ng point object nang walang x o y coordinate gamit ang mga klase at hindi iyon perpekto. Hayaan mo akong ipakita sa iyo.
Gumawa tayo ng punto at i-print ito bago natin itakda ang x coordinate. Ang pagpapatakbo ng aming programa ay nagreresulta sa isang error sa katangian tulad nito:
Nangangahulugan ito na ang point object ay walang katangian na tinatawag na x. Ngayon ang problema ay posible na magkaroon ng point object na walang x o y coordinate. Hindi ito makatwiran dahil sa tuwing pinag-uusapan natin ang isang punto, kailangan nating malaman kung saan matatagpuan ang puntong iyon. Upang malutas ang problemang ito, gumagamit kami ng isang constructor. Ang isang constructor ay isang function na tinatawag sa oras ng paglikha ng isang bagay.
Narito kung paano namin ginagamit ang isang constructor. Una, ipasa natin ang mga halaga ng x at y coordinates sa programa sa itaas.
point = Point(10, 20)
print(point.x)
Ngayon, kailangan nating magdagdag ng isang espesyal na pamamaraan sa klase na ito na tinatawag na constructor. Ang syntax nito ay ganito:
def __init__(self, x, y):
init
ay maikli para sa nasimulan, at ito ang function o ang paraan na matatawag kapag ang isang bagong point object ay nilikha. Ang x at y ay idinagdag pagkatapos self
para magdagdag ng dalawang karagdagang parameter.
Pagkatapos nito, dapat nating imapa ang x at y sa mga naipasa na halaga ie 10 at 20
self.x = x
self.y = y
Ginagamit namin ang self
upang sumangguni sa kasalukuyang bagay at pagkatapos ay itinakda namin ang x attribute sa x argument na ipinasa sa function na "x". Sa ganitong paraan, gamit init
paraan, maaari naming simulan ang aming mga bagay. Ang pamamaraang ito ay tinutukoy bilang isang tagabuo. Patakbuhin natin ang ating programa.
Ngayon, maaari nating baguhin ang mga x at y na coordinate sa ibang pagkakataon. I-update natin ang x coordinate:
point = Point(10, 20)
point.x = 11
print(point.x)
Ngayon, ang x coordinate ay na-update sa halagang 11.
Magsanay
Narito ang isang kawili-wiling ehersisyo para sa iyo.
Gusto kong tukuyin mo ang isang bagong uri na tinatawag na tao. Ang mga bagay na "Tao" na ito ay dapat may "name
"attribute pati na rin ang isang"talk()
”Paraan.
Ito ay isang simpleng gawain at hindi dapat tumagal ng higit sa ilang minuto.
Solusyon
Magsimula sa pagtukoy sa klase na "Tao" tulad nito:
class Person:
self.name = name
Tutukuyin namin ang tagabuo sa ibang pagkakataon. Ngayon, maaari tayong lumikha ng object na "Tao". Tawagin natin itong John
john = Person("John Smith")
print(john.name)
john.talk()
Ngayon, pumunta sa unang bahagi ng code at lumikha ng isang constructor.
def __init__(self, name):
Ang huling code ay magiging ganito:
Maaari mo ring gamitin ang mga naka-format na string at iba pang mga konsepto kasabay ng mga klase at konstruktor.
Pamana
Ang inheritance ay isa pang konsepto na nauugnay sa mga klase na nagbibigay-daan sa iyong muling gumamit ng code.
Isaalang-alang ang piraso ng code na ito.
class Dog:
def walk(self):
print("walk")
Gumawa kami ng klase na "Aso" na may "lakad" na paraan. Sa paraang ito, ipi-print lang namin ang walk message sa terminal. Sabihin nating, sa isang tunay na programa, Mayroong 10 linya ng code sa halip na isang linya lamang dito. Sa hinaharap, kung kailangan ng isa pang klase upang magkaroon ng "lakad" na paraan, kailangan nating ulitin ang lahat ng code na iyon. Ito ay hindi perpekto.
Sa programming, mayroon kaming isang prinsipyo na tinatawag na DRY na kung saan ay maikli para sa huwag ulitin ang iyong sarili. Sabihin nating minsan sa hinaharap, may matutuklasan tayong problema sa ating "paglakad" na paraan at kung inulit o nadoble natin ang pamamaraang ito sa maraming iba pang lugar, kailangan nating bumalik at ayusin ang problemang iyon sa bawat lugar na nadoble natin ito. code. Kaya't sa programming ay hindi natin dapat tukuyin ang isang bagay nang dalawang beses.
Mayroong iba't ibang mga diskarte upang malutas ang problemang ito ngunit dito natin matututunan ang isa na mas madali para sa mga nagsisimula at ito ay tinatawag na mana. Sa kasong ito, gagawa kami ng isa pang klase na "mammal" at tutukuyin ang aming "lakad" na katangian sa klase na iyon.
class Mammal:
def walk(self):
print("walk")
Pagkatapos tukuyin ang aming klase na "Mammal" maaari naming gamitin ang mana upang maipasa ang mga katangiang tulad nito:
Parehong minana ng mga klase ng aso at pusa ang lahat ng pamamaraan ng klase na tinukoy sa kanilang parent class. Ngayon, maaari tayong magdagdag ng mga pamamaraang partikular sa mga aso tulad nito:
class Dog:
def bark(self):
print("bark")
Balutin!
Ito ay tungkol sa mga klase, constructor at muling paggamit ng code sa mga klase na may mga konsepto ng mana. Ngayon ay malapit na kaming matapos ng aming serye. Sa puntong ito, dapat ay makagawa ka ng mahusay, nababasa at maigsi na mga code sa Python.
Makikita natin ang konsepto ng modules at packages sa susunod na lecture.
Mag-iwan ng Sagot