Introducció a les funcions

Fins ara heu utilitzat funcions predefinides del Python que heu incorporat als vostres programes, tant si són del sistema com d’altres biblioteques. Començarem per definir i clarificar alguns conceptes sobre les funcions.

La idea de funció es pot entendre com una relació entre dos elements o conjunts d’elements on cada element d’un dels conjunts (el conjunt d’entrada) està relacionat amb exactament un element de l’altre (el conjunt de sortida)

Una altra manera (més matemàtica) de dir-ho és: una funció pren un argument x com a entrada, del qual en treu un valor de sortida f(x).

Per començar, repassarem alguns exemples de funcions matemàtiques.

També sabeu com utilitzar algunes funcions definides pel sistema o d’alguna de les llibreries de Python. En el cas de les funcions d’un llenguatge informàtic, les entrades seran dades d’algun tipus de dada del llenguatge, igual que els valors de sortida.

Normalment, una funció té limitacions en tant al tipus de dades que accepta. És possible que a més del tipus de dades, existeixin limitacions en els arguments per entrar en una funció (per exemple, math.sqrt() només accepta valors numèrics positius).

En termes més senzills i intuïtius, podeu pensar en una funció com una “màquina” que pren un valor (o conjunt de valors) com a entrada i que produeix un altre valor com a sortida, seguint una regla o un procediment definit.

Per començar a entendre una funció, el primer que cal fer és definir quins són els arguments d’entrada, i quins poden ser els valors de sortida.

Des del punt de vista informàtic, una funció és un bloc de codi reutilitzable que du a terme una tasca específica. Les funcions predefinides són aquelles que ja estan implementades en el llenguatge de programació i es poden utilitzar sense haver de definir-les.

El domini d’una funció informàtica fa referència als tipus de dades o valors que pot acceptar com a entrada, mentre que el codomini fa referència als valors que pot produir com a sortida.

Els llenguatges de programació tipats com C requereixen que es declari el tipus de dada que una funció pot acceptar com a entrada i el tipus de dada que retorna com a sortida. Això proporciona una major seguretat a l’hora de programar, ja que impedeix que es passin dades de tipus incorrectes a les funcions.

En Python, els tipus de dades són dinàmics, el que significa que no cal declarar-los explícitament. Tot i això, el concepte de tipus de dades incorrectes encara és rellevant. Python permet passar qualsevol tipus de dada a una funció, però si la funció no està dissenyada per manipular aquest tipus, pot provocar errors o resultats inesperats.

Com ja heu après, per utilitzar una funció de Python podeu utilitzar la documentació en línia per consultar la signatura d’una funció, utilitzant la funció help().

Help on built-in function abs in module builtins:

abs(x, /)
    Return the absolute value of the argument.

>>> nom = 'Pere'
>>> edat = '23'
>>> print('em dic', nom, 'i tinc' , edat ,'anys')
em dic Pere i tinc 23 anys
>>> 
>>> print('em dic', nom, 'i tinc' , edat ,'anys', sep='_', end='!!!')
em dic_Pere_i tinc_23_anys!!!>>> 

print(*args, sep=' ', end='\n', file=None, flush=False)
    Prints the values to a stream, or to sys.stdout by default.

sorted(iterable, /, *, key=None, reverse=False)
    Return a new list containing all items from the iterable in ascending order.

En el següent codi podeu veure que si apliqueu la funció abs() sobre un valor numèric funciona bé. Però si l’apliqueu sobre una cadena o bé sobre una llista, generarà un error:

>>> abs(-3)
3
>>> abs(2.234)
2.234
>>> abs('hola')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: bad operand type for abs(): 'str'
>>> abs([3])
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: bad operand type for abs(): 'list'

abs(x, /)
    Return the absolute value of the argument.

int abs(int n);
long int abs(long int n);

Fins ara s’ha parlat de funcions, però també cal explicar què són els mètodes. La programació orientada a objectes és un paradigma de programació que intenta proporcionar un model basat en objectes que contenen dades i procediments associats, coneguts com a mètodes.

