Variables i constants

Per tal de conèixer el concepte de variables en programació us plantegem un repte que anirem resolent pas a pas.

El repte consisteix a crear els primers programes seqüencials a l’intèrpret interactiu. Aquests programes faran sevir variables per donar instruccions a l’intèrpret interactiu. Veureu com ens ajuden a automatitzar un procés de resolució d’un problema.

Obriu un terminal i engegueu l’intèrpret interactiu de Python.

python3
Python on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> 

Utilitzeu l’intèrpret interactiu per a calcular la mitjana dels nombres 3, 5 i 6.

La manera de fer-ho seria la següent:

>>> ( 3 + 5 + 6 ) / 3
4.666666666666667

Després feu el mateix amb els nombres 2, 8 i 10.

El que us diu l’intèrpret interactiu serà semblant al següent:

>>> (2 + 8 + 10) / 3
6.666666666666667

Està clar que cada vegada que vulgueu repetir els càlculs amb diferents nombres, haureu de reescriure els seus valors directament.

L’objectiu de la programació és “automatitzar” aquest càlcul. Com fer-ho?

L’algorisme, per calcular la mitjana de 3 nombres pas a pas seria el següent:

1. “Escollir” els 3 valors.
2. Fer la suma.
3. Dividir entre tres.
4. Mostrar la quantitat.

Cal que escriviu una instrucció que no depengui del valor de les dades. O més ben dit, que es pugui fer servir amb diferents valors.Per a fer això, s’utilitza el que anomenem variables.

Per “omplir” una variable s’usa l’operador d’assignació, que es representa amb el signe =.

És a dir, el nom de la variable sempre es posa a l’esquerra, seguit del signe =. Després una expressió que pot ser tan complicada com calgui.El nom de la variable està subjecte a unes restriccions i l’expressió pot contenir dades i operadors. El més important és que en cada execució, quan el processador trobi la instrucció on apareix la variable, aquesta variable tingui un valor concret. En una assignació, sempre s’ha de fer el càlcul de la dreta i posteriorment assignar el resultat a la variable que té el nom de l’esquerra.

num1 = 2

num2 = 1 + 3	

num3 = num1 + 3	

Si voleu que el processador mostri el valor d’una variable, cal que li demaneu escrivint el seu nom. Penseu (i comproveu amb l’intèrpret) quant valdrà la variable num3 després de les següents instruccions:

num1 = 1
num2 = 3
num3 = 10 + num1 + num2
num3

La resposta ha de ser 14.

En el següent cas, quant valdrà la variable num3 en finalitzar la darrera instrucció?

num3 = 1
num3 = num3 + 1
num3 = num3 + 1
num3

La resposta ha de ser 3.

I en el següent cas, quins valors tindran num1, num2 i num3 en finalitzar?

num1 = 1
num1 = num1 + 1
num1
num2 = num1 + 1
num2
num3 = num1 + num2
num3

num1 valdrà 2, num2 valdrà 3 i num3 valdrà 5.

Comproveu què passa si feu la següent assignació.

>>> num1 = 1
>>> num3 = num1 + num4

Si ho comproveu, veureu que obtindreu la següent resposta:

>>> num1 = 1
>>> num3 = num1 + num4
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'num4' is not defined. Did you mean: 'num1'?

En aquesta última assignació, el processador s’ha queixat perquè la variable num4 no tenia cap valor (no hem fet cap assignació anterior). De manera que no ha pogut calcular l’expressió de la dreta de l’operador assignació (num1 + num4) i no pot donar valor a la variable num3.

El processador és “tan llest” que ens intenta ajudar i vol verificar que no ens hàgim equivocat amb el nom de la variable. Com que el processador sí que té emmagatzemat el valor de num1, però no el de num4, ens pregunta si ens volíem referir a la variable num4.

num3 = num3 + 1 

Deduïu quant valdrà la variable num1 després de les instruccions següents, i comproveu el resultat amb l’intèrpret interactiu:

num1 = 11
num1 = num1 + 1
num1 = num1 + 1
num1 = num1 + 1
num1

El valor inicial era 11 i hem efectuat tres vegades la instrucció d’afegir una unitat. De manera que el resultat final serà 14.

Repetiu el problema de la mitjana utilitzant variables per als nombres 3, 5 i 6:

num1 = 3
num2 = 5
num3 = 6
mitjana = (num1 + num2 + num3) / 3
mitjana

El resultat us donarà 4.666666666666667

Calculeu la mitjana dels nombres 2, 8 i 5:

num1 = 2
num2 = 8
num3 = 5
mitjana = (num1 + num2 + num3) / 3
mitjana

Fixeu-vos que si voleu calcular la mitjana de tres nombres qualssevol, només cal que modifiqueu les instruccions on assigneu els valors a les variables. Les instruccions on es processa la informació (en aquest exemple només és la del càlcul), es mantenen inalterables independentment dels valors que escolliu. En l’última instrucció li demanem al processador la sortida de les dades processades.

Acabeu d’automatitzar el càlcul de la mitjana de tres nombres. De fet, acabeu de fer el vostre primer programa, l’únic és que en comptes d’escriure les instruccions en un fitxer, les doneu d’una en una a l’intèrpret de Python.

Només us caldrà aprendre a llegir els valors, que són les dades d’entrada, i escriure les instruccions en un fitxer de text.

El següent pas del nostre repte serà escriure les instruccions per calcular el perímetre i l’àrea d’una circumferència si en sabeu el seu radi. Recordeu que per l’àrea i el perímetre d’una circumferència de radi r cal aplicar les següents fórmules matemàtiques:

On r és el radi de la circumferència i π és la constant matemàtica que tothom coneix.

Tenint en compte aquesta fórmula, com calcularíeu l’àrea d’una circumferència de radi 5? Probablement, a Python haureu utilitzat les següents instruccions a l’intèrpret interactiu:

>>> radi = 5
>>> area = radi ** 2 * 3.1416
>>> area
78.53999999999999
>>> perimetre = 2 * radi * 3.1416
>>> perimetre
31.416

Fixeu-vos que per a utilitzar el nombre π (3.1416), hem hagut d’escriure dues vegades el seu valor. Això és una mica pesat, per una banda, i per l’altra incrementem la possibilitat de cometre errors.Si posem el seu valor en una “caixeta” i li diem PI, en cas que algú mirés el programa, el trobaria molt més llegible, a més d’evitar els inconvenients anteriors. Aquesta “caixeta”, com a concepte, és el mateix que una variable, però amb un matís una mica diferent; no varia al llarg de tot el programa sinó que es manté constant.

És per això que en aquests casos parlem de “constants”, i de manera arbitrària els programadors les escriuen en majúscules. Hi ha llenguatges en què, quan defineixes una constant el processador, no et deixa canviar el seu valor, però no és el cas del Python. Les constants les escrivim en majúscules només per llegibilitat.

Aplicant això, les instruccions del nostre programa quedarien així;

>>> radi = 5
>>> PI = 3.1416
>>> area = radi ** 2 * PI
>>> area
78.53999999999999
>>> perimetre = 2 * radi * PI
>>> perimetre
31.416

Oi que s’entén millor?

El següent pas és usar constants per a calcular l’increment d’un preu amb l’IVA. Heu d’utilitzar l’intèrpret interactiu per definir les instruccions per a calcular l’augment de preu d’un producte que val 22 € (dada d’entrada), després d’haver-li aplicat l’IVA general que és del 21%. Una possible solució seria aquesta:

preu_original = 22
increment = preu_original * 21/100
preu_final = preu_original + increment
preu_final

El preu final serà de 26,62 €.

Si voleu calcular el preu final d’un producte sanitari, que té un IVA reduït del 10%, haureu de repetir les instruccions, buscar on hi havia el 21% de l’IVA general i modificar-ho a tot arreu. És complicat i el risc d’errors és gran.

Això facilitarà que si en una nova execució necessitem que canviï (perquè l’IVA és diferent), es pugui fer de manera senzilla. Amb aquestes consideracions les instruccions serien les següents:

IVA = 10
preu_original = 22
increment = preu_original * IVA / 100
preu_final = preu_original + increment
preu_final

