Innehållsförteckning[Dölj][Visa]
I den här föreläsningen kommer vi att lära oss om klasser, konstruktörer och arv i python.
Dessa begrepp är verkligen viktiga i ett stort program där olika typer behövs för att definieras.
Klasser
Klasser är viktiga i programmering och de är inte specifika för python. Många andra programmeringsspråk stödja begreppet klasser. Vi använder klasser för att definiera nya datatyper.
Hittills har vi lärt oss om de grundläggande datatyperna i Python som siffror, strängar och booleaner. Dessa är de grundläggande eller enkla datatyperna i Python. Vi har också sett ett par komplexa datatyper som listor och ordböcker.
Även om dessa typer är extremt användbara, kan de inte alltid användas för att modellera komplexa koncept. Tänk till exempel på idén om en punkt eller en kundvagn. En kundvagn är inte en boolean eller en lista. Det är en annan typ av data. Så vi kan använda klasser för att definiera nya typer för att modellera verkliga koncept.
Låt oss nu definiera en ny datatyp som kallas punkt. Den här nya typen kommer att ha metoder som vi kontrollerat tidigare.
Så här gör du:
Vi börjar med att definiera en klass genom att använda nyckelordet "class" och direkt efter det ger vi vår klass ett namn.
class Point
Titta nu på namnkonventionen jag har använt här. Jag har skrivit den första bokstaven med stor bokstav här, det här är vad vi kallar en pascal namnkonvention. Denna konvention skiljer sig från den vi använder för att namnge våra variabler och funktioner, för vilka vi alltid använder gemener och separerar flera ord med ett understreck. Men när vi namnger klasser använder vi inte ett understreck för att separera flera ord istället, vi använder den första bokstaven i varje ord med stor bokstav.
Efter att ha definierat vår klass används ett kolon vilket betyder att nu ett block definieras.
class Point:
def move (self):
I det här blocket kan vi definiera alla funktioner eller metoder som hör till punkter. Till exempel kan vi definiera en funktion som kallas "flytta" för att flytta en punkt. Observera att så fort vi skriver öppen parentes lägger PyCharm automatiskt till "jag" här. Detta är ett speciellt nyckelord och låt mig återkomma till detta snart. Låt oss skriva ut "flytta" på terminalen.
print("move")
Låt oss definiera en annan metod som "rita" och skriva ut den på terminalen.
def draw(self):
print("draw")
Vi är klara med definitionen av vår "punkt"-klass. Med denna nya typ kan vi skapa nya objekt. En klass definierar helt enkelt ritningen eller mallen för att skapa objekt som är de faktiska instanserna baserat på den ritningen. För att skapa ett objekt skriver vi namnet på vår klass och kallar det sedan precis som en funktion. Detta skapar ett nytt objekt och returnerar det sedan. Sedan kan vi lagra det objektet i en variabel. Låt mig visa dig:
Här har vi definierat en "punkt1" som är en tredimensionell punkt. Du kan se det, vi kan skriva ut individuella koordinater på terminalen.
Vi kan använda de två metoderna "rita" och "flytta" med denna punkt.
Så för att sammanfatta använder vi klasser för att definiera nya typer och dessa typer kan ha metoder som vi definierar i klassens kropp. Klasser kan ha attribut som vi kan ställa in var som helst i våra program.
konstruktörer
Hittills har vi lärt oss hur man skapar nya typer med hjälp av klasser. Nu finns det ett litet problem med denna implementering. Vi kan skapa ett punktobjekt utan en x- eller y-koordinat med hjälp av klasser och det är inte idealiskt. Låt mig visa dig.
Låt oss skapa en punkt och skriva ut den innan vi ställer in x-koordinaten. Att köra vårt program resulterar i ett attributfel som detta:
Det betyder att punktobjektet inte har något attribut som kallas x. Nu är problemet att det är möjligt att ha ett punktobjekt utan x- eller y-koordinater. Det här är inte vettigt eftersom när vi pratar om en punkt måste vi veta var den punkten finns. För att lösa detta problem använder vi en konstruktor. En konstruktor är en funktion som anropas när ett objekt skapas.
Så här använder vi en konstruktör. Låt oss först skicka x- och y-koordinatvärdena i programmet ovan.
point = Point(10, 20)
print(point.x)
Nu måste vi lägga till en speciell metod i den här klassen som kallas en konstruktor. Dess syntax är så här:
def __init__(self, x, y):
init
är en förkortning för initialized, och det här är funktionen eller metoden som anropas när ett nytt punktobjekt skapas. X och y läggs till direkt efter self
för att lägga till två extra parametrar.
Efter det bör vi mappa x och y till de godkända värdena, dvs. 10 och 20
self.x = x
self.y = y
Vi använder self
för att referera till det aktuella objektet och sedan sätter vi x-attributet till x-argumentet som skickas till funktionen "x". På detta sätt använder man init
metod kan vi initiera våra objekt. Denna metod kallas en konstruktör. Låt oss köra vårt program.
Nu kan vi ändra x- och y-koordinaterna senare. Låt oss uppdatera x-koordinaten:
point = Point(10, 20)
point.x = 11
print(point.x)
Nu uppdateras x-koordinaten till värdet 11.
Motionera
Här är en intressant övning för dig.
Jag vill att du definierar en ny typ som kallas en person. Dessa "Person"-objekt ska ha ett "name
"-attribut samt ett "talk()
”Metod.
Det är en enkel uppgift och bör inte ta mer än ett par minuter.
Lösning
Börja med att definiera klassen "Person" så här:
class Person:
self.name = name
Vi kommer att definiera konstruktören senare. Nu kan vi skapa "Person"-objektet. Låt oss kalla det John
john = Person("John Smith")
print(john.name)
john.talk()
Gå nu vidare till den första delen av koden och skapa en konstruktor.
def __init__(self, name):
Den slutliga koden kommer att se ut så här:
Du kan också använda formaterade strängar och andra koncept i kombination med klasser och konstruktorer.
Arv
Arv är ett annat koncept förknippat med klasser som låter dig återanvända en kod.
Tänk på den här koden.
class Dog:
def walk(self):
print("walk")
Vi har skapat en klass "Hund" med en "gå"-metod. Med den här metoden skriver vi helt enkelt ut promenadmeddelandet på terminalen. Låt oss säga att i ett riktigt program finns det 10 rader kod istället för bara en rad här. I framtiden, om en annan klass behövs för att ha "walk"-metoden, måste vi upprepa all den koden. Detta är inte idealiskt.
Inom programmering har vi en princip som heter DRY som är en förkortning för inte upprepa dig själv. Låt oss säga att vi någon gång i framtiden upptäcker ett problem med vår "walk"-metod och om vi har upprepat eller duplicerat den här metoden på många andra ställen, måste vi komma tillbaka och åtgärda problemet på varje enskilt ställe där vi har duplicerat detta. koda. Så det är därför vi i programmering inte ska definiera något två gånger.
Det finns olika tillvägagångssätt för att lösa detta problem men här ska vi lära oss det som är lättare för nybörjare och det kallas arv. I det här fallet kommer vi att skapa en annan klass "däggdjur" och definiera vårt "walk"-attribut i den klassen.
class Mammal:
def walk(self):
print("walk")
Efter att ha definierat vår "Däggdjur"-klass kan vi använda arv för att skicka attributen så här:
Både hund- och kattklasserna ärver alla klassmetoder som definierats i deras föräldraklass. Nu kan vi lägga till metoder som är specifika för hundar så här:
class Dog:
def bark(self):
print("bark")
Sammanfatta!
Det här handlade om klasserna, konstruktörerna och återanvändning av koden i klasser med arvskoncept. Nu närmar vi oss slutet på vår serie. Vid det här laget bör du kunna producera bra, läsbara och koncisa koder i Python.
Vi kommer att se konceptet med moduler och paket i nästa föreläsning.
Kommentera uppropet