Megistone

Il Linguaggio HTML

Introduzione
L’acronimo HTML (Hyper Text Markup Language) può essere tradotto con Linguaggio per IperTesti a Marcatori. Questo linguaggio nasce da un’intuizione di Tim Berners–Lee, del CERN (Centro Europeo per la Ricerca Nucleare) di Ginevra. Egli si pose il problema di sviluppare un codice che permettesse lo scambio di documenti di natura scientifica usando i collegamenti a distanza tra computer anche su macchine con sistemi operativi differenti.
Per capire la filosofia con cui vengono composte le pagine Internet, consideriamo la possibile descrizione di un libro. Per noi il libro sarà un’entità delimitata da due particolari simboli che chiamiamo marcatori (tag).

Leggi tutto: Il Linguaggio HTML

La matemagica Ovvero: giochiamo un po’ per continuare ad esercitarci

1. Quanti soldi hai in tasca?
Vuoi scoprire quanti soldi ha in tasca un tuo amico?
Chiedigli di:

1. partire dalla somma (s) dei soldi che ha in tasca (ad es. € 35)
2. Moltiplicarla per 2: 35x2=70 (2s)
3. Aggiungere tre al prodotto: 70+3=73 (2s+3)
4. Moltiplicare la somma per 5: 5x73=365 5(2s+3)=10s+15
5. Sottrarre 6: 365-6=359 10s+15-6=10s+9
6. Darti il risultato finale: 359
   Togli l’unità e saprai che ha in tasca 35 euro!

Il gioco si basa sulle proprietà algebriche dei numeri: si sa che in algebra x può assumere qualsiasi valore numerico. Se io scrivo l’espressione algebrica 10x+9 e poi assegno a x successivamente il valore 1, 4, 20
per x=01 il risultato sarà 019
per x=04 il risultato sarà 049
per x=20 il risultato sarà 209.
Cosa si nota?
Il numero scelto compare nelle decine tolto il numero finale e pertanto è sufficiente togliere le unità per indovinare il gioco.

Proviamo a trasformare questo gioco in un programma per il computer:
# quanti soldi hai in tasca
print "Vediamo se indovino subito quanti soldi hai in tasca"
print "Moltiplica il numero dei soldi che hai in tasca per 2"
print "Ora aggiungi 3 al prodotto"
print "Ora moltiplica per 5"
print "Sottrai 6"
soldiintasca = input ("Inserisci ora il risultato ottenuto")
soldiintasca = str(soldiintasca)
print "Secondo me hai in tasca", soldiintasca[1:3], "euro"

2. Indovina la data del compleanno
Chiedi a una tua amica di moltiplicare mentalmente per 5 il numero del mese in cui è nata (5m). Supponiamo che sia nata il 13 giugno (5x6=30).
Poi chiedile di:

1. aggiungere 7: 30+7=37 (5m+7)
2. moltiplicare per 4: 37x4=148 (4(5m+7)=20m+28)
3. aggiungere 13: 148+13=161 (20m+28+13=20m+41)
4. moltiplicare per 5: 161x5=805 (5(20m+41)=100m+205)
5. aggiungere il giorno del mese in cui è nata: 805+13=818 (100m+205+g)
6. sottrarre 205 dal numero ottenuto: 818-205=613 (100m+g+205-205).
   

Chiedi alla tua amica di dirti il numero ottenuto (613): dalle centinaia otterrai il mese e dalle unità il giorno.
Non ti resta che di ricordarti di augurarle, a tempo debito, Buon compleanno!

# indovina la data del compleanno
print "Vediamo se indovino subito la data del compleanno\n"
print "Moltiplica il numero del mese in cui sei nata per 5\n"
print "Ora aggiungi 7\n"
print "Ora moltiplica per 4\n"
print "Aggiungi 13\n"
print "Moltiplica per 5\n"
print "Aggiungi il giorno del mese in cui sei nato\n"
print "Sottrai 205 dal numero ottenuto\n"
compleanno = input ("Inserisci ora il risultato ottenuto\n")
compleanno = int(compleanno)
x= 999
if compleanno > x:
comp = str(compleanno) # trasforma il numero in stringa
else:
comp = '0' + str(compleanno)
if comp[0:2] == "01":
mese = "gennaio"
elif comp[0:2] == "02":
mese = "febbraio"
elif comp[0:2] == "03":
mese = "marzo"
elif comp[0:2] == "04":
mese = "aprile"
elif comp[0:2] == "05":
mese = "maggio"
elif comp[0:2] == "06":
mese = "giugno"
elif comp[0:2] == "07":
mese = "luglio"
elif comp[0:2] == "08":
mese = "agosto"
elif comp[0:2] == "09":
mese = "settembre"
elif comp[0:2] == "10":
mese = "ottobre"
elif comp[0:2] == "11":
mese = "novembre"
elif comp[0:2] == "12":
mese = "dicembre"
print "Sei nata il ", comp[2:4], "del mese di", mese

3. Indovina la data della Rivoluzione Francese
Chiedi a un tuo amico di:

1. moltiplicare il numero del mese per 5: 5x7=35 (5m)
2. sottrarre 3 al risultato: 35-3=32 (5m-3)
3. raddoppiare il numero ottenuto: 32x2=64 (2(5m-3)=10m+6)
4. moltiplicarlo per 10: 64x10=640 (100m-60)
5. aggiungere il giorno: 640+14= 654 (100m-60+g)
6. dirti il numero ottenuto:654
   Aggiungi 60 e otterrai 714
   (100m+g+60-60)
   

La data dell’inizio della Rivoluzione Francese è 14 luglio.

4. gioco del TRIS
Regole: i giocatori, che sono sempre solo due, scelgono ciascuno una lettera o un simbolo. Sul computer è meglio scegliere una lettera perché è più facile da rappresentare, quindi il primo giocatore sceglierà la N e il secondo la R.
Per giocare avranno a disposizione una scacchiera composta da 9 riquadri disposti su 3 file con il seguente schema:

   1 2 3
a  x x x
b  x x x
c  x x x

Inseriranno a turno un simbolo nello spazio scelto ancora libero. Vincerà chi per primo riuscirà ad inserire 3 simboli consecutivi in orizzontale oppure in verticale o in diagonale.
Ad esempio:

    1 2 3       1 2 3       1 2 3
a  N N N  a  N x R   a  N x x
b  R x x   b  R N x   b  N R x
c  x x R   c   x x N   c  N x R

Ora con molta attenzione impostiamo le varie parti del programma.

La scacchiera
Per rappresentare la scacchiera utilizzeremo nove variabili che chiameremo a1, a2, a3, b1, b2, b3, c1, c2, c3.
Ciascuna di queste variabili può assumere soltanto tre valori: “R” oppure “N” oppure “X”.
Inizialmente tutte le variabili assumono il valore X; successivamente, se, ad esempio, il giocatore che ha scelto “N” come suo simbolo mette quel simbolo nella riga a in corrispondenza della colonna 2, la variabile a2 assumerà il valore “N”.

La visualizzazione della scacchiera
Per visualizzare la scacchiera è sufficiente scrivere questo breve programma:

print '\t 1 \t 2 \t 3 \n'
print 'a \t', a1, '\t', a2, '\t', a3, '\n'
print 'b \t', b1, '\t', b2, '\t', b3, '\n'
print 'c \t', c1, '\t', c2, '\t', c3, '\n'

Avremo bisogno di visualizzare la scacchiera molte volte nell'arco della partita, quindi converrà scrivere una funzione per la visualizzazione.

def scacchiera():
     print '\t 1 \t 2 \t 3 \n'
     print 'a \t', a1, '\t', a2, '\t', a3, '\n'
     print 'b \t', b1, '\t', b2, '\t', b3, '\n'
     print 'c \t', c1, '\t', c2, '\t', c3, '\n'