El Python és un llenguatge orientat a objectes, de manera que els objectes poden tenir mètodes.

En el codi següent podeu veure un exemple de com definim una dada anomenada cadena que és un objecte, i com, sobre aquesta, cridem al mètode isDigit():

>>> cadena = '201'
>>> cadena.isdigit()
True

Com que el mateix objecte engega el mètode, no cal que es passi a ell mateix per argument, de manera que “enganya” una mica.

Help on method_descriptor:

isdigit(self, /)
    Return True if the string is a digit string, False otherwise.
    
    A string is a digit string if all characters in the string are digits and there
    is at least one character in the string.

En aquest cas, la documentació indica els valors de sortida i explica què fa el mètode.

Aquesta informació us ha de permetre a interpretar els resultats en les operacions següents:

• En el primer cas, podeu veure com es defineix la variable cadena que serà un objecte sobre el qual es guarda una cadena de caràcters.

>>> cadena = '123'
>>> cadena.isdigit()
True
>>> cadena = 'hola'
>>> cadena.isdigit()
False
>>> '12.3'.isdigit()
False

• En cas que no es defineixi la variable explícitament, Python la crearà en memòria per permetre cridar un mètode sobre aquesta:

>>> '12.3'.isdigit()
False

• Però si intenteu crear-la sobre un valor que no es pot convertir a variable ni pot ser un nom de variable, tindreu un error:

>>> 12.isdigit()
<stdin>:1: SyntaxWarning: invalid decimal literal
  File "<stdin>", line 1
    12.isdigit()
SyntaxError: invalid syntax

• Finalment, si crideu al mètode amb un paràmetre, també us donarà un error perquè no n’espera cap:

>>> '12'.isdigit(3)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: str.isdigit() takes no arguments (1 given)

En aquest apartat s’aprofundirà en la interpretació de la documentació proporcionada per l’ajuda en línia. L’objectiu és desxifrar els tipus de dades dels arguments d’entrada i dels valors de retorn que proporcionen les funcions.

Per poder utilitzar una funció predefinida és indispensable no només proporcionar-li els tipus de dades correctes (i evitar errors o resultats inesperats), sinó entendre què retornaran perquè el programa que utilitza la funció en pugui fer un bon ús.

Si consulteu la documentació d’aquest mètode (amb help(str.replace) ), obteniu la pàgina següent:

Help on method_descriptor:

replace(self, old, new, count=-1, /)
    Return a copy with all occurrences of substring old replaced by new.
    
      count
        Maximum number of occurrences to replace.
        -1 (the default value) means replace all occurrences.
    
    If the optional argument count is given, only the first count occurrences are
    replaced.

Cal que, amb l’ajuda de l’intèrpret interactiu, aprengueu a utilitzar el mètode i pugueu definir amb rigor els tipus d’entrada i de retorn.

La documentació indica que:

• replace() s’ha de cridar proporcionant 2 arguments obligatoris (old i new), i un opcional (count), que té un valor per defecte. Si no hi ha tercer argument, count prendrà el valor -1).
• self indica que actua sobre la cadena que el crida. La barra indica la fi dels paràmetres obligatoris.
• El tipus de dada de count està clar que ha de ser un enter.
• Els tipus que poden prendre els paràmetres old i new no estan determinats explícitament. Però podeu deduir que es tracta de cadenes.

Ara cal que feu proves amb l’intèrpret interactiu per aprendre a utilitzar el mètode replace().

>>> a = 'hola'
>>> b = 'patata'
>>> a.replace('h', 't')
'tola'
>>> b.replace('ta', 'pap')
'papappap'
>>> b.replace('ta', 'pap', 1)
'papapta'
>>> b.replace('ta', 'pap', 0)
'patata'
>>> b.replace('ta', 'pap', 7)
'papappap'
>>> b.replace('ta', 'pap', -3)
'papappap'

Podeu descriure els tipus dels valors d’entrada i sortida així:

Entrada: str, str, int (opcional)

Sortida: str

