Scarica Python - concetti di base e più Appunti in PDF di Elementi di Informatica solo su Docsity!
Introduzione al Python
Informatica – DAMS
Phyton è un esempio di linguaggio di alto livello; un linguaggio di programmazione ad alto livello è un linguaggio di programmazione caratterizzato da una significativa astrazione dai dettagli del funzionamento di un calcolatore e dalle caratteristiche del linguaggio macchina. I linguaggi di programmazione ad alto livello sono progettati per essere facilmente comprensibili dagli esseri umani, fino a includere alcuni elementi del linguaggio naturale. Per essere eseguiti da un calcolatore, i programmi scritti in linguaggio ad alto livello devono
essere tradotti o interpretati da un altro programma.
Come su può immaginare sentendo la definizione di “linguaggio di alto livello” esistono anche linguaggi di basso livello (linguaggio macchina, linguaggio assembly); i computer possono eseguire, ad esempio, soltanto programmi scritti in linguaggi di basso livello. Compilazione ed interpretazione: Un linguaggio ad alto livello, per definizione, non è direttamente "eseguibile" da parte del calcolatore. I programmi di alto livello vengono trasformati in programmi di basso
livello eseguibili dal computer tramite due tipi di elaborazione: Compilazione : in questo modello viene usato un programma detto compilatore , la cui funzione è quella di tradurre il programma sorgente (ovvero nel linguaggio ad alto livello) in un programma in linguaggio macchina di basso livello. Prima dell’esecuzione, il programma di alto livello viene chiamato codice sorgente, mentre, dopo la traduzione il programma tradotto viene chiamato codice oggetto o eseguibile.
Interpretazione : in questo modello viene usato un programma detto interprete , la cui funzione è quella di interpretare le istruzioni del programma sorgente ed eseguirle. A differenza del compilatore, l'interprete non produce mai un eseguibile. Di conseguenza, interprete e sorgente sono sempre necessari a ogni esecuzione del programma.
Codice Sorgente Compilatore Codice Oggetto Esecutore Risultato
Scrivere ed eseguire un programma in Python: Esso è considerato un linguaggio interpretato; I programmi sono eseguiti da un interprete con due differenti modi di utilizzo: a linea di comando o in modo script. Un programma in Python : Un programma è una sequenza di istruzione che specificano come effettuare una elaborazione matematico o simbolico. Un gruppo di istruzioni comuni a qualunque linguaggio di programmazione sono:
- Input: ricezione di dati da tastiera, da file o da altro dispositivo;
- Output: scrittura di dati su video, su file o trasmissione ad altro dispositivo;
- Matematiche: esecuzione di semplici operazioni matematiche quali l’addizione e sottrazione;
- Condizionali: controllo di alcune condizione ed esecuzione della sequenza di istruzioni appropriata.
- Ripetizione: ripetizione di un’azione, di solito con qualche variazione.
In genere la programmazione è la suddivisione di un compito grande e complesso in una seria di sotto- compiti sufficientemente semplici da poter essere eseguiti tramite una di questa istruzioni. Variabili, espressioni e istruzioni: Le variabili ci permettono di salvare valori in memoria per riutilizzarli in futuro. Una delle caratteristiche più potenti in un linguaggio di programmazione è la capacità di manipolare variabili. Una variabile è un nome che si riferisce ad un valore. L'istruzione di assegnazione crea nuove
variabili e assegna loro un valore: **_>>> messaggio = “Come va?” >>> n = 17 >>> pi = 3.
print messaggio >>> print n >>> print pi Come va? 17 3._** Le variabili hanno un tipo; la funzione type (x) ci permettere di conoscere il tipo di valore presente
all’interno della variabile. Variabili e parole riservate : I programmatori generalmente scelgono dei nomi significativi per le loro variabili, documentando così a che cosa servono. I nomi delle variabili possono essere lunghi quanto si desidera e possono contenere sia lettere che numeri, ma devono sempre iniziare con una lettera. È legale
usare sia lettere maiuscole che minuscole. Ricorda comunque che l'interprete le considera diverse così che:
Numero, NUmEro e numero, sono a tutti gli effetti variabili diverse. Il carattere di sottolineatura “è lo spazio” (_) può far parte di un nome ed è spesso usato in nomi di variabile composti da più parole. In alternativa le parole possono essere composte usando l'iniziale maiuscola per ciascuna di esse, con il resto dei caratteri lasciati in minuscolo come in “IlMioNome”. Assegnando un nome illegale alla variabile otterrai un messaggio d'errore di sintassi:
>>> 76strumenti = "grande banda" >>> milione$ = 1000000 >>> class = "Computer Science 101" SyntaxError: invalid syntax SyntaxError: invalid syntax SyntaxError: invalid syntax
76strumenti è illegale perché non inizia con una lettera. milione$ è illegale perché contiene un carattere non
valido (il segno di dollaro $). Ma cosa c'è di sbagliato in class? class è una delle parole riservate di Python. Le parole riservate definiscono le regole del linguaggio e della struttura e non possono essere usate come nomi di variabili. Python ha 28 parole riservate:
and continue else for import not raise
assert def except from in or return
break del exec global is pass try
class elif finally if lambda print while
Istruzione : Un'istruzione è un'operazione che l'interprete Python può eseguire. Esistono due tipi di istruzioni:
istruzioni di stampa note e di assegnazione. Quando scrivi un'istruzione sulla riga di comando, Python la esegue e se previsto stampa il risultato a video. Un'istruzione di assegnazione di per sé non produce risultati visibili mentre il risultato di un'istruzione di stampa è un valore mostrato a video. Un'espressione è una combinazione di valori, variabili e operatori.
Python - Concetti di Base
L'operatore modulo: L'operatore modulo opera sugli interi (e sulle espressioni intere) e produce il resto della divisione del primo operando diviso per il secondo. In Python l'operatore modulo è rappresentato dal segno percentuale (%). La sintassi è la stessa degli altri operatori matematici:
**_>>> Quoziente = 7 / 3 >>> Resto = 7 % 3
print Quoziente >>> print Resto 2 1_**
Espressioni Booleane : Un' espressione booleana è un'espressione che è o vera o falsa. In Python un'espressione che è vera ha valore 1, un'espressione falsa ha valore 0. L'operatore == confronta due valori e produce un risultato di tipo booleano:
>>> 5 == 5 >>> 5 == 6 1 0
Nella prima riga i due operandi sono uguali, così l'espressione vale 1 ( vero ); nella seconda riga 5 e 6 non sono uguali, così otteniamo 0 ( falso ). L'operatore == è uno degli operatori di confronto ; gli altri sono:
x != y # x è diverso da y? x > y # x è maggiore di y? x < y # x è minore di y?
else: print x, "e’ dispari"
Così per ogni valore intero di x, StampaParita mostra il messaggio appropriato. Quando chiami questa funzione puoi fornire qualsiasi espressione intera come argomento.
**_>>> StampaParita(17)
StampaParita(y+1)_**
Condizioni in serie: Talvolta ci sono più di due possibilità per la continuazione del programma, così possiamo aver bisogno di più di due ramificazioni. Un modo per esprimere questo caso sono le condizioni in serie :
if x < y: print x, "e' minore di", y elif x > y: print x, "e' maggiore di", y else: print x, "e", y, "sono uguali"
elif è l'abbreviazione di "else if", che in inglese significa "altrimenti se". Anche in questo caso solo uno dei rami verrà eseguito, a seconda del confronto tra x e y. Non c'è alcun limite al numero di istruzioni elif ma è eventualmente possibile inserire un'unica istruzione else che deve essere l'ultima dell'elenco e che rappresenta l'azione da eseguire quando nessuna delle condizioni precedenti è stata soddisfatta. La presenza di un'istruzione else è facoltativa.
Condizioni annidate: Un'espressione condizionale può anche essere inserita nel corpo di un'altra espressione condizionale: un'espressione di questo tipo viene detta "condizione annidata".
if x == y: print x, "e", y, "sono uguali" else: if x < y: print x, "e' minore di", y else: print x, "e' maggiore di", y
La prima condizione (if x == y) contiene due rami: il primo è scelto quando x e y sono uguali, il secondo quando sono diversi. All'interno del secondo (subito sotto il primo else:) troviamo un'altra istruzione if, che a sua volta prevede un'ulteriore ramificazione. Entrambi i rami del secondo if sono istruzioni di stampa ma potrebbero contenere a loro volta ulteriori istruzioni condizionali. Sebbene l'indentazione delle istruzioni renda evidente la struttura dell'esempio, le istruzioni condizionali annidate in livelli sempre più profondi diventano sempre più difficili da leggere, quindi è una buona idea evitarle quando è possibile.
L'istruzione while: I computer sono spesso usati per automatizzare compiti ripetitivi: il noiosissimo compito di ripetere operazioni identiche o simili un gran numero di volte senza fare errori è qualcosa che riesce bene ai computer. Dato che l'iterazione è così comune, Python fornisce vari sistemi per renderla più semplice da implementare. Il primo sistema è l'istruzione while. Ecco come ContoAllaRovescia viene riscritto usando l'istruzione while:
def ContoAllaRovescia(n): while n > 0: print n n = n- print "Partenza!"
La chiamata ricorsiva è stata rimossa e quindi questa funzione ora non è più ricorsiva. Puoi leggere il programma con l'istruzione while come fosse scritto in un linguaggio naturale: "Finché (while) n è più grande di 0 stampa il valore di n e poi diminuiscilo di 1. Quando arrivi a 0 stampa la stringa Partenza!". In modo più formale ecco il flusso di esecuzione di un'istruzione while:
- Valuta la condizione controllando se essa è vera (1) o falsa (0).
- Se la condizione è falsa esci dal ciclo while e continua l'esecuzione dalla prima istruzione che lo segue.
- Se la condizione è vera esegui tutte le istruzioni nel corpo del while e torna al passo 1. Il corpo del ciclo while consiste di tutte le istruzioni che seguono l'intestazione e che hanno la stessa indentazione. Questo tipo di flusso è chiamato ciclo o loop. Nota che se la condizione è falsa al primo controllo, le istruzioni del corpo non sono 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. Nel caso di ContoAllaRovescia possiamo essere certi che il ciclo è destinato a terminare visto che n è finito ed il suo valore diventa via via più piccolo così da diventare, prima o poi, pari a zero. In altri casi può non essere così facile stabilire se un ciclo avrà termine:
def Sequenza(n): while n != 1: print n, if n%2 == 0: # se n e' pari n = n/ else: # se n e' dispari n = n*3+
La condizione per questo ciclo è n!=1 cosicché il ciclo si ripeterà finché n è diverso da 1.
Ogni volta che viene eseguito il ciclo il programma stampa il valore di n e poi controlla se è pari o dispari. Se è pari, n viene diviso per 2. Se dispari, è moltiplicato per 3 e gli viene sommato 1. Se il valore passato è
3, la sequenza risultante è 3, 10, 5, 16, 8, 4, 2, 1. Dato che n a volte sale e a volte scende in modo abbastanza casuale non c'è una prova ovvia che n raggiungerà 1 in modo da far terminare il ciclo. Per qualche particolare valore di n possiamo facilmente determinare a priori il suo termine (per esempio per le potenze di 2) ma per gli altri nessuno è mai riuscito a trovare la dimostrazione che il ciclo ha termine.
Funzioni: Una funzione è una sequenza di istruzioni che esegue una determinata operazione. Hai già visto un esempio di chiamata di funzione:
type("32") <type 'string'>
Il nome della funzione è type e mostra il tipo di valore della variabile. Il valore della variabile, che è chiamato argomento della funzione, deve essere racchiuso tra parentesi. È comune dire che una funzione "prende" o "accetta" un argomento e "ritorna" o "restituisce" un risultato. Il risultato è detto valore di ritorno. Alcune funzioni matematiche:
acos(x) #restituisce l’arcocoseno di x
asin(x) #restituisce l’arcoseno di x atan(x) #restituisce l’arcotangente di x exp(x) #restituisce e**x modf(x) #restituisce la parte frazionaria ed intera di x. Entrambi i risultati riportano il segno di x. La parte intera è restituita come numero in virgola mobile.
pow(x, y) #restituisce x**y
Funzioni e moduli:
Python è provvisto di un modulo matematico che permette di eseguire le più comuni operazioni matematiche. Un modulo è un file che contiene una raccolta di funzioni raggruppate. Prima di poter usare le funzioni di un modulo dobbiamo dire all'interprete di caricare il modulo in memoria. Questa operazione viene detta "importazione":
**_>>> Frutto = "banana"
Lettera = Frutto[1] print Lettera_**
L'espressione Frutto[1] seleziona il carattere numero 1 dalla stringa Frutto. La variabile Lettera contiene il risultato. Quando stampiamo Lettera abbiamo però una sorpresa:
a
La prima lettera di "banana" logicamente non è "a": in informatica i conteggi partono spesso da 0 e non da 1 come potrebbe sembrare normale e per accedere al primo carattere di una stringa dobbiamo quindi richiedere il numero 0, per il secondo il numero 1 e così via. Sembra un po' illogico ma ci farai facilmente l'abitudine perché questo è il modo normale di contare in molti linguaggi di programmazione. L'espressione tra parentesi quadrate è chiamata indice. Un indice identifica un particolare elemento di un insieme ordinato che nel nostro caso è l'insieme dei caratteri di una stringa. L'indice può essere una qualsiasi espressione intera.
Lunghezza: La funzione len ritorna il numero di caratteri di una stringa:
**_>>> Frutto = "banana"
len(Frutto) 6_**
Per ottenere l'ultimo carattere di una stringa potresti essere tentato di fare qualcosa di simile a:
Lunghezza = len(Frutto) Ultimo = Frutto[Lunghezza] # ERRORE!
ma c'è qualcosa che non va: infatti ottieni un errore (^) IndexError: string index out of range dato che stai facendo
riferimento all'indice 6 quando quelli validi vanno da 0 a 5. Per ottenere l'ultimo carattere dovrai quindi scrivere:
Lunghezza = len(Frutto) Ultimo = Frutto[Lunghezza-1]
In alternativa possiamo usare indici negativi che in casi come questo sono più comodi, contando a partire dalla fine della stringa: l'espressione Frutto[-1] ritorna l'ultimo carattere della stringa, Frutto[-2]il penultimo e così via.
Elaborazione trasversale e cicli for: Molti tipi di elaborazione comportano un'azione su una stringa un carattere per volta. Spesso queste elaborazioni iniziano dal primo carattere, selezionano un carattere per volta e continuano fino al completamento della stringa. Questo tipo di elaborazione è definita elaborazione trasversale o attraversamento , in quanto attraversa la stringa dall'inizio alla fine. Un modo per implementare un'elaborazione trasversale è quello di usare un ciclo while :
Indice = 0 while Indice < len(Frutto): Lettera = Frutto[Indice] print Lettera Indice = Indice + 1
Questo ciclo attraversa la stringa e ne mostra una lettera alla volta, una per riga. La condizione del ciclo è Indice < len(Frutto) così che quando Indice è uguale alla lunghezza della stringa la condizione diventa falsa, il corpo del ciclo non è eseguito ed il ciclo termina. L'ultimo carattere cui si accede è quello con indice len(Frutto)-1 che è l'ultimo carattere della stringa.
Esercizio: scrivi una funzione che prende una stringa come argomento e la stampa un carattere per riga partendo dall'ultimo carattere. Usare un indice per attraversare un insieme di valori è un'operazione così comune che Python fornisce una sintassi ancora più semplice: il ciclo for.
for Lettera in Frutto: print Lettera
Ad ogni ciclo, Lettera assume il valore del prossimo carattere della stringa Frutto, così che Frutto viene attraversata completamente finché non rimangono più caratteri da analizzare.
Porzioni di stringa: Un segmento di stringa è chiamato porzione. La selezione di una porzione è simile alla selezione di un carattere:
**_>>> s = "Pietro, Paolo e Maria"
print s[0:6] Pietro print s[8:13] Paolo print s[16:21] Maria_**
L'operatore [n:m] ritorna la stringa a partire dall' "n-esimo" carattere incluso fino all' "m-esimo" escluso. Questo comportamento non è intuitivo, e per comprenderlo è meglio immaginare i puntatori tra i caratteri, come nel diagramma seguente:
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:
**_>>> Frutto = "banana"
Frutto[:3] 'ban' Frutto[3:] 'ana'_**
Confronto di stringhe: Gli operatori di confronto operano anche sulle stringhe. Per vedere se due stringhe sono uguali:
if Parola == "BANANA": print "stai parlando di un frutto!"
Altri operatori di confronto sono utili per mettere le parole in ordine alfabetico:
if Parola < "BANANA": print "la tua parola" + Parola + "viene prima di BANANA." elif Parola > "BANANA": print "la tua parola" + Parola + "viene dopo BANANA." else: print "hai inserito la parola BANANA"
Devi comunque fare attenzione al fatto che Python non gestisce le parole maiuscole e minuscole come facciamo noi in modo intuitivo: in un confronto le lettere maiuscole vengono sempre prima delle minuscole, così che:
"BANANA" < "BAnana" < "Banana" < "bANANA" < "banana" "ZEBRA" < "banana"
Un modo pratico per aggirare il problema è quello di convertire le stringhe ad un formato standard (tutto maiuscole o tutto minuscole) prima di effettuare il confronto.
Immutabilità delle stringhe: Si può essere tentati di usare l'operatore porzione [] alla sinistra di un'assegnazione, con l'intenzione di cambiare un carattere di una stringa:
>>> string.find("banana", "na") 2 Inoltre ammette un argomento ulteriore per specificare da dove vogliamo iniziare la nostra ricerca: >>> string.find("banana", "na", 3) 4 Ancora, può prendere due argomenti che specificano il dominio di ricerca, cioè la porzione di stringa originale dove vogliamo effettuare la ricerca: >>> string.find("bob", "b", 1, 2)
- In questo esempio la ricerca fallisce perché la lettera 'b' non appare nel dominio definito dagli indici 1 e 2 (da 1 incluso fino a 2 escluso). Classificazione dei caratteri: È spesso necessario esaminare un carattere e controllare se questo è maiuscolo, minuscolo, o se si tratta di una cifra o di uno spazio bianco. A questo scopo il modulo string fornisce parecchie costanti molto utili. La stringa string.lowercase contiene tutti i caratteri che il sistema considera minuscoli. Allo stesso modo string.uppercase contiene tutti i caratteri maiuscoli. Guarda cosa contengono queste stringhe: **_>>> print string.lowercase
print string.uppercase print string.digits_** Possiamo usare queste costanti e la funzione find per classificare i caratteri. Per esempio se find (string.lowercase, Carattere) ritorna un valore diverso da -1 allora Carattere è minuscolo (un valore diverso da -1 indicherebbe infatti la posizione del carattere trovato): def Minuscolo(Carattere): return string.find(string.lowercase, Carattere) != - In alternativa possiamo usare l'operatore in che determina se un carattere compare in una stringa: def Minuscolo(Carattere): return Carattere in string.lowercase o il consueto operatore di confronto: def Minuscolo(Carattere): return 'a' <= Carattere <= 'z' Se Carattere è compreso tra 'a' e 'z' deve per forza trattarsi di una lettera minuscola.
Python -Stringhe
Cosa è una lista? Una lista è una serie ordinata di valori, ognuno identificato da un indice. I valori che fanno parte della lista sono chiamati elementi. Le liste sono simili alle stringhe essendo insiemi ordinati di caratteri, fatta eccezione per il fatto che gli elementi di una lista possono essere di tipo qualsiasi. Liste e stringhe (e altri tipi di dati che si comportano da insiemi ordinati) sono chiamate sequenze.
Valori della lista: Ci sono parecchi modi di creare una lista nuova, e quello più semplice è racchiudere i suoi elementi tra parentesi quadrate ([ e ]):
[10, 20, 30, 40] ["Pippo", "Pluto", "Paperino"]
Il primo esempio è una lista di quattro interi, il secondo una lista di tre stringhe. Gli elementi di una stessa lista non devono necessariamente essere tutti dello stesso tipo. Questa lista contiene una stringa, un numero in virgola mobile, un intero ed un'altra lista:
["ciao", 2.0, 5, [10, 20]]
Una lista all'interno di un'altra lista è detta lista annidata.
Le liste che contengono numeri interi consecutivi sono così comuni che Python fornisce un modo semplice per crearle:
>>> range(1,5) [1, 2, 3, 4]
La funzione range prende due argomenti e ritorna una lista che contiene tutti gli interi a partire dal primo (incluso) fino al secondo (escluso). Ci sono altre due forme per range. Con un solo argomento crea una lista a partire da 0:
>>> range(10) [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
Se è presente un terzo argomento questo specifica l'intervallo tra valori successivi, chiamato passo. Questo esempio mostra come ottenere una stringa dei numeri dispari tra 1 e 10:
>>> range(1, 10, 2) [1, 3, 5, 7, 9]
Infine esiste una lista speciale che non contiene alcun elemento: è chiamata lista vuota ed è indicata da []. Con tutti questi modi di creare liste sarebbe un peccato non poter variare il contenuto di una lista o poter passare liste come parametri di funzioni. Infatti entrambe queste cose possono essere fatte:
**_>>> Vocabolario = ["amico", "casa", "telefono"]
Numeri = [17, 123] ListaVuota = [] print Vocabolario, Numeri, ListaVuota ['amico', 'casa', 'telefono'] [17, 123] []_**
Accesso agli elementi di una lista: La sintassi per l'accesso agli elementi di una lista è la stessa che abbiamo già visto per i caratteri di una stringa: anche in questo caso facciamo uso dell'operatore porzione ([]). L'espressione tra parentesi quadrate specifica l'indice dell'elemento (non dimenticare che gli indici partono da 0!):
**_>>> print Numeri[0] 17
Numeri[1] = 123_**
È comune usare una variabile di ciclo come indice di una lista:
Squadre = ["Juventus", "Inter", "Milan", "Roma"]
i = 0 while i < 4: print Squadre[i] i = i + 1
Questo ciclo while conta da 0 a 4: quando l'indice del ciclo i vale 4 la condizione diventa falsa e il ciclo termina. Il corpo del ciclo è eseguito solo quando i è 0, 1, 2 e 3. Ad ogni ciclo la variabile i è usata come indice della lista: questo tipo di elaborazione è chiamata elaborazione trasversale di una lista o attraversamento di una lista.
Lunghezza di una lista: La funzione len ritorna la lunghezza di una lista. È sempre bene usare len per conoscere il limite superiore in un ciclo, piuttosto che usare un valore costante: in questo modo se la lunghezza della lista dovesse cambiare non dovrai scorrere il programma per modificarne i cicli, e sicuramente len funzionerà correttamente per liste di ogni lunghezza:
Squadre = ["Juventus", "Inter", "Milan", "Roma"]
i = 0 while i < len(Squadre): print Squadre[i] i = i + 1
L'ultima volta che il ciclo è eseguito i vale len(Squadre) - 1 che è l'indice dell'ultimo elemento della lista. Quando al successivo incremento i diventa len(Squadre) la condizione diventa falsa ed il corpo non è eseguito, dato che len(Squadre) non è un indice valido.
>>> [1, 2, 3] * 3
[1, 2, 3, 1, 2, 3, 1, 2, 3]
Nel primo esempio abbiamo ripetuto [0] quattro volte. Nel secondo abbiamo ripetuto la lista [1, 2, 3] tre volte.
Porzioni di liste: Le porzioni che abbiamo già visto per quanto riguarda le stringhe lavorano anche con le liste:
**_>>> Lista = ['a', 'b', 'c', 'd', 'e', 'f']
Lista[1:3] ['b', 'c'] Lista[:4] ['a', 'b', 'c', 'd'] Lista[3:] ['d', 'e', 'f'] Lista[:] ['a', 'b', 'c', 'd', 'e', 'f']_**
Le liste sono mutabili: A differenza delle stringhe le liste sono mutabili e ciò significa che gli elementi possono essere modificati. Usando l'operatore porzione nella parte sinistra dell'assegnazione possiamo aggiornare un elemento:
**_>>> Frutta = ["banana", "mela", "susina"]
Frutta[0] = "pera" Frutta[-1] = "arancia" print Frutta ['pera', 'mela', 'arancia']_**
Con l'operatore porzione possiamo modificare più elementi alla volta:
**_>>> Lista = ['a', 'b', 'c', 'd', 'e', 'f']
Lista[1:3] = ['x', 'y'] print Lista ['a', 'x', 'y', 'd', 'e', 'f']_**
Possiamo rimuovere elementi da una lista assegnando loro una lista vuota:
_>>> Lista = ['a', 'b', 'c', 'd', 'e', 'f']
Lista[1:3] = [] print Lista ['a', 'd', 'e', 'f']_
Possono essere aggiunti elementi ad una lista inserendoli in una porzione vuota nella posizione desiderata:
**_>>> Lista = ['a', 'd', 'f']
Lista[1:1] = ['b', 'c'] print Lista ['a', 'b', 'c', 'd', 'f'] Lista[4:4] = ['e'] print Lista ['a', 'b', 'c', 'd', 'e', 'f']_**
Cancellazione di elementi: Usare le porzioni per cancellare elementi delle liste non è poi così pratico ed è facile sbagliare. Python fornisce un'alternativa molto più leggibile. del rimuove un elemento da una lista:
**_>>> a = ['uno', 'due', 'tre']
del a[1] a ['uno', 'tre']_**
Come puoi facilmente immaginare del gestisce anche gli indici negativi e avvisa con messaggio d'errore se l'indice è al di fuori dei limiti ammessi. Puoi usare una porzione come indice di del : **_>>> Lista = ['a', 'b', 'c', 'd', 'e', 'f']
del Lista[1:5]_**
>>> print Lista ['a', 'f']
Come abbiamo già visto la porzione indica tutti gli elementi a partire dal primo indice incluso fino al secondo indice escluso.
Oggetti e valori: Se eseguiamo queste istruzioni
a = "banana" b = "banana"
sappiamo che sia a che b si riferiscono ad una stringa contenente le lettere " banana ". A prima vista non possiamo dire se puntano alla stessa stringa in memoria. I possibili casi sono due:
Nel primo caso a e b si riferiscono a due diverse "cose" che hanno lo stesso valore. Nel secondo caso si riferiscono alla stessa "cosa". Queste "cose" hanno un nome: oggetti. Un oggetto è un qualcosa cui può far riferimento una variabile. Ogni oggetto ha un identificatore unico che possiamo ricavare con la funzione id. Stampando l'identificatore di a e di b possiamo dire subito se le due variabili si riferiscono allo stesso oggetto:
**_>>> id(a) 135044008
id(b) 135044008_**
Otteniamo lo stesso identificatore e ciò significa che Python ha creato in memoria un'unica stringa cui fanno riferimento entrambe le variabili a e b. In questo ambito le liste si comportano diversamente dalle stringhe, dato che quando creiamo due liste queste sono sempre oggetti diversi:
**_>>> a = [1, 2, 3]
b = [1, 2, 3] id(a) 135045528 id(b) 135041704_**
Il diagramma di stato in questo caso è
a e b hanno lo stesso valore ma non si riferiscono allo stesso oggetto.
