Bazat e programimit të drejtuar nga ngjarjet

Çfarë është një ngjarje?

Deri tani programet e tua kanë ecur nga lart poshtë dhe pastaj janë ndalur. Bënë pikërisht atë që shkrove, në radhën që e shkrove, pa u ndalur kurrë të pyesin se çfarë doje më pas. Programet e vërteta nuk janë kështu. Një lojë Minesweeper nuk bën asgjë derisa ti të klikosh një kuti. Telefoni yt rri i qetë derisa të shtypësh një tast. Këto programe e kalojnë pjesën më të madhe të kohës duke pritur.

Një ngjarje është një veprim që vjen nga jashtë programit që po ekzekutohet, por që ndryshon atë që bën programi. Shtyp një tast, klikon miun, lëviz miun: secili prej tyre është një ngjarje. Programi nuk vendos se kur ndodhin. Ti vendos. Programimi i drejtuar nga ngjarjet është thjesht të shkruash kod që pret këto veprime dhe reagon ndaj tyre.

Ngjarje të zakonshme janë:

• shtypja e një tasti në tastierë (një tast shigjete, një tast shkronje)
• klikimi i miut
• lëvizja e miut
• shkurtoret si Ctrl+C për të kopjuar ose Ctrl+V për të ngjitur

Mendoje Turtle-in tënd si një robot të vogël në ekran. Deri tani ti i thoje çdo lëvizje që në fillim. Tani do ta lësh një person ta drejtojë atë drejtpërdrejt.

Të dëgjosh një shtypje tasti

Që të reagosh ndaj një tasti, të duhen tri gjëra: një ekran që mund t'i dëgjojë ngjarjet, një funksion që thotë çfarë të bëhet, dhe një rresht që lidh një tast me atë funksion. Në Turtle duket kështu.

screen = turtle.Screen()

def my_function():
    # shkruaj kodin këtu
    pass

screen.onkey(my_function, "Up")
screen.listen()

Lexoje rresht pas rreshti. screen = turtle.Screen() krijon ekranin që do t'i dëgjojë ngjarjet. Funksioni është ai që ekzekutohet kur ndodh ngjarja. screen.onkey(my_function, "Up") thotë: kur të shtypet tasti "Up", thirr my_function. Emri i tastit mund të jetë "Up", "Down", "Left" ose "Right". Në fund, screen.listen() i thotë ekranit të fillojë t'u kushtojë vëmendje. Pa atë rresht të fundit, nuk ndodh asgjë.

Një gjë i zë të gjithëve herën e parë. Ti i jep my_function, jo my_function(). Me kllapa, Python-i do ta ekzekutonte funksionin tani menjëherë dhe do t'i jepte ekranit rezultatin e tij. Pa kllapa, ti i jep ekranit vetë funksionin, që ai ta thërrasë më vonë, sa herë që shtypet tasti.

Ja një Etch-A-Sketch i vogël. Katër tastet e shigjetave e drejtojnë breshkën nëpër ekran dhe ajo lë një vijë pas vetes.

import turtle

screen = turtle.Screen()
pen = turtle.Turtle()

def go_up():
    pen.setheading(90)
    pen.forward(20)

def go_down():
    pen.setheading(270)
    pen.forward(20)

def go_left():
    pen.setheading(180)
    pen.forward(20)

def go_right():
    pen.setheading(0)
    pen.forward(20)

screen.onkey(go_up, "Up")
screen.onkey(go_down, "Down")
screen.onkey(go_left, "Left")
screen.onkey(go_right, "Right")
screen.listen()

turtle.done()

Vër re se nuk ka asnjë cikël që i thotë breshkës të lëvizë. Ajo lëviz vetëm kur ti shtyp një tast, njëzet piksela çdo herë. Programi nuk bën asgjë ndërkohë, thjesht pret ngjarjen tjetër.

Të dëgjosh një klikim miu

Një klikim miu punon pothuajse njësoj, me një ndryshim: një klikim ndodh në një vend, ndaj funksioni e merr atë vend. Funksioni duhet të marrë dy argumente, x dhe y, në atë radhë. Ato janë koordinatat e miut në çastin kur klikove.

screen = turtle.Screen()

def my_function(x, y):
    # shkruaj kodin këtu
    pass

screen.onclick(my_function)

Ky program i vogël e çon lapsin aty ku klikon dhe lë një shenjë atje.

import turtle

screen = turtle.Screen()
pen = turtle.Turtle()
pen.penup()

def go_to_click(x, y):
    pen.goto(x, y)
    pen.stamp()

screen.onclick(go_to_click)

turtle.done()

Meqë funksionit i jepen x dhe y, ai e di gjithmonë saktësisht ku ra klikimi, kështu që mund ta çojë breshkën drejt e atje.

Makinat me gjendje

Sapo një program fillon të reagojë ndaj ngjarjeve, del një pyetje e dobishme: çfarë duhet të bëjë e njëjta ngjarje në çaste të ndryshme? Shtypja e të njëjtit buton në telefon bën një gjë kur ekrani është i kyçur dhe një gjë tjetër kur është i çkyçur. Butoni nuk ndryshoi. Gjendja e telefonit ndryshoi.

Një makinë me gjendje është një sistem që gjendet gjithmonë në një prej pak gjendjeve, dhe ngjarjet e çojnë nga një gjendje te tjetra. Një telefon nis në një gjendje që mund ta quajmë "Në pritje të PIN-it". Fut PIN-in e saktë dhe kalon te "Gati". Kyçe dhe kalon te "I kyçur". Çdo shigjetë është një ngjarje.

Një semafor është shembulli më i thjeshtë. Ai kalon nëpër tri gjendje, që mund t'i numërojmë 0, 1 dhe 2, dhe çdo "tik" e çon te gjendja tjetër, duke u kthyer prapa te 0 pas 2-shit.

state = 0  # 0 = jeshile, 1 = e verdhë, 2 = e kuqe

def next_light():
    global state
    state = (state + 1) % 3
    print("Gjendja tani është", state)

% 3 e mban numrin brenda intervalit 0, 1, 2 përgjithmonë, kështu që pas së kuqes kthehet te jeshilja. Lidh next_light me një shtypje tasti dhe ke një semafor që mund ta ecësh vetë hap pas hapi. Kjo çift, një ngjarje nga jashtë dhe një copë e vogël gjendjeje e mbajtur mend nga brenda, është zemra e pothuajse çdo aplikacioni dhe loje që përdor.

Provo veten

1. Me fjalët e tua, çfarë e bën një program "të drejtuar nga ngjarjet", dhe si dallon kjo nga një program që ecën nga lart poshtë dhe ndalet?
2. Te screen.onkey(go_up, "Up"), pse shkruajmë go_up dhe jo go_up()? Çfarë do të shkonte keq me kllapat?
3. Një funksion për klikimin e miut shkruhet def my_function(x, y):, kurse një funksion për tastin është thjesht def my_function():. Pse funksioni i klikimit ka nevojë për dy argumente dhe ai i tastit për asnjë?