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

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]

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

Le Funzioni

Una funzione è soltanto un pezzo di programma cui viene dato un nome.
Riprendiamo in esame l'esempio degli “scrittori”:

risposta1 = raw_input ("chi e' l'autore dei Promessi Sposi? ")
if risposta1 == "Manzoni":
       print "la risposta e' esatta"
       print "bravo!!"
else:
       print "risposta errata!"
       print "la risposta esatta e': Manzoni"
       print "Studia di più"
risposta2 = raw_input ("chi e' l'autore della Divina Commedia? ")
if risposta2 == "Dante":
       print "la risposta è esatta"
       print "bravo!!"
else:
       print "risposta errata!"
       print "la risposta esatta è: Dante"
       print "Studia di più"

Hai osservato come il programmatore nel trattare la seconda risposta ripete molte cose che aveva già scritto per la prima ? Questo non è né comodo né veloce. Fortunatamente esiste in Python, come in molti altri linguaggi di programmazione, un meccanismo semplice per specificare una sola volta delle operazioni ricorrenti e per richiamare quelle operazioni ogni volta che ci servono.

Questo meccanismo è la “funzione”

Le funzioni sono utili quando dobbiamo far eseguire al computer più volte le stesse operazioni perché queste si possono scrivere una sola volta nella funzione. Questa sarà identificata con un nome. Ogni volta che abbiamo bisogno di eseguire quelle operazioni chiamiamo la funzione, scrivendo semplicemente il suo nome.
Possiamo immaginare la funzione come un “cameriere” (in gergo tecnico tra gli informatici si chiama “servente”) al quale si insegnano certe mansioni da svolgere in casa.
Ad esempio, al cameriere si spiega come “preparare la colazione” nel modo seguente:

1. prepara i croissant
2. fai il caffè
3. scalda il latte

Dopo averlo spiegato una volta non e' più necessario ripetere tutte le volte gli ordini 1, 2 e 3 ma basta chiedere al cameriere di “preparare la colazione”.

