Diferència entre revisions de la pàgina «ASIX-M3-UF2-A1»

Revisió del 19:58, 4 gen 2021

Descomposició funcional

• L’objectiu serà resoldre el problema general com a una suma de subproblemes més petits.

• La solució a cada subproblema s’anomena subrutina o subprograma, i a Java, mètode.

• Permet la reutilització del codi, facilita la seva lectura i el seu manteniment.

• Escriure codi més genèric facilita la seva reutilització.

Disseny descendent

• El mètode del disseny descendent consisteix en descompondre el problema a resoldre en altres més senzills. A aquests se'ls aplica el mateix procediment fins arribar a problemes prou petits que podem resoldre directament.

• Refinament de l’algorisme (stepwise refinement) és com es coneix aquest procediment de descomposició.

• Representació en forma d'arbre:

- Cada node és un mòdul, o problema, o solució hipotètica.

- Cada subarbre depenent d'aquest node es fa servir per a la resolució d'aquest subproblema.

- El node del nivell més alt és el problema de partida.

- L’algorisme serà correcte si la solució que es dóna a cada nivell ho és.

- El programa es pot construir de sota a dalt creant primer procediments que resolguin els mòduls de detall que, un cop comprovats seran utilitzats per altres procediments més generals fins a arribar a la creació del programa.

Reutilització de subproblemes resolts

• La descomposició mitjançant disseny descendent permet reaprofitar la solució de subproblemes idèntics, o força semblants.

• Qualsevol subproblema d’un nivell donat pot ser part de qualsevol subproblema d’un nivell superior. Per remarcar

• En descompondre un problema, s'ha d'intentar fer-ho de manera que es forci l’aparició de subproblemes repetits, i així la seva resolució es pot reaprofitar en diversos llocs.

Aplicació correcta del disseny descendent

Diferents persones poden arribar a conclusions diferents sobre com dur a terme la descomposició. Entre totes les solucions diferents possibles, algunes es poden considerar millors que d’altres. De fet, res impedeix, partir d'una solució concreta i aplicar refinaments que la millorin.

Criteris per a l'avaluació de la descomposició:

• Si un problema que sembla a priori força complex es descompon en molts pocs nivells, potser val la pena fer una segona ullada. Inversament, si un problema no massa complex té massa nivells, potser s’ha anat massa lluny en la descomposició.

• Veure si el nombre de passes incloses a cadascun dels subproblemes no és excessivament gran i és fàcil de seguir i entendre. En cas contrari, potser encara faria falta aplicar nous nivells de descomposició.

• Repassar que els noms assignats als subproblemes siguin autoexplicatius i expressin clarament la tasca que estan resolent. Sense ni tan sols llegir les seves passes, caldria entendre perfectament què s’assoleix en resoldre’ls. En cas contrari, potser la descomposició no està agrupant conjunts de passes realment relacionades entre elles.

• Si absolutament cap dels subproblemes és reutilitzat enlloc, especialment en descomposicions en molts nivells, és molt possible que no s’hagi triat correctament la manera de descompondre alguns subproblemes.

• Vinculat al punt anterior, l’aparició de subproblemes molt semblants o idèntics, però tractats per separat en diferents llocs, també sol ser indici que no s’està aplicant la capacitat de reutilitzar subproblemes correctament.

Programació modular

La programació modular consisteix en dividir un programa gran i/o complex en subprogrames més petits o simples, aconseguint fer-lo més comprensible i manejable. Per això, s'implementen funcions, classes i mòduls.

Funció

Funcions

• Bloc de codi amb un nom associat.
• Pot rebre zero o més arguments com a entrada.
• Por retornar un valor i/o realitzar una tasca.
• L'ús de funcions permet fer una programació estructurada:

• modularització: segmentar un programa complex en mòduls més simples facilitant la programació i la depuració.
• reutilització: una mateixa funció es pot utilitzar des de diferents punts d'un programa i també des de diferents programes.

• Python disposa de moltes funcions integrades i permet la creació de funcions per part dels programadors.

• Sintaxi:

def nomFuncio(arg_1, arg_2, ..., arg_n):
    ...
    return value