Fins ara, hem explorat l’ús de les funcions i mètodes predefinits en Python. Ara, és el moment d’aprendre a definir les vostres pròpies funcions, el que us permetrà crear blocs de codi independents, reutilitzables i modulars.

Fixeu-vos en el següent programa: llegeix la part numèrica d’un DNI (passat per argument), i mostra la lletra corresponent. Aquesta primera versió és la que es faria sense utilitzar funcions. L’anomenarem dni_inicial.py:

import sys
LLETRES_DNI = 'TRWAGMYFPDXBNJZSQVHLCKE'

dni = int(sys.argv[1])

#Càlcul de la lletra
pos = dni % len(LLETRES_DNI)
print(LLETRES_DNI[pos])

Aquesta és una nova versió del mateix programa, però en el que es defineix i s’utilitza una funció anomenada lletra_dni(). A aquesta versió l’anomenarem dni_funcio.py:

import sys

def lletra_dni(num_dni):
	'''
	Funció que rep un nombre que representa un dni i retorna la lletra
	corresponent
	Entrada: int (nombre que representa un dni)
	Sortida: str (caràcter corresponent a una lletra en majúscula)
	'''
	LLETRES_DNI = 'TRWAGMYFPDXBNJZSQVHLCKE'
	pos = dni % len(LLETRES_DNI)
	return LLETRES_DNI[pos]

#Programa Principal
dni = int(sys.argv[1])
#Càlcul de la lletra
print(lletra_dni(dni))

En la figura es mostra programa amb els números de línia.

Explicació dels nous conceptes:

• En la línia 3 es defineix la funció lletra_dni. Per a definir una funció, s’utilitza la paraula clau def seguida del nom de la funció, parèntesis i els noms dels paràmetres que s’utilitzaran per a codificar-la.
• Les línies 4 a 9 corresponen al docstring de la funció. El docstring és un comentari (i, per tant, és transparent per al processador) que dona informació sobre l’ús de la funció.
• En les línies 10 a 12 hi ha el codi de la funció.
• En la línia 12 apareix la paraula clau return. L’objectiu de les funcions és transformar les dades d’entrada en un valor de sortida. Quan s’ha calculat aquest valor es retorna el control al programa, amb la paraula return i el valor de retorn que ha d’utilitzar el programa que ha invocat la funció.
• Les línies 14 a 17 són el codi del programa principal.
• En la línia 17 s’invoca la funció. Des del programa es passa com a argument el valor de la variable entera dni. Aquest valor concret s’envia a la funció i se substitueix pel paràmetre dni_numeric.

• La funció acaba quan es recupera la identació del codi principal. En el nostre exemple, la darrera línia de la funció seria la 12. Habitualment és on hi és el return.

Quan ens referim a les entrades a una funció, de vegades ens hi referim com als arguments de la funció, i en altres ocasions com a paràmetres de la funció. Els dos conceptes estan molt lligats, però convé saber diferenciar-los, ja que és important que en comprengueu les diferències.

:~$ python3 dni_funcio.py 12345678
Z

Les diferències entre els paràmetres i els arguments són:

Paràmetres:

• Els paràmetres són els noms de les variables que es defineixen en la signatura d’una funció o mètode.
• Són utilitzats per definir els requisits de la funció i per especificar quines dades es necessiten per dur a terme una certa operació.
• Els paràmetres es defineixen quan es declara la funció o el mètode i són les variables locals dins del cos de la funció.
• Aquests paràmetres serveixen com a placeholders per les dades que s’esperen rebre quan la funció o mètode sigui cridat.

Arguments:

• Els arguments són les dades reals que es passen a una funció o mètode quan aquest és cridat.
• Són les instàncies o valors concrets que es passen a la funció o mètode perquè aquest pugui operar sobre elles.
• Els arguments es proporcionen quan es crida la funció o el mètode, i s’han d’ajustar als paràmetres definits en la signatura de la funció o mètode.
• Quan es crida una funció o mètode, els arguments s’associen als paràmetres segons l’ordre en què són passats o mitjançant noms de paràmetres (en el cas de les funcions amb arguments que tenen nom).

Els docstrings són útils per aclarir la funcionalitat d’una funció i proporcionar informació sobre com ha de ser utilitzada correctament. Són una part important de la documentació del codi i ajuden els altres programadors (o fins i tot a vosaltres mateixos en el futur) a entendre i utilitzar la funció de manera efectiva.

Un docstring s’escriu com una cadena de text multilínia entre tres cometes, i es col·loca just després de la definició de la funció, abans del cos de la funció.

abs(x, /)
    Return the absolute value of the argument.

def lletra_dni(num_dni):
	'''
	Funció que rep un nombre que representa un dni i retorna la lletra
	corresponent
	Entrada: int (nombre que representa un dni)
	Sortida: str (caràcter corresponent a una lletra en majúscula)
	'''

El docstring és un comentari, de manera que és transparent per al processador. No és necessari perquè es pugui executar el codi. Però serà obligatori en les funcions que definiu vosaltres en aquest curs. Si el nom de la funció és molt descriptiu, l’explicació es pot obviar. Però serà imprescindible d’ara endavant que cada funció vagi sempre acompanyada del seu docstring on quedi clar quins tipus de dades espera rebre la funció i quin serà el seu tipus de retorn.

El fet que el Python no sigui un llenguatge tipat permet que de vegades es defineixin funcions o que s’utilitzin sense tenir en compte per a quines dades estan pensades. El docstring serà el primer pas que haureu de fer en el moment de determinar les funcions d’un programa. Aquesta reflexió us ajudarà a trobar la solució idònia per implementar a cada programa.

L’objectiu principal d’una funció és crear una rutina o un procés, que sol finalitzar amb el càlcul d’un valor (tot i que ja sabeu que hi ha funcions que no retornen res, com la funció print()).

return s’utilitza dins del cos d’una funció per especificar el valor que la funció ha de retornar quan és cridada. Aquest valor pot ser qualsevol tipus de dada: nombres, cadenes, llistes, tuples, diccionaris, objectes, o fins i tot altres funcions.

Quan una funció arriba a la clàusula return, s’atura l’execució de la funció i el valor especificat després del return és retornat a la part del programa que ha cridat la funció. Això significa que la funció pot calcular o manipular dades i retornar el resultat perquè altres parts del programa l’utilitzi.

És important notar que una funció pot tenir més d’una clàusula return, però només es pot arribar a executar una d’elles per crida a la funció. Quan s’arriba a un return, la funció finalitza i retorna el valor especificat, saltant-se qualsevol línia de codi que pugui existir després del return.

Quan crideu una funció que heu definit en el mateix programa, heu de seguir el mateix procés que quan cridem funcions predefinides pel sistema, amb la diferència que abans cal haver definit la funció.

• Definició de la funció: primer, heu de definir la funció. Python permet definir funcions enmig del programam principal, però com que la llegibilitat és fonamental en aquest curs, cal que definiu les funcions abans del programa principal. La definició de la funció inclou el nom de la funció, els seus paràmetres (si n’hi ha), el docstring i el bloc de codi que defineix la funcionalitat de la funció.
• Crida a la funció: després de definir la funció, podeu cridar-la des d’altres parts del teu programa (inclòs dins d’una altra funció). Per cridar la funció, simplement escriviu el nom de la funció seguit dels parèntesis. Si la funció requereix arguments, introduïu-los dins dels parèntesis.
• Execució del codi de la funció: quan es crida la funció, el codi dins de la funció s’executarà amb els valors proporcionats com a arguments (si n’hi ha). La funció pot realitzar diverses accions i càlculs, i pot retornar un valor mitjançant la clàusula return.
• Utilització del valor de retorn (si n’hi ha): si la funció retorna un valor, aquest valor es pot utilitzar en altres parts del programa. Podeu emmagatzemar el valor de retorn en una variable o utilitzar-lo directament en altres càlculs o operacions.

Per acabar d’entendre el primer programa amb funcions, cal fer-ne un seguiment. Farem el seguiment del programa dni_funcio.py que podeu consultar a figura.

