Estructura repetitiva while

Per a introduir la primera estructura iterativa s’utilitzarà un programa senzill, el programa de l’algorisme del màxim. D’entrada, estudiareu una versió per a trobar el màxim de tres nombres enters positius, i s’aniran fent passos fins que quedi clara la nova estructura.

El punt de partida és el programa de l’algorisme del màxim, en concret per a tres nombres. Recordeu com funciona.

1. S’inicialitza una variable anomenada màxim amb el valor zero, perquè sabem que els nombres introduïts seran positius.
2. Per al primer nombre, es fan les següents instruccions:
   1. Es llegeix.
   2. Si és major que el màxim, el màxim pren el nou valor.
3. Per al segon nombre, es fan les següents instruccions:
   1. Es llegeix.
   2. Si és major que el màxim, el màxim pren el nou valor.
4. Per al tercer nombre, es fan les següents instruccions:
   1. Es llegeix.
   2. Si és major que el màxim, el màxim pren el nou valor.
5. Es mostra el valor del màxim.

El codi és el següent:

maxim = 0	# Com que els nombres son positius, podem inicialitzar a 0

# per al primer nombre
b = int(input())
if b > maxim:
	maxim = b
	
# per al segon nombre	
b = int(input())
if b > maxim:
	maxim = b

# per al tercer nombre	
b = int(input())
if b > maxim:
	maxim = b

#mostrem el màxim	
print(maxim)

Ara cal ampliar el mateix programa per calcular el màxim de 5 nombres llegits. Observeu i reflexioneu sobre què cal afegir o sobre què es repeteix per cada nou nombre.

Per cada nou nombre que entri en el programa, caldrà que afegiu el següent fragment de codi abans de mostrar el valor del màxim:

# per a cada nombre	
b = int(input())
if b > maxim:
	maxim = b

Podeu veure que és un codi que repeteix un fragment del programa anterior. El fragment que es repeteix per a cada valor entrat.

L’objectiu d’aquest pas és reescriure el programa utilitzant l’estructura repetitiva while.

while condició:
  instruccions del cos del bucle

De la mateixa manera que amb la clàusula if de les estructures condicionals, el while depèn d’una condició. Mentre la condició sigui certa s’aniran repetint les mateixes instruccions, avaluant de nou la condició a cada volta. En el moment que la condició sigui falsa, se sortirà del bucle i es continuarà amb les noves instruccions del programa.

Per escriure un bucle while és necessari determinar quatre coses i el consell és que ho feu seguint aquest ordre:

1. El cos del bucle.
2. La condició de la repetició.
3. El valor inicial de la variable de la qual depèn la condició (que s’ha de definir fora del bucle).
4. Com es modifica aquesta variable dins el bucle.

Si s’aplica a l’exemple del màxim:

1. El cos del bucle: seran les instruccions que es repeteixen per cada nombre.
2. La condició de repetició: l’establiu tenint en compte que voleu calcular el màxim per a tres nombres. Cal determinar una condició que compti les vegades. Si utilitzeu un comptador, sembla clar que la condició haurà de ser alguna cosa semblant a “mentre el comptador sigui menor o igual que tres”.
3. El valor inicial de la variable comptador: quan heu pensat en la condició ja s’ha determinat que es farà servir una variable que serà un comptador. Aquesta variable l’haureu d’iniciar a zero o a un.
4. Com es modifica la variable: si voleu que el comptador compti les voltes que es fan al bucle, en el cos del bucle hi haureu de posar una instrucció per afegir una unitat a cada volta.

La variable comptador es podria inicialitzar a 0 o a 1. Això implicaria que la condició de sortida variaria una mica:

• Si es comença amb l’1, es pot posar comptador ⇐ 3.
• Si es comença amb el 0, es pot posar comptador < 3

Tot i que us sembli més senzilla la primera opció, es recomana fer-ho com en l’exemple, inicialitzat el comptador a 0.

Tenint en compte els aspectes que heu decidit, ja podeu construir el programa. A continuació teniu el codi:

