D'en Karel al Python

Glossari

Aquest és el vocabulari complet d'en Karel.

Accions: el que en Karel fa

move()           # avança una casella en la direcció que mira
turn_left()      # gira 90° a l'esquerra (no es mou)
turn_right()     # gira 90° a la dreta (no es mou)
turn_around()    # fa mitja volta (180°), no es mou
grab()           # recull la perla de la casella actual
drop()           # deixa una perla a la casella actual

Condicions: el que en Karel pot preguntar

front_is_clear()      # el davant és lliure?
front_is_blocked()    # el davant té obstacle?
left_is_clear()       # l'esquerra és lliure?
right_is_clear()      # la dreta és lliure?
pearl_here()          # hi ha una perla en aquesta casella?
bag_is_empty()        # la motxilla és buida?

Estructures: la forma del programa

for i in range(5):       # repetir un nombre exacte de vegades
    move()

while front_is_clear():  # repetir mentre es compleixi una condició
    move()

if pearl_here():         # decidir entre dues opcions
    grab()
else:
    move()

if right_is_clear():     # decidir entre tres o més opcions
    turn_right()
elif front_is_clear():
    move()
else:
    turn_left()

def anar_al_final():     # crear una instrucció pròpia
    while front_is_clear():
        move()

Operadors lògics: combinar condicions

if front_is_clear() and not pearl_here():
    move()

if pearl_here() or bag_is_empty():
    grab()

Pensar abans d'escriure: precondició i postcondició

Quan decideixes crear una funció pròpia fent servir def, li estàs ensenyant a en Karel una paraula nova. Aquí entren dues idees que les persones que programen en l'àmbit professional sempre tenen al cap:

• Precondició. Quina és la situació just abans que comenci la meva funció. On és en Karel? Cap a on mira? Què hi ha al voltant?
• Postcondició. Quina situació deixo després que la funció s'hagi executat. On haurà acabat, en Karel? Cap a on estarà mirant? Ha canviat alguna condició del món, com per exemple el nombre de perles que hi ha?

Mira aquest exemple. Volem una funció girar_cantonada_dreta() perquè en Karel giri a la dreta i avanci una casella:

def girar_cantonada_dreta():
    # Precondició:  en Karel té la dreta lliure
    # Postcondició: en Karel ha girat 90° a la dreta i ha avançat 1 casella
    turn_right()
    move()

Si crides aquesta funció amb una paret a la dreta, en Karel s'estavellarà. La culpa no és de la funció: és de qui l'ha cridat sense respectar la precondició. Per això abans d'usar-la sempre comprovaràs if right_is_clear():.

Aquest hàbit — escriure mentalment (o en un comentari) què espero i què deixo — és una de les diferències més grans que trobem quan es programa en l'àmbit professional. T'estalviarà hores de cercar errors i és, de debò, una de les bones pràctiques que més et farà créixer com a programadora o programador.

Tot el que has escrit és Python

Potser no t'ho esperaves: el codi que has escrit durant tot el curs és Python real.

for, while, if, elif, else, def, and, or, not… tot això és Python. No una versió simplificada. No un llenguatge de joguina. Python de debò.

La diferència és que en Karel, les úniques «accions» eren move(), grab(), turn_left()… En Python real, les accions són molt més variades: pots escriure text a la pantalla, llegir fitxers, fer càlculs matemàtics, crear pàgines web, entrenar intel·ligències artificials. Però l'estructura del codi — iteracions, condicions, funcions — és exactament la que ja coneixes.

Compara: en Karel vs. Python

Fixa't com l'estructura és idèntica. Només canvien les accions de dins:

# Karel                           # Python
for i in range(5):                for i in range(5):
    move()                            print("Hola!")

if pearl_here():                  if edat >= 18:
    grab()                            print("Major d'edat")
else:                             else:
    move()                            print("Menor d'edat")

def puja_grao():                  def saluda(nom):
    turn_left()                       print("Hola, " + nom)
    move()
    turn_right()
    move()

La columna de l'esquerra la coneixes bé. La de la dreta és Python per a un ordinador real. Fixa't: l'estructura és idèntica.

Què hi ha de nou a Python?

Python afegeix coses que en Karel no necessitava:

Variables — en Karel, la motxilla era l'única manera de «recordar» un número. En Python, pots guardar qualsevol valor amb un nom:

punts = 0
punts = punts + 10

Entrada i sortida — en Karel, el resultat del programa era la posició final d'en Karel al món. En Python, pots demanar informació a l'usuari i mostrar-li resultats:

nom = input("Com et dius? ")
print("Hola, " + nom + "!")

Tipus de dades — en Karel, tot eren caselles i perles. En Python hi ha números (42, 3.14), text ("Hola"), llistes ([1, 2, 3]), i molt més.

Però la manera de pensar — descompondre el problema, crear funcions amb noms clars, usar iteracions i condicions — és la mateixa. Això és el que has après amb en Karel: no un llenguatge, sinó una manera de pensar.

Les idees que no canvien mai

Sigui quin sigui el llenguatge de programació que aprenguis en el futur (JavaScript, C, Java, Rust, Go…), hi trobaràs les mateixes cinc idees:

1. Seqüència: les instruccions s'executen en ordre, de dalt a baix.
2. Repetició: for i while existeixen a tots els llenguatges.
3. Decisió: if/else existeix a tots els llenguatges.
4. Abstracció: les funcions (def) permeten donar noms a blocs de codi reutilitzables.
5. Descomposició: partir un problema en parts amb noms clars és la tècnica fonamental de l'enginyeria del software.

Aquestes cinc idees les has practicat amb en Karel. Ara les portaràs amb tu.

Per on continuo?

Ara ves als Reptes. Combina tot el que saps per resoldre els problemes que se't plantegen. Un últim consell: abans de teclejar línies de codi, agafa paper i llapis, i pensa bé la teva estratègia!