Forum libero

Scritto da:
> Ciao dada, se un gatto - uno a caso - volesse studiare ingegneria genetica per capirne qualcosa, dove e come dovrebbe iniziare?
>
> Un testo universitario di biologia generale.
> Un testo universitario di genetica generale.
>
> Già qui occorrono i testi giusti che non faciano perdere tempo.
>
> E poi?

e' un po strano l'orientamento riguardo ai testi, il primo problema e' la velocita' a cui stanno cambiando le cose nell'ambiente, anche a livello basilare.

nature ha risolto il problema cosi' e questo testo lo usano davvero nelle universita'

http://www.nature.com/nature_education/interactive...
non lo ho comprato ma mi piacerebbe farlo.

ad ogni modo la biologia e' vasta, i professori stessi ti riempiono di dispense prese da testi diversi e li usano principalmente per le immagini. per assurdo i libri di testo delle superiori, se abbastanza recenti, ti forniscono gia' una bella serie di immagini ed diagrammi che ti assicuro sono tutt'altro che semplici, in italiano i vari campbell edition sono quelli che usano dalle superiori alla prima reintroduzione alla biologia all'universita', come introduzione generale vanno benissimo se approfondisci con qualche risorsa internet.

dopodiche' cmq mi sembra di capire che questo yoda qualunque, pardon, gatto qualunque, voglia conoscere la scorciatotia per capire qualcosa di genetica, ecco quella non sta sui libri di biologia ma passa da almeno due libri di testo interi, scegline uno a caso da qualche libreria universitaria che sia almeno degli anni 2010 e li intorno riguardo a:

Citologia ed istologia

poi

chimica organica

e subito dopo puoi gettarti sulla genetia vera e propria, ovvero

biologia molecolare

genetica

di tutte queste parole chiave trovi libri di testo interi dedicati all'argomento, welcome aboard.

Scritto da: avvelentani
> Scritto da: dada216
> > also, come va? che dite?
> >
> >
> > ad ogni modo, ho una questione di informatica che mi cruccia, sto perdendo un po di tempo per rilassarmi ergo python.
> >
> >
> >
> > diciamo che io abbia questo codice:
> >

> > def f(x):
> > x = x+1
> > print("il valore di x nella funzione f(x) e:", x)
> > return x
> > 
> > x = 5
> > z = f(x)
> > print(x)
> > print(z)

> >
> > il risultato di questa corsa e':
> >

> > ('il valore di x nella funzione f(x) e:', 6)
> > 5
> > 6
> > 

> >
> > se invece io lo modifico cosi:
> >
> >

> > def f(x):
> > x = x+1
> > print("il valore di x nella funzione f(x) e:", x)
> > return x
> > 
> > x = 5
> > x = f(x)
> > print(x)
> > print(x)

> >
> > alla fine della corsa dice:
> >

> > ('il valore di x nella funzione f(x) e:', 6)
> > 6
> > 6
> > 

>
> Sei confuso perche' ci sono due variabili 'x' in questo codice.
>

esattamente, lo ho provato a fare per capire meglio cosa stava succeddendo ai bindings.

> 1. La variabile x globale definita alla riga
>

> x = 5
> 

>
> il cui scope e` globale
>
> 2. La variable x locale alla funziona f definita alla riga
>

> def f(x):
> 

>
> il cui scope e` limitato all'interno della funzione f.

aha, pero' viene in effetti gia' creato un binding al momento del parsing, binding di cosa di preciso?
lo scope quindi e' indipendente dai binding?

i binding vengono effettuati sequenzialmente e poi l'esecuzione delle istruzioni all'interno dei vari scope (dipendente dalla posizione ed ordine delle chiamate alle varie funzioni) dipende dal flow del programma? correct?

>
> >
> > se provo a seguire i memory binding passo passo mi sorgono delle questioni, seguendoli in ordine:
> >
> > 1) definizione della funzione f(x) <- cosa succede ai memory binding?
>
> Viene creata una variabile chiamata 'f' a cui viene assegnato il codice della funzione

