Informatica ed elementi di programmazione I, Appunti di Elementi di Informatica

Scarica Informatica ed elementi di programmazione I e più Appunti in PDF di Elementi di Informatica solo su Docsity!

Appunti di Informatica ed elementi di programmazione I

Docenti: Radoslaw Niewiadomski Maurizio Boscaini Appunti di: Mussetti Giulia

LEZIONI DI TEORIA – Radoslaw Niewiadomski

INDICE

1. Intro, Ambiente di sviluppo, Programma, Algoritmo…………………………………………………

2. Comandi base di disegno…………………………………………………………………………………………

3. Codifica di immagini, Colori………………………………………………………………………………………

4. Funzioni, Animazioni………………………………………………………………………………………………..

5. Variabili, Operatori, Debugging……………………………………………………………………………….

6. Bit, La memoria delle immagini……………………………………………………………………………….

7. Condizioni………………………………………………………………………………………………………………

8. Iterazioni, Cicli………………………………………………………………………………………………………..

9. Codifica di numeri e caratteri…………………………………………………………………………………

10. Eventi…………………………………………………………………………………………………………………….

11. Arrays…………………………………………………………………………………………………………………….

12. Programmazione ad oggetti…………………………………………………………………………………..

Lezioni di pratica – Maurizio Boscaini……………………………………………………………………………

COMANDI………………………………………………………………………...…………………………………………..

ESERCIZI..………………………………………………………………………...…………………………………………… 99

TIP : Ti consiglio, alla fine di ogni capitolo, di eseguire gli esercizi che trovi alla fine di questo pdf. Sono più o meno ordinati come gli argomenti trattati nella parte teorica. Ti possono servire a fissare meglio le conoscenze o a capire meglio qualcosa che magari ti è sfuggito.

ALGORITMO

*ALGORITMO = {Risoluzione di un problema attraverso una sequenza di passi discreti, ordinati, finiti e ripetibili(ogni volta che lo faccio, arrivo sempre allo stesso risultato).} Un algoritmo ha 5 PROPRIETA':

• Atomicità: ogni passo non deve essere ulteriormente scomponibile
• Non ambiguità: interpretazione univoca
• Finitezza: numero finito di passi
• Terminazione: tempo finito
• Effettività: risultato univoco, se così non è, ci sarà un errore ALGORITMO ≠ PROGRAMMA:

Un algoritmo è una procedura computazionale intelligibile dall'uomo.

Un programma è una procedura computazionale comprensibile dalla macchina.

Nella nostra vita usiamo tanti algoritmi (es. ricette culinarie) e vengono quasi sempre espressi in un

linguaggio umano. Quando questi algoritmi vengono codificati in un linguaggio di programmazione,

creiamo un programma basato su quell'algoritmo.

ES: Algoritmo di calcolare la media matematica= (1+2+3+4+5)/5=?

Programma che calcola la media matematica=

float media=somma/temp.length;

ESPORTAZIONE

Qualsiasi programma venga scritto con Processing, poi può

essere esportato seguendo il percorso: File - Esporta applicazione

• Selezionare il sistema operativo - Esporta

A questo punto sarà possibile condividerlo e utilizzarlo su

qualsiasi computer con quel sistemaoperativo, senza la necessità

di aver installato Processing

Questa operazione è possibile solo se il programma è stato prima

salvato da qualche parte. Nellastessa cartella del programma, ora

c'è anche un file del tipo nomeProgramma.java.

È un file testuale. Aprendolo comparirà il nostro programma in codice java "puro", ovvero non

mediato da un ambiente di sviluppo, come Processing. Infatti, analizzandolo vedremo che ci

sonodelle parti in più, che normalmente Processing ci risparmia.

Inoltre, da questo file possiamo vedere che il nostro intero programma è diventato una classe

(vedilezione sulle classi).

2) Comandi base di disegno

INTRO

Questi comandi sono SPECIFICI di Processing, non appartengono a JAVA, ma sono stati aggiunti per facilitare lacreazione di prodotti grafici. In processing, come in Java, OGNI COMANDO deve essere chiuso da ; La CANVAS è una finestra di output grafico di dimensioni standard 100x100: Le dimensioni si possono modificare con size(x,y); X= n. di pixel su una riga. X cresce andando verso destra e diminuisce verso sinistra. Y= n. di pixel su una colonna. Y cresce andando verso il basso e diminuisce verso l'alto. Può essere vista come un PIANO CARTESIANO in cui il punto (0,0) è il primo pixel in alto a sinistra. Quando vogliamo disegnare qualcosa, quindi, dobbiamo indicare DOVE lo vogliamo utilizzando appunto le coordinate di questo piano. ES: size(300,200); sarà una canvas larga 300 pixels e alta 200. point (150, 100); disegnerà un punto in mezzo al canvas É POSSIBILE disegnare FUORI dal canvas, ma ciò che disegniamo non verrà visualizzato.