# Algoritme del màxim amb bucle while (per a nombres naturals)

NOMBRES = 3	#Quantitat de nombres que entrem per buscar el màxim

maxim = 0    # Com que els nombres son positius, podem inicialitzar a 0

#inicialitzem el comptador de vegades
comptador = 0

# Instrucció while:
# while condició :   	 (i no 'sortim' fins que la condició és False)
while comptador < NOMBRES:
    
    #cos del bucle. Es repeteix vàries vegades
    b = int(input())
    if b > maxim:
   	 maxim = b
   	 
    #incrementem la quantitat de vegades que hem fet el cos del bucle
    comptador = comptador + 1

# Fora del bucle. Només es fa UNA vegada
print(maxim)

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.

Fixeu-vos en les línies següents:

• Línia 4: es defineix una constant per a fer el programa més reutilitzable. Modificant aquesta quantitat el programa servirà per buscar el màxim de la quantitat de nombres que vulgueu. Si poseu 7, per exemple, servirà per trobar el màxim de 7 nombres.
• Línia 6: s’inicialitza el màxim a zero, ja que els nombres llegits seran positius o zero.
• Línia 9: s’inicialitza la variable comptador.
• Línia 13: entrada al bucle while amb la condició. Sempre ha d’acabar amb :.
• Línies 15 a 21: cos del bucle (per això estan indentades). Té dues parts: la primera és el que heu identificat que s’ha de repetir per cada nombre (en el nostre cas, la lectura i la comparació).
• Línia 21: segona part del cos, on es modifica la variable de la qual depèn la condició.
• Línia 24: instrucció de fora del bucle. Aquesta instrucció només s’executarà una vegada, i serà després que l’avaluació de la condició hagi donat False.

Un cop teniu el codi, el primer que cal fer és el seguiment del programa. Feu-lo introduint els nombres 2, 0 i 7. Quantes vegades s’executa el cos del bucle? Quantes vegades s’avalua la condició? El joc de proves el teniu recollit a la taula: .

Si compteu les vegades que s’executen les instruccions del bucle (la línia 16, per exemple), veureu que s’executen 3 vegades. En canvi, la condició de la línia 13 s’avalua un total de 4 vegades. Això és així perquè del bucle while sempre se surt per la línia del while, en el moment en què la condició és falsa.

En aquest apartat veureu un parell d’exemples de programes senzills utilitzant el bucle while. En aquests programes, farem servir els operadors compostos d’assignació. Aquests operadors són +=, -=, *=, /=, %=, / /= i * *=, tot i que els més utilitzats, de llarg, són els comptadors i += 1 o 1 -= 1. Serveixen per simplificar combinacions d’operadors aritmètics (+, -, *, /, %, / / i * *) i assignacions =. Per exemple, la instrucció

i += 1

equival a l’assignació

i = i + 1 

i la instrucció

i -= 1

equival a l’assignació

i = i - 1 

Segurament l’exemple més utilitzat en el moment d’explicar les estructures repetitives és el del compte enrere: fer un programa que llegeixi un nombre enter positiu, faci un compte enrere fins al zero i exploti una bomba.

Especificacions d’entrada: nombre enter >= 0.

El joc de proves el teniu recollit a la taula:

Si seguiu els passos per a elaborar el programa:

1. Cos del bucle:
   1. Mostrar el nombre
   2. Reduir una unitat al nombre
2. Condició: mentre num ⇐ 0
3. Inicialització de la variable: el nombre amb el qual voleu començar és el nombre llegit.
4. Modificació de la variable de la qual depèn la condició: si la condició depèn de la variable num, i tal com s’ha definit el cos del bucle, la variable numes modificarà en el pas: reduir una unitat al nombre.
5. Potser dubteu de si la instrucció print(‘BUUUM’) ha d’estar a dins o vora el bucle. La pregunta que us heu de formular és: quantes vegades es repeteix? Si la resposta és només una, és que l’heu de posar a fora, una vegada s’hagi acabat.

