Estructures condicionals

Com no pot ser de cap altra manera, s’aplicarà la metodologia apresa per a resoldre el primer programa condicional.

El primer programa que fareu aplicant estructures condicionals serà un programa “porter de discoteca”. L’única dada d’entrada d’aquest programa serà l’edat, i el programa contestarà “Benvingut” o “ets menor d’edat”, segons el cas.

Són molt simples. Heu d’utilitzar l’intèrpret interactiu i fer operacions del tipus:

>>> 12 >= 18
False
>>> 18 >= 18
True

Aquests serien els casos per edat igual a 12, i per edat igual a 18. La resposta és l’esperada: si es té 12 anys és fals que es pugui entrar, i si se’n té 18, ja és cert que es pugui entrar.

El més habitual quan es parla d’edats és pensar en nombres enters. Es podria arribar a parlar de 15 anys i mig, però en el llenguatge parlat segur que mai es diu que algú té 20.25 anys quan la persona en qüestió té 20 anys i 3 mesos. Es podria debatre si acceptar o no l’edat de 0 anys, però és més raonable començar amb l’edat de 0 anys que amb 1 any.

De manera que les especificacions d’entrada seran: 1 nombre enter (edat) major o igual a 0.

El joc de proves el teniu recollit a la taula:

És suficient el joc de proves? Quan heu fet els exemples a mà, heu observat que hi ha dos casos: ser benvingut o no. En el joc de proves heu inclòs un exemple de cada possibilitat, el cas límit en què canvia (el 18), i el cas límit en què comença (el zero). Es pot assegurar que s’han contemplat tots els casos possibles.

El refinament d’aquest programa també és senzill. Els refinaments successius no calen. Ja podeu crear un nou fitxer amb l’editor de text i copiar i omplir la capçalera amb les dades necessàries (entre elles la descripció del programa i les especificacions d’entrada).

El fitxer, en aquests moments, hauria d’estar així:

# Administració de Sistemes informàtics
# IOC
# 
# Autor: Antonia
# Data: 23-08-2058
#
# Versió: 23.2
#
# Descripció: Determinació si és major d'edat
# Especificacions d'entrada: 1 nombre enter major o igual a 0

# llegir l'edat
edat = int(input())

# si és major d'edat
	# instruccions True

#si no
	# instruccions False

Així quedarà el programa una vegada codificat:

# Administració de Sistemes informàtics
# IOC
# 
# Autor: Antonia
# Data: 23-08-2058
#
# Versió: 23.2
#
# Descripció: Determinació si és major d'edat
# Especificacions d'entrada: 1 nombre enter major o igual a 0

# llegir l'edat
edat = int(input())

# si és major d'edat
if edat >= 18:
	# instruccions True
	print('Benvingut')

#si no
else:
	# instruccions False
	print( 'Ets menor d\'edat')

La figura mostra el codi com es mostra a l’editor, amb els números de línia i amb les paraules reservades mostrades amb un color que les identifica.

Aquestes són les novetats del programa:

• En la línia 25 apareix una expressió booleana, que és el mateix que una condició.
• En la mateixa línia 25 apareix la paraula reservada if. Introdueix una condició i una bifurcació en el camí. És a dir, si la condició és certa (si el resultat de l’expressió booleana que representa la condició és True) es faran unes instruccions, i en cas contrari (else), se’n faran unes altres.
• La mateixa línia on hi ha el if i la condició ha de finalitzar amb el caràcter :.
• Les línies 26 i 27 només s’executaran en cas que la resposta de la condició de la línia 25 sigui True.
• En la línia 30 apareix una altra paraula reservada: else. Significa “sinó”, i sempre ha d’anar precedida per alguna instrucció anterior amb el if i una condició. En el else no s’avalua cap condició (s’ha avaluat en la línia del if), i també ha de finalitzar amb el caràcter :.
• Les línies 31 i 32 només s’executaran si el resultat de l’expressió booleana ha estat False.

El Python és un llenguatge que s’estructura mitjançant la indentació. Això vol dir que les instruccions que s’han d’executar amb l’ if són les que estan escrites en les línies posteriors, més endins. S’han d’escriure després d’un tabulador.

Després de la condició i després de l’ else hi ha el símbol :.Defineix que el codi posterior s’ha d’indentar. Per a Python, un tabulador o un espai en blanc són el mateix. La recomanació és fer servir sempre el tabulador. Ara, cal escriure el programa i aconseguir executar-lo.

S’ha de verificar el joc de proves per assegurar que el programa funciona:

videoioc@debian-xtec:~/Documents/progamacio$ python3 porter_discoteca.py 
16
Ets menor d'edat
videoioc@debian-xtec:~/Documents/progamacio$ python3 porter_discoteca.py 
18
Benvingut
videoioc@debian-xtec:~/Documents/progamacio$ python3 porter_discoteca.py 
87
Benvingut
videoioc@debian-xtec:~/Documents/progamacio$ python3 porter_discoteca.py 
0
Ets menor d'edat

Ja podeu assegurar que, si el joc de proves és correcte, el programa funciona adequadament.

Si el programa no s’executa o el joc de proves no s’acompleix, cal trobar l’error i resoldre’l. Això ho fareu amb l’ajuda dels refinaments i afegint impressions per pantalla, print entre el codi fins a localitzar la instrucció que no té el resultat que s’esperava. En aquest cas no ha calgut.

Hi ha dues estructures condicionals en què es pot presentar un condicional simple: el cas de l’ if / else (que acabeu de veure), i l’ if (sense else). Es presentarà un exemple per a cada cas i se’n farà un seguiment. Cal que editeu el fitxer d’exemple, l’executeu, comproveu que el joc de proves que es proporciona és correcte i en feu el seguiment en els casos proposats.

L’objectiu dels pròxims programes és determinar si un nombre és positiu, zero o negatiu, però amb variacions.Cada fragment correspon a un joc de proves (que s’ha escrit abans de fer el programa) que coincideix amb el resultat de l’execució. En aquest cas heu de fer a la inversa i escriure el joc de proves que s’adiu amb el programa mostrat.

Cal tenir en compte que cap programa està bé o malament, simplement són programes que responen a interessos diferents. El que determina que estigui bé o no és que el joc de proves coincideix amb les execucions.

L’estructura if / else correspon al si / sinó. És a dir, que si la condició és True s’executen unes instruccions i en cas que sigui False unes altres.

if condicio:
    #Instruccions True
else:
    #Instruccions False
#S'uneixen els dos camins

Partireu del següent codi exemple que implementa un if / else:

a = int(input())

if a >= 0:
	print(“positiu o zero”)
else:
	print(“negatiu”)
print(“Fi execució”)

Per a fer el joc de proves, cal que trobeu un exemple de cada camí i especificar què passa en el cas límit. Necessitareu un cas amb un nombre positiu, un altre amb un nombre negatiu i per últim, el cas del zero.

Especificacions d’entrada: 1 nombre enter qualsevol.

Joc de proves: detallat a taula

Què fa el processador en el moment que apareix una instrucció amb un condicional? En el seguiment per al codi que estem estudiant, veureu com actua. Hi ha un seguiment per a cada entrada del joc de proves.

La figura mostra el codi com del programa if/else amb els números de línia.

A la taula teniu el seguiment del programa quan l’entrada és el valor 5.

Us heu de fixar en el següent:

• En la línia 13 entra el valor 5, com a enter, i s’assigna a la variable a.
• La línia 14 està en blanc i no fa res. Podríeu escriure el número de la línia i deixar les accions en blanc, però millor no posar-la, ja que és transparent per al processador.
• En la línia 15 s’avalua el resultat d’una condició. En la taula del refinament heu d’afegir una columna per mostrar-lo. Encara que al llarg del programa hi hagi diverses condicions, es posen tots els resultats en una única columna per simplificar.
• Com que la condició és True, “entrem” l’ if i s’executen les instruccions indentades a “sota”. Per això s’escriu el que passa en la línia 16.
• No s’executen (i, per tant, NO estan en el seguiment) ni la línia del else ni les instruccions que s’han de fer si entra a l’ else, és a dir, si la condició és False.
• Una vegada s’han acabat les instruccions del condicional, les dues branques s’ajunten i es fa el mateix en tots els casos. Això se sap perquè en la línia 19 torna a haver-hi una instrucció que no està indentada.

Podeu comprovar que la sortida del seguiment és la mateixa que es produeix si executeu el programa i entreu el nombre 5.

A continuació fareu el seguiment per al cas en que el valor d’entrada és 0. Ho teniu recollit a la taula.

La taula de seguiment per al nombre 0 és exactament igual que per al nombre 5. Com que el resultat de la condició és el mateix (True), el camí recorregut també.

En el cas de que el valor d’entrada sigui -3, el seguiment que tindríeu és el que us mostra la taula.