ES: point (-150, 300);

Aumentando le dimensioni di canvas è possibile vedere ciò che prima era fuori dal margine destro e sottostante. Ma non potremo MAI vedere elementi che escono dal margine sinistro o superiore (come in questo caso). ELEMENTI BASE DI GRAFICA Con tanti punti è possibile creare delle linee, con delle linee è possibile creare delle figure. Ma ci sono dei comandi che ci semplificano il lavoro: vedi "Comandi". Le figure vengono di default colorate di bianco, ma è possibile cambiare colore con il comando fill (r,g,b);. Non è possibile però colorare una figura che abbiamo creato utilizzando solo punti o linee. ES. di un prodotto grafico semplice con questi elementi:

I principali tipi di spazio colore sono:

• RGB (rosso, verde, blu): è adattivo , ed è il più conosciuto e usato nella tecnologia. Ogni colore, qui, viene identificato da 3 numeri: il valore della sua componente rossa, il valore della sua componente verde e il valore di quella blu. Ognuna di queste componenti può assumere valori da 1 a 255 (256 valori x 3). É facileutilizzarlo per i colori più semplici, ma per colori più complessi/ricercati è difficile ricordarsi tutte le componenti.
• CMY(K) (ciano, magenta, giallo, (nero)): è sottrattivo, ed è quello utilizzato dalla stampa. Non sempre c'è ilnero: si può creare con l'unione dei 3 colori, però è più dispendioso.
• HSL (tinta, saturazione, luminosità) /HSB (tinta, saturazione, brightness) /HS*: è più intuitivo se devo "indovinare" il colore che mi serve. Normalmente, la tinta varia da 0 a 360. Invece s e b da 0 a 100 (S=0: grigio / S=100: colore vivido. B=0: nero B=100: bianco) RICORDA: usare il comando per il colore PRIMA dell'oggetto che voglio colorare. Il tool in Strumenti - Selezionatore di colori ci dice quali sono le 3 componenti di r, g e b da utilizzare. Oppure le 3 componenti h, s, e b. Altrimenti si può fare copia-incolla del codice esadecimale (ES: #FFFFFF). É possibile passare da una modalità all'altra di spazio colore, oppure modificare il range dei valori con il comando colorMode (RGB, 100,100,100); INOLTRE, a prescindere dallo spazio colore scelto, è possibile utilizzare un quarto parametro (0-100) che indica la trasparenza.

4) Funzioni, Animazioni

FUNZIONI