Tenint en compte les anteriors consideracions, el codi del programa del compte enrere serà:

num_inicial = int(input())

# compte enrera
num = num_inicial
while num >= 0:
	print(num)
	num -= 1
	
print('BUUUM')

És important tenir present que sempre cal verificar que el joc de proves s’acompleixi. En el cas dels bucles, és molt fàcil que es produeixi algun desajust: es fa una volta més o menys, no es mostra el primer nombre (quan en el joc de proves s’ha especificat que sí), o no apareix el zero abans del BUUUM. Sempre s’ha de comprovar l’operador de la condició (entre > i >= hi ha diferència), o el valor de la inicialització de la variable de la qual depèn la condició.

El programa mostrarà les potències del número 2 que siguin menors a un valor màxim, en aquest cas, 100. Per exemple, si les potències de 2 són: 1, 2, 4, 8, 16, 32, 64, 128, etc. I el valor màxim és el 100, els valors que hauria de mostrar el programa seran: 1, 2, 4, 8, 16, 32, 64, etc.

Els exemples que heu vist fins ara tenien un element en comú: en tots els casos se sabia la quantitat de repeticions que es volia fer, i la condició depenia d’un comptador. En aquest nou exemple, no se sap quantes voltes s’haurà de fer en el bucle, però sí la condició de sortida. És un programa que no té joc de proves, ja que no es demana cap entrada.

Quan heu de provar un programa, és molt bona idea modificar les condicions que us imposen i pensar en nombres més petits. En aquest cas, es farà el programa per a les potències de 2 menors que 10 (que us serà més senzill de controlar). I amb posterioritat modificareu el nombre màxim per 100.

La sortida (en el cas que busqueu les menors de 10), serà: 1, 2, 4, 8. Si seguiu els passos per a elaborar el programa:

1. Cos del bucle:
   1. Mostrar la potència.
   2. Calcular la potència següent.
2. Condició: mentre la potència sigui menor que el màxim (10).
3. Inicialització de la variable: si es parla de potència, s’hauria d’inicialitzar en 1, ja que és la primera potència de dos que es vol mostrar.
4. Modificació de la variable de la qual depèn la condició: si la condició depèn de la variable potència, i tal com s’ha definit el cos del bucle, la variable num es modificarà a dins del bucle. Cada cop que es calcula la potència següent.
5. Es fa alguna acció fora del bucle? És a dir, hi ha alguna instrucció que s’hagi de fer una única vegada en acabar? La resposta és que no; mostrem els valors dins del bucle, és una instrucció repetida.

Tenint en compte les anteriors consideracions, el codi del programa serà:

MAXIM = 10

potencia = 1 # la primera potència de dos

while potencia < MAXIM:
	print(potencia)
	potencia *= 2 # és el mateix que potencia = potencia * 2

Aquest programa us serviria fàcilment per trobar les potències del nombre 2 inferiors a 100. Només caldria canviar el valor de MAXIM. En aquest cas la dificultat de càlcul entre 10 i 100 no és molta. Però heu d’aprendre a simplificar els enunciats i començar amb execucions senzilles, de les quals estigueu molt segurs dels resultats que us ha de donar el programa.

Si voleu calcular el màxim de 5 nombres, podeu escriure els 5 nombres pel teclat i provar el programa. En canvi, si voleu calcular el màxim de 100 o 1000 nombres, el problema ja és un altre, sobretot si voleu fer més d’una execució amb el mateix conjunt de nombres.

Els administradors de sistemes no fan els programes pensant que interactuaran amb un humà. Les dades solen entrar per la línia d’ordres, i en cas de fer-ho l’entrada estàndard (el que per defecte és el teclat), no s’escriu la informació per a cada execució, sinó que es redirigeix l’entrada perquè sigui el flux d’un fitxer.

El que coneixeu com a joc de proves, amb unes dades d’entrada per a cada execució, solen ser fitxers que contenen les dades per a cadascuna de les execucions. Aquestes dades entren al programa redirigint el flux del fitxer a l’entrada estàndard, stdin.