En aquest cas, el preu final és de 24,2€. Heu guanyat en facilitat per modificar (és senzill adaptar-lo a l’IVA que es requereixi) i en llegibilitat.

Finalment, analitzarem els errors més comuns amb els quals us podeu trobar quan comenceu a utilitzar les variables.

• Variable no definida:

>>> num = num + 1
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'num' is not defined. Did you mean: 'sum'?

Si utilitzem una variable que no existeix a la dreta de l’assignació, és impossible calcular el seu valor i assignar-lo a l’esquerra. L’intèrpret ens intenta ajudar per si ens hem equivocat amb el nom.

• Error de sintaxi:

>>> num 1 = 2
  File "<stdin>", line 1
    num 1 = 2 
        ^
SyntaxError: invalid syntax

El nom d’una variable no pot tenir espais en blanc, ja que el processador ho interpreta com a la variable num i el nombre enter 1. I es queixa perquè una assignació només pot contenir el nom de la variable a la part de l’esquerra. Els noms de les variables tenen unes limitacions, la més important de les quals és que no poden contenir espais en blanc.

• Error de sintaxi:

>>> 2 + 2 = num
  File "<stdin>", line 1
    2 + 2 = num
    ^^^^^
SyntaxError: cannot assign to expression here. Maybe you meant '==' instead of '='?

És habitual que per començar ens equivoquem i intentem fer una assignació “al revés”. Recordeu que per assignar un valor a una variable a l’esquerra de l’igual només pot haver-hi el nom. És per això que l’intèrpret “pensa” que volem fer una acció diferent d’una assignació (s’imagina que potser el que volem és comparar, que es faria amb l’operador ==).

Els conceptes bàsics sobre variables i constants que hem vist us permetran fer-les servir en els programes que feu. Tot seguit en fem una recopilació. Variables: com definir-les i quin nom donar-les. Una variable és un contenidor que guarda un valor. Una variable de Python sempre té dues parts: un nom i un valor.

El símbol = és l’operador d’assignació i serveix per donar un valor a una variable.

L’assignació d’una variable sempre es fa d’aquesta manera:

nom_variable  =  expressió

L’expressió ha de ser una combinació ben escrita de dades i operadors. Les variables poden contenir dades de qualsevol tipus (molt més enllà dels enters i float).

Per utilitzar una variable és necessari que durant l’execució, aquesta tingui un valor concret.

Limitacions en els noms de les variables

Cal que el nom de la variable sigui descriptiu. Al processador li és igual, però els programes també els hem de mirar i entendre els humans i poder deduir -a partir del seu nom- què conté una variable ens fa la vida més fàcil.

Ja sabeu que la llegibilitat és una de les característiques més desitjables dels programes i els noms descriptius de les variables són una de les coses que més llegibilitat aporten.

Els noms de les variables estan subjectes a unes restriccions:

• Els caràcters que els componen han de ser lletres majúscules o minúscules, nombres o el caràcter _” (però no poden començar per un dígit).
• No poden ser cap de les paraules reservades del Python (entre d’altres, les paraules reservades són if, else, while, for, True, False…).
• Python és sensible al tipus (case_sensitive en anglès). Això vol dir que les variables pi i PI són diferents.
• S’aconsella, a través de la guia d’estil “PEP 8 — Style Guide for Python Code” (peps.python.org/pep-0008), que els noms de les variables siguin en minúscules, amb paraules separades pel caràcter underscore (_). Per exemple: preu_base

En la mateixa execució es pot assignar la mateixa variable a un valor d’un tipus diferent sense que hi hagi cap problema pel processador.

De totes maneres, no és una pràctica gaire aconsellable, ja que sí que comporta problemes als humans: és molt important, sobretot pel programador, saber sempre quin tipus de dada conté cada variable. Evita molts errors.

Constants

Una constant és el mateix que una variable, però el seu valor no ha de variar al llarg del programa.

En aquest cas posem el nom en majúscules per llegibilitat, per indicar que es tracta d’un valor que no varia al llarg de tota l’execució.

L’ús de constants és molt útil per facilitar la modificació d’un programa (fins i tot amb l’intèrpret interactiu).

Heu de resoldre el problema de “normalitzar” una quantitat de segons. És a dir, que heu de transformar un nombre de segons en una quantitat d’hores, minuts i segons equivalents, de manera que estigui normalitzat (que s’expressi en hores, minuts i segons correctes).

Començareu utilitzant l’intèrpret interactiu per a un cas concret, i després reproduireu el mateix algorisme utilitzant variables per a aconseguir automatitzar-lo.

D’entrada començareu per un exemple fàcil. Voleu saber quantes hores, minuts i segons són 63 segons.

Quins càlculs heu de fer amb l’intèrpret interactiu abans de pensar en instruccions?

>>> 63 // 60
1
>>> 63 % 60
3

Aquestes senzilles operacions us indiquen que 63 segons són un minut sencer (la divisió entera del total de segons entre la quantitat de segons que formen un minut), i que sobren 3 segons (el residu de la divisió anterior). És a dir, 63 segons corresponen a un minut i tres segons en valors normalitzats.

En teniu prou amb aquest exemple? No, ja que si hi ha més de 59 minuts, s’han de fer més càlculs fins a trobar les hores. Com ho fareu en el cas de 123456 segons?

>>> 123456 // 60
2057
>>> # 123456 segons corresponen a 2057 minuts sencers
>>> 123456 % 60
36
>>> # 'sobren' 36 segons, que seran els segons finals
>>> 2057 // 60
34
>>> # 2057 minuts corresponen a 34 hores senceres
>>> 2057 % 60 
17
>>> # d'aquestes 34 hores en "sobren" 17 minuts, que son els minuts finals

Heu calculat que 123456 segons corresponen a 34 hores, 17 minuts i 36 segons.

Abans de pensar amb fer cap programa, és imprescindible que sapigueu fer els càlculs a mà (o amb l’intèrpret interactiu). Si no ho teniu molt clar, de cap manera li podreu explicar amb instruccions a l’ordinador.

En aquest exemple hem introduït el símbol #.

Quan el processador llegeix aquest símbol, sap que el que hi ha fins al final de línia no ho ha d’interpretar. És un text per a la persona que llegeix el codi, no pel processador. Per exemple, del codi anterior, només ha processat aquestes línies:

>>> 123456 // 60
2057
>>> 123456 % 60
36
>>> 2057 // 60
34
>>> 2057 % 60 
17

Ara cal automatitzar aquests càlculs, incorporant l’ús de variables, de manera que les mateixes instruccions us serveixin per normalitzar qualsevol quantitat de segons que desitgeu.

A cada pas, en comptes d’escriure el valor concret del càlcul, caldrà que el deseu en una variable per poder accedir-hi quan ho necessiteu.

En la primera instrucció heu calculat la quantitat de minuts sencers que corresponen als segons de l’entrada.

Anomenareu segons_inicial a la dada d’entrada. I minuts_totals al valor d’aquest càlcul.

segons_inicials = 123456
minuts_totals = segons_inicials // 60

Després heu calculat el valor dels segons finals (el residu de la divisió). Aquesta nova dada la desareu en una variable que anomeneu segons_finals (ja que és un dels resultats que busqueu).

segons_finals = segons_inicials % 60

El tercer pas ha estat calcular les hores finals. Per a aconseguir-ho, heu fet la divisió entera dels minuts totals que hi ha, entre 60, ja que una hora conté 60 minuts.

hores_finals = minuts_totals // 60

Per acabar, només us queda calcular la quantitat de minuts finals. Aquest resultat són els minuts que “sobren” després d’haver agrupat els minuts totals en hores senceres.

minuts_finals = minuts_totals % 60

Aquí teniu el programa complet per comprovar-ho. En les últimes 4 línies li heu demanat al processador les dades de sortida que necessiteu, però podeu demanar-li també quin és el valor de la variable minuts_totals per poder comprovar que tot va bé.

segons_inicials = 123456
minuts_totals = segons_inicials // 60
segons_finals = segons_inicials % 60
hores_finals = minuts_totals // 60
minuts_finals = minuts_totals % 60
hores_finals
minuts_finals
segons_finals

Si repetiu les mateixes instruccions modificant la quantitat de segons inicials, veureu que resolen el problema per a qualsevol valor.