Se nel nostro programma non utilizziamo alcuna funzione, come tutti i comandi visti fino ad ora, avremo uno static sketch , altrimenti un dinamic sketch. Non è possibile mischiare sketch static con dinamici, quindi o solo funzioni o nessuna funziona. FUNZIONE = {Pezzo di codice che ha un nome e può essere richiamato all'interno del programma.} Fa lo stesso lavoro delle variabili, ma:

• VARIABILI: memorizzano un valore, una lettera, una singola cosa
• FUNZIONI: memorizzano un intero pezzo di codice Sono utili per:
• La leggibilità del codice
• Riusabilità
• Evitare ripetizioni
• Più facile da correggere "Funzioni" già esistenti sono: line (), size (), ecc. É possibile anche CREARE nuove funzioni Come creare una nuova funzione? Return type Nome Variabili: parametri di input (non obbligatorio) La sequenza di comandi della funzione è delimitata dalle parentesi graffe Come riutilizzare la funzione nel programma? Basta chiamarla per nome e dare un valore alle variabili di input. Si può richiamare tutte le volte che si vuole Vengono chiamate "Funzioni" proprio per l'analogia esistente con le funzioni matematiche: da un input d'ingresso (x), fornisce un output (y).

Il risultato cambia (la pallina viene ogni volta CANCELLATA dallo sfondo E DISEGNATA IN UN POSTO DIVERSO, creando un'animazione "senza residui"): La pallina continuerà all'infinito, anche fuori dal canvas. Se volessi farla riiniziare da capo, una volta raggiunto l'angolo in basso a destra, basta limitare x e y con %: x=x+1; y=y+1; x=x % width; y= y % heigth; Ora un esempio un po' più complesso: int y = 0; // dichiaro la variabile che userò per l'altezza delle linee int grey = 0; //dichiaro la variabile che userò per il colore delle linee void setup(){ size(250,250); //imposto le dimensioni di canvas } void draw(){ //imposto il colore delle linee con la variabile. In questo caso, a differenza del primo,è essenziale che questo comando sia in draw, e non in setup. Perché a differenza di prima, ora ilcolore cambierà. stroke(grey); line (0,y,100,y); //imposto le coordinate della linea, che cambierà solo la sua posizione in altezza y = y+1; //ogni volta che draw è chiamato, y è incrementato di 1 (quindi ogni volta la linea è disegnata un pixel più giù) y = y % 125; //imposto il limite dell'altezza della linea: la linea non verrà disegnata oltre il 125° pixel, ricomincerà da capo grey = grey+1; //faccio in modo che anche il colore incrementi: da 0 (nero) fino a… grey = grey % 250; //imposto il massimo gradiente del colore a 250. Arrivato al 250° grado di grigio, ripartirà da 0 } Notiamo che il limite del colore è il doppio di quello di Y, quindi il colore ripartirà ogni 2 cicli completi di linee.

FUNZIONI PERSONALIZZATE

Sono molto utili quando vogliamo ripetere una cosa uguale in diversi posti del canvas. Permette anche di ridurre la lunghezza del codice e permette di trovare facilmente errori. Come creare una nuova funzione? Ricordare che le nuove funzioni vanno CREATE fuori da setup e draw. Poi può anche essere richiamata e utilizzata in setup o draw. CREARLA returnType funcion_name (type param1, type param2, ecc.) { Intestazione Statements; Corpo della funzione } RICHIAMARLA (in draw o setup) funcion_name (param1, param2, ecc.); Qui assegno un valore numerico ai parametri (parametri attuali) (o argomenti), se ci sono

• Returntype: può essere un valore (int float, ecc.) oppure un disegno in canvas (void)
• Nel nome non ci devono essere spazi e non deve iniziare con un numero.
• Input parameters: Qui posso dichiarare le variabili - parametri formali (o parametri) (non obbligatorio, es. in draw sono vuote). Sono LOCALI, quindi esistono solo nella funzione. Non sono obbligatori, ma sono molto utili appunto per parametrizzare la funzione, ovvero permettere che questa funzione possa funzionare con qualsiasi parametro, modificabili quando la funzione viene richiamata. Se però vengono dichiarati tot parametri formali, devono esserci tot parametri attuali, altrimenti apparirà un messaggio d'errore
• Statements: possono utilizzare i parametri che verranno utilizzate nella funziona. Nel caso in cui il returntype sia un valore (int, float, ecc.) alla fine della mia funzione devo inserire la parola chiave return (); ES: Voglio disegnare tanti occhi. Prima di tutto ne devo disegnare uno e crearne il codice:

5) Variabili, Operatori, Debugging

VARIABILI

RICORDIAMO CHE: QUALSIASI file alla fine viene riportato a sequenze di 0 e 1. Ma diversi tipi di DATI richiedono diversi tipi di memoria per essere memorizzati. Quando vogliamo chiedere al computer di memorizzare qualcosa ci occorre una VARIABILE, che ha un nome che ci permette poi anche di richiamarla. É come dare un nome ad un cassetto e ci metto le informazioni: alla fine trovo l'informazione che mi serve cercando il nome della variabile/cassetto corrispondente (ES: età, nome, ecc.). É possibile dichiarare e utilizzare quante variabili vogliamo all'interno dello stesso programma, a patto che abbiano tutte un nome diverso (ad esclusione di quelle all'interno di un blocco*, ma anche dentro ad uno stesso blocco se ho più di una variabile devono avere un nome diverso). VARIABILE: type name_newVariable = value; *SCOPE OF A VARIABLE = { Un identificatore è un nome che nel programma identifica i suoi elementi costitutivi.}

• variabili
• costanti
• funzioni/metodi
• classi L'ambito di visibilità di un identificatore determina la parte di programma dove esso può essere utilizzato, quindi dove è conosciuto. Ogni volta che viene dichiarata una variabile, è importante vedere DOVE è dichiarata, in base a questo ne esistono di due tipi:
• GLOBALI: sono dichiarate fuori da ogni parentesi, solitamente all'inizio del programma. Ha una visibilità globale
• LOCALI: sono dichiarate in una parentesi (tonda, come ad esempio in for, o graffa come ad esempio in setup o qualsiasi altra funzione). Ha una visibilità limitata al blocco (una parte di programma delimitatadalle parentesi graffe) in cui viene dichiarata È possibile avere due variabili con lo stesso nome, a patto che non siano entrambe globali o non siano entrambe locali della stessa funzione. In questo caso può essere difficile capire quale variabile stiamo chiamando. È bene sempre ricordare che println() o il debugger sono strumenti utili per capirlo, se non si è sicuri. Però in linea generale:
• Se esiste un'unica variabile globale con quel nome: posso chiamarla ovunque voglio all'interno del programma
• Se esiste un'unica variabile locale con quel nome: posso chiamarla solo nella funzione in cui è stata dichiarata. All'infuori della chiusura della graffa non esisterà più.
• Se esiste una variabile locale e una globale con lo stesso nome: mi "risponderà" quella locale
• Se esistono più variabili locali con lo stesso nome (una funzione dentro l'altra), anche qui mi risponderà quella più vicina ES:

I tipi di variabili principali sono:

• int (indica numeri interi)
• float/double (indicano numeri decimali)
• boolean (può avere solo due valori: true o false)
• char (indica un carattere, es lettera o carattere speciale)
• void (restituisce un disegno sulla canvas. Usata nelle funzioni- vedi sotto) ES. int point_x = 50; OPPURE: int point_x; prima dichiara il tipo e il nome della variabile, quindi "prenota" un posto inmemoria point_x = 50; poi assegna un valore alla variabile È necessario DICHIARARE sempre una variabile prima di usarla, quindi dire di che tipo è e come si chiama. Non è possibile inserire un valore di un certo tipo dentro una variabile che è stata dichiarata di un tipo "più piccolo". ES: NON SI PUO' FARE int point_x = 50.68; MA SI PUO' FARE float point_x = 50; boolean > byte > char > int > long > float > double 1 bit > 8 bit > 16 bit > 32 bit > 64 bit > 32 bit > 64 bit Utilizzando le variabili io poi possono richiamarle quando voglio, semplicemente scrivendo il loro nome.Non è possibile utilizzare, richiamare una variabile a cui non sia stato affidato un valore. Posso cambiare quando voglio il valore alla variabile, ma il suo valore precedente andrà perso. ES. int point_x = 50; point_x = 30; da adesso in poi la variabile vale 30, non più 50 Esistono alcune variabili di default: width, heigth che fanno riferimento alla larghezza e altezza di canvas. Questo può essere utile perché permette di riutilizzare sempre lo stesso codice per disegnare la stessa cosa, ma in posizioni diverse. ES:

Questi operatori sono molto utili applicati alle variabili: ES: int x = 0; x= x+1; funziona "da destra a sinistra": prima aggiunge 1 al valore della variaibile x, 0. Poi assegna il risultato di questa somma di nuovo ad x, quindi ora x non varrà più 0, ma 1. Lo stesso vale per x--; x-=1; x=x-1; La differenza però sta nel se metti prima ++/-- o prima x:

• a++ = prima viene chiamata la variabile, poi viene aumentata di uno
• ++a = prima c'è l'aumento, poi viene chiamata la variabile e le viene applicato l'incremento che c'è stato ES: b vale 1 all'inizio. c vale 1, prima assegno, poi incremento. Sotto c vale 2, perché prima viene incrementata e poiassegnata. Operazioni tra variabili:
• int e int = int
• float e float = float
• int e float = float DEBUGGING Significa "cercare, trovare e possibilmente risolvere gli errori", i bug. Esistono 3 tipi di errori:
• Errori di compilazione/di sintassi: facili da trovare, vengono anche segnalati dalle ondine rosse e da un messaggio rosso sulla console. Quando ci sono questi errori il programma non può nemmeno essere lanciato. Di solito il messaggio in console è chiaro e permette di risolvere subito, altrimenti si può googlareo cercare sul reference di Processing (link nei comandi) (es. int x=3.14; cerco di mettere un float dentro unint)
• Errori di esecuzione (runtime/eccezioni): durante l'esecuzione del programma si ferma e dà il messaggio di errore. Anche qui si può utilizzare Google, il reference di Processing oppure il Debugger. (es. int x= 1/0. E'giusto a livello di compilazione, quindi il programma viene lanciato, ma si ferma perché non è possibile dividere per 0). Questi possono essere sempre presenti o occasionali. Nel primo caso sono più facili da individuare, nel secondo caso anche impossibili (ad es. se il programma viene sempre testato con valori che non dannoproblemi)
• Errori di logica: il programma funziona, ma non abbiamo il risultato che desideravamo. Sono molto difficilida trovare e risolvere Un semplice metodo per scovare gli errori è utilizzare println(); per vedere come cambiano le variabili ad ogni ciclo. Altrimenti si può utilizzare il debugger di Processing, che permette di analizzare il programma in slow motion e punto per punto, per vedere ad ogni singolo passo come cambia il valore della variabile.

Come utilizzare il Debugger?

1. Cliccare sull'icona della farfalla:
2. Si aprirà una finestra vuota:
3. Cliccare sul numero della linea (che diventerà un diamantino) da cui vogliamo partire per fare il debugging (break-point)
4. Cliccare su "run" per far partire il programma. Si fermerà automaticamente al break-point. Da lì in poipossiamo procedere step by step con il secondo pulsante in alto a sinistra:
5. Analizzare ciò che compare nella finestra "Variabili":

ES:

Ho un'immagine di 7x4 pixel in bianco e nero (1 bit). Ma se aumento la risoluzione e ho un'immagine di 14x pixel in gradazioni di grigio. Se voglio invece aumentare, anziché la risoluzione, che resta 7x4 pixel i livelli di colore (con 256 livelli di grigio (8bit) anziché bianco e nero (1 bit)); Infine, se voglio avere la mia immagine a colori (256x3, quindi 3x8 bit), a parità di risoluzione: PER CODIFICARE UN VIDEO, invece, oltre alla risoluzione (XxY pixel) e al colore, bisogna tenere in considerazione la durata del video (in secondi) e la sua qualità (in FPS), che se non viene specificata, solitamente in Europa è di 25FPS: Per convertire da bit in megabyte:bit/8 e poi /1.000. Quindi: BIT NECESSARI = LARGHEZZA X ALTEZZA X COLORE X SECONDI X FPS

7) Condizioni

ISTRUZIONI CONDIZIONALI

Sono fondamentali nell'esecuzione di un algoritmo, e quindi anche di un programma. Permettono al programmatore per specificare che una parte di codice viene eseguita SOLO SE alcune condizioni sono vere, altrimenti quella parte di codice verrà ignorata e si passerà a ciò che sta dopo la chiusura della graffa dell'istruzione condizionale. if (condition) { statements; } COME SCRIVERE LA CONDIZIONE tra parentesi tonde: Deve essere una frase che può essere valutata come vera o falsa, quindi solitamente consiste in un paragone tra due elementi, con un operatore relazionale (vedi Sett. 2) È possibile esprimere più di una condizione nelle parentesi tonde:

• ((condizione 1) && (condizione 2)) se voglio che entrambe siano verificate
• ((condizione 1) || (condizione 2)) se basta che solo una delle due sia verificata E' anche possibile scrivere più di un'istruzione condizionale di seguito all'altra, ad esempio per far cambiare colore ad una pallina nel tempo. Quindi le tre istruzioni sono SEQUENZIALI: int x = 0 ; dichiaro la variabile, che sarà il mio contatore void draw (){ if (x>100) { la prima condizione: quando x supera il 100, allora fill(0,255,0); la pallina sarà verde } if (x>200) { la seconda condizione: quando x sarà oltre i 200, fill(255,0,0); la pallina diventerà rossa } ellipse(50,50,10,10); x=x+1; grazie a questo comando, inserito dentro il draw, ogni volta la mia x viene incrementata di 1, quindi per le prime 100 volte che } viene eseguito sarà verde e dalla duecentesima in poi rosse Questa istruzione può anche essere utilizzata, ad esempio, per riportare il programma al punto inziale. Ad esempio, una pallina, con certo di coordinate x, y, che faccio viaggiare per tutto il canvas, posso farla tornare alpunto di partenza con: x=x % width; Oppure con if: if (x>=width) { quando la pallina avrà raggiunto il bordo destro: x=0; la pallina ricomincerà dal bordo sinistro } È possibile usare un if dentro l'altro quante volte si vuole, a patto che vengano tutte chiuse correttamente le graffe. È anche possibile scrivere un if senza parentesi graffe, ma in quel caso, se la condizione è falsa, non verrà eseguita solo la prima istruzione subito dopo. Se abbiamo bisogno per un'unica situazione, di più di due casi diversi, o usiamo tanti if in sequenza, oppure possiamo usare: