{"id":957,"date":"2011-08-06T09:48:05","date_gmt":"2011-08-06T09:48:05","guid":{"rendered":"http:\/\/www.iprog.it\/blog\/?p=957"},"modified":"2012-04-30T18:44:13","modified_gmt":"2012-04-30T17:44:13","slug":"le-istruzioni-condizionali-e-la-ricorsione","status":"publish","type":"post","link":"https:\/\/www.iprog.it\/blog\/python\/le-istruzioni-condizionali-e-la-ricorsione\/","title":{"rendered":"Lezione 5 Python Le istruzioni condizionali e la ricorsione"},"content":{"rendered":"
\n

\"\"<\/a><\/p>\n

Salve a tutti e bentrovati ad una nuova lezione sul Python! Oggi introdurremo le istruzioni condizionali del Python (molto simili a quelle degli altri linguaggi) e la ricorsione che altro non \u00e8 che un altro modo di impostare il proprio programma. A breve ne parleremo.<\/p>\n

L\u2019operatore modulo<\/strong><\/p>\n

L\u2019operatore modulo opera sugli interi (e sulle espressioni intere) e produce il resto della divisione del primo operando diviso per il secondo. In Python l\u2019operatore modulo \u00e8 rappresentato dal segno percentuale (%). La sintassi \u00e8 la stessa degli altri operatori matematici:<\/p>\n

[code lang=”objc”]
\n&gt;&gt;&gt; Quoziente = 7 \/ 3
\n&gt;&gt;&gt; print Quoziente
\n2
\n&gt;&gt;&gt; Resto = 7 % 3
\n&gt;&gt;&gt; print Resto
\n1
\n[\/code]<\/p>\n

Cos\u00ec 7 diviso 3 d\u00e0 2, con il resto di 1.
\nL\u2019operatore modulo \u00e8 molto utile in quanto ti permette di controllare se un<\/p>\n

numero \u00e8 divisibile per un altro: se x % y \u00e8 0, allora x \u00e8 divisibile per y.<\/p>\n

Inoltre pu\u00f2 essere usato per estrarre la cifra pi\u00f9 a destra di un numero: \u00a0x%10 restituisce la cifra pi\u00f9 a destra in base 10. Allo stesso modo x%100 restituisce le ultime due cifre.<\/p>\n

\n

Espressioni Booleane<\/strong><\/p>\n

Un\u2019espressione booleana \u00e8 un\u2019espressione che pu\u00f2 essere o vera o falsa. In Python un\u2019espressione che \u00e8 vera ha valore 1, un\u2019espressione falsa ha valore 0. E cos\u00ec \u00e8 anche in molti altri linguaggi di programmazione.<\/p>\n

L\u2019operatore == confronta due valori e produce un risultato di tipo booleano:<\/p>\n

\n
>>> 3 == 3\r\n1\r\n>>> 3 == 2\r\n0<\/pre>\n
Nella prima riga i due operandi sono uguali, cos\u00ec l\u2019espressione vale 1 (vero); nella seconda riga 3 e 2 non sono uguali, cos\u00ec otteniamo 0 (falso).<\/p>\n
L\u2019operatore == \u00e8 uno degli operatori di confronto; gli altri sono:<\/p>\n
x!=y \u00a0 \u00a0 \u00a0#x \u00e8 diverso da y?
\nx>y \u00a0 \u00a0 \u00a0# x \u00e8 maggiore di y?
\nx<y \u00a0 \u00a0 \u00a0 #x \u00e8 minore di y?
\nx>=y \u00a0 \u00a0 \u00a0# x `e maggiore o uguale a y?<\/p>\n
x<=y \u00a0 \u00a0 \u00a0#x \u00e8 minore o uguale a y?<\/p>\n
Sebbene queste operazioni ti possano sembrare familiari, i simboli Python sono diversi da quelli usati comunemente in matematica. Un errore comune \u00e8 quello di usare il simbolo di uguale (=) invece del doppio uguale (==): ricorda che = \u00e8 un operatore di assegnazione e == un operatore di confronto. Inoltre in Python non esistono simboli del tipo =< e =>, ma solo gli equivalenti <= e >=.<\/p>\n
\n
Operatori logici<\/strong><\/p>\n
Ci sono tre operatori logici: and, or e not. Il significato di questi operatori \u00e8 simile al loro significato in italiano: per esempio, (x>0) and (x<10) \u00e8 vera solo se x \u00e8 pi\u00f9 grande di 0 e meno di 10.<\/p>\n
(n%2==0) or (n%3==0) \u00e8 vera se si verifica almeno una delle due condizioni e ci\u00f2 \u00e8 se il numero \u00e8 divisibile per 2 o per 3.<\/p>\n
Infine, l\u2019operatore not nega il valore di un\u2019espressione booleana, trasformando in falsa un\u2019espressione vera e viceversa. Cos`\u0131 se x>y \u00e8 vera (x \u00e8 maggiore di y), not(x>y) \u00e8 falsa.<\/p>\n
A dire il vero gli operatori booleani dovrebbero restituire un valore vero o falso, ma da questo punto di vista Python non sembra essere troppo fiscale: infatti ogni valore diverso da zero viene considerato vero e lo zero \u00e8 considerato falso.<\/p>\n
>>> x=5 >>> xand1 1
\n>>> y=0 >>> yand1 0<\/p>\n
In generale, le righe appena viste pur essendo lecite non sono considerate un buon esempio di programmazione: se vuoi confrontare un valore con zero \u00e8 sempre meglio farlo in modo esplicito, con un\u2019espressione del tipo<\/p>\n
>>> x!=0<\/p>\n
\n
Esecuzione condizionale<\/strong><\/p>\n
Per poter scrivere programmi di una certa utilit\u00e0 dobbiamo essere messi in grado di valutare delle condizioni e di far seguire differenti percorsi al flusso di esecuzione a seconda del risultato della valutazione. Le istruzioni condizionali ci offrono questa possibilit\u00e0. La forma pi\u00f9 semplice di istruzione if \u00e8 la seguente:<\/p>\n
if x > 0:\r\n  print \"x e\u2019 positivo\"<\/pre>\n
L\u2019espressione booleana dopo l\u2019istruzione if \u00e8 chiamata condizione. L\u2019istruzione indentata che segue i due punti della riga if viene eseguita solo se la condizione \u00e8 vera. Se la condizione \u00e8 falsa non viene eseguito alcunch\u00e8.<\/p>\n
Come nel caso di altre istruzioni composte, l\u2019istruzione if \u00e8 costituita da un\u2019intestazione e da un blocco di istruzioni:<\/p>\n
INTESTAZIONE:\r\n  PRIMA RIGA DI ISTRUZIONI\r\n  SECONDA RIGA DI ISTRUZIONI\r\n  ......\r\n  ULTIMA RIGA DI ISTRUZIONI<\/pre>\n
L\u2019intestazione inizia su di una nuova riga e termina con il segno di due punti. La serie di istruzioni indentate che seguono sono chiamate blocco di istruzioni. La prima riga di istruzioni non indentata marca la fine del blocco di istruzioni e non ne fa parte. Un blocco di istruzioni all\u2019interno di un\u2019istruzione composta \u00e8 anche chiamato corpo dell\u2019istruzione.<\/p>\n
Non c\u2019\u00e8 un limite al numero di istruzioni che possono comparire nel corpo di un\u2019istruzione if ma deve sempre essercene almeno una. In qualche occasione pu\u00f2 essere utile avere un corpo vuoto, ad esempio quando il codice corrispondente non \u00e8 ancora stato scritto ma si desidera ugualmente poter provare il programma. In questo caso puoi usare l\u2019istruzione pass, che \u00e8 solo un segnaposto e non fa niente. Se non vi \u00e8 chiaro potete considerare (se conoscete l’assembly) l’istruzione pass come l’istruzione NOP, No Operation, ovvero: non fare nulla e prosegui.<\/p>\n
if x > 0: pass<\/p>\n
\n
Esecuzione alternativa<\/strong><\/p>\n
Una seconda forma di istruzione if \u00e8 l\u2019esecuzione alternativa, nella quale ci sono due possibilit\u00e0 di azione e il valore della condizione determina quale delle due debba essere scelta. La sintassi \u00e8:<\/p>\n
[code lang=”objc”]
\nif x%2 == 0:
\n  print x, &quot;e\u2019 pari&quot;
\nelse:
\n  print x, &quot;e\u2019 dispari&quot;
\n[\/code]<\/p>\n
Se il resto della divisione intera di x per 2 \u00e8 zero allora sappiamo che x \u00e8 pari e il programma mostra il messaggio corrispondente. Se la condizione \u00e8 falsa viene\u00a0eseguita la serie di istruzioni descritta dopo la riga else (che in inglese significa \u201caltrimenti\u201d).<\/p>\n
\n
Le due alternative sono chiamate ramificazioni perch \u0301e rappresentano delle ramificazioni nel flusso di esecuzione del programma, e solo una di esse verr\u00e0 effettivamente eseguita.<\/p>\n
Una nota: se avete bisogno di controllare la parit\u00e0 di un numero (vedere se il numero \u00e8 pari o dispari), potreste desiderare di creare una funzione apposita da poter riutilizzare in seguito:<\/p>\n
[code lang=”objc”]
\ndef Parita(x):
\n  if x%2 == 0:
\n    print x, &quot;e\u2019 pari&quot;
\n  else:
\n    print x, &quot;e\u2019 dispari&quot;
\n[\/code]<\/p>\n
Cos\u00ec per ogni valore intero di x, Parita mostra il messaggio appropriato. Quando chiamate questa funzione puoi fornire qualsiasi espressione intera come argomento.<\/p>\n
>>> Parita(17)\r\n>>> Parita(y+1)<\/pre>\n<\/div>\n<\/div>\n
\n
Condizioni in serie<\/strong><\/p>\n
Talvolta ci sono pi\u00f9 di due possibilit\u00e0\u00a0per la continuazione del programma, cos\u00ec possiamo aver bisogno di pi\u00f9 di due ramificazioni. Un modo per esprimere questo caso sono le condizioni in serie:<\/p>\n
[code lang=”objc”]
\nif x &lt; y:
\n  print x, &quot;e\u2019 minore di&quot;, y
\nelif x &gt; y:
\n  print x, &quot;e\u2019 maggiore di&quot;, y
\nelse:
\n  print x, &quot;e&quot;, y, &quot;sono uguali&quot;
\n[\/code]<\/p>\n
elif \u00e8 l\u2019abbreviazione di \u201celse if\u201d, che in inglese significa \u201caltrimenti se\u201d. Anche in questo caso solo uno dei rami verr\u00e0 eseguito, a seconda del confronto tra x e y. Non c\u2019\u00e0 alcun limite al numero di istruzioni elif ma \u00e8 eventualmente possibile inserire un\u2019unica istruzione else che deve essere l\u2019ultima dell\u2019elenco e che rappresenta l\u2019azione da eseguire quando nessuna delle condizioni precedenti \u00e8 stata soddisfatta. La presenza di un\u2019istruzione else \u00e8 facoltativa.<\/p>\n
[code lang=”objc”]
\nif scelta == \u2019A\u2019:
\n  FunzioneA()
\nelif scelta == \u2019B\u2019:
\n  FunzioneB()
\nelif scelta == \u2019C\u2019:
\n  FunzioneC()
\nelse:
\n  print &quot;Scelta non valida&quot;
\n[\/code]<\/p>\n<\/div>\n
Le condizioni sono controllate nell\u2019ordine in cui sono state scritte. Se la prima \u00e8 falsa viene provata la seconda e cos\u00ec via. Non appena una \u00e8 verificata viene eseguito il ramo corrispondente e l\u2019intera istruzione if viene conclusa. In ogni caso, anche se fossero vere altre condizioni, dopo l\u2019esecuzione della prima queste vengono trascurate. Se nessuna condizione \u00e8 vera ed \u00e8 presente un else verr\u00e0 eseguito il codice corrispondente; se non \u00a0\u00e8 presente non verr\u00e0 eseguito niente.<\/p>\n
\n
Condizioni annidate<\/strong><\/p>\n
Un\u2019espressione condizionale pu\u00f2 anche essere inserita nel corpo di un\u2019altra espressione condizionale: un\u2019espressione di questo tipo viene detta \u201ccondizione annidata\u201d.<\/p>\n
[code lang=”objc”]
\nif x == y:
\n  print x, &quot;e&quot;, y, &quot;sono uguali&quot;&lt;\/pre&gt;
\nelse:
\n if x &lt; y:
\n&lt;pre&gt;    print x, &quot;e\u2019 minore di&quot;, y
\n  else:
\n    print x, &quot;e\u2019 maggiore di&quot;, y
\n[\/code]<\/p>\n
La prima condizione (if x == y) contiene due rami: il primo \u00e8 scelto quando x e y sono uguali, il secondo quando sono diversi. All\u2019interno del secondo (subito sotto il primo else:) troviamo un\u2019altra istruzione if, che a sua volta prevede un\u2019ulteriore ramificazione. Entrambi i rami del secondo if sono istruzioni di stampa ma potrebbero contenere a loro volta ulteriori istruzioni condizionali.<\/p>\n
Sebbene l\u2019indentazione delle istruzioni renda evidente la struttura dell\u2019esempio, le istruzioni condizionali annidate in livelli sempre pi\u00f9 profondi diventano sempre pi\u00f9 difficili da leggere, quindi \u00e8 una buona idea evitarle quando \u00e8 possibile.<\/p>\n
Gli operatori logici permettono un modo molto semplice di semplificare le espressioni condizionali annidate:<\/p>\n
[code lang=”objc”]
\nif 0 &lt; x:
\n  if x &lt; 10:
\n    print &quot;x e\u2019 un numero positivo.&quot;
\n[\/code]<\/p>\n
L\u2019istruzione di stampa print \u00e8 eseguita solo se entrambe le condizioni (x>0 e x<10) sono verificate contemporaneamente. Possiamo quindi usare l\u2019operatore booleano and per combinarle:<\/p>\n
[code lang=”objc”]
\nif 0&lt;x and x&lt;10:
\n  print &quot;x e\u2019 un numero positivo.&quot;&lt;\/pre&gt;
\n&lt;\/div&gt;
\n&lt;div&gt;<\/p>\n
Questo tipo di condizione \u00e8 cos\u00ec frequente che Python permette di usare una forma semplificata che ricorda da vicino quella corrispondente usata in matematica:
\n&lt;pre&gt;if 0 &lt; x &lt; 10:
\n  print &quot;x e\u2019 un numero positivo.&quot;
\n[\/code]<\/p>\n
A tutti gli effetti i tre esempi sono equivalenti per quanto riguarda la semantica del programma.<\/p>\n
L\u2019istruzione return<\/strong><\/div>\n
L\u2019istruzione return ti permette di terminare l\u2019esecuzione di una funzione prima di raggiungerne la fine. Questo pu\u00f2 servire quando viene riconosciuta una condizione d\u2019errore:<\/p>\n
import math<\/p>\n
[code lang=”objc”]
\ndef StampaLogaritmo(x):
\n  if x &lt;= 0:
\n    print &quot;Inserire solo numeri positivi!&quot;
\n    return
\n  risultato = math.log(x)
\n  print &quot;Il logaritmo di&quot;,x,&quot;e\u2019&quot;, risultato
\n[\/code]<\/p>\n
La funzione StampaLogaritmo accetta un parametro chiamato x. La prima operazione controlla che esso sia positivo; in caso contrario stampa un messaggio d\u2019errore e termina prematuramente la funzione con return.<\/p>\n
Ricordate che dovendo usare una funzione del modulo math \u00e8 necessario importare il modulo!<\/p>\n
Ricorsione<\/strong><\/div>\n
Abbiamo detto che \u00e8 perfettamente lecito che una funzione ne chiami un\u2019altra e di questo avete avuto modo di vedere parecchi esempi. Abbiamo invece trascurato di dirti che \u00e8 anche lecito che una funzione possa chiamare s\u00e9 stessa. Pu\u00f2 non essere immediatamente ovvio il motivo per cui questo sia utile, ma questa \u00e8 una delle cose pi\u00f9 interessanti che un programma possa fare. Per fare un esempio dai un\u2019occhiata a questa funzione:<\/p>\n
[code lang=”objc”]
\ndef ContoAllaRovescia(n):
\n  if n == 0:
\n    print &quot;Partenza!&quot;
\n  else:
\n    print n
\n    ContoAllaRovescia(n-1)
\n[\/code]<\/p>\n<\/div>\n<\/div>\n<\/div>\n
ContoAllaRovescia si aspetta che il parametro sia un intero positivo. Se n vale 0, viene stampata la scritta Partenza!. Altrimenti stampa n e poi chiama la funzione ContoAllaRovescia (cio\u00e8 s\u00e9 stessa) con un argomento che vale n-1.Cosa succede quando chiamiamo una funzione come questa?<\/p>\n
>>> ContoAllaRovescia(3)
\nL\u2019esecuzione di ContoAllaRovescia inizia con n=3. Dato che n non \u00e8 0, essa<\/p>\n
stampa il valore 3, e poi richiama s\u00e9 stessa…<\/p>\n
L\u2019esecuzione di ContoAllaRovescia inizia con n=2. Dato che n non \u00e8 0, essa stampa il valore 2, poi richiama s\u00e9 stessa…<\/p>\n
L\u2019esecuzione di ContoAllaRovescia inizia con n=1. Dato che n non \u00e8 0, essa stampa il valore 1, poi richiama s\u00e9 stessa…<\/p>\n
L\u2019esecuzione di ContoAllaRovescia inizia con il valore di n=0. Dal momento che n \u00e8 0, essa stampa il testo \u201cPartenza!\u201d e poi ritorna.<\/p>\n
La funzione ContoAllaRovescia che aveva n=1; e poi ritorna.<\/p>\n
La funzione ContoAllaRovescia che aveva n=2; e poi ritorna. E quindi torna in \"page61image10400\" __main__ \u00a0 (questo \u00e8 un trucco). Il risultato \u00e8 questo:<\/p>\n
3\r\n2\r\n1\r\nPartenza!<\/pre>\n<\/div>\n
\n
Ricorsione infinita<\/strong><\/p>\n
Se una ricorsione non raggiunge mai il suo stato di base la chiamata alla funzione viene eseguita all\u2019infinito ed in teoria il programma non giunge mai alla fine. Questa situazione \u00e8 conosciuta come ricorsione infinita e non \u00e8 generalmente considerata una buona cosa. Questo \u00e8 un programma minimo che genera una ricorsione infinita:<\/p>\n
\n
def Ricorsione():\r\n  Ricorsione()<\/pre>\n
Nella maggior parte degli ambienti un programma con una ricorsione infinita non viene eseguito senza fine, dato che ogni chiamata ad una funzione impegna un po’ di memoria del computer e questa memoria prima o poi finisce. Python stampa un messaggio d\u2019errore quando \u00e8 stato raggiunto il massimo livello di ricorsione possibile:<\/p>\n
  File \"<stdin>\", line 2, in Ricorsione\r\n  ...\r\n  File \"<stdin>\", line 2, in Ricorsione\r\nRuntimeError: Maximum recursion depth exceeded<\/pre>\n<\/div>\n
\n
Inserimento da tastiera<\/strong><\/p>\n
I programmi che abbiamo scritto finora sono piuttosto banali, nel senso che non accettano inserimenti di dati da parte dell\u2019operatore, limitandosi a eseguire sempre le stesse operazioni.<\/p>\n
Python fornisce un insieme di funzioni predefinite che permettono di inserire dati da tastiera. La pi\u00f9 semplice di esse \u00e8 raw input. Quando questa funzione \u00e8 chiamata il programma si ferma ed attende che l\u2019operatore inserisca qualcosa, confermando poi l\u2019inserimento con Invio (o Enter). A quel punto il programma riprende e raw input ritorna ci\u00f2 che l\u2019operatore ha inserito sotto forma di stringa:<\/p>\n
>>> Inserimento = raw_input ()\r\nTesto inserito\r\n>>> print Inserimento\r\nTesto inserito<\/pre>\n
Prima di chiamare raw input \u00e8 una buona idea stampare un messaggio che avvisa l\u2019operatore di ci\u00f2 che deve essere inserito. Questo messaggio \u00e8 chiamato prompt. L\u2019operazione \u00e8 cos\u00ec comune che il messaggio di prompt pu\u00f2 essere passato come argomento a raw input:<\/p>\n
>>> Nome = raw_input (\"Qual e\u2019 il tuo nome? \")\r\nQual e\u2019 il tuo nome? Arturo\r\n>>> print Nome\r\nArturo<\/pre>\n
Se il valore da inserire \u00e8 un intero possiamo usare la funzione input:<\/p>\n
Prompt = \"A che velocita\u2019viaggia il treno?\\n\"\r\nVelocita = input(Prompt)<\/pre>\n<\/div>\n
\n
Se l\u2019operatore inserisce una serie di cifre questa \u00e8 convertita in un intero ed assegnata a Velocita. Sfortunatamente se i caratteri inseriti dall\u2019operatore non rappresentano un numero, il programma stampa un messaggio d\u2019errore e si blocca:<\/p>\n
>>> Velocita = input (Prompt)\r\nA che velocita\u2019viaggia il treno?\r\nottanta all\u2019ora\r\nSyntaxError: invalid syntax<\/pre>\n
Per evitare questo tipo di errori \u00e8 generalmente meglio usare la funzione raw_input per ottenere una stringa di caratteri e poi usare le funzioni di conversione per ottenere gli altri tipi.<\/p>\n
E anche per oggi \u00e8 tutto ragazzi, vi aspetto alla prossima!<\/p>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n","protected":false},"excerpt":{"rendered":"
Salve a tutti e bentrovati ad una nuova lezione sul Python! Oggi introdurremo le istruzioni condizionali del Python<\/p>\n","protected":false},"author":5,"featured_media":800,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[10],"tags":[1062,1375,123,1063,1352],"class_list":["post-957","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-python","tag-istruzioni","tag-lezione","tag-python-2","tag-ricorsione","tag-salve"],"yoast_head":"\nLezione 5 Python Le istruzioni condizionali e la ricorsione - iProg<\/title>\n<meta name=\"robots\" content=\"index, follow, max-snippet:-1, max-image-preview:large, max-video-preview:-1\" \/>\n<link rel=\"canonical\" href=\"https:\/\/www.iprog.it\/blog\/python\/le-istruzioni-condizionali-e-la-ricorsione\/\" \/>\n<meta name=\"twitter:card\" content=\"summary_large_image\" \/>\n<meta name=\"twitter:title\" content=\"Lezione 5 Python Le istruzioni condizionali e la ricorsione - iProg\" \/>\n<meta name=\"twitter:description\" content=\"Salve a tutti e bentrovati ad una nuova lezione sul Python! Oggi introdurremo le istruzioni condizionali del Python\" \/>\n<meta name=\"twitter:image\" content=\"https:\/\/www.iprog.it\/blog\/wp-content\/uploads\/2011\/08\/python01.jpg\" \/>\n<meta name=\"twitter:creator\" content=\"@iprogblog\" \/>\n<meta name=\"twitter:site\" content=\"@iprogblog\" \/>\n<meta name=\"twitter:label1\" content=\"Scritto da\" \/>\n\t<meta name=\"twitter:data1\" content=\"Fabio\" \/>\n\t<meta name=\"twitter:label2\" content=\"Tempo di lettura stimato\" \/>\n\t<meta name=\"twitter:data2\" content=\"12 minuti\" \/>\n<script type=\"application\/ld+json\" class=\"yoast-schema-graph\">{\"@context\":\"https:\\\/\\\/schema.org\",\"@graph\":[{\"@type\":\"Article\",\"@id\":\"https:\\\/\\\/www.iprog.it\\\/blog\\\/python\\\/le-istruzioni-condizionali-e-la-ricorsione\\\/#article\",\"isPartOf\":{\"@id\":\"https:\\\/\\\/www.iprog.it\\\/blog\\\/python\\\/le-istruzioni-condizionali-e-la-ricorsione\\\/\"},\"author\":{\"name\":\"Fabio\",\"@id\":\"https:\\\/\\\/www.iprog.it\\\/blog\\\/#\\\/schema\\\/person\\\/5f7d1474b2b5e8fe635f84906efc8c51\"},\"headline\":\"Lezione 5 Python Le istruzioni condizionali e la ricorsione\",\"datePublished\":\"2011-08-06T09:48:05+00:00\",\"dateModified\":\"2012-04-30T17:44:13+00:00\",\"mainEntityOfPage\":{\"@id\":\"https:\\\/\\\/www.iprog.it\\\/blog\\\/python\\\/le-istruzioni-condizionali-e-la-ricorsione\\\/\"},\"wordCount\":2329,\"commentCount\":0,\"image\":{\"@id\":\"https:\\\/\\\/www.iprog.it\\\/blog\\\/python\\\/le-istruzioni-condizionali-e-la-ricorsione\\\/#primaryimage\"},\"thumbnailUrl\":\"https:\\\/\\\/www.iprog.it\\\/blog\\\/wp-content\\\/uploads\\\/2011\\\/08\\\/python01.jpg\",\"keywords\":[\"istruzioni\",\"Lezione\",\"python\",\"ricorsione\",\"Salve\"],\"articleSection\":[\"Python\"],\"inLanguage\":\"it-IT\",\"potentialAction\":[{\"@type\":\"CommentAction\",\"name\":\"Comment\",\"target\":[\"https:\\\/\\\/www.iprog.it\\\/blog\\\/python\\\/le-istruzioni-condizionali-e-la-ricorsione\\\/#respond\"]}]},{\"@type\":\"WebPage\",\"@id\":\"https:\\\/\\\/www.iprog.it\\\/blog\\\/python\\\/le-istruzioni-condizionali-e-la-ricorsione\\\/\",\"url\":\"https:\\\/\\\/www.iprog.it\\\/blog\\\/python\\\/le-istruzioni-condizionali-e-la-ricorsione\\\/\",\"name\":\"Lezione 5 Python Le istruzioni condizionali e la ricorsione - iProg\",\"isPartOf\":{\"@id\":\"https:\\\/\\\/www.iprog.it\\\/blog\\\/#website\"},\"primaryImageOfPage\":{\"@id\":\"https:\\\/\\\/www.iprog.it\\\/blog\\\/python\\\/le-istruzioni-condizionali-e-la-ricorsione\\\/#primaryimage\"},\"image\":{\"@id\":\"https:\\\/\\\/www.iprog.it\\\/blog\\\/python\\\/le-istruzioni-condizionali-e-la-ricorsione\\\/#primaryimage\"},\"thumbnailUrl\":\"https:\\\/\\\/www.iprog.it\\\/blog\\\/wp-content\\\/uploads\\\/2011\\\/08\\\/python01.jpg\",\"datePublished\":\"2011-08-06T09:48:05+00:00\",\"dateModified\":\"2012-04-30T17:44:13+00:00\",\"author\":{\"@id\":\"https:\\\/\\\/www.iprog.it\\\/blog\\\/#\\\/schema\\\/person\\\/5f7d1474b2b5e8fe635f84906efc8c51\"},\"inLanguage\":\"it-IT\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\\\/\\\/www.iprog.it\\\/blog\\\/python\\\/le-istruzioni-condizionali-e-la-ricorsione\\\/\"]}]},{\"@type\":\"ImageObject\",\"inLanguage\":\"it-IT\",\"@id\":\"https:\\\/\\\/www.iprog.it\\\/blog\\\/python\\\/le-istruzioni-condizionali-e-la-ricorsione\\\/#primaryimage\",\"url\":\"https:\\\/\\\/www.iprog.it\\\/blog\\\/wp-content\\\/uploads\\\/2011\\\/08\\\/python01.jpg\",\"contentUrl\":\"https:\\\/\\\/www.iprog.it\\\/blog\\\/wp-content\\\/uploads\\\/2011\\\/08\\\/python01.jpg\",\"width\":\"405\",\"height\":\"142\"},{\"@type\":\"WebSite\",\"@id\":\"https:\\\/\\\/www.iprog.it\\\/blog\\\/#website\",\"url\":\"https:\\\/\\\/www.iprog.it\\\/blog\\\/\",\"name\":\"iProg\",\"description\":\"perch\u00e9 reinventare la ruota?\",\"potentialAction\":[{\"@type\":\"SearchAction\",\"target\":{\"@type\":\"EntryPoint\",\"urlTemplate\":\"https:\\\/\\\/www.iprog.it\\\/blog\\\/?s={search_term_string}\"},\"query-input\":{\"@type\":\"PropertyValueSpecification\",\"valueRequired\":true,\"valueName\":\"search_term_string\"}}],\"inLanguage\":\"it-IT\"},{\"@type\":\"Person\",\"@id\":\"https:\\\/\\\/www.iprog.it\\\/blog\\\/#\\\/schema\\\/person\\\/5f7d1474b2b5e8fe635f84906efc8c51\",\"name\":\"Fabio\",\"image\":{\"@type\":\"ImageObject\",\"inLanguage\":\"it-IT\",\"@id\":\"https:\\\/\\\/secure.gravatar.com\\\/avatar\\\/03f928dca7330002301d292e5dc1b2fca35722d24a0628eaf129fd52acfc0a99?s=96&r=g\",\"url\":\"https:\\\/\\\/secure.gravatar.com\\\/avatar\\\/03f928dca7330002301d292e5dc1b2fca35722d24a0628eaf129fd52acfc0a99?s=96&r=g\",\"contentUrl\":\"https:\\\/\\\/secure.gravatar.com\\\/avatar\\\/03f928dca7330002301d292e5dc1b2fca35722d24a0628eaf129fd52acfc0a99?s=96&r=g\",\"caption\":\"Fabio\"},\"description\":\"Esperienza nella progettazione e sviluppo di Applicazioni mobili. Integro le conoscenze acquisite in ambito accademico con un continuo studio di nuove tecnologie che mi permettano di creare applicazioni sempre pi\u00f9 affidabili sicure ed efficienti. Venite a trovarmi sul blog Fabiosoft Google+\",\"sameAs\":[\"http:\\\/\\\/www.fabiosoft.com\",\"https:\\\/\\\/www.facebook.com\\\/devfabionisci\\\/\",\"http:\\\/\\\/it.linkedin.com\\\/in\\\/fabionisci\"],\"url\":\"https:\\\/\\\/www.iprog.it\\\/blog\\\/author\\\/fabiosoft\\\/\"}]}<\/script>\n<!-- \/ Yoast SEO plugin. -->","yoast_head_json":{"title":"Lezione 5 Python Le istruzioni condizionali e la ricorsione - iProg","robots":{"index":"index","follow":"follow","max-snippet":"max-snippet:-1","max-image-preview":"max-image-preview:large","max-video-preview":"max-video-preview:-1"},"canonical":"https:\/\/www.iprog.it\/blog\/python\/le-istruzioni-condizionali-e-la-ricorsione\/","twitter_card":"summary_large_image","twitter_title":"Lezione 5 Python Le istruzioni condizionali e la ricorsione - iProg","twitter_description":"Salve a tutti e bentrovati ad una nuova lezione sul Python! Oggi introdurremo le istruzioni condizionali del Python","twitter_image":"https:\/\/www.iprog.it\/blog\/wp-content\/uploads\/2011\/08\/python01.jpg","twitter_creator":"@iprogblog","twitter_site":"@iprogblog","twitter_misc":{"Scritto da":"Fabio","Tempo di lettura stimato":"12 minuti"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"Article","@id":"https:\/\/www.iprog.it\/blog\/python\/le-istruzioni-condizionali-e-la-ricorsione\/#article","isPartOf":{"@id":"https:\/\/www.iprog.it\/blog\/python\/le-istruzioni-condizionali-e-la-ricorsione\/"},"author":{"name":"Fabio","@id":"https:\/\/www.iprog.it\/blog\/#\/schema\/person\/5f7d1474b2b5e8fe635f84906efc8c51"},"headline":"Lezione 5 Python Le istruzioni condizionali e la ricorsione","datePublished":"2011-08-06T09:48:05+00:00","dateModified":"2012-04-30T17:44:13+00:00","mainEntityOfPage":{"@id":"https:\/\/www.iprog.it\/blog\/python\/le-istruzioni-condizionali-e-la-ricorsione\/"},"wordCount":2329,"commentCount":0,"image":{"@id":"https:\/\/www.iprog.it\/blog\/python\/le-istruzioni-condizionali-e-la-ricorsione\/#primaryimage"},"thumbnailUrl":"https:\/\/www.iprog.it\/blog\/wp-content\/uploads\/2011\/08\/python01.jpg","keywords":["istruzioni","Lezione","python","ricorsione","Salve"],"articleSection":["Python"],"inLanguage":"it-IT","potentialAction":[{"@type":"CommentAction","name":"Comment","target":["https:\/\/www.iprog.it\/blog\/python\/le-istruzioni-condizionali-e-la-ricorsione\/#respond"]}]},{"@type":"WebPage","@id":"https:\/\/www.iprog.it\/blog\/python\/le-istruzioni-condizionali-e-la-ricorsione\/","url":"https:\/\/www.iprog.it\/blog\/python\/le-istruzioni-condizionali-e-la-ricorsione\/","name":"Lezione 5 Python Le istruzioni condizionali e la ricorsione - iProg","isPartOf":{"@id":"https:\/\/www.iprog.it\/blog\/#website"},"primaryImageOfPage":{"@id":"https:\/\/www.iprog.it\/blog\/python\/le-istruzioni-condizionali-e-la-ricorsione\/#primaryimage"},"image":{"@id":"https:\/\/www.iprog.it\/blog\/python\/le-istruzioni-condizionali-e-la-ricorsione\/#primaryimage"},"thumbnailUrl":"https:\/\/www.iprog.it\/blog\/wp-content\/uploads\/2011\/08\/python01.jpg","datePublished":"2011-08-06T09:48:05+00:00","dateModified":"2012-04-30T17:44:13+00:00","author":{"@id":"https:\/\/www.iprog.it\/blog\/#\/schema\/person\/5f7d1474b2b5e8fe635f84906efc8c51"},"inLanguage":"it-IT","potentialAction":[{"@type":"ReadAction","target":["https:\/\/www.iprog.it\/blog\/python\/le-istruzioni-condizionali-e-la-ricorsione\/"]}]},{"@type":"ImageObject","inLanguage":"it-IT","@id":"https:\/\/www.iprog.it\/blog\/python\/le-istruzioni-condizionali-e-la-ricorsione\/#primaryimage","url":"https:\/\/www.iprog.it\/blog\/wp-content\/uploads\/2011\/08\/python01.jpg","contentUrl":"https:\/\/www.iprog.it\/blog\/wp-content\/uploads\/2011\/08\/python01.jpg","width":"405","height":"142"},{"@type":"WebSite","@id":"https:\/\/www.iprog.it\/blog\/#website","url":"https:\/\/www.iprog.it\/blog\/","name":"iProg","description":"perch\u00e9 reinventare la ruota?","potentialAction":[{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https:\/\/www.iprog.it\/blog\/?s={search_term_string}"},"query-input":{"@type":"PropertyValueSpecification","valueRequired":true,"valueName":"search_term_string"}}],"inLanguage":"it-IT"},{"@type":"Person","@id":"https:\/\/www.iprog.it\/blog\/#\/schema\/person\/5f7d1474b2b5e8fe635f84906efc8c51","name":"Fabio","image":{"@type":"ImageObject","inLanguage":"it-IT","@id":"https:\/\/secure.gravatar.com\/avatar\/03f928dca7330002301d292e5dc1b2fca35722d24a0628eaf129fd52acfc0a99?s=96&r=g","url":"https:\/\/secure.gravatar.com\/avatar\/03f928dca7330002301d292e5dc1b2fca35722d24a0628eaf129fd52acfc0a99?s=96&r=g","contentUrl":"https:\/\/secure.gravatar.com\/avatar\/03f928dca7330002301d292e5dc1b2fca35722d24a0628eaf129fd52acfc0a99?s=96&r=g","caption":"Fabio"},"description":"Esperienza nella progettazione e sviluppo di Applicazioni mobili. Integro le conoscenze acquisite in ambito accademico con un continuo studio di nuove tecnologie che mi permettano di creare applicazioni sempre pi\u00f9 affidabili sicure ed efficienti. Venite a trovarmi sul blog Fabiosoft Google+","sameAs":["http:\/\/www.fabiosoft.com","https:\/\/www.facebook.com\/devfabionisci\/","http:\/\/it.linkedin.com\/in\/fabionisci"],"url":"https:\/\/www.iprog.it\/blog\/author\/fabiosoft\/"}]}},"views":2770,"_links":{"self":[{"href":"https:\/\/www.iprog.it\/blog\/wp-json\/wp\/v2\/posts\/957","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.iprog.it\/blog\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.iprog.it\/blog\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.iprog.it\/blog\/wp-json\/wp\/v2\/users\/5"}],"replies":[{"embeddable":true,"href":"https:\/\/www.iprog.it\/blog\/wp-json\/wp\/v2\/comments?post=957"}],"version-history":[{"count":0,"href":"https:\/\/www.iprog.it\/blog\/wp-json\/wp\/v2\/posts\/957\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/www.iprog.it\/blog\/wp-json\/wp\/v2\/media\/800"}],"wp:attachment":[{"href":"https:\/\/www.iprog.it\/blog\/wp-json\/wp\/v2\/media?parent=957"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.iprog.it\/blog\/wp-json\/wp\/v2\/categories?post=957"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.iprog.it\/blog\/wp-json\/wp\/v2\/tags?post=957"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}