Recordeu que per a fer un seguiment s’ha d’escollir un cas concret i anar fent els càlculs que faria el processador, indicant com canvien els valors de les variables a cada instrucció. Quan el programa crida una funció, passa momentàniament el control a la funció. En el seguiment es representarà amb una taula a part (una funció és una subrutina; el procés de la funció és diferent del del programa). Quan s’ha obtingut el valor de retorn, se segueix amb el flux del programa. Les funcions no intervenen en el programa fins que no són cridades.

Un programa de Python (el programa principal) comença en la primera instrucció que es troba indentada més a l’esquerra (en la columna 1). En l’exemple que ens ocupa, el flux del programa principal s’inicia en la línia 15. Farem el cas en què per la línia d’ordres s’escriu la cadena '12345678' (recordeu que sys.argv és una llista de cadenes).

A la taula hi ha el seguiment del programa principal corresponent al programa dni_funcio.py que teniu a figura.

En la línia 15 es carrega el valor enter 12345678. Tot i que la funció sys.argv(1) és una cadena, el valor '12345678' de tipus str s’ha passat com a argument a la funció int(), que l’ha transformat en enter. Aquest valor enter s’ha desat a la variable dni.

En la línia 17 s’invoca a la funció lletra_dni, definida en el mateix fitxer. En aquest punt, el programa principal es queda a l’espera i es passa el control a la funció, de la qual fem el seguiment en la taula.

Fer un seguiment d’una funció és el mateix que fer el seguiment d’un programa, l’única diferència és que les dades, en comptes d’entrar per l’entrada estàndard (com amb input()), o per la línia d’ordres (com si s’utilitza sys.argv), entren com a arguments, amb un tipus i un valor concrets. Aquests valors es “carreguen” en els paràmetres, que actuen com una variable al llarg de la definició de la funció. Vegem-ho:

• En el nostre cas, el paràmetre num_dni de la línia 3 pren el valor 12345678, com a enter, que és el que li ha passat el programa principal en la línia 15 i que era el valor que tenia l’argument dni.
• En la línia 10 es crea la variable LLETRES_DNI.
• La línia 11 és una assignació a la variable pos. Cal calcular l’operació de la dreta. Primer s’ha d’aplicar la funció len() a la constant, que dona el resultat de 23 (hi ha 23 lletres). També s’ha de fer el càlcul 12345678 % 23. El resultat d’aquesta operació és 14 i és el valor que pren la variable pos.
• En la línia 12 es fa l’última operació i s’envia en valor de retorn. Primer es calcula quin és el caràcter que ocupa la catorzena posició (la lletra ‘Z’), i es retorna aquest valor al programa principal.
• En aquest moment cal anar a la taula i seguir allà on s’havia deixat: en la línia 17, en el punt en què s’havia cridat a la funció lletra_dni(). Aquesta funció retorna el valor 'Z'. Aquest valor es podria emmagatzemar per utilitzar més endavant, però s’ha optat per mostrar-lo per la sortida estàndard.
• En la taula, la filera corresponent a la línia 19 ha de mostrar 'Z' com a valor de sortida del programa.

Fixeu-vos que en aquest exemple, l’argument amb el qual es crida la funció es representa amb la variable dni, i, en canvi, el nom del paràmetre és num_dni. Eviteu costi el que costi que es diguin igual.

Una funció no és més que una part d’un programa i, per tant, s’han de codificar seguint la mateixa metodologia que s’utilitza per a un programa. Recordeu quins són els passos:

1. Entendre l’enunciat.
2. Fer un o diversos exemples a mà.
3. Fer el joc de proves i les especificacions d’entrada.
4. Fer el primer refinament.
5. Fer els refinaments successius.
6. Codificar.
7. Executar i comprovar el joc de proves.
8. Fer el seguiment dels fragments que siguin necessaris per identificar i resoldre errors.