Seguiu les següents instruccions:

1. Copieu el programa del màxim en un fitxer (en aquest exemple li direm maxim_while.py)
2. Editeu un altre fitxer i escriviu 3 nombres, un en cada línia. Deseu-lo amb el nom que vulgueu (per exemple, nombres.txt)
3. En la terminal (si esteu situats en el directori on hi ha els dos fitxers), executeu l’ordre següent:

   videoioc@debian-xtec:~/Documents/programacio$ python3 maxim_while.py < nombres.txt 
   12 

El contingut del fitxer nombres.txt de l’exemple era el següent:

3
12
7

Modifiqueu el programa del màxim perquè accepti 25 nombres (només cal canviar el valor NOMBRES = 25), feu un fitxer amb 25 nombres enters positius i comproveu que el programa també funciona.

python3 nom_programa.py < entrada.txt 

python3 nom_programa.py > sortida.txt 

Seguim amb els fitxers maxim_while.py i nombres.txt. Executeu l’ordre:

videoioc@debian-xtec:~/Documents/programacio$ python3 maxim_while.py < nombres.txt > sortida.txt 

Podreu comprovar que en el directori Documents/programacio s’ha creat un fitxer que es diu sortida.txt, i que conté el número 12; el resultat de l’execució del programa maxim_while.py amb les dades d’entrada del fitxer nombres.txt.

videoioc@debian-xtec:~/Documents/programacio$ cat
hola
hola
adeu
adeu

text = input()
print(text)

videoioc@debian-xtec:~/Documents/programacio$ cat < prova.txt
hola
adeu

Molts dels programes que es fan en els cursos de programació consten de preguntes i respostes entre l’ordinador i l’usuari. Aquests són els programes interactius.

En els programes interactius, la presència de l’usuari i la seva presa de decisions són imprescindibles per a l’execució del programa. Ja sabeu que la majoria dels programes que haureu de fer com a administradors no seran programes interactius, és a dir, no programareu pensant que hi haurà un usuari interactuant, o responent les preguntes de l’ordinador. Però, així i tot, és important aprendre a crear aquests programes. Ho estudiarem proposant un programa d’exemple.

Feu un programa en què l’ordinador jugui amb l’usuari: l’ordinador “pensarà” un nombre entre 0 i 100 i l’usuari l’haurà d’endevinar. Per cada nombre que proposi l’usuari, el programa li dirà si el que té pensat és major o menor. Quan l’endevini mostrarà un missatge de text que dirà FELICITATS.

Per a codificar aquest programa caldrà que utilitzeu una funció per generar nombres aleatoris. S’aprofitarà l’ocasió per mostrar com actua la funció help().

La funció help() del Python és una de les més importants que cal aprendre a utilitzar. Us ajudarà a buscar com es diuen i com s’utilitzen algunes funcions, mètodes, objectes…

Per exemple, si engegueu l’intèrpret interactiu i teclegeu:

>>>help(pow)

Obtindreu una pàgina del manual amb la següent informació:

Help on built-in function pow in module builtins:

pow(base, exp, mod=None)
    Equivalent to base**exp with 2 arguments or base**exp % mod with 3 arguments
    
    Some types, such as ints, are able to use a more efficient algorithm when
    invoked using the three argument form.

Cal entendre el que explica:

• La primera línia indica que es tracta d’una funció del mòdul built-ins (el de les funcions incorporades).
• En la segona línia es mostra el nom de la funció (pow) i la manera d’invocar-la. Es crida amb tres arguments (el que es posa dins els parèntesis, separat per comes) que es diuen base, exp i mod. Aquest últim, a més, té un valor per defecte (el que va després del = ). Això vol dir que es pot cridar només amb dos arguments, que seran la base i l’exponent, i el mòdul agafarà per defecte el valor None.
• Què fa aquesta funció? Doncs fa el mateix que elevar la base a l’exponent (com hem fet fins ara), i si es crida amb els tres, ens retorna el resultat mòdul el tercer argument. Això serveix en termes d’eficiència: ara no us interessa especialment.

Comproveu amb l’intèrpret interactiu que el resultat de les següents instruccions és l’esperat:

>>> pow(2, 3)
8
>>> pow(2,3,5)
3

La instrucció pow(2, 3, 5) és pow(2, 3) % 5. És a dir 8 % 5 i per això el resultat és 3.

Comproveu la informació que dona help() amb la funció print():

>>>help(print)



help on built-in function print in module builtins:

print(*args, sep=' ', end='\n', file=None, flush=False)
    Prints the values to a stream, or to sys.stdout by default.
    
    sep
      string inserted between values, default a space.
    end
      string appended after the last value, default a newline.
    file
      a file-like object (stream); defaults to the current sys.stdout.
    flush
      whether to forcibly flush the stream.
(END)

La funció print() és molt més potent del que semblava fins ara. Fixeu-vos que podeu definir un separador (que per defecte és un espai), i que si no voleu que cada print estigui en una línia diferent podeu modificar el valor del paràmetre end. Tot això no cal saber-ho, però és imprescindible que si ho necessiteu, tingueu recursos per a buscar-ho.

Hi ha un mòdul, que es diu random, que conté objectes relacionats amb els nombres aleatoris. Però si intenteu buscar amb help() com fer-ho servir, i teclegeu:

>>> help(random)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'random' is not defined

És a dir, no hi ha entrades. Per què?

Perquè random no és un mòdul incorporat per defecte, en canvi, sí que ho són la funció print() i la funció power(). Per poder utilitzar random cal que l’importeu, tant si treballeu amb l’intèrpret interactiu com si esteu codificant un programa.

Executeu ara les següents instruccions:

>>> import random
>>> help(random)

Apareix l’ajuda de tot el mòdul. Hi ha una descripció general, les classes, les funcions… Encara que no recordeu el nom exacte, es pot buscar amb l’ajuda. La funció que necessiteu per generar nombres aleatoris es diu randint.

Per buscar-la a l’ajuda (i per invocar-la en el programa), cal primer importar el mòdul random i després utilitzar-la afegint el nom del mòdul a davant, com a continuació:

>>> help(random.randint)

I l’ajuda obtinguda:

Help on method randint in module random:

randint(a, b) method of random.Random instance
    Return random integer in range [a, b], including both end points.

Aquesta funció retorna un nombre enter aleatori entre els nombres a i b (inclosos). Per exemple:

>>> random.randint(1, 100)
85
>>> random.randint(1, 10)
1

Per a codificar el programa cal seguir la metodologia que coneixeu: començar amb les especificacions d’entrada, un petit joc de proves i el refinament. En aquest cas, no sabeu quantes entrades hi haurà, però sí que cal que deixeu molt clar que seran enters entre 1 i 100 (inclosos). I com a joc de proves es pot posar un exemple d’execució (suposant que coneixeu el nombre escollit).

Especificacions d’entrada: nombres enters que compleixin n >= 1 i n ⇐ 100

El joc de proves el teniu recollit a la taula.

Podeu comprovar que el següent programa acompleix el joc de proves:

# Administració de Sistemes informàtics
# IOC
# 
# Autor: Antonia
# Data: 28-09-2058
#
# Versió: 3.2
#
# Descripció: Endevinar un nombre
# Especificacions d'entrada: 1 nombre enter major o igual a 1 i menor o igual a 100

import random

n_secret = random.randint(1, 100) # generem el nombre
#print(n_secret)

candidat = int(input('Escriu un nombre entre el 1 i el 100\n'))
 
# fins que el trobem
while candidat != n_secret:

	if candidat < n_secret:
		print('El nombre que busques és major')
	elif candidat > n_secret:
		print('El nombre que busques és menor')

	candidat = int(input('Escriu un nombre entre el 1 i el 100\n'))

print('Felicitats! el nombre era:', n_secret)

