Appunti Fondamenti di Informatica

� La funzione non viene eseguita fino a quando non

viene chiamata.

Modello Run time fa due cose:

-istruzione

*assegnazione variabile num.

*invocazione funzione fattoriale, quando invochiamo la

funzione nel modello si crea un puntatore ad uno spazio

locale della memoria, quando apre lo spazio di memoria ad

x viene sostituito il numero preso da tastiera

*assegnazione fatt=1

*ciclo for i=1,2,3,4(all'uscita del for fatt sarà 24)

*chiusura della funzione con fatt=24( quando la funzione

termina a livello della memoria, lo spazio della memoria

scompare, della funzione rimane solo i return che se lo

prende il print viene quindi solo visualizzato)

- in memoria si crea una variabile di tipo num

MODELLO RUNTIME E VISIBILITA DELLE VARIABILI

Il modello di Run Time definisce quando e dove una

variabile esiste nella memoria, mentre lo scope

(visibilità) definisce dove puoi usare quella variabile

nel codice.

In altre parole:

Il modello di run time gestisce la creazione e

 distruzione delle variabili durante l’esecuzione.

Lo scope stabilisce in quali parti del codice la

 variabile è visibile e accessibile.

1. Dove una variabile è visibile dipende da dove

viene creata

Se una variabile viene creata dentro una funzione, è

 visibile solo dentro quella funzione (scope locale).

Se viene creata fuori da tutte le funzioni, è visibile

 ovunque (scope globale), ma non modificabile

dentro una funzione senza global.

� 2. Quando una variabile è creata dipende dal run

time

Una variabile viene creata nel momento in cui

 l’istruzione viene eseguita.

Il modello di run time assegna lo spazio in memoria

 a quella variabile.

Quando l'esecuzione esce dallo scope (es. fine della

 funzione), la variabile viene distrutta (memoria

liberata).

Aspetto Run Time Scope

Quando nasce Al momento Quando entra

la variabile dell’esecuzione nello scope

Quando esce dallo scope Quando esce dallo

Quando muore (es. fine funzione) scope

In base allo scope Solo nel blocco

Dove è visibile definito dove è dichiarata

In base alla

Gestione Stack (locale), heap posizione nel

memoria (dinamica) codice

� In conclusione

✔ Il modello run time è responsabile dell’esecuzione

e della gestione della memoria.

✔ Lo scope (visibilità) è una regola del linguaggio che

dice dove puoi usare una variabile nel codice.

Il legame tra i due è che lo scope determina la durata

e la visibilità della variabile, e il run time ne gestisce la

vita in memoria durante l’esecuzione

CONFRONTO TRA DUE CODICI:

l1=[1,2,3] ⇾ Cosa succede:

l2=[2,5,12, 17]

def merge(l1,l2): l1 e l2 sono liste.



l3=[] Il metodo append() aggiunge



l3.append(l1) l’intera lista come un singolo

l3.append(l2) elemento.

return l3 Quindi l3 diventa una lista di

 liste: [[l1], [l2]]

Non è un "vero merge", perché le liste non vengono

unite elemento per elemento, ma solo inserite dentro

una nuova lista come oggetti interi.

l1=[1,2,3]

l2=[2,5,12,17]

def merge(l1,l2):

l3=[]

for i in range(len(l1)):

l3.append(l1[i])

for i in range(len(l2)):

l3.append(l2[i])

return l3

print(merge(l1,l2))

print(l1+l2)

MODELLO RUNTIME, ISTRUZIONI:

1. Assegnazione l1

2. Assegnazione l3

3. Quando il programma incontra la riga def

merge(...), non esegue nulla subito, viene solo

creato un riferimento in memoria alla funzione

merge.

4. Chiamata della funzione merge(l1, l2)

-Creazione della lista l3 = [].

-Primo ciclo for i in range(len(l1)): aggiunge [1,2,3]

a l3.

-Secondo ciclo for i in range(len(l2)): aggiunge

[2,5,12,17] a l3.

-Restituzione di l3 contenente [1,2,3,2,5,12,17].

5. Esecuzione del comando print(merge(l1, l2))

Il valore [1,2,3,2,5,12,17] viene stampato.

6. Fine dell'esecuzione

Dopo l’output, il programma termina e la memoria

delle variabili viene liberata.

OSS: l3 è locale, esiste solo dentro merge() e viene

restituita col return.

� Cosa succede a livello di passaggio dei parametri

In Python, quando chiami merge(l1, l2), l1 e l2 sono

passati per riferimento.

MA: la funzione merge() non modifica direttamente né

l1 né l2. Li usa solo in lettura.

Quindi anche se vengono passati per riferimento, è come

se fossero passati per valore, perché non vengono

modificati.

Di conseguenza, il comportamento appare come se fosse