"il codice della funzione", ovvero? stiamo proprio parlando delle istruzioni che ho scritto nell'indentatura? vengono prese e messe in memoria bindate alla variabile f? a questo punto il parametro che io specifico tra parentesi che cosa indica di preciso?

perche' se io faccio questo piccolo cambiamento e invece che def f(x) scrivo def f(y)

def f(y):
    x = x+1
    print('il valore di x nella funzione f(y) e:', x)
    return x

x = 5
x = f(y)
print(x)
print(x)

il risultato e':

Traceback (most recent call last):
  File "example.py", line 7, in <module>
    x = f(y)
NameError: name 'y' is not defined

ergo ho pensato di renderlo tutto coerente con l'utilizzo di due variabili con nomi diversi

def f(y):
    y = x+1
    print('il valore di y nella funzione f(y) e:', y)
    return y

x = 5
y = f(y)
print(x)
print(y)

il risultato e'

Traceback (most recent call last):
  File "example.py", line 7, in <module>
    y = f(y)
NameError: name 'y' is not defined

quando mi verrebbe invece di pensare che se la sarebbe dovuta cavare ed avrebbe dovuto (nelle mie intenzioni) fare 5 + 1 ed assegnare il valore 6 alla variabile y.
quindi non ho capito un cazzo riguardo ai parametri delle funzioni ed a cosa sto scrivendo.

>
> > 2) binding di x=5
>
> viene creata una variabile globale x e gli viene assegnato il valore 5
>
> > 3) binding di x=f(x) <- e' qua il cambio di scope? questo non puo essere un binding dato il comportamento del programma, o sbaglio?
>
> succedono due cose su questa riga:
>
> 1. viene chiamata la funzione f, per fare questo viene creato un nuovo binding per la variabile x [b]locale alla funzione f[/b] e gli viene assegnato il valore 5, risultato della valutazione della variabile x [b]globale[/b].

se eseguo il codice modificato con y infatti si lamenta del fatto che y non e' stato definito, quindi l'unica ragione per la quale il codice con due variabili con lo stesso nome funziona e' proprio perche' hanno lo stesso nome?

> 2. il risultato della chiamata ad f viene assegnato alla variabile x [b]globale[/b]
>
> > 4) cambio di scope
>
> si` ma lo scope globale resta sempre attivo.
>
> > 5) esecuzione di x = x+1
> >
> > come cazzo a fatto a farlo prendendo il primo binding di x=5 se io gli ho fatto rifafre il binding come x=f(x)?
>
> in questo momento esistono due variabili x, la variabile globale e l'argomento di f.
>
> > x=5 a quel punto non dovrebbe essere diventato cibo per il garbage collector? evidentemente no, o si?
>
> No perche' lo scope globale continua ad esistere anche durante l'esecuzione di f. Mentre f viene eseguita la x globale non e` "out of scope" ma "shadowed", ovvero inaccessibile perche' coperta dalla variabile x locale ad f. Quando f termina la variabile locale x va out of scope e la variabile globale x smette di essere shadowed.

grande, ho capito perche' x nei print successivi alla chiamata x poteva valere sia 5 sia 6, il valore 5 rimaneva shadowed e riscritto se ad effettuare la chiamata fosse x = f(x) ma non quando ad effettuarla era z = f(x).

pero' non ho ancora caapito perche' questo non funziona.

def f(y):
    y = x+1
    print('il valore di x nella funzione f(y) e:', x)
    print('il valore di y nella funzione f(y) e:', y)
    return y

x = 5
y = f(y)
print(x)
print(y)

-->

Traceback (most recent call last):
  File "example2.py", line 8, in <module>
    y = f(y)
NameError: name 'y' is not defined

**Modificato dall'autore il 22.06.2017 14:48**