ASIX-M3-UF2-A1

De wikiserver
Dreceres ràpides: navegació, cerca

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.
Disseny modular

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
Disseny modular
  • 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

Un diagrama de flujo, también llamado Flujograma de Procesos o Diagrama de Procesos, representa la secuencia o los pasos lógicos (ordenados) para realizar una tarea mediante unos símbolos. Dentro de los símbolos se escriben los pasos a seguir.

Los diagramas de flujo representan la secuencia lógica o los pasos que tenemos que dar para realizar una tarea mediante unos símbolos y dentro de ellos se describen los pasos ha realizar.

Un diagrama de flujo debe proporcionar una información clara, ordenada y concisa de todos los pasos a seguir.

Por lo dicho anteriormente, podríamos decir que: "Un diagrama de flujo es una representación gráfica o simbólica de un proceso".

El proceso o pasos que representa el diagrama de flujo puede ser de cualquier tipo, desde los pasos para freír un huevo, como luego veremos, hasta los pasos para realizar un enorme programa informático.

Muchas veces antes de realizar un diagrama de flujo se realiza un "Algoritmo" del problema o proceso a desarrollar. Un algoritmo describe una secuencia de pasos escritos para realizar un tarea. El Diagrama de Flujo es su representación esquemática.

Algoritmo: Escribir los pasos ordenados a realizar para solucionar el problema.

Diagrama de Flujo: Representación mediante un esquema con símbolos del algoritmo.

Los diagramas de flujo son una excelente herramienta para resolver problemas, comprender el proceso a seguir así como para identificar posibles errores antes del desarrollo final de la tarea. Cómo Hacer un Diagrama de Flujo Normalmente para realizar un diagrama de flujo primero se hace lo que se llama el algoritmo. Un algoritmo es una secuencia de PASOS LÓGICOS a seguir para resolver un problema de forma escrita.

¿Para qué se Usan los Diagramas de Flujo?

Se usan para hacer un programa informático, para analizar lo que tiene que hacer un robot, en los procesos industriales, etc.

Un diagrama de flujo es útil en todo aquello que se necesite una previa organización antes de su desarrollo.

En la realización de un programa informático es imprescindible primero realizar el diagrama de flujo, independientemente del lenguaje de programación que usemos después. Una vez que tenemos nuestro diagrama de flujo solo tendremos que conocer las órdenes del lenguaje que realizan esas tareas que se especifican en el diagrama.

Reglas y Símbolos Para la Construcción de un Diagrama de Flujo

1. Todos los símbolos han de estar conectados

2. A un símbolo de proceso pueden llegarle varias líneas

3. A un símbolo de decisión pueden llegarle varias líneas, pero sólo saldrán dos (Si o No, Verdadero o Falso).

4. A un símbolo de inicio nunca le llegan líneas.

5. De un símbolo de fin no parte ninguna línea.

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