Les especificacions d’entrada, en el cas de les funcions, es contemplen en el docstring. Quan es defineix una funció, el primer que s’ha de fer sempre és pensar en un nom adequat i definir el docstring de la funció. De la mateixa manera, abans de codificar és necessari definir un joc de proves, i abans de codificar, també caldrà fer el refinament en l’editor de text. El que modificarem una mica amb les funcions serà la verificació del codi amb l’execució del joc de proves, creant un test-driver per comprovar la funció.

El test-driver, o controlador de proves, és una estratègia de desenvolupament de programari utilitzada per provar funcions, mètodes o components de codi de manera sistemàtica. En l’àmbit de les funcions, el test-driver és un petit programa que crida la funció que volem provar amb diversos conjunts d’entrades i comprova si les sortides són les esperades (verifica el joc de proves).

Abans d’utilitzar una funció en un programa cal fer-ne i comprovar el test-driver. A banda de verificar la funció, servirà com a documentació de la mateixa: el joc de proves quedarà documentat amb el test-driver de la funció.

def lletra_dni(num_dni):
	'''
	Funció que rep un nombre que representa un dni i retorna la lletra
	corresponent
	Entrada: int (nombre que representa un dni)
	Sortida: str (caràcter corresponent a una lletra en majúscula)
	'''
	LLETRES_DNI = 'TRWAGMYFPDXBNJZSQVHLCKE'
	pos = dni % len(LLETRES_DNI)
	return LLETRES_DNI[pos]

# Test-driver
lletra_dni(12345678)
lletra_dni(23456780)

Després d’estudiar aquest exemple és molt possible que us pregunteu què guanyeu definint funcions per programar. Podeu pensar, inclús, que no fan més que embolicar i enterbolir el programa.

A continuació teniu un llistat dels avantatges de programar de manera modular (és a dir, separant les coses en mòduls). Una funció no és més que una part del programa que s’ha modulat i s’ha programat de manera independent.

En l’exemple del càlcul del DNI, s’ha separat del programa el codi del càlcul. Permet centrar l’atenció en la globalitat sense perdre’s en els detalls. Aquest programa és molt senzill, però al llarg de la unitat formativa anireu creant programes, amb moltes línies de codi. Apartar les instruccions que defineixen les funcions us ajudarà molt a fer-vos una idea del funcionament d’un programa només amb una mirada ràpida.

Quan es repeteixen un seguit d’instruccions que tenen un objectiu comú en un programa podem evitar reescriure tot el codi si definim una funció. Si en un altre punt del programa fos necessari calcular la lletra d’un altre DNI, no caldria repetir el codi. Només cridant la funció amb un nou argument ja n’hi hauria prou.

Les funcions permeten reutilitzar codi de manera molt més fàcil que com ho fèiem fins ara (retallant i enganxant). Però calia anar amb compte amb els noms de les variables, la indentació i tenir molt clar quina era la primera i última línia que ens calia retallar. Les funcions són fragments de codi independents i molt més fàcils de reutilitzar.

El càlcul de la lletra es podria utilitzar, per exemple, en una funció que calculi si un DNI és correcte o no. Aquest seria un cas en què una funció és cridada per una altra funció, on fa una feina molt específica.

Si per una estranya raó es decidís modificar la cadena del càlcul del DNI, només caldria fer-ho en la funció on es defineix la lletra, deixant intacte el codi de tots els programes que l’utilitzen. Separar les funcionalitats d’un programa permet que si cal modificar o millorar una part es pugui fer sense afectar als programes o aplicacions que l’utilitzen.

Modular és dividir un programa en diversos mòduls o blocs. Les funcions ens permeten modular i així organitzar el codi en parts més senzilles de programar. Fer una funció que calculi la lletra d’un DNI i després utilitzar-la en un programa (o millor en una altra funció) que validi si el DNI és o no correcte, és més senzill que pensar un programa que ho faci tot de cop.

En últim lloc, tot el codi que utilitzem dins d’una funció està encapsulat. Les funcions només s’executen si són cridades des del programa principal. Processen les seves instruccions i retornen un resultat a la part del codi del programa principal que les ha invocat. Els valors d’aquestes variables internes són locals i no entren en conflicte amb la resta del programa, ni que tinguin els mateixos noms.