A continuació es mostraran els errors més freqüents quan es comença a treballar amb bucles. En els tres programes següents, es mostraran versions del programa del compte enrere que corresponen al següent joc de proves.

Especificacions d’entrada: nombre enter >= 0.

El joc de proves el teniu recollit a la taula:

Fixeu-vos en el següent programa del compte enrere:

num_inicial = int(input())

while num_inicial >= 0:
	print(num_inicial)
	
print('BUUUUM')
::note:
Per interrompre l'execució d'un programa podeu utilitzar la combinació de tecles //Ctrl + c// .
:::

Si l’executeu obtindreu un resultat com el següent:

videoioc@debian-xtec:~/Documents/programacio$ python3 compte_enrrera.py 
5
5
5
5
5
5
^C5
Traceback (most recent call last):
  File "/home/videoioc/Documents/programacio/compte_enrrera.py", line 27, in <module>
    print(num_inicial)
KeyboardInterrupt

Quan un programa no aconsegueix sortir d’un bucle, la major part de les vegades la culpa és que no es modifica el valor de la variable que intervé en la condició. En aquest exemple, dins del bucle no es canvia el valor de valor_inicial. De manera que sempre val 5, i quan el programa avalua el resultat de la condició sempre és False. Mai es podrà sortir.

És fàcil fer-se un embolic en el moment amb els operadors, la inicialització i l’ordre de les instruccions.

num_inicial = int(input())
i = num_inicial

while i > 0 :
	i = i - 1
	print(i)
	
print('BUUUUM')

El resultat de l’execució d’aquesta versió és:

videoioc@debian-xtec:~/Documents/programacio$ python3 compte_enrrera_2.py 
5
4
3
2
1
0
BUUUUM

Aquesta versió no acompleix amb el joc de proves, ja que s’hauria de mostrar el 5 i no es fa. No és fàcil pensar com actuarà exactament el programa, sobretot en els moments d’entrar o sortir del bucle. És per això que sempre heu d’executar un cas simple en el qual pugueu comprovar que la sortida és exactament el que ha de ser.

Fixeu-vos en la nova versió del programa:

num_inicial = int(input())
i = num_inicial

while i > 0 :
	print(i)
	i = i - 1
	if i == 0:
	  print(i)
		print('BUUUUM')

L’execució per al 5 és:

videoioc@debian-xtec:~/Documents/programacio$ python3 compte_enrrera_2.py 
5
5
4
3
2
1
0
BUUUUM

El programa funciona perquè s’acompleix el joc de proves. Però no és un programa correcte, ja que s’han escrit instruccions a dins del cos del bucle que només s’acompleixen una única vegada en acabar: això vol dir que s’han de definir fora del bucle.

Per tal de consolidar tot el que hem anat exposant, aquí teniu un resum dels conceptes clau apresos en aquesta lliçó.

Per escriure un bucle while és necessari determinar quatre coses i el consell és que ho feu seguint aquest ordre:

1. El cos del bucle.
2. La condició de la repetició.
3. El valor inicial de la variable de la qual depèn la condició (que s’ha de definir fora del bucle).
4. Com es modifica aquesta variable dins el bucle.

while condició:
  instruccions del cos del bucle

La redirecció de fitxers per stdin és una bona alternativa a l’entrada manual de dades.

python3 nom_programa.py < entrada.txt 

L’efecte que té aquesta ordre és la mateixa que si escrivíssiu els mateixos caràcters del fitxer entrada.txt per teclat.

python3 nom_programa.py > sortida.txt 

En aquest cas, el sistema operatiu crearà un fitxer de nom sortida.txt (o el sobreescriurà en un que ja existeixi) i hi escriurà i desarà els caràcters que la sortida del programa mostrava per pantalla.

Un dels mòduls que utilitzareu és el mòdul random, relacionat amb els nombres aleatoris. Per generar un nombre aleatori entre a i b (inclosos), heu d’importar el mòdul random al principi del programa o a l’intèrpret interactiu:

import random

Tot seguit, heu d’utilitzar la funció:

num = random.randint(a, b)