Se il cameriere svolge anche le funzioni di cuoco, noi gli spieghiamo una ricetta per fare gli spaghetti alla carbonara che ci piacciono tanto e gliela scriviamo su un foglio. Ogni volta che vogliamo mangiare gli spaghetti alla carbonara gli diciamo semplicemente “spaghetti alla carbonara”. A questo punto il cuoco si rilegge la ricetta ed esegue le operazioni elementari descritte (fai bollire l'acqua, aggiungi il sale, ecc. ecc.).
Nel caso del nostro esempio del programma degli “scrittori” si deve chiedere al cameriere, ossia alla funzione, di eseguire le seguenti operazioni:

1. porre la domanda e acquisire la risposta
2. verificare se la risposta data e' uguale a quella corretta
3. se la risposta e' corretta, visualizzare il messaggio di congratulazioni
4. se la risposta e' errata, visualizzare il messaggio di rimprovero e il
   messaggio per ricordare la risposta corretta.

Il nostro “cameriere”, ossia la funzione, dovrà eseguire proprio queste operazioni ogni volta che porremo una nuova domanda. Al cameriere, ossia alla funzione, sarà sufficiente indicare la domanda e la risposta esatta.
In pratica dobbiamo scrivere un breve programma che esegua le operazioni che abbiamo elencato, dopo aver dato il nome alla funzione e alle scatole (ossia alle variabili) di cui la funzione avrà bisogno.
La nostra funzione si chiamerà “interrogazione”.
domanda sarà la scatola contenente la domanda.
risposta_esatta sarà la scatola destinata a contenere la risposta esatta.
Tutto questo andrà scritto su una sola riga, che sarà la prima linea della funzione.

def interrogazione (domanda, risposta_esatta)
Questa linea indica all'interprete che vogliamo definire un blocco di istruzioni che potrà essere eseguito a richiesta in un qualunque altro punto del programma semplicemente scrivendo il suo nome (interrogazione), dopo aver indicato la domanda e la risposta corretta.

Quindi la prima linea della funzione dovrà contenere:

la parolina def (abb. ne di define, definisci)	def
il nome che ho deciso di dare alla funzione	interrogazione
i nomi delle scatole su cui lavorerà la funzione, separati da virgole e racchiusi da parentesi	domanda risposta_esatta

Dopo la definizione, occorre scrivere la funzione, cioè il programma che lavorerà sulle scatole indicate. Nel nostro caso:

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ù!"

Confrontiamolo ora con il pezzo di programma da cui siamo partiti e che non volevamo ripetere tante volte. Notiamo subito che il codice è diventato molto più generale perché tutte le risposte sono scritte dentro delle variabili che potranno assumere valori diversi in situazioni diverse.
Mentre il programma valeva solo per domande sugli scrittori, la funzione può essere usata in un programma che pone domande di storia, di geografia, di calcio ecc. 

Programma	Funzione
if risposta == "Manzoni":   print "la risposta è esatta"   print "bravo!!" else:   print "risposta errata!"   print "la risposta esatta è:                       Manzoni" print "Studia di più"	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ù!"

Si può usare qualsiasi nome per una funzione, tranne le parole riservate di Python. Le definizioni di funzione sono delle istruzioni come le altre. Tuttavia, esse saranno eseguite soltanto quando saranno chiamate.

Nota bene!!
Le istruzioni all'interno di una definizione non sono eseguite finché la funzione non viene chiamata.

CHIAMATA DI FUNZIONE
Ora dobbiamo imparare come chiamare la funzione, ossia ordinare alla funzione stessa di eseguire le operazioni in essa contenute.

In generale, la chiamata di una funzione viene effettuata scrivendo il nome della funzione, seguita dai nomi delle scatole su cui lavorare separati da virgole e racchiuse da parentesi.
Nel caso del programma che avevamo scritto avremo:

domanda1 = "chi e' l'autore dei Promessi Sposi? "
risposta_esatta1 = "Manzoni"
interrogazione (domanda1, risposta_esatta1)
domanda2 = "chi e' l'autore della Divina Commedia? "
risposta_esatta2 = "Dante"
interrogazione (domanda2, risposta_esatta2)

Fermiamoci a riflettere e a riassumere ciò che abbiamo detto finora a proposito di programmi e del flusso di esecuzione del programma.

1. L'esecuzione inizia sempre alla prima riga del programma e le istruzioni sono eseguite una alla volta dall'alto verso il basso.
2. Una funzione deve essere definita prima del suo uso (l'interprete deve sapere che la funzione esiste e cosa fa).
3. La definizione di funzione non altera il flusso di esecuzione del programma e le istruzioni all'interno della funzione non sono eseguite finché questa non viene chiamata (questo vuol dire che, se definisco la funzione all'inizio del programma, l'interprete legge la definizione ma non fa nulla e prosegue nell'esecuzione del programma finché non trova la chiamata della funzione).
4. La chiamata della funzione è una deviazione nel flusso di esecuzione:
   invece di proseguire con l'istruzione successiva, l'esecuzione salta alla prima riga della funzione chiamata ed esegue tutte le sue istruzioni; alla fine della funzione il flusso riprende dal punto dov'era stato deviato dalla chiamata di funzione. Fortunatamente Python è sufficientemente intelligente da ricordare dove il flusso di esecuzione viene via via interrotto e sa dove riprendere quando una funzione è conclusa.
5. Quando il flusso del programma giunge all'ultima istruzione, dopo la sua esecuzione il programma è terminato.
   Ricordate che la definizione della funzione termina con l'ultima istruzione indentata.

Vediamo ora il nostro programma scritto con e senza l'uso della funzione
“interrogazione”:
(il programma è scritto in nero e la definizione di funzione in blu)

senza

con

risposta1 = raw_input("chi è l'autore dei Promessi Sposi? ") if risposta1 == "Manzoni":               print "la risposta è esatta"               print "bravo!!" else:               print "risposta errata!"               print "la risposta esatta è: Manzoni"               print "Studia di più" risposta2 = raw_input("chi è l'autore della Divina Commedia? ") if risposta2 == "Dante":               print "la risposta è esatta"               print "bravo!!" else:               print "risposta errata!"               print "la risposta esatta è: Dante"               print "Studia di più'"

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 = "chi e' l'autore dei Promessi Sposi? " risposta_esatta1 = "Manzoni" interrogazione (domanda1, risposta_esatta1) domanda2 = "chi e' l'autore della Divina Commedia? " risposta_esatta2 = "Dante" interrogazione (domanda2, risposta_esatta2)

Nota bene!
I nomi delle variabili usate nella istruzione di chiamata della funzione sono diversi dai nomi delle variabili usate nella definizione.

def interrogazione (domanda, risposta_esatta): - >DEFINIZIONE
interrogazione (domanda1, risposta_esatta1): -> CHIAMATA

Infatti la prima cosa che fa la funzione quando viene chiamata è prendere le scatole usate nella istruzione con cui è stata chiamata, scoperchiarle e mettere il loro contenuto nelle corrispondenti scatole usate all'interno della funzione.
Il contenuto di domanda1 viene scritto in domanda e il contenuto di risposta_esatta1 viene scritto in risposta_esatta.

Definizione
La funzione è una sequenza di istruzioni che esegue una determinata operazione.

Perché è necessaria questa operazione?
Le scatole all'interno della funzione sono “invisibili” all'esterno e sono utilizzate solo dentro il corpo della funzione.
In questo modo la semplice funzione che abbiamo scritto potrà essere utilizzata da voi per altri programmi o da qualche vostro amico per costruire programmi più complicati. E questo è il secondo motivo, forse il più importante, per cui si scrivono le funzioni.
I programmi attuali sono diventati cosi complicati che nessun programmatore, per quanto bravo, riuscirebbe a scriverli da solo. Qualunque programma è sempre composto per una piccola parte da nuove istruzioni e per la maggior parte da funzioni già scritte in precedenza.

Esercizi
Inserisci un numero e stampa la sua radice quadrata.
Per risolvere questo esercizio devi prima leggere questa breve spiegazione.
Ora che sai cosa sono le funzioni, devi sapere anche che Python è provvisto di una raccolta di funzioni già pronte che ti permettono di eseguire le più comuni operazioni matematiche.
La raccolta di funzioni si chiama ovviamente: math
Prima di poter usare le funzioni fornite da math, devi dire all'interprete di
caricare le funzioni in memoria.
Questa operazione, che si chiama "importazione", si scrive:

>>> import math

A questo punto hai a disposizione tutte le funzioni matematiche tra cui anche la radice quadrata. Per usare la funzione "radice quadrata" dovrai scrivere:

nome_modulo.nome_funzione (valore)
nel nostro caso sarà: math.sqrt( )

Ad esempio:

import math
print math.sqrt(4)

Soluzione:

import math
numero = input("Scrivi un numero")
print "la radice quadrata di", numero, 'è', math.sqrt(numero)

ancora funzioni…ma un po’ più difficili
l’istruzione return

In tutti gli esempi precedenti, la funzione chiamata eseguiva completamente una certa attività. A differenza dei casi precedenti, qualche volta la funzione chiamata esegue dei calcoli il cui risultato serve al programma chiamante. Vediamo un esempio:

def doppio(numero):
       numero_per_due = numero * 2
       return numero_per_due

L’istruzione return numero_per_due ordina alla funzione doppio di trasmettere al programma chiamante il valore numero_per_due.
Nel programma chiamante non si dovrà scrivere numero_per_due perché questa è una variabile della funzione e le variabili delle funzioni sono invisibili all’esterno, ma si scriverà un’istruzione del tipo:

pippo = 7 + doppio(5)

In sostanza tutto avviene come se il contenuto della scatola della funzione numero_per_due fosse trasferito nella scatola del programma principale doppio.

funzioni che chiamano funzioni

Nel corpo di una funzione si può anche scrivere una o più istruzioni che chiamino altre funzioni. Al limite, una funzione può anche chiamare se stessa.
Vediamo un esempio difficile.
Supponiamo di voler calcolare il fattoriale del numero 7. Occorre scrivere:

fatt = 7*6*5*4*3*2

La funzione che calcola il fattoriale di un numero n dovrà essere scritta come n moltiplicato per il fattoriale di (n-1); ad esempio:

fatt(7) = 7 * fatt(6)

E la funzione sarà:

def fatt(n):
       if n == 1:
           return 1
       else:
       return n * fatt(n-1)

Esercizi
Riscriviamo per comodità la funzione interrogazione:

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ù!"

Ora proviamo a inventare altre situazioni in cui questa funzione può tornare utile. Ad esempio, una interrogazione di storia.

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 fu 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)

