---
title: ASIX1 M03. 005. Estructures de control.
tags: asix, programació, estructures de control
---
# ASIX1 M03: Programació bàsica
[vincle a font en MarkDown](https://hackmd.io/@JdaXaviQ/H1x1DIv4F)
---
## 005. Estructures de control.
### Blocs d'instruccions
Dins del paradigma de la programació estructurada, els llenguatges permeten agrupar o _estructurar_ les sentències en blocs. No tots els llenguatges utilitzen la mateixa sintaxi per a agrupar les ordres, Python fa ús de la [indentació](https://ca.wikipedia.org/wiki/Sagnat), també conegudat com a sagnat o sagnia, per a agrupar les ordres provocant que els blocs de sentències siguin clarament visibles i fent que la estructura del programa sigui molt visual. Totes les línies d'un programa que comparteixen bloc tenen el mateix nombre de espais en blanc o tabulacions (nosaltres en aquest mòdul utilitzarem 4 espais en blanc per a cada nivell d'agrupació) a l'esquerra.
### Condicional. if *(booleà)*: elif *(booleà)*: else:
La estructura _**if**_ ens permet prendre decisions al mig del nostre programa i executar un bloc d'instruccions o un altre depenent d'alguna condició que es dona en temps d'execució.
La sintaxi del condicional és la següent:
La paraula reservada __if__ seguida d'una __condició__ que s'avalua a 'true' o a 'false' el signe tipogràfic de dos punts '__:__'
El següent parràgraf de codi sempre va indentat i són les instruccions que només s'executaran si la condició és certa. Quan deixem de indentar el text estem indicant que ja hem sortit del bloc afectat pel condicional.
```python=
# part del programa que s'executa amb
# normalitat abans d'arribar al condicional.
if condicio:
# bloc d'instruccions
# a executar només si
# la condició és certa
# resta del programa que s'executa sempre
# independentment del valor de la condició.
```
#### Exemples d'ús:
```python=
print ("Introdueix un nombre natural")
nombre = int(input())
if nombre % 2 == 0:
print("La meitat de ", nombre, " es ", nombre // 2)
```
Eventualment podem introduir un bloc d'instruccions que només s'executin quan la condició és certa; provocant una bifurcació al fluxe del programa: o executem un bloc d'instruccions o l'altra, mai els dos i mai cap.
```python=
print ("Introdueix un nombre natural parell")
nombre = int(input())
if nombre % 2 == 0:
print("La meitat de ", nombre, " es ", nombre // 2)
else:
print("El nombre demanat havia de ser parell i el teu no ho és.")
print("Torna-ho a provar!")
```
I finalment, podem enllaçar diferents condicions per a generar múltiples camins de pas, forçant al programa a passar només per un d'ells:
```python=
print ("Quina qüalificació has aconsseguit?")
qualificacio = float(input())
if qualificacio < 5:
print("Insuficient")
elif qualificacio < 6:
print("Suficient")
elif qualificacio < 7:
print("Be")
elif qualificacio < 9:
print("Notable")
else:
print("Excel·lent")
```
#### [Taller de condicionals al Google Colab](https://colab.research.google.com/drive/1bD2OrRWRRFXaRUTGfpJMTR1gn0f8hWOC?usp=sharing)
### Bucles while *(booleà)*:
Els programadors som gent a les que no ens hi agrada fer la mateixa tasca de forma repetitiva moltes vegades i especialment, detestem escriure més d'una vegada el mateix text. És per aquesta raó que tots els llenguatges de programació presenten estructures que ens permeten repetir una tasca les vegades que calgui. De vegades sabrem abans de començar quantes vegades haurà de repetir el nostre equip una tasca per nosaltres, però d'altres vegades, haurem de dir-li a la màquina com reconèixer quan ha d'aturar-se. En aquests casos utilitzarem la estructura de **bucle while**.
Per exemple si volem que l'usuari ens doni per consola un nombre parell i ens introdueix un nombre senar, el podem avissar tantes vegades com calgui fins que introdueixi un nombre parell:
```python=
"""
parell.py
Author: Xavi Quesada
Creation date: october 3, 2021
Read one even number from console and returns its half.
"""
nombre = -1
while (nombre % 2) != 0:
print("Si us plau, introdueix un nombre natural parell")
nombre = int(input())
if nombre % 2 != 0:
print("****************************")
print("* Aquest nombre era senar. *")
print("****************************")
print("La meitat de ", nombre, " es ", nombre // 2)
```
### Bucles for:
Com hem comentat abans, hi ha vegades que sabem exactament abans de començar quantes vegades hem de repetir una acció, per exemple: un cop per cada element d'una llista.
```python=
"""
iteracio_llista.py
Author: Xavi Quesada
Creation date: october 3, 2021
Runs one action for each element in a list.
"""
fruites = ['taronja', 'pressec', 'cirera']
for fruita in fruites:
print("Em menjaria una ", fruita)
print("Com n'estaven de bones!!!")
```
Python ens permet iterar sobre un string (cadena de text) com si fos una llista:
```python=
for c in "pepito":
print(c)
```
__Output:__
```
p
e
p
i
t
o
```
És posible que volguem iterar un nombre determinat de vegades. A Python, utilitzem la funció __range()__ per a obtenir una sèrie de nombres ordenats de forma creixent (predeterminada) o també decreixent.
### La funció range:
A la funció range() li podem passar 1, 2 o 3 paràmetres.
- Si només li passem un paràmetre, ens retorna una sèrie que comença en 0 i _compta_ d'un en un fins al nombre immediàtament inferior al paràmetre que li hem passat. Per exemple:
```python=
for index in range(5): # Executarà 5 vegades les sentències que hi ha dins del bucle.
print(index)
```
__Sortida:__
```bash=
0
1
2
3
4
```
Exemple de programa que escriu 100 vegades: _'No parlarè a classe.'_ i li afegeix al devant el número d'ordre.
```python=
for x in range(100):
print(x, " No parlarè a classe.")
```
- Quan a la funció range li passem 2 paràmetres, els interpreta com l'inici i la fi (sense incloure el segon paràmetre) de la seqüencia:
```python=
for index in range(5, 10):
print(index) # Escriu els nombres del 5 al 9 (ambdòs inclosos)
```
- I per finalitzar, si li passem 3 paràmetres, els interpreta com l'inici, la fi i l'increment a realitzar a cada iteració, per defecte el tercer paràmetre és 1.
```python=
# Programa que compta de 2 en dos començant per 20 i terminant al número 30
for index in range(20, 31, 2):
print(index)
```
També podem executar bucles dins d'altre bucles:
```python=
cotxes = ["Seat Ibiza", "Honda Civic", "Toyota Yaris"]
motoritzacio = ["Gasolina", "Hibrid"]
for m in motoritzacio:
for c in cotxes:
print(c, "amb motor", m)
```
## Exemples d'estructures de control amb _'nom propi'_ (només per a nosaltres!!!)
### El salt de granota:
Durant aquest curs anomenarem salt de granota als bucles que iteren un rang on podem definir l'inici, el final i el pas o distància del __salt__.
```python=
#!/usr/bin/python3
# _*_ coding: utf-8 _*_
import sys
"""
salt_de_granota.py passa per un rang de nombres enters saltant sempre la mateixa quantitat
ex: python3 salt_de_granota 10 20 2
10, 12, 14, 16, 18, 20
"""
def main(inici, final, salt):
result = ""
if salt > 0:
final += 1
elif salt <0:
final -= 1
else:
raise ValueError ("El valor del salt no pot ser 0")
for comptador in range(inici, final, salt):
if result == "":
result += str(comptador)
else:
result += ", " + str(comptador)
return result
if __name__ == "__main__":
print(main(int(sys.argv[1]),int(sys.argv[2]),int(sys.argv[3])))
```
### El lloro:
El lloro ilustra un altre tipus de bucles, on repetirem fins que s'assoleixi una condició que a priori no sabem quan passarà, com per exemple, que l'usuari es cansi d'introduïr valors.
```python=
#!/usr/bin/python3
# _*_ coding: utf-8 _*_
import sys
"""
lloro.py repeteix les frases de l'usuari fins que ens cansem i
escrivim una frase buida
"""
__author__ = "Xavi Quesada"
__email__ = "f.javier.quesada@iesjoandaustria.org"
__license__ = "GPL V3"
def main():
frase_de_l_usuari = None
while frase_de_l_usuari != "":
frase_de_l_usuari = input("L'usuari diu: ")
if frase_de_l_usuari != "":
print(frase_de_l_usuari)
if __name__ == "__main__":
main()
```
Sign in with Wallet
Connect another wallet