Il controllo della vittoria
Questa operazione dovrà essere ripetuta dopo ogni mossa nel corso della partita e quindi converrà scrivere una funzione che chiameremo “vittoria”.
La funzione "vittoria" avrà un'unica variabile su cui operare, il nome “N” oppure “R” del giocatore che ha fatto la sua giocata. A questa variabile diamo il nome "n".
def vittoria(n):
     if ((a1 == n and a2 == n and a3 == n) or (b1 == n and b2 == n and b3 == n) or
        (c1 == n and c2 == n and c3 == n) or
       (a1 == n and b1 == n and c1 == n) or (a2 == n and b2 == n and c2 == n) or
       (a3 == n and b3 == n and c3 == n) or
       (a1 == n and b2 == n and c3 == n) or (a3 == n and b2 == n and c1 == n)):
          EsisteVincitore = 'si'
     else:
          EsisteVincitore = 'no'
     return EsisteVincitore

variabili globali, variabili locali
La funzione "vittoria" contiene una novità importante su cui dobbiamo riflettere insieme.
In una funzione di Python si possono introdurre variabili che appartengono al programma principale, come a1,..., c3..., che sono chiamate "variabili globali", perché hanno un valore globale indipendentemente da dove sono
scritte. Inoltre, vi sono variabili come "EsisteVincitore" che sono valide soltanto entro il corpo della funzione e che sono chiamate "variabili locali".
Le variabili locali non sono utilizzabili fuori dal corpo della funzione; inoltre, entro una funzione non si può modificare il valore di una variabile globale.
Se vogliamo utilizzare il valore di una variabile locale entro il programma principale dobbiamo scrivere, come abbiamo fatto in "vittoria", una istruzione come

return EsisteVincitore

L'istruzione "return" trasferisce il valore della variabile locale "EsisteVincitore" nella scatola che ha il nome della funzione (nel nostro caso, "vittoria"). Quando poi, nel programma principale, scriveremo, ad esempio,

partitafinita = vittoria('R')

il contenuto di "vittoria" sarà trasferito nella variabile globale "partitafinita". In sostanza, il contenuto della variabile locale "EsisteVincitore" (che può essere "si" oppure "no") viene dapprima trasferito nella scatola di nome "vittoria" e poi nella scatola di nome "partitafinita".

Il programma principale
Per scrivere il programma principale serviranno molte testoline pensanti perché è un programma un po' lungo e non sempre facilissimo.

# Il programma inizia ponendo tutte le nove variabili uguali a 'x'.
a1 = 'x'
a2 = 'x'
a3 = 'x'
b1 = 'x'
b2 = 'x'
b3 = 'x'
c1 = 'x'
c2 = 'x'
c3 = 'x'
# Poi visualizza la scacchiera

scacchiera()

# Quindi inizializza una variabile di nome "nmosse" che conta il numero delle mosse fatte dai giocatori e la variabile "partitafinita" che indica quando la partita è finita.

nmosse = 0
partitafinita = 'no'

# Poi informa che muoverà prima “N”.

print 'Il primo giocatore sarà N \n'

# A questo punto il programma entra in un ciclo che sarà percorso più volte. Poiché il numero totale delle mosse non può superare 9 (il numero delle posizioni sulla scacchiera) il ciclo sarà controllato dalla variabile "nmosse", che abbiamo posto = 0. Dopo la prima mossa, nmosse sarà posta = 1 e dopo la seconda mossa nmosse sarà posta = 2. A questo punto si torna all'inizio del ciclo che quindi sarà descritto al massimo 5 volte.
Prima di tutto si invita il giocatore a fare la propria mossa. Il programma verificherà che la mossa sia corretta con le istruzioni:

print 'Muova N \n'
mossafatta = 'no'
x = raw_input('Dove vuoi scrivere N: a1, a2, a3, b1, b2, b3, c1, c2, c3? \n')
if x == 'a1' and a1 == 'x':
   a1 = 'N'
   mossafatta = 'si'

# In sostanza il programma verifica che la posizione dove il giocatore intende collocare il proprio simbolo contenga una "x" e sostituisce quella "x" con il simbolo ("N" o "R") del giocatore stesso. La variabile "mossafatta" viene inizializzata al valore "no" e viene posta = "si" se il giocatore ha indicato una mossa corretta, ossia uno dei simboli a1,a2,.....c3, come propria risposta e non ha chiesto di sostituire il simbolo dell'avversario con il proprio. Se il giocatore richiede una mossa non legittima o dà una risposta non corretta, verrà squalificato.
Nota bene che quando si scopre che c'è un vincitore (EsisteVincitore = 'si') si pone nmosse = 10 per uscire subito dal ciclo. Se il numero delle mosse fatte è = 0 e non c'è vincitore, il programma decide il pareggio e pone nmosse = 10 per uscire dal ciclo.

while nmosse < 9 :
    print 'Muova N \n'
    mossafatta = 'no'
    x = raw_input('Dove vuoi scrivere N: a1, a2, a3, b1, b2, b3, c1, c2, c3\n')
    if x == 'a1' and a1 == 'x':
       a1 = 'N'
       mossafatta = 'si'
    elif x == 'a2' and a2 == 'x':
       a2 = 'N'
       mossafatta ='si'
    elif x == 'a3' and a3 == 'x':
       a3 = 'N'
       mossafatta ='si'
    elif x == 'b1' and b1 =='x':
       b1 = 'N'
       mossafatta ='si'
    elif x == 'b2' and b2 == 'x':
       b2 = 'N'
       mossafatta ='si'
    elif x == 'b3' and b3 == 'x':
       b3 = 'N'
       mossafatta ='si'
    elif x == 'c1' and c1 == 'x':
       c1 = 'N'
       mossafatta ='si'
    elif x == 'c2' and c2 == 'x':
      c2 = 'N'
      mossafatta ='si'
    elif x == 'c3' and c3 == 'x':
      c3 = 'N'
      mossafatta ='si'
    if mossafatta == 'no':
       print 'SQUALIFICATO!'
       partitafinita = 'si'
       nmosse = 10
    scacchiera()
    nmosse = nmosse + 1
    partitafinita = vittoria('N')
    if partitafinita == 'si':
       print 'Ha vinto N \n'
       nmosse = 10
    elif nmosse == 9:
       print 'PAREGGIO'
       nmosse = 10

# Se non si sono fatte tutte le mosse, il programma invita il giocatore "R" a fare la sua mossa e procede al controllo di questa mossa con la stessa logica che è stata adottata per "N".

if partitafinita == 'no' and nmosse < 9:
   nmosse = nmosse +1
   mossafatta = 'no'
   print 'La mossa tocca a R \n'
   x = raw_input('Dove vuoi scrivere R: a1, a2, a3, b1, b2, b3, c1, c2, c3? \n')
   if x == 'a1' and a1 == 'x':
     a1 = 'R'
     mossafatta = 'si'
  elif x == 'a2'and a2 == 'x':
    a2 = 'R'
    mossafatta = 'si'
  elif x == 'a3'and a3 == 'x':
    a3 = 'R'
    mossafatta = 'si'
 elif x == 'b1'and b1 == 'x':
   b1 = 'R'
   mossafatta = 'si'
 elif x == 'b2'and b2 == 'x':
  b2 = 'R'
  mossafatta = 'si'
 elif x == 'b3'and b3 == 'x':
  b3 = 'R'
  mossafatta = 'si'
 elif x == 'c1'and c1 == 'x':
 c1 = 'R'
 mossafatta = 'si'
elif x == 'c2'and c2 == 'x':
c2 = 'R'
mossafatta = 'si'
elif x == 'c3'and c3 == 'x':
c3 = 'R'
mossafatta = 'si'
if mossafatta == 'no':
   print 'SQUALIFICATO!'
   partitafinita = 'si'
   nmosse = 10
scacchiera ()
partitafinita = vittoria('R')
if partitafinita == 'si':
   print 'Ha vinto R \n'
   nmosse = 10

Le liste

Cos’è una lista? È come quella che si fa quando bisogna fare la spesa? O come quando si fa l’elenco degli amici da invitare alla festa per il compleanno?
Una lista è un insieme ordinato di valori di qualunque tipo, proprio come la lista della spesa.
Vediamo qualche esempio:
[3,6,9,12,15] lista di tutti numeri interi
["Luigi","Mario","Nicola","Giuseppina"] lista di tutte stringhe
["pane","latte","zucchero",1,15,230,"bicchieri",1.5,2.5]
lista mista: 3 stringhe, 3 numeri interi, 1 stringa, 2 numeri decimali
I valori della lista sono chiamati “elementi” .
Le parentesi quadrate [ ] iniziano e finiscono la lista e la virgola (“,”) separa un elemento della lista dall'altro.
Come abbiamo visto in uno degli esempi precedenti, non è obbligatorio che gli elementi di una lista siano tutti dello stesso tipo, tutti numeri o tutte stringhe, ossia una lista può essere non omogenea.
Esiste poi una lista speciale chiamata “lista vuota” e si indica con [ ].
La lista vuota non contiene alcun elemento.
Esempi:
["pane","latte","zucchero",1,15,230,"bicchieri",1.5,2.5]
[1,"due",3.0]
[]
["tabellina del cinque",5,10,15,20,25]

Ovviamente, alle liste possiamo dare un nome.
spesa
=["pane","latte","zucchero",1,15,230,"bicchieri",1.5,2.5]
vocabolario = ["bicicletta","casa","scuola"]
dati_di_delpiero = ["Del Piero", "Alessandro", 1974]
lista_vuota = []

Ma le liste sono un tipo di variabile?

Si, le liste sono un tipo di variabile. Variabili "composte".
Le variabili ordinarie immagazzinano un singolo valore.
Le liste sono variabili che possono contenere più di un valore.
Possiamo pensarle come composte da una serie di scatole.
Vediamo ora come si fa ad accedere ai singoli elementi di una lista.
Prova a scrivere il seguente programma e analizza attentamente il risultato:
Squadre = ["Juventus", "Inter", "Milan", "Roma"]
i = 0
while i < 4:
  print Squadre[i]
  i = i + 1

Questo programma assegna alla lista squadre alcuni valori e con il ciclo while “attraversa” la lista e ne visualizza un elemento alla volta.
Per farlo usa un indice (nel nostro caso “i”).
Squadre[i] individua l'elemento i della lista squadre.
Quindi è possibile accedere separatamente a ciascun elemento della lista.

Ricordi che abbiamo parlato di insieme ordinato di valori?
Gli elementi di una lista sono valori numerati e identificati da un indice.
Un indice identifica un particolare elemento di un insieme ordinato che nel
nostro caso è l'insieme degli elementi della lista.
La numerazione degli elementi della lista inizia da 0.

Squadre[0] è la stringa "Juventus"
Squadre[1] è la stringa "Inter"
Squadre[2] è la stringa "Milan"
Squadre[3] è la stringa "Roma"

oppure

dati_di_delpiero[0] è la stringa "Del Piero"
dati_di_delpiero[2] è la stringa "1974"

Appare chiaro da questi esempi che l'elemento [0] è il primo e l'elemento [2] è il terzo.

Nota bene: Fai attenzione al fatto che gli indici di una lista, cosi come gli indici di una stringa, iniziano sempre da zero; può sembrarti strano, ma i calcolatori preferiscono iniziare a contare da zero. Quindi per accedere al primo elemento di una lista dobbiamo scrivere [0] e non [1].
Esercitati a selezionare gli elementi di tutte le liste che abbiamo usato come esempio e prova a scrivere un ciclo WHILE per attraversarle e visualizzare gli elementi su video, come nell'esempio seguente, con la lista: [3,6,9,12,15]

1. Innanzitutto dobbiamo dare un nome alla lista:
   tabellina = [3,6,9,12,15]
2. Quindi selezionare gli elementi:
   >>>print tabellina[0]
   3
   .......
   .......
   .......
3. Ora scriviamo il ciclo per attraversare la lista:
   i = 0
   while i < 5:
   print tabellina[i]
   i = i + 1

Ora che hai una buona dimestichezza con le liste, specifichiamone meglio l'uso. Ad esempio:
Cosa succede con questa espressione?
dati_di_delpiero[1] = "Ale"
L'operatore porzione [ ] può comparire sia a destra che a sinistra del simbolo = di un'espressione. A destra indica l'elemento specificato, a sinistra cambia uno degli elementi della lista (nell'esempio all'elemento 1 viene assegnato il valore “Ale”). Quindi il secondo elemento della lista dati_di_delpiero[1] diventa: "Ale".
A differenza delle stringhe, le liste sono “mutabili”, cioè gli elementi della lista possono essere sostituiti da valori diversi da quelli iniziali. È quindi possibile cambiare il valore di un elemento di una lista con un'istruzione di assegnazione.
Se a dati_di_delpiero aggiungiamo un quarto elemento per indicare i gol fatti, scriveremo:
dati_di_delpiero = ["Alessandro","Del Piero", 32, 205]
Ogni volta che Del Piero segnerà un goal scriverò:
dati_di_delpiero[3] = dati_di_delpiero[3] + 1
e, ogni anno, il giorno del suo compleanno, il 9 novembre, scriverò
dati_di_delpiero[2] = dati_di_delpiero[2] + 1

Indici
Si accede agli elementi di una lista nel modo già visto per accedere ai caratteri di una stringa.
print dati_di_delpiero[1] -> Visualizza: il secondo elemento della lista, ossia Alessandro
Una qualsiasi espressione che produca un intero può essere un indice.
Ad esempio: tabellina[5-1] visualizza: 12
Prova a usare un numero decimale come indice e analizza il messaggio di errore
che compare:
TypeError: sequence index must be integer
Prova a leggere o a modificare un elemento che non esiste. Ad esempio:
tabellina[7] = 2
L'interprete cerca di assegnare a tabellina[7] il valore 2.
Anche qui analizza attentamente il messaggio di errore:
IndexError: list assignment index out of range

Cosa succede se l'indice ha valore negativo? ad esempio: tabellina[-2]
Se un indice ha valore negativo il conteggio parte dalla fine della lista.
Per verificarlo prova a scrivere: dati_di_delpiero[-3]
Questo metodo di usare l’indice negativo si rivela molto comodo quando non si ricorda la lunghezza della lista. Sappiamo che se scriviamo [-1] accederemo all’ultimo elemento, [-2] al penultimo e così via.
Infine, come abbiamo visto all’inizio, una variabile di ciclo può essere usata come indice di lista. Esempio:
amici = ["Gianni", "Luigi", "Carlo"]
i = 0
while i <3:
print amici[i]
i = i +1

Lista speciale
È una lista composta da tutti numeri interi consecutivi, talmente comune che Python fornisce un modo speciale per crearla. La funzione range è lo strumento usato per crearla. Infatti, scrivere [0,1,2,3,4] è equivalente a scrivere range[5].
Cioè, la funzione range crea una lista che parte da 0 e arriva fino al numero indicato dall'indice.
range[10] è equivalente a [0,1,2,3,4,5,6,7,8,9].
Con range si può scrivere: range[1,5] che è equivalente a [1,2,3,4].
La funzione range in questo caso legge dalla lista di interi gli elementi che partono dal primo indice incluso e arrivano all'ultimo indice escluso.
Con range possiamo scrivere anche espressioni del tipo:
range[1,10,2] che è equivalente a [1,3,5,7,9]
Il terzo indice si chiama "passo" e indica con quale intervallo leggere i numeri dalla lista di interi partendo da 1 e arrivando a 10 escluso. In questo caso legge il primo, il terzo, il quinto e cosi via fino a 10-1, ottenendo una lista di numeri dispari.
Che lista ottieni con questa funzione, range[2,10,2] ?       [2, 4, 6, 8]

3 – Lunghezza di una lista
La funzione len applicata ad una lista produce il numero di elementi di una lista, come nelle stringhe.
>>>allievi=["luigi","marco","filippo","paola","gabriella","silvia"]
>>>i = 0
>>>while i < len(allievi):
>>> print allievi[i]
>>> i = i + 1
luigi marco filippo paola gabriella silvia

4 – Operazioni sulle liste
Come per le stringhe, l'operatore + concatena le liste:
>>>allievi_3A = ["luigi","marco","filippo","paola","gabriella","silvia"]
>>>allievi_4E = ["gabriele","alessandro","anna","michela","antonio"]
>>>allievi = allievi_3A + allievi_4E
>>>print allievi
luigi marco filippo paola gabriella silvia gabriele alessandro anna michela antonio

L'operatore * ripete una lista un dato numero di volte.
>>>numeri * 4
3 6 9 12 15 3 6 9 12 15 3 6 9 12 15 3 6 9 12 15
>>>allievi_4E * 2
gabriele alessandro anna michela antonio gabriele alessandro anna michela antonio

5 – Sezione di lista
Una sezione di lista è l'analogo di una sezione di stringa e ha la stessa logica di funzionamento. Infatti, come per le stringhe, si adotta l'operatore porzione :
>>>amici = ["Gianni", "Luigi", "Carlo")
>>>amici[0:3]
gianni luigi carlo
>>amici[1:3]
luigi carlo
>>>allievi_4E =
["gabriele","alessandro","anna","michela","antonio"]
>>>allievi_4E[1:3]
[alessandro,anna ]
>>>allievi[1:2]
[alessandro]

Con questo operatore possiamo eliminare uno o più elementi di una lista assegnando alla corrispondente sezione una stringa vuota.
>>>allievi_4E = ["gabriele","alessandro","anna","michela","antonio"]
>>>allievi_4E[1:3] = []
>>>print allievi_4E
gabriele michela antonio
Ma non è così pratico ed è facile sbagliare. Con la funzione del è molto più facile cancellare un elemento da una lista.
>>>allievi_4E = "gabriele","alessandro","anna","michela","antonio"]
>>> del allievi_4E[1:3]
>>>print allievi_4E
gabriele michela antonio
Vediamo un altro esempio:
>>>Squadre = ["Juventus", "Inter", "Milan", "Roma"]
>>>del Squadre[1]
>>>print Squadre
Juventus Milan Roma
Analogamente possiamo inserire uno o più elementi in una lista inserendoli in una sezione vuota nella posizione desiderata, come nella terza istruzione del programma seguente:
>>>allievi_4E = ["gabriele","alessandro","anna","michela","antonio"]
>>>print allievi[2:2]
[]
>>>allievi_4E[2:2] = ["sandra", "andrea"]
>>>print allievi_4E
gabriele alessandro sandra andrea anna michela antonio

Cosa si ottieneo se scrivo quanto segue?
>>>allievi_4E =
["gabriele","alessandro","anna","michela","antonio"]
>>>print allievi_4E[:4]
>>>print allievi_4E[3:]
>>>print allievi_4E[:]
Se non viene specificato il primo indice la porzione parte dall'inizio della stringa.
Senza il secondo indice la porzione finisce con il termine della stringa.
Se mancano entrambi gli indici si intende tutta la lista.

LISTE annidate
Un elemento di una lista può essere a sua volta una lista.
>>>tabellina = [3,6,9,12,15,[10,20,30]]
>>>print tabellina[5]
10 20 30
Il sesto elemento della lista tabellina è a sua volta una lista.

Nell'esempio la lista allievi_4E è diventata una lista di liste:
>>>allievi_4E =
[["bianchi","gabriele"],["verdi","alessandro"],["rossi","anna"],["neri","michela
"],["viola","antonio"]]
>>>print allievi_4E[2]
rossi anna

Cosa si ottiene se si scrive print allievi_4E[2][0]?
Si ottiene come risultato [rossi].
Si può estrarre un elemento da una lista annidata con due metodi differenti.
Il primo è il seguente:
>>>allievo = allievi_4E[2]
>>> allievo[0]
rossi
Si crea una lista che si chiama allievo e prendo il primo elemento di quella nuova
lista.
Il secondo permette di scrivere direttamente:
>>>allievi_4E[2][0]
Questa espressione deve essere letta da sinistra verso destra: trova il terzo
elemento (2) della lista allievi_4E
ed essendo questo elemento a sua volta una lista, ne estrae il primo elemento (0).

Il ciclo FOR
Riprendiamo l’esempio:
allievi = ["luigi","marco","filippo","paola","gabriella","silvia"]
i = 0
while i < len(allievi):
      print allievi[i],
     i = i + 1

luigi marco filippo paola gabriella silvia
Questo ciclo può essere scritto anche in questo modo:

allievi = ["luigi","marco","filippo","paola","gabriella","silvia"]
for allievo in allievi:
      print "Ora stampo l'allievo: ", allievo
Possiamo leggere quasi letteralmente: “Fai quello che segue per ciascun allievo nella lista allievi, lavorando la prima volta sul primo elemento, la seconda sul secondo, e cosi via.
Stesso risultato, ma il programma è molto più conciso.
In termini generali si deve scrivere:

for <nome di variabile> in <nome di lista>:

L’istruzione for significa:
per ciascuna variabile della lista fai tutto quello che segue

In modo più formale la lista viene analizzata dal primo elemento sino all'ultimo.
La prima volta:
1. alla variabile allievo assegna il valore allievi[0]
2. esegue i comandi che seguono i due punti
3. ritorna all’istruzione for e prosegue fin quando trova un elemento nella lista.

Negli esempi che seguono cerchiamo di capire a cosa può servire il ciclo for

Stampiamo il quadrato dei primi 10 numeri interi.
for numero in range(11):
print "il quadrato di ", numero, " è ", numero * numero
il quadrato di 0 è 0
il quadrato di 1 e` 1
il quadrato di 2 e` 4
il quadrato di 3 e` 9
il quadrato di 4 e` 16
il quadrato di 5 e` 25
il quadrato di 6 e` 36
il quadrato di 7 e` 49
il quadrato di 8 e` 64
il quadrato di 9 e` 81
il quadrato di 10 e` 100

Misuriamo ora la lunghezza di alcune parole:
vocabolario=['alba','banana','carro','dodici','giacca','finestra']
for parola in vocabolario:
print parola, len(parola)
alba 4
banana 6
carro 5
dodici 6
giacca 5
finestra 8

Per uscire immediatamente da un ciclo for o while si può usare l’istruzione break.
Vediamo un esempio semplice: un programma che stampa tutti i numeri positivi fino a 100 ma se viene inserito 0 si interrompe.
i = 1
while i < 100:
      i = input('inserisci un numero da 0 a 100 ')
      if i == 0:
        break
      print "il numero è ", i
i = i + 1
print 'Finito'

Notare che se il ciclo avesse un else questo non verrebbe mai eseguito.

Fare le cose “con stile”

Prima di passare allo step successivo, dedicato interamente alla grafica, vediamo insieme qualche accorgimento utile per facilitarci nella scrittura di programmi più complessi, con molte righe di codice.
I programmi che eseguono operazioni complesse hanno tantissime righe di codice e a volte può essere veramente difficile ricordarsi la logica con cui sono state scritte.
I programmatori hanno una regola fondamentale quando scrivono i loro programmi: la coerenza.

È molto importante che il codice del programma sia scritto in modo da rispettare alcune regole che il programmatore decide all'inizio cosi poi gli sarà facile leggerlo in seguito quando dovrà correggerlo o cambiarlo.
Cominciamo...

Indentazioni
Quando si inizia a scrivere, si decida quanti spazi lasciare nelle indentazioni delle istruzioni e lascia sempre quelli.
Ricordarsi di usare sempre e solo la sbarra spaziatrice.
Se si utilizzasse il tasto di tabulazione, si potrebberoavere dei problemi; infatti, i computer seguono formattazioni diverse per il TAB.
Nell'esempio seguente lasciamo sempre 4 spazi:

def interrogazione(domanda,risposta_esatta):
    risposta_allievo = raw_input(domanda)
        if risposta_esatta == risposta_allievo:
               print "La risposta è esatta"
               print "Bravissimo"
        else:
            print "Risposta errata"
            print "La risposta esatta è ", risposta_esatta
            print ". Studia di più!"

Separazioni
È una buona regola separare le definizioni di funzioni lasciando due righe bianche.
Si possono usare le righe bianche anche all'interno del programma e delle funzioni, moderatamente, per indicare le sezioni logiche, cioè le parti di programma che risolvono problemi diversi.

Spazi bianchi in Espressioni e Istruzioni sono da evitare
• immediatamente entro parentesi tonde, quadre o graffe
• subito prima di virgola, punto e virgola, o due punti
• subito prima della parentesi aperta che inizia la lista degli argomenti in una chiamata
• subito prima della quadra aperta che inizia un indicizzazione
• più di uno spazio attorno a un assegnamento o operatore per allinearlo con altri, tipo:
• x      = 1
• y      = 2

Lunghezza massima delle righe
Molto spesso sui PC di uso comune le righe sono di 80 caratteri.
Se scrivi linee più lunghe, queste verranno "ripiegate" e risulteranno brutte e soprattutto difficili da leggere.
Cercate quindi di limitare ogni linea a un massimo di 79 caratteri (una linea di esattamente 80 caratteri rischierebbe infatti di venire comunque ripiegata).
Comunque, se proprio non ci riuscite, il modo migliore di dividere linee lunghe è come vedi nell'esempio
seguente:
print altezza_media_femmine
altezza_media_classe =((altezza_media_femmine*femmine)+
                      (altezza_media_maschi*maschi))/alunni
print altezza_media_classe
Ricordarsii di indentare bene la riga che continua a capo e sempre nello stesso modo.

I commenti
I "commenti" sono parole, frasi o proprio testi brevi che servono a spiegare bene le operazioni che il codice esegue. I commenti non sono esaminati dall'interprete che quando li incontra passa oltre.
È molto importante aggiungere nei programmi alcune osservazioni che spiegano le operazioni che vengono fatte perché il codice risulta molto più comprensibile anche allo stesso autore, che dopo un po' di mesi può anche non ricordarsi più perché aveva scritto le istruzioni in quel modo.
Attenzione a scrivere bene i commenti: inserire dei commenti che contraddicono il codice è molto peggio che non avere commenti!
Anche per i commenti valgono le raccomandazioni precedenti.

I commenti possono essere "a blocco" e allora si riferiscono al codice che li segue.
• Se il codice è indentato anche i commenti a blocco vanno indentati esattamente come quel codice.
• Ogni riga di un commento a blocco inizia con # .
• Si possono separare i paragrafi entro un commento a blocco con una riga vuota che contiene
soltanto un #.
• Il commento può essere lungo quanto si vuole, non ci sono limiti sulla lunghezza.
• È meglio circondare i commenti a blocco con una riga bianca sopra e una sotto per renderli più visibili.

I commenti possono essere anche "in linea" ovvero sulla stessa riga dell'istruzione.
Questi commenti non dovrebbero dire delle cose ovvie, ad esempio:
x = x+1 # Incremento x
è un commento ovvio e quindi inutile e soprattutto distrae chi legge il programma!!!

I commenti in linea dovrebbero essere separati da almeno due spazi dall'istruzione e devono iniziare con un # seguito da un singolo spazio. Ricordati di non usare spesso i commenti in linea perché l'effetto finale è di un programma poco leggibile, meglio usare alcuni blocchi anche lunghi ma messi nei punti cruciali del programma.
Vediamo un esempio prima senza i commenti e poi con alcuni commenti.
def interrogazione(domanda,risposta_esatta):
     risposta_allievo = raw_input(domanda)
      if risposta_esatta == risposta_allievo:
          print "La risposta è esatta"
          print "Bravissimo"
     else:
           print "Risposta errata"
         print "La risposta esatta è ", risposta_esatta
         print ". Studia di più!"
domanda1 = "In che anno è caduto l'impero romano d'occidente? "
risposta_esatta1 = "476"
interrogazione(domanda1, risposta_esatta1)
domanda2 = "Chi è stato il primo presidente degli Stati Uniti? "
risposta_esatta2 = "Washington"
interrogazione(domanda2, risposta_esatta2)
domanda3 = "In che anno è terminata la prima guerra mondiale? "
risposta_esatta3 = "1918"
interrogazione(domanda3, risposta_esatta3)

Ora rivediamo lo stesso esercizio con i commenti:
# Programma “interrogazione di storia”
# a ogni domanda chiama la funzione
# interrogazione
# funzione che controlla la risposta dell'allievo, confrontandola con la
# risposta esatta
def interrogazione(domanda,risposta_esatta):
    risposta_allievo = raw_input(domanda)
    if risposta_esatta == risposta_allievo:
        print "La risposta è esatta"
        print "Bravissimo"
    else:
    print "Risposta errata"
    print "La risposta esatta è ", risposta_esatta
       print ". Studia di più!"

# prima domanda
domanda1 = "In che anno e` caduto l'impero romano d'occidente? "
risposta_esatta1 = "476"
interrogazione(domanda1, risposta_esatta1) # prima chiamata di funzione
# seconda domanda
domanda2 = "Chi e' stato il primo presidente degli Stati Uniti? "
risposta_esatta2 = "Washington"
interrogazione(domanda2, risposta_esatta2)..... # seconda chiamata di funzione
# terza domanda
domanda3 = "In che anno e` finita la prima guerra mondiale? "
risposta_esatta3 = "1918"
interrogazione(domanda3, risposta_esatta3 # terza chiamata di funzione

Scoprire gli errori (debugging)

Può capitare che un programma funzioni correttamente ma che il risultato sia diverso da quello che ci si aspetti oppure che un programma non faccia nulla o ancora che non si fermi più quando va in esecuzione; insomma spesso i programmi contengono degli errori che non è sempre facile scoprire. In inglese gli errori si chiamano "bug", insetti che si infiltrano tra le righe del programma, ed è per questo che la tecnica di scoprire gli errori si chiama "debugging".
Il primo passo per scoprire un errore è capire con che tipo di errore si ha a che fare.

Un tipo di errore molto comune è l'errore di sintassi. Si verifica quando sbagli a scrivere un istruzione (ad esempio mancano i due punti alla fine di una istruzione if) e compaiono i messaggi: SyntaxError,
invalid syntax. Python può eseguire un programma solo se il programma è sintatticamente corretto, altrimenti il programma non è eseguito e l'interprete trasmette un messaggio d'errore.
Ecco alcune raccomandazioni per evitare i più comuni errori di sintassi.

• controllare di non usare parole riservate per dare i nomi alle variabili
• controllare i due punti alla fine delle istruzioni dove sono necessari
• controllare l'indentazione
• controllare che le parentesi siano appaiate correttamente ( una parentesi non chiusa costringe Python a cercare la fine nelle righe successive...)
• controllare che non ci sia un "=" anziché un "=="

Un altro tipo di errore è l'errore in esecuzione (runtime error).
Cioè il programma non fa nulla oppure si blocca, oppure continua all'infinito, oppure ancora si sta cercando di dividere un numero per 0. In tutti questi casi la sintassi è corretta ma qualcosa va storto.
E qui il controllo diventa più difficile. Vediamo i casi possibili:
- Il programma non fa nulla: magari si ha delle funzioni ma ti sei dimenticato di mettere nel programma la chiamata di funzione. Controllare bene che ci siano tutte le chiamate alle funzioni.
- Il programma si blocca o continua all'infinito. Controllare i cicli, forse il programma non esce mai da un ciclo.
Un metodo semplice e utile di scoprire gli errori nei cicli è quello di stampare i risultati di ogni operazione usando l'istruzione print immediatamente prima di entrare nel ciclo e una subito dopo
l'uscita. Ad esempio: print "entrata nel ciclo" e print "uscita dal ciclo".
Cosi se eseguendo il programma vedi il primo messaggio ma non il secondo sei sicuro che il ciclo è infinito!

Inserire le istruzioni di "print" per scoprire gli errori in esecuzione è un metodo ottimo e può essere usato come nell'esempio di prima oppure per:
- stampare i valori delle variabili prima e dopo una condizione (if, while) per verificare che cambino.
- stampare i parametri di una funzione
- aggiungere le istruzioni print lungo il flusso del programma ti permette di seguire la traccia di cosa sta facendo Python ed eventualmente dove sbaglia
Attenzione a non farsi sommergere dalle "print". Bisogna metterne poche e quando non servono bisogna ricordarsi di toglierle.
Spesso vedere stampati i dati ti aiuta a scoprire indizi utili a trovare la soluzione agli errori.
Ma non disperarsi se si è davvero bloccati! Anche ai migliori succede. In questo caso la soluzione migliore è smetterla di guardare il codice, fermarsi e poi ritornare "freschi". A volte ci vuole molto tempo per trovare un errore ed è meglio fare la ricerca con la mente riposata.
I migliori hacker sostengono che i posti sicuri per trovare i bug sono itreni, le docce, il letto...!!!
Il lavoro di debugging a volte può essere frustrante ma è anche una delle parti più creative, stimolanti ed interessanti della programmazione.
In un certo senso per fare il debug bisogna diventare detective: si è messi di fronte agli indizi e bisogna ricostruire i processi e gli eventi che hanno portato ai risultati che si è ottenuto.
Come diceva Sherlock Holmes "Quando hai eliminato l'impossibile ciò che rimane, per quanto improbabile, deve essere la verità".

Vediamo un esempio di debugging così capirai più facilmente l’uso dell’istruzione print come strumento di debugging. Riprendiamo un esercizio:
La soluzione corretta, con le "print" per il debugging e i commenti è:
maschi = 8
femmine =10
alunni = maschi + femmine
print alunni
M = 1.55 #altezza di Mario
FML = 1.60*3 #altezza di Fabio, Matteo, Luca
AAGG = 1.50*4 #altezza di Aldo Andrea Giovanni Giacomo
altezza_media_maschi = (M + FML+ AAGG)/ maschi
print altezza_media_maschi
MGEF = 1.55*4 #altezza di Marta Giovanna Elisabetta Francesca
SCS = 1.50*3 #altezza di Stefania Chiara Simonetta
A = 1.68 #altezza di Arianna
DD = 1.63*2 #altezza di Daria, Domitilla
altezza_media_femmine = (MGEF+ SCS + A + DD)/femmine
print altezza_media_femmine
altezza_media_classe =((altezza_media_femmine*femmine)+(altezza_media_maschi*maschi))/
alunni
print altezza_media_classe

Facciamo un errore:
maschi = 8
femmine =10
alunni = maschi + femmine
print alunni
M = 1.55
FML = 1.60*3
AAGG = 1.50*4
altezza_media_maschi = (M + FML+ AAGG)/ maschi
print altezza_media_maschi
MGEF = 1.55*4
SCS = 1.50*3
A = 1.68
DD = 1.63*5 (errore inserito)
altezza_media_femmine = (MGEF+ SCS + A + DD)/femmine
print altezza_media_femmine
altezza_media_classe =((altezza_media_femmine*femmine)+(altezza_media_maschi*mas
chi))/alunni
print altezza_media_classe

Dopo aver verificato che l'altezza media delle femmine ha un valore che è sbagliato, proviamo ad inserire alcune istruzioni di stampa (print) per controllare il valore delle variabili che utilizziamo per calcolare il valore - altezza media delle femmine. Così si vedrà che il valore della variabile DD è sbagliato e sarà facile correggere l’errore:

maschi = 8
femmine =10
alunni = maschi + femmine
print alunni
M = 1.55
FML = 1.60*3
AAGG = 1.50*4
altezza_media_maschi = (M + FML+ AAGG)/ maschi
print altezza_media_maschi
MGEF = 1.55*4
SCS = 1.50*3
A = 1.68
DD = 1.63*5
print AA
print SCS
print A
print DD
altezza_media_femmine = (MGEF+ SCS + A + DD)/femmine
print altezza_media_femmine
altezza_media_classe
=((altezza_media_femmine*femmine)+(altezza_media_maschi*maschi))/alunni
print altezza_media_classe

Inserendo queste quattro istruzioni di print potremo accorgerci dell'errore che abbiamo fatto.

 

I cicli

Come si sa è possibile assegnare più valori ad una stessa variabile, con la variabile che assume sempre l'ultimo valore assegnato.
Ad esempio:

Num = 3
print Num,
Num = 9
print Num

Il risultato di questo programma è 3 9, perché la prima volta che Num è stampato il suo valore e`3, la seconda 9.
Nota bene: La virgola dopo la prima istruzione print evita il ritorno a capo dopo la stampa; in questo modo entrambi i valori appaiono sulla stessa riga.
Detto questo, si provi a scrivere il seguente programma e analizza cosa succede.

a = 1
while a < 4 :
print a
a = a + 1

Prova a leggere il programma con l'istruzione while come fosse scritto in un linguaggio naturale (while significa: finché, fintantoché). Otterrai:
"Finché (while) a è minore di 4 stampa il valore di a e poi aumentalo di 1.  Quando arrivi a 4 esci perché a deve essere minore di 4”.

Si provi ora a scrivere un programma per stampare:

1. tutti i numeri minori di 10
2. tutti i numeri da 100 a 1000 compresi.

Come hai capito questo comando viene usato per eseguire le azioni ripetitive e i computer sono bravissimi a ripetere le azioni tante volte. Per risolvere questo tipo di problema si usano i “cicli” o “loop” (che in inglese significa appunto "ciclo").
Ci sono due tipi di “cicli” e tra i due c'è una differenza molto importante.
Il primo, chiamato while, viene usato quando non si sa prima quante volte deve ripetere l'azione.
Il secondo, chiamato for, è usato quando si sa in anticipo quante volte si dovrà ripetere l'azione.

Il programma precedente può essere rappresentato cosi:

Vediamo ora insieme i programmi 1 e 2.

1. Stampa tutti i numeri minori di 10
   a = 0
   while a < 10:
        print a,
        a = a + 1
2. Stampa tutti i numeri da 100 a 1000
   a = 100
   while a <= 1000:
   print a,
   a = a + 1

Riprendiamo ora il semplice programma di prima:

programma	visualizza
a =1 while a < 4 : print a a = a + 1	1 2 3

 

Ripetiamo. L’istruzione while significa: "fai tutto quello che segue fintantoché la relazione scritta fra la parola while e i due punti è soddisfatta".

Nota bene: i due punti sono obbligatori 

In modo più formale il flusso di esecuzione di un'istruzione while è il seguente:

1. Valuta la condizione controllando se essa è vera o falsa.
2. Se la condizione è falsa esci dal ciclo while e continua l'esecuzione dalla prima istruzione che lo segue.
3. Se la condizione è vera esegui tutte le istruzioni nel corpo del while e torna al passo 1.

Nel nostro caso il programma esegue le istruzioni:
print a
a = a + 1
tre volte, cioè finché a è minore di 4.
Ecco in dettaglio quello che succede in quelle tre volte.

Il programma esce dal ciclo.

Più in generale, se si scrive:
while <relazione> :
<istruzione 1>
<istruzione 2>
<istruzione 3>
il programma esegue il seguente ciclo:

Nota bene: Tutte le istruzioni che seguono la

while <relazione> :

devono essere indentate se fanno parte delle cose da fare quando <relazione> è soddisfatta.

Se la condizione è falsa al primo controllo, le istruzioni del corpo non saranno mai eseguite.
Il corpo del ciclo dovrebbe cambiare il valore di una o più variabili così che la condizione possa prima o poi diventare falsa e far così terminare il ciclo. In caso contrario il ciclo si ripeterebbe all'infinito, determinando un ciclo infinito.
Esaminiamo ora il seguente programma.

a = 3
    while a > 2:
           print a
           a = a + 1

Il programma stampa prima 3, poi 4, poi 5 e cosi via, e non si ferma mai.
Perché?
Se volete evitare che il vostro PC continui a visualizzare la successione dei numeri naturali, premete contemporaneamente i tasti CTRL e C.
Molto bene, il vostro programma di lavoro sta procedendo regolarmente.
Ora dedichiamo un po’ di tempo ad esercitarti, l’esercizio e la pratica sono indispensabili se si vuole diventare un bravo programmatore.

Esercitiamoci insieme

Provate ad eseguire questi due programmi.
Programma 1
a = 1
while a < 100 :
      a = a+1
Programma 2
a = 1
while a < 100000 :
      a = a + 1

Cosa fanno questi due programmi?
Perché il secondo dura più del primo?
A cosa possono servire questi programmi?

Qualche volta, nel corso di un programma complesso, può essere opportuno fermarsi un po’ di tempo per consentire all’utilizzatore del programma di riflettere prima di proseguire. I due programmi precedenti servono proprio a questo, ossia a perdere tempo.
Quanto tempo?
Dipende dalla velocità del calcolatore. Infatti, un calcolatore molto veloce può eseguire una delle due istruzioni:
while a < 100:
a = a + 1
in un decimo di milionesimo di secondo.
Si provi a rispondere a questa domanda: fa perdere più tempo il programma 1 oppure il programma 2?

Visualizza tutti i numeri compresi fra 0 e 100.
i = 0
while i <= 100 :
     print i
     i = i + 1
Visualizza tutti i numeri compresi fra 3 e 9.
i = 3
while i <= 9 :
      print i
      i = i + 1
Visualizza in ordine decrescente i numeri da 200 a 100.
i = 200
while i >= 100 :
      print i
      i = i - 1
Scrivi il programma “Conto alla rovescia” che - finché (while) n è più grande di 0 - stampa il valore di n e poi lo diminuisce di 1. Quando arriva a 0 stampa la stringa “Pronti…VIA!"-.
n = 10
while n > 0 :
      print n
      n = n - 1
print "Pronti ...VIA!"

Quando esegui il programma, scopri che la visualizzazione dei numeri è troppo veloce. Come si può fare per rallentarla?

Visualizza la tabellina del sette stampando i numeri di seguito sulla stessa riga.
i = 1
while i <= 10 :
print 7*i,
i = i + 1
10.8 Scrivi un programma che attende finche non viene inserita la password corretta.
(La password la decidi tu, ad es. “chicchiricchi”).
password = "python"
while password != "chicchiricchi":
password = raw_input("Password:")
print "Entra pure"
10.9 Visualizza tutti i numeri dispari compresi fra 1 e 100.
i = 1
while i < 100 :
print i
i = i + 2
10.10 Stampa la frase “Aiuto! Non mi fermo più” infinite volte usando il ciclo while.
(Per fermare il programma usa i tasti CTRL + C)
i=1
while i != 0 :
print "Aiuto! Non mi fermo più"
i = i + 1
e poi stampa il messaggio di seguito, senza saltare una riga fra uno e l’altro e senza andare a capo.
(Per fermare il programma usa i tasti CTRL + C)
i=1
while i <> 0 :
print "Aiuto! Non mi fermo più",
i = i + 1

Visualizza la tabellina del sette stampando i numeri di seguito sulla stessa riga.
i = 1
while i <= 10 :
print 7*i,
i = i + 1
Scrivere un programma che attende finché non viene inserita la password corretta.
(La password la decidi tu, ad es. “chicchiricchi”).
password = "python"
while password != "chicchiricchi":
    password = raw_input("Password:")
print "Entra pure"
10.9 Visualizza tutti i numeri dispari compresi fra 1 e 100.
i = 1
while i < 100 :
print i
i = i + 2
Stampa la frase “Aiuto! Non mi fermo più” infinite volte usando il ciclo while.
(Per fermare il programma usa i tasti CTRL + C)
i=1
while i != 0 :
    print "Aiuto! Non mi fermo più"
    i = i + 1
e poi stampa il messaggio di seguito, senza saltare una riga fra uno e l’altro e senza andare a capo.
(Per fermare il programma usa i tasti CTRL + C)
i=1
while i <> 0 :
    print "Aiuto! Non mi fermo più",
    i = i + 1

Provare a trovare i divisori di un numero usando il ciclo while.
i=1
n = input("qual è il numero di cui vuoi trovare i divisori? ")
print n, " è divisibile per "
while i < n :
    if n%i == 0 :
        print i,
i = i + 1
Scrivere un programma che chieda il risultato dell'operazione 15 x 17 tante volte sino a quando non viene indicata la soluzione corretta.
corretto = "no"
while corretto == "no":
    risposta = input("quanto vale 15 x 17? ")
    if risposta == 15*17:
        corretto = "si"
        print "Brava!"
    else:
        corretto = "no"

I Cicli annidati

Precedentemente abbiamo risolto il programma n.1 ma quando lo eseguiamo scopriamo che il conteggio alla rovescia è molto veloce. Troppo.
a = 1
while a < 100 :
a = a+1
La soluzione che conta lentamente non è altro che la fusione dei due programmi.
n = 10
while n > 0 :
      print n
      a = 1
      while a < 1000000 :
            a = a + 1
      n = n - 1
print "Pronti ...VIA!"

Nota bene: Quest'ultimo programma contiene due cicli while, di cui il secondo, quello introdotto per "perdere tempo", è ANNIDATO entro il primo.
Notare come è stato scritto il programma:
l'istruzione while a < 1000000 è indentata rispetto a while n > 0 mentre l'istruzione a = a + 1 è indentata rispetto a while a < 1000000.

Le istruzioni che possono essere annidate non devono essere necessariamente dello stesso tipo, possono essere disomogenee.
Ad esempio, posso annidare una decisione (IF), oppure un ciclo di altro tipo (FOR), e anche una funzione.

Esercizi:

Scrivere un programma per stampare il quadrato e il cubo dei numeri da 1 a 10.
i = 1
while i <= 10 :
    e = 1
    while e <= 3 :
        print i ** e, " ",
        e = e + 1
    print
    i = i + 1
Scrivere un programma che chiede una sequenza di numeri da aggiungere ad una somma. Per terminare inserisci 0.
a = 1
somma = 0
print 'Inserisci i numeri da aggiungere alla somma '
print 'Quando hai finito inserisci 0'
while a != 0 :
        print 'La somma è:',somma
        a = input('Numero? ')
        somma = somma + a
print 'Totale =',somma

Scrivere un programma per stampare la Tavola Pitagorica.
print " TAVOLA PITAGORICA"
print
riga = 1
while riga <= 10 :
    colonna = 1
    while colonna <= 10 :
        print '\t', riga * colonna,
        colonna = colonna + 1
    riga = riga + 1
    print

Il carattere di backslash '\' indica l'inizio di una sequenza di escape.
Le sequenze di escape sono usate per rappresentare caratteri “speciali” e invisibili come la tabulazione ('\t') e il ritorno a capo ('\n') e possono comparire in qualsiasi punto di una stringa.

Indovina un numero! Scrivi un programma per indovinare un numero
numero = 27
indovina = 0
while indovina!= numero :
    indovina = input("Indovina un numero: ")
    if indovina > numero:
        print "Troppo grande"
    elif indovina < numero :
            print "Troppo piccolo"
print "BRAVO!!"

….ancora sulle STRINGHE

Sinora abbiamo visto che una stringa è una serie di caratteri, cifre, lettere o altri simboli che si trovano sulla tastiera, cioè un messaggio qualunque.
Inoltre, sappiamo che una stringa per essere considerata tale deve essere racchiusa tra virgolette (semplici o doppie) e che si possono fare alcune operazioni con le stringhe.
Possiamo scrivere:
"ciao" * 3 oppure "ciao" + "ciao" + "ciao" oppure
"ciao" * 2 + "ciao"
invece
"ciao"/4 oppure "ciao" + 5 oppure "18" + 8
sono sbagliate e generano un syntax error.
Che cosa hanno di diverso le stringhe dagli altri tipi di dati (interi, floating point)?
Le stringhe sono qualitativamente diverse dagli altri tipi di dati perché sono composte di unità più piccole: i caratteri.
Per questo le stringhe sono dati “composti” in alternativa ai dati “semplici” che sono gli interi e i floating point.
Questo ci consente di trattare una stringa come fosse una singola entità oppure di agire sulle sue singole parti (i caratteri) a seconda di ciò che stiamo facendo. Come si fa ad agire sui singoli caratteri?

Quale sarà il risultato di questo programma?
squadra = "Juventus"
messaggio = squadra[0] + squadra[2] + squadra[3] + squadra[4] + squadra[5] + squadra[6] + squadra[7]
print squadra
print messaggio
>>>Juventus
>>>Jventus

Come si individuano i singoli caratteri.
Nella variabile squadra abbiamo messo la stringa tutta intera mentre nella variabile messaggio l'abbiamo inserita come sequenza di caratteri.
squadra[i] e` una stringa fatta di un solo carattere e non è altro che il carattere di Juventus che occupa la posizione i + 1.
L'espressione tra parentesi quadrate seleziona i caratteri della stringa. Quindi squadra[0] seleziona il primo carattere, squadra[1] il secondo e cosi via.
Ricordati che i calcolatori iniziano quasi sempre a contare da 0.
L'espressione tra parentesi quadrate è chiamata indice.
Un indice individua un particolare elemento di una stringa e può essere una qualsiasi espressione intera.
Un'espressione aritmetica negativa come –i fra parentesi quadre [-i] indica il carattere posto nella posizione (i + 1) a partire dal fondo.
Così, ad esempio,
squadra[-0] è uguale al carattere "s"
squadra[-2] è uguale al terzultimo carattere, ossia "t".
Cosa si ottiene scrivendo il seguente programma?
>>>squadra = "Juventus"
>>>messaggio = "VIVA" + " " + squadra[0] + squadra[1] + squadra[2] + squadra[3]
>>>print squadra
>>>print messaggio
Juventus
VIVA Juve

Porzioni di stringa
Nell'esempio precedente abbiamo preso una parte della stringa Juventus sommando i primi 4 caratteri; potevamo ottenere lo stesso risultato usando l'espressione
messaggio = "VIVA" + squadra[0:4]
che vuol dire “seleziona tutto il pezzo di stringa a partire dal carattere [0], il primo, fino al carattere [4], il quinto, escluso.
Quale sarà il risultato di:
squadra[:3]
>>>
squadra[3:]
>>>
squadra[:]
>>>
Se non è specificato il primo indice (prima dei due punti :) la porzione parte dall'inizio della stringa. Senza il secondo indice la porzione finisce con il termine della stringa.
Di conseguenza squadra[:] è la stringa intera.
Gli indici di porzione sbagliati vengono gestiti con eleganza: un indice troppo grande viene rimpiazzato con la dimensione della stringa, un indice destro minore di quello sinistro restituisce una stringa vuota.

Lunghezza di una stringa
La lunghezza di una stringa è rappresentato dal numero di caratteri che contiene.
La funzione len (nome della stringa) restituisce la lunghezza della stringa, cioè restituisce il numero di caratteri della stringa.
>>>squadra = "Roma"
>>>print len(squadra)
4
Quanto vale len("Juventus")?
Osserva che abbiamo scritto len(squadra) senza virgolette perché squadra è il nome di una variabile e invece abbiamo scritto len(“Juventus”) perché in questo caso abbiamo inserito direttamente la stringa tra parentesi.
Quanto vale len("squadra")?
Le stringhe sono immutabili.
>>>squadra = "roma"
>>>squadra[0] = "t"
TypeError: object doesn't support item assignment
Se proviamo a cambiare il primo carattere della stringa “roma” il risultato non è toma ma un messaggio di errore perché le stringhe non sono modificabili.
Provate a pensare come si potrebbe ottenere un risultato simile.
La soluzione è:
squadra2 = "t" + squadra[1:4]
Abbiamo creato una nuova stringa concatenando la lettera “t” ad una porzione della stringa “roma”. Il risultato è “toma” ma questa operazione non ha avuto alcun effetto sulla stringa originale.

Facciamo qualche esercizio per comprendere il significato delle funzioni:
>>>3
3
>>>repr(3) (converte un intero in una stringa)
'3'
Riflettete su questo esempio: il 3 contenuto fra le parentesi è un numero;la risposta del sistema '3' è una stringa costituita da un solo carattere, il carattere '3'.
>>>repr(-321)
'-321'
>>>"32"
'32'

>>>int(32) (converte una stringa in un intero )
32
La funzione int produce un numero intero.
Essa può avere come argomento sia una stringa che rappresenti un numero intero sia un'espressione che rappresenti un numero decimale di cui sarà prodotto il valore intero corrispondente, come appare chiaro dagli esempi seguenti.
>>>”32”*2
'3232'
Questo è un risultato che può apparire strano.
Siccome * si applica non al numero 32 ma alla stringa fatta dai due caratteri '3' e '2', * ha il significato di "replica la stringa tante volte", come già sappiamo.
>>> int("32") * 2
64
>>>repr(3.21) (da decimale a string)
'3.21'
>>>int(3.21) (da decimale a intero)
3
>>>int(-3.21)
-3
>>> float("3.21") (converte una stringa in un decimale)
3.21

Che cosa viene visualizzato con il programma?
py = "Python"
i=0
while i < 6:
print py[i], '\t' , py[0:i+1], '\t', py[i]+py[i-1]+py[i-2]
i=i+1
Ecco il risultato:
P P Pno
Y Py yPn
T Pyt tyP
H Pyth hty
o Pytho oht
N Python noh