Vediamo alcuni esempi di funzioni che utilizzano l’istruzione return.
print “Programma che calcola il doppio di un numero”
def doppio(numero):
    numero_per_due = numero*2
    return numero_per_due
numero = input(“Inserisci un numero “)
doppio(numero)
print “il doppio è: “, numero

In questo esempio calcoliamo l’area della figura:

Scriviamo una funzione che consenta di calcolare l’area di un rettangolo.
def area_rettangolo(base, altezza):
      return base * altezza
Scriviamo una funzione che calcoli l’area di un cerchio di raggio r.
def area_cerchio(raggio):
       return 3,14 * raggio**2
Utilizziamo ora le due funzioni che abbiamo scritto per calcolare l’area della figura azzurra.
print “Programma che calcola l’area della figura azzurra”
def area_rettangolo(base, altezza):
    return base * altezza
def area_cerchio(raggio):
    return 3,14 * raggio*2
area_figura = area_rettangolo(3,2) +
area_rettangolo(5,3) + 2 * area_cerchio(1)/2
print “l’area della figura azzurra è: “, area_figura

Quest’ultimo esempio mostra come calcolare la potenza di un numero senza usare la funzione definita da Python ma usando una funzione definita da noi.
def potenza(numero, esponente):
    if esponente == 1:
          return numero
else:
          return potenza(numero,esponente-1) * numero
numero = input("Inserisci un numero ")
esponente = input("Inserisci l’esponente ")
print potenza(numero, esponente)