• Els arguments es passen per valor: si canvien el seu valor dins de la funció, no canvien "a fora".
• Per modificar variable no locals a la funció, cal definir-les com a globals en la primera línia.

def nomFuncio(arg_1, arg_2, ..., arg_n):
    global var_1, var_2
    ...
    return value

Exemple senzill:

>>> def salutacio(nom):
...     print("Hola "+ nom + "!")
...
>>> salutacio("Pep")
Hola Pep!

Mòduls

Moduls

__init__

• Un mòdul és un arxiu amb un codi independent i una determinada funcionalitat.
• Pot ser utilitzat per qualsevol aplicació.
• Es poden utilitzar mòduls propis de python, de tercers o propis.
• Conté funcions, classes, definicions, ...
• Per poder utilitzar un mòdul s'ha d'importar prèviament.

import modul    # 'modul': nom del mòdul a importar

• Si volem importar només algunes parts del mòdul:

from modul import funcio_1, funcio_2   # 'funcio_x': funcions del mòdul.

Paquets

• S'utilitza per organitzar els mòduls.
• Pot contenir mòduls i altres paquets.
• Per tractar un directori com a paquet cal que contingui el fitxer __init.py__
• __init.py__ pot:

• estar buit.
• contenir codi d'inicialització del paquet.
• contenir el conjunt de variables __ALL__.

jocCombat /
|-__init__.py
|-regles /
    |-__init__.py
    |-monedes.py
    |-lluitador.py
    |-bestiari.py
    |-combat.py
|-interficie /
    |-__init__.py
    |-entradaTeclat.py
    |-sortidaPantalla.py

• Es poden importar submòduls individualment:

>>>import jocCombat.regles.lluitador                # Càrrega el mòdul lluitador
>>>jocCombat.regles.lluitador.danyar(lluitador, 2)  # Cal fer referència al nom complert

• Es pot importar el submòul:

>>>from jocCombat.regles import lluitador           # Càrrega el mòdul lluitador
>>>lluitador.danyar(lluitador, 2)                   # No cal utilitzar el prefix del paquet

• Es poden només les funcions que necessitem:
• Es pot importar el submòul:

>>>from jocCombat.regles.lluitador import danyar    # Càrrega la funció lluitador
>>>danyar(lluitador, 2)                             # Utilitzem directament la funció

• La forma from jocCombat import * importaria tots els submòduls:

• En general, no és recomanable.
• Pot ser massa lent.
• Pot tenir efectes no desitjats.
• Es pot definir una llista anomenada __all__ amb els mòduls que s'importaran quan s'utilitzi import *-
• Per exemple, si l'arxiu jocCombat/regles/__init__.py conté el codi:

__all__ = ["llluitador", "bestiari"]

• Aleshores:

>>>from jocCombat.regles import *    # només s'importaran els mòduls de la llista __all__

Diagrames de flux

Els diagrames de flux es poden utilitzar per representar gràficament una seqüència ordenada de passos lògics per fer una tasca. Per fer aquesta representació, s'utilitzen un conjunt de símbols en els que es descriuen els passos a fer.

Abans de fer un diagrama de flux es convenient fer un algoritme que descrigui quins són els passos a seguir per fer la tasca.

• Algoritme: Passos ordenats per fer una tasca.

• Diagrama de Flux: Representació gràfica amb símbols de l'algoritme.

Un cop tenim l'algoritme / diagrama de flux, haurem de fer el programa utilitzen les ordres corresponents del llenguatge de programació emprat.

• Símbols emprats:

• Regles:

1. Tots els símbols han d'estar connectats.

2. A un símbol d'un procés poden arribar varies línies.

3. A un símbol de decisió poden arribar varies línies, però només poden sortir dos (Sí o No, Cert o Fals).

4. A un símbol d'inici no poden arribar línies.

5. D'un símbol fi no surt cap línia.

Los símbolos que se usan para realizar los diagramas de flujo son lo siguientes:

- En el Símbolo de decisión puede tomar los valores de salida SI o NO o también VERDADERO o FALSO.

- El símbolo de Inicio o Final del Diagrama puedes ser un cuadrado con los bordes redondeados o una elipse.

- Se pueden utilizar colores para lo símbolos. Ejemplos de Diagramas de Flujo