Aquest seguiment ja és substancialment diferent:

• El resultat de l’expressió booleana de la línia 15 és False.
• Això provoca que se salti la línia 16 i totes les posteriors fins a trobar el else.
• El processador entra a l’ else, i per això és necessari escriure la línia 17 en el seguiment, tot i que no es modifiqui cap variable.
• S’executen les instruccions de l’ else (línia 18).
• Finalment, s’ajunten les dues branques i se segueix l’execució en comú.

Un if no sempre ha d’anar acompanyat d’un else. En aquest cas, si la condició és certa, s’efectuen unes instruccions que no es fan quan és falsa.

if condicio:
    #Instruccions True
#S'uneixen els dos camins

El següent codi és un exemple d’ if (sense else).

a = int(input())

if a >= 0:
	print(“positiu”)

print(“Fi execució”)

Especificacions d’entrada: 1 nombre enter qualsevol

Un joc de proves corresponent a aquest programa és que podeu trobar a la taula.

Per fer els seguiments necessitem el codi amb el número de línia, ho teniu a la figura.

Si a l’entrada (l’input de la línia 13), introduïm el valor 5, la taula de seguiment és la taula.

Fent el seguiment pas a pas, podeu interpretar què farà el processador:

• En la línia 13 entra el valor 5.
• La condició de la línia 15 és certa, per tan s’han d’executar les instruccions del True.
• En la línia 16 es mostra una cadena per pantalla.
• El flux del programa torna al camí comú i s’executa la línia 18.

La taula de seguiment per un valor d’entrada 0 seria gairebé la mateixa (exceptuant el valor de la a en la línia 13 que valdria 0). Vegeu la taula.

Si a l’entrada (l’input de la línia 13), introduïm el valor -3, la taula de seguiment és la que detalla la taula.

Si analitzeu pas per pas el que fa el processador, trobareu els següents casos:

• En la línia 13 es llegeix el valor 0, que s’assigna a la a.
• En la línia 15 s’avalua la condició. Com que és falsa, no hem d’entrar a les instruccions indentades (i no han d’aparèixer els números de les línies en la taula de seguiment).
• En la línia 18 s’ajunten les dues branques i se segueix amb les instruccions comunes.

Fixeu-vos que en aquest cas no s’ha executat cap instrucció que no s’hagi fet en el camí del True. Simplement, si la condició és certa s’executen unes instruccions extra.

El primer programa que fareu amb una estructura condicional niada té el següent enunciat:

“Feu un programa que llegeixi un enter i digui si és positiu, si és el nombre zero o si és negatiu. En tots els casos, abans de finalitzar sortirà la frase: Fi execució.”

Les especificacions d’entrada i el joc de proves seran els següents:

Especificacions d’entrada: un nombre enter qualsevol. Joc de proves: vegeu la taula

Podeu pensar que d’entrada, s’ha de seguir la mateixa estructura que el primer programa if/else. En el moment en què hem aïllat el cas que el nombre és positiu o zero, cal que feu una segona pregunta. En aquest exemple és difícil escriure el refinament, ja que és quasi el mateix que el mateix codi. Compareu-lo amb aquest altre (el primer exemple if/else):

La figura mostra el codi del programa if/else.

El codi que ho implementa és:

a = int(input())
if a > 0 :
	print(“positiu o zero”)
else:
	print(“negatiu”)
print(“Fi execució”)

Si en la línia 16, en comptes de mostrar directament una frase, torneu a fer una pregunta, obtindreu una nova bifurcació segons si és cert (el nombre serà positiu), o fals (en aquest cas serà 0, ja que en aquesta branca només s’hi ha entrat si s’era major o igual a zero). El programa ja codificat tindrà l’aspecte que podeu veure a la figura.

El codi que ho implementa és:

a = int(input())
if a >= 0 :
  if a == 0 :
    print(“zero”)
  else:
	  print(“positiu”)
else:
	print(“negatiu”)
print(“Fi execució”)

La diferència és que en el cas que la condició sigui True, la instrucció que segueix en el primer programa és un nou condicional. Aquest és un exemple de condicionals niats.

A continuació seguirem l’exemple d’ if niat bàsic

a = int(input())
if a >= 0:
	if a == 0:
		print(“zero”)
	else:
		print(“positiu”)
else:
	print(“negatiu”)
print(“Fi execució”)

La figura mostra el codi del programa if niat.

Aquest és el seguiment del programa dels if niats en cada cas del joc de proves.

La taula recull el seguiment quan el valor d’entrada és 5.

Fixeu-vos què fa les següents línies:

• En la 14 llegeix el valor 5.
• En la 16 avalua la condició. El resultat és True i entra a la 17.
• En la línia 17 ha d’avaluar una nova condició. En aquest cas, el valor 5 dona el resultat False. El flux ha d’anar a buscar la partícula else, i per això salta fins a la línia 19 (va al else que està indentat amb el if de la línia 17).
• Executa la instrucció de la línia 20 (les corresponents a l’ else).
• Quan surt, a la línia 21, troba l’ else corresponent a l’ if de la línia 16. Com que la condició havia donat True, s’ha de saltar les línies fins a trobar el camí comú, en la línia 24.

Ara veureu quin seria el seguiment amb el valor d’entrada 0. Ho teniu recollit a la taula taula.

Si feu el seguiment del programa, trobareu que el processador farà el següent:

• En la línia 14 es llegeix el valor de la a.
• La condició de la línia 16 (la del primer if) és certa, de manera que segueix cap avall.
• A la línia 17 troba una nova condició, que torna a ser certa: ha de seguir “baixant”.
• Entra a la línia 18 i executa la instrucció.
• S’ha de saltar el else de la línia 17, corresponent al if de la línia 17 (el que es troba en la mateixa indentació), ja que la resposta era True.
• S’ha de saltar també l’ else de la línia 21 (corresponent al if de la línia 16).
• Torna a la branca comuna a partir de la línia 24. La instrucció està indentada a la primera columna, el que significa que s’executarà sempre.

Finalment, quen el valor d’entrada és -3, tindreu el seguiment recollit a la taula.

Si analitzeu pas a pas què fa el processador en executar el programa, trobareu el següent:

• En la línia 14 s’assigna a la variable a.
• El resultat d’avaluar la condició a la línia 16 és False.
• Ha de saltar les instruccions del True i anar a buscar el else.
• Passa per la línia 21 perquè “torna a entrar” en el else. Per aquest motiu s’ha d’escriure la línia 21
• En la línia 22 executa les instruccions del else.
• Torna a la trajectòria comuna en la línia 24.

En l’exemple anterior sembla més lògic enfocar el problema pensant en el fet que cal escollir una alternativa entre tres possibles (positiu, zero o negatiu). En comptes d’optar primer entre dues opcions, i després distingir entre si és positiu o zero. La partícula elif us ajudarà a guanyar en llegibilitat en aquests casos.

Quan heu de fer diverses comparacions que són de la mateixa importància, el programa queda més clar i més llegible utilitzant l’estructura elif que diferents if niats. El resultat final és el mateix.

if condicio1:
    #Instruccions 1
elif condicio2:
    #Instruccions 2
# es poden afegir la quantitat d'instruccions elif que es necessitin
# es pot afegir o no la clàusula else:

#S'uneixen els camins

Amb exemples concrets s’entén millor.

El següent codi implementa l’estructura que estudiarem:

a = int(input())
if a > 0 :
	print(“positiu”)
elif a == 0:
	print(“zero”)
else:
	print(“negatiu”)
print(“Final execució”)

El joc de proves és exactament el mateix que en el programa anterior, vegeu lataula.

La figura mostra el codi del programa que implementa l’estructura if/elif/else.

Vegem ara com es fan els seguiments en aquest cas. El seguiment del programa quan l’entrada és el valor 5, ho teniu recollit a la taula.

El recorregut que fa el processador (el que anomenem flux del programa) és el següent:

• En la línia 13 es llegeix el valor 5, que s’assigna a la a.
• En la línia 15 s’avalua la condició del if. En aquest cas és True, de manera que s’entra i s’executen les instruccions posteriors.
• S’executa la línia 16.
• Quan ha acabat, salta totes les altres instruccions relatives al condicional i retorna al “camí comú”.
• La primera instrucció després del condicional és la línia 22. S’executa i s’acaba el programa.

Quan el valor d’entrada és 0, el seguiment del programa serà el següent, vegeu la taula.

Si analitzeu pas a pas que fa el processador quan executa el programa i el valor d’entrada és 0, trobareu el següent:

• Entra a la línia 13.
• La primera condició, corresponent al if de la línia 15, és False.
• Se salta les instruccions del True i va a buscar la següent condició del elif, a la línia 17. En aquest cas el resultat és True i entra a les instruccions de sota.
• Executa la instrucció de la línia 18.
• Se salta els següents casos del condicional (tant l’else com si hi hagués més condicions amb elif).
• Torna a la branca comuna a partir de la línia 22.

Finalment, si el valor entrat és -3, el seguiment del programa seria el que podeu observar a la taula.

En aquest cas, el programa farà el següent:

• En la línia 13 s’assigna el -3 a la variable a.
• El resultat de l’avaluació de la condició del if en la línia 15 és False. Ha de saltar a la següent branca del elif.
• En la línia 17, avalua la condició del elif, amb resultat False. Ha de saltar a la següent branca.
• En la línia 19 troba el else, que indica que ha d’entrar.
• Executa la instrucció de la línia 20
• En la línia 22 torna al camí comú.

A continuació estudiarem un exemple de if/elif (sense else):

a = int(input())
if a >= 0:
	print(“positiu”)
elif a == 0:
	print(“zero”)
print(“Final execució”)

Especificacions d’entrada: 1 nombre enter qualsevol. La taula de seguiment la teniu recollida a la taula.

En aquest cas, farem el seguiment només per al valor -3. Els altres són similars a l’exemple anterior. La figura mostra el codi del programa que implementa l’estructura if/elif.

El seguiment per al -3, ho teniu recollit a lataula.

Així doncs, el programa farà el següent:

• En la línia 15 s’assigna el -3 a la variable a.
• El resultat de l’avaluació de la condició del if en la línia 17 és False. Ha de saltar a la següent branca del elif.
• En la línia 19, avalua la condició del elif, amb resultat False. Ha de buscar la següent branca.
• S’acaba el condicional i no ha entrat en cap branca, de manera que no ha executat cap instrucció. En la línia 22 torna al camí comú.

Per acabar, cal estudiar un últim cas. Es pot donar la situació en què s’utilitzin diversos condicionals sense que estiguin niuats, sinó un darrere l’altre.

S’han d’utilitzar estructures condicionals independents quan les condicions no estan lligades entre si. És a dir, quan el fet que se n’acompleixi una no implica que no es puguin acomplir les altres.

Suposem que hem de fer un fragment de programa en el qual entrin dos nombres enters qualsevol, a i b. El programa haurà d’agafar el valor absolut dels dos nombres d’entrada i, en el cas que cap dels dos sigui zero, mostrar els valors. Si alguna de les entrades és zero, el programa dirà “Hi ha zeros”. Aquest programa podria servir, per exemple, per comprovar nombres abans de fer una divisió. A la taula teniu recollit el seguiment del programa.

Que la primera dada sigui positiva o no, no té res a veure amb el fet que ho sigui la segona. D’aquí es dedueix que hauran de ser dues condicions independents. El codi del programa podria ser aquest:

a = int(input())
b = int(input())

if a < 0:
	a = -a
if b < 0:
	b = -b
if a == 0 or b == 0:
	print('Hi ha zeros')
else:
	print(a, b)

L’estructura consta de 3 condicionals simples i independents. Els dos primers són if i el tercer és un if/else. Són els tres independents i no es pot crear cap estructura niuada.

Una estructura condicional és simple quan té una única condició. Es parla d’estructures condicionals niades quan en una branca d’un condicional apareix una nova condició (que porta a una nova bifurcació del flux).

Podem utilitzar, segons les nostres necessitats, les següents estructures:

• Sentència if

if condicio:
  instrucions si la condició és True

• Sentència if/else

if condicio:
  instrucions si la condició és True
else:
  instruccions si la condició és False

La partícula else mai va acompanyada d’una condició.

• Sentència elif

if condicio1:
  instrucions si la condició1 és True
elif condicio2:
  instruccions si la condició2 és True

#Podem utilitzar els elif que considerem necessaris

else:	#Pot no ser-hi
  instruccions si totes les condicions anteriors son false

Una sentència elif sempre té un if que avalua la primera condició. Les següents condicions van precedides de la partícula elif. En últim lloc, pot existir o no la partícula else (segons si volem recollir els casos restants o no). La partícula else mai va acompanyada d’una condició.

• Altres estructures condicionals niades. No sempre que hi hagi una estructura condicional niada es pot resumir utilitzant l’estructura elif. Hi haurà programes en què aniran apareixent branques sense cap elif.
• Condicionals independents.En realitat no és una estructura diferent, sinó que és la unió de diverses de les estructures anteriors.S’ha de vigilar perquè de vegades es confon una estructura condicional niada amb dos o més estructures condicionals independents. El resultat no és el mateix.