{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "

3: Tipi di Dati e Data Structures

\n", "\n", "
\n", "\n", "
\n", "\n", "
\n", "\n", "Python conosce vari tipi di dati. Il tipo di una variabile viene ricavato dal valore che le viene assegnato. Nei linguaggi in cui un programma deve essere compilato prima di essere eseguito il tipo di ciascuna variabile deve essere dichiarato prima di assegnare alla variabile un valore.\n", "Python è un linguaggio interpretato i comandi vengono letti ed eseguiti sequenzialmente." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "3.1 Dati numerici\n", "---------\n", "\n", "I tipi numerici built-in sono i numeri interi (integers, int), che possono essere anche rappresentati in base esadecimale, ottale o binaria, i numeri reali (floating point, float) e quelli complessi." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Numeri interi\n", "\n", "Una successione di cifre che non contenga il punto di separazione viene interpretato come un numero intero. " ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "35**42" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Numeri esadecimali\n", "\n", "Sono numeri interi in base 16. Le cifre sono$\\,$ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, a, b, c, d, e, f." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "a = 0xf\n", "int(a)" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "b = 1357\n", "hex(b)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Numeri reali\n", "\n", "Una successione di cifre che contenga il punto di separazione viene interpretato come un numero reale.\n", "__I numeri reali sono rappresentati in modo approssimato (10-14 cifre di precisione).__" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "0.3" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "0.1*3" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Numeri reali in notazione scientifica: $1.3\\, 10^{-4}$ si scrive 1.3e-4." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "a = 9.3e-4\n", "b = 3.0e+17\n", "a*b" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Python, di default, scrive i numeri reali in formato non scientifico. Se vogliamo la risposta in notazione scientifica è necessario chiederlo esplicitamente (Maggiori informazioni più avanti.)." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "f\"{a*b:e}\"" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Numeri complessi\n", "\n", "In Python (come in Fortran e Matlab) i numeri complessi sono built-in. Qualche esempio:" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "x = 1.2 + 3.7j # Nessuno spazio fra il valore della parte immaginaria e il simbolo `j`\n", "x" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "x.imag # Parte immaginaria" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "x.real # Parte reale" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "x * x.conjugate()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "La sintassi per le operazioni fra numeri complessi è identica a quella per le operazioni fra numeri reali:" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "x * x" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "3 * x" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Se si utilizza una variabile per la parte immaginaria, la notazione per costruire un numero complesso è: " ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "a = 1.\n", "b = -0.5\n", "c = a + b*1j\n", "print(c)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Per eseguire operazioni più complicate (come fare radici quadrate di numeri complessi etc) è nessario usare il modulo `cmath` (Complex MATHematics):" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "import cmath\n", "cmath.sqrt(x)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Funzioni che si applicano a tutti i tipi di numeri\n", "\n", "La funzione `abs()` restituisce il valore assoluto o modulo di un numero:" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "a = -45.463\n", "abs(a)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "`abs()` funziona anche per numeri complessi." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "b = abs(1 + 2j)\n", "b" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "b*b" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "
\n", "

Imparare Facendo

\n", "
    \n", "
  1. Assegnate alla variabile x il valore 4/2. Verificate come viene rappresentato x.\n", "
  2. Costruite un numero complesso di parte reale 2.7 e di parte immaginaria -0.73. Calcolatene il complesso coniugato.\n", "
  3. Calcolate il quadrato di 1+1j. Convincetevi della correttezza del risultato.\n", "
  4. Cercate on line informazioni sui numeri ottali e sul modo di rappresentarli in python.\n", "
  5. Costruite la funzione abs_square che prenda come argomento un numero complesso z e restitisca il prodotto di z\n", " e del suo complesso coniugato. Verificate che il risultato restituito da abs_square coincide, all'interno della precisione dei calcoli fra numeri reali, con abs(z)**2. \n", "
\n", "
" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "##### Informazioni ulteriori\n", "\n", "- Un'introduzione informale ai numeri. [Python tutorial, section 3.1.1](http://docs.python.org/tutorial/introduction.html#using-python-as-a-calculator)\n", "\n", "- Python Library Reference: una presentazione formale dei tipi numerici, \n", "\n", "- Think Python, [Sec 2.1](http://www.greenteapress.com/thinkpython/html/book003.html)\n", "\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "3.2 Sequenze\n", "-----------\n", "\n", "Stringhe, liste e ntuple (tuples) sono *sequenze*. Possono essere *indicizzate* e *sezionate* (*sliced*) nello stesso modo.\n", "\n", "Tuples e stringhe sono “immutable” (fondamentalmente significa che non è possibile cambiare i singoli elementi in una ntupla, e non possiamo modificare i singoli caratteri all'interno di una stringa) mentre le liste sono “mutable” (cioè possiamo cambiare gli elementi di una lista.)\n", "\n", "Le sequenze condividono le operazioni seguenti:\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "
a[i]restituisce l'*i*-esimo elemento di `a`; a[0] è il primo elemento
a[i:j]restituisce gli elementi da *i* fino a *j* − 1
len(a)restituisce il numero di elementi nella sequenza
min(a)restituisce il valore più piccolo della sequenza
max(a)restituisce il valore più grande nella sequenza
a.count(x)restituisce il numero di volte in cui la sottosequenza x compare nella sequenza a
x in arestituisce `True` se `x` è un elemento di `a`, `False` in caso contrario
a + bconcatena `a` e `b`
n * aconcatena `n` copie della sequenza `a`
\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### 3.2.1 Stringhe\n", "\n", "Una stringa è una sequenza (immutable) di caratteri. Una stringa può essere definita usando single quotes:" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "a = 'Hello World'" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "double quotes:" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "a = \"Hello World\"" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "oppure triple quotes di entrambi i tipi" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "a = \"\"\"Hello World\"\"\"\n", "a = '''Hello World'''" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Avere più delimitatori possibili per una stringa è utile quando un delimitatore è presente nella stringa. Esempio: supponiamo di voler assegnare alla variabile mystr la stringa *L'ultimo dei Mohicani*. " ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "mystr = 'L'ultimo dei Mohicani'\n", "mystr" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "mystr = \"L'ultimo dei Mohicani\"\n", "mystr" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "La stringa vuota è:" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "\"\"" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Un particolare carattere può essere estratto usando il suo indice" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "a = 'trentatre'\n", "a[2]" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "my_str = \"abc\"\n", "print('Il primo carattere di my_str è: ',my_str[0])\n", "print('Il secondo carattere di my_str è: ',my_str[1])" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Il numero di caratteri in una stringa (la sua *lunghezza*) si ottiene con la funzione `len()`:" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "a = \"Hello Moon\"\n", "print('La lunghezza di \"Hello Moon\" è:',len(a))\n", "b = \"\"\n", "print('La lunghezza della stringa vuota è:',len(b))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Si possono combinare (“concatenare”) due stringhe usando l'operatore `+` (è preferibile usare `join` di cui parleremo più avanti):" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "'Hello ' + 'World'" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Si possono anche concatenare due stringhe semplicemente scrivendole una accanto all'altra:" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "'a' 'b'" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Sugli oggetti di Python possono agire metodi (legati a una *classe*), con la sintassi:
\n", "- var.method()\n", "\n", "oppure funzioni, che si applicano con la notazione:
\n", "- funzione(var)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Un metodo particolarmente utile è `split()` che converte una stringa in una lista di stringhe:" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "a = \"This is a test sentence.\"\n", "a.split()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Il meodo `split()` divide le stringhe dove trova *white space*. White space significa qualsiasi carattere che viene stampato come spazio bianco, come uno spazio oppure più spazi consecutivi oppure il carattere tab.\n", "\n", "È possibile passare una \"separator string\" a `split()`, spezzando la stringa originaria sulls stringa di separazione (che viene eliminata). Per esempio,\n", "per avere una lista di frasi complete si potrebbe usare il punto \".\" come separatore:" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "a = \"The dog is hungry. The cat is bored. The snake is awake.\"\n", "a.split(\".\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Oppure:" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "a = \"Pippo(--)Pluto(--)Paperino\"\n", "a.split(\"(--)\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Il metodo opposto per le stringhe è `join` che si usa come segue:" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "a = \"The dog is hungry. The cat is bored. The snake is awake.\"\n", "s = a.split('.')\n", "s" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "\".\".join(s) # join prende una lista come argomento" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "\" STOP\".join(s) # Si noti che la stringa comincia con uno spazio. \n", " # Lo spazio dopo il separatore è lo spazio che segue il punto nel testo originale." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Per concatenare stringhe senza introdurre caratteri extra si può utilizzare la `stringa vuota`:" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "''.join(['Nel',' ','mezzo',' ','del',' ','cammin',' ','di',' ','nostra',' ','vita'])" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "
\n", "

Imparare Facendo

\n", "
    \n", "
  1. Trovate il numero di parole nella frase \"Quel ramo del lago di Como, che volge a mezzogiorno, tra due catene non interrotte di monti\" considerando solo gli spazi come separatori.\n", "
  2. Date le variabili a = 37 e b = '42', fate la somma di a e b\n", "
      \n", "
    1. come numeri interi.\n", "
    2. come stringhe.\n", "
    \n", "
\n", "
" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Non è possibile modificare direttamente gli elementi di una stringa (è `immutabile`):" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "a = \"This is a test sentence.\"\n", "a[1] = 3" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Ciononostante, le stringhe possiedono parecchi metodi utili che modificano la stringa di partenza. Per esempio `upper()` restituisce una nuova stringa in cui tutti i caratteri della stringa iniziale diventano maiuscoli:" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "a.upper()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "`a` non viene modificata dall'applicazione di `upper` che restituisce una nuova stringa:" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "a" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "È però sempre possibile assegnare la nuova stringa alla variabile precedente:" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "a = \"Going Nowhere Fast\"\n", "a = a.upper()\n", "a" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Considerazioni analoghe valgono per `replace` che sostituisce una sottostringa con un'altra:" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "b = \"Stairways to Heaven\"\n", "b = b.replace(\"Heaven\",\"Hell\")\n", "b" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "
\n", "

Imparare Facendo

\n", "
    \n", "
  1. Usate dir per avere la lista di metodi/funzioni applicabili a una stringa.\n", "
  2. Usate help per avere informazioni più dettagliate sulle funzioni index, replace e count.\n", "
  3. Assegnate alla variabile frase il valore \"Fratelli d'Italia, l'Italia s'è desta\". In frase determinate l'indice della prima \"e\"; contate il numero di \"i\"; sostituite tutti gli apostrofi con \"&\".\n", "
\n", "
" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "##### Informazioni ulteriori\n", "\n", "- Introduzione alle stringhe, [Python tutorial 3.1.2](http://docs.python.org/tutorial/introduction.html#strings)\n", "\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### 3.2.2 Liste\n", "\n", "Una liste è una sequenza mutabile di oggetti. Gli oggetti possono essere di qualsiasi tipo, per esempio numeri interi:" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "a = [34, 12, 54]\n", "a" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "o stringhe:" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "a = ['dog', 'cat', 'mouse']\n", "a" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Si può creare una lista anche con la funzione `list`:" ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "['M', 'i', 'c', 'k', 'y', ' ', 'M', 'o', 'u', 's', 'e']" ] }, "execution_count": 2, "metadata": {}, "output_type": "execute_result" } ], "source": [ "a = list('Micky Mouse')\n", "a" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Una lista vuota è rappresentata da `[]`:" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "a = []" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Come per le stringhe, il numero di elementi in una lista può essere trovato con la funzione`len()`:" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "a = ['dog', 'cat', 'mouse']\n", "len(a)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "È anche possibile *mescolare* tipi diversi nella stessa lista:" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "a = [123, 'duck', -42, 17, 0, 'elephant']\n", "a" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "In Python una lista è un oggetto. È quindi possibile che una lista contenga delle altre liste perchè una lista contiene una sequenza di oggetti:" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "a = [1, 4, 56, [5, 3, 1], 300, 400]" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Si possono combinare (“concatenare”) due liste usando l'operatore `+`:" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "[3, 4, 5] + [34, 35, 100]" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Si possono modificare gli elementi di una lista usando una assegnazione:" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "a = [1,2]\n", "a" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "a = [\"pippo\",3.14,\"pluto\"]\n", "a" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Per accedere agli elementi di una lista:" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "a = ['a','b','c','d','e','f']\n", "print(a[1])\n", "print(a[2:4])" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "a[2] = 'f'\n", "print(a)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Si può aggiungere un oggetto al fondo di una lista con il metodo `append()`. Notate che `append` modifica la lista su cui agisce e non restituisce nulla; come si dice, agisce \"in place\"." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "a = [34, 56, 23]\n", "a.append(42)\n", "a" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Si può inserire un oggetto all'indice voluto in una lista con il metodo `insert()`:" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "aList = [123, 'xyz', 'zara', 'abc']\n", "aList.insert( 3, 2009)\n", "print(\"Final List : \", aList)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Si può eliminare un oggetto da una lista chiamando il metodo `remove()` e passandogli l'oggetto da eliminare. Per esempio:" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "a = [34, 56, 23, 42]\n", "a.remove(56)\n", "a" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Ad una lista posso applicare il metodo `pop`, che non ho menzionato. Per ottenere informazioni più dettagliate:" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "help(list.pop)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### Nested lists\n", "Gli elementi di una lista possono, a loro volta, essere liste in questo caso si parla di liste annidate o nested lists." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "a_nest = [10,[20,21,22],30]" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Per accedere agli elementi di una nested list:" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "a_nest[1]" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "a_nest[1][2]" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### Come ordinare una lista\n", "\n", "Posso usare il metodo `sort` oppure la funzione `sorted`:" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "l = [1,3,2]\n", "dir(l)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Il metodo `sort` modifica la lista su cui opera e NON restituisce una lista risultato." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "l.sort()\n", "print(l)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "La funzione `sorted` non modifica la lista su cui viene fatta agire e restituisce una nuova lista" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "l1=sorted(l)\n", "print(l1)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### Il comando range()\n", "\n", "Il comando `range(n)` genera la lista degli interi da 0 fino a *n-1* (attenzione!), un tipo speciale di lista, che è spesso necessaria. Alcuni esempi:" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "list(range(3))" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "list(range(10))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Questo comando si usa spesso con i `for loops`. Per esempio, per stampare i numeri 02,12,22,32,…,102, si può usare il codice seguente:" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "for i in range(11):\n", " print(i**2)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Il comando range prende un parametro opzionale per l'inizio della sequenza di interi (start) e un altro parametro opzionale per il *passo* (*step*). Spesso si scrive `range([start],stop,[step])` dove gli argomenti in parentesi quadrate (square brackets) (cioè start e step) sono opzionali. \n", "Notate che il valore corrispondente a `start` è il primo elemento presente nella lista, mentre il valore corrispondente a `stop` è il \"primo escluso\" e non compare nella lista. Alcuni esempi:" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "list(range(3, 10)) # start=3" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "list(range(3, 10, 2)) # start=3, step=2" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "list(range(10, 0, -1)) # start=10,step=-1" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "list(range(0.,1.,0.1))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Perchè usiamo `list(range())`?\n", "\n", "In Python 3, `range()` genera i numeri on demand. Quando si usa `range()` in un for loop, questo è più efficiente, perchè non occupa memoria con una lista di numeri. Passare il comando `range()` a `list()` lo forza a generare immediatamente tutti i numeri." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "
\n", "

Imparare Facendo

\n", "
    \n", "
  1. Assegnate alla variabile L1 la lista [1,4,2,3].\n", "
      \n", "
    1. Create una nuova lista L2 ordinando, in ordine crescente, L1 con il metodo sorted.\n", "
    2. Ordinate in ordine decrescente la lista L1 con il metodo sorted.\n", "
    3. Eliminate l'ultimo elemento di L1.\n", "
    \n", "
  2. Costruite la lista degli interi decrescenti da 9 a 2 entrambi compresi.\n", "
  3. Costruite la lista dei numeri divisibile per 3 compresi fra 0 e 100.\n", "
\n", "
" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "
\n", "

Imparare Facendo

\n", "
    \n", "
  1. Usate dir per avere la lista di metodi/funzioni applicabili a una lista.\n", "
  2. Usate help per avere informazioni più dettagliate sulle funzioni extend, e reverse.\n", " Notate che entrambi i metodi agiscono \"in place\"\n", "
  3. Assegnate alla variabile lis il valore [1,2,3].\n", "
      \n", "
    1. Moltiplicate lis per 2.\n", "
    2. Costruite a partire da lis la lista lis1 con gli elementi di lis in ordine inverso.\n", "
    3. Costruite la somma di lis e lis1 usando il comando append.\n", "
    4. Costruite la somma di lis e lis1 usando il comando extend.\n", "
    \n", "
  4. Costruite una funzione add_to_list che prenda come argomento una lista L e la restituisca aggiungendo come ultimi elementi \"penultimo\" e \"ultimo\".\n", "
  5. Costruite una funzione reverse che prenda come argomento una lista di numeri reali L e la restituisca ordinata.\n", "
\n", "
" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "##### Informationi ulteriori\n", "\n", "- Introduzione alle Liste, [Python tutorial, section 3.1.3](http://docs.python.org/tutorial/introduction.html#lists)\n", "- Funzioni e metodi che operano su Liste, [Python tutorial, section 5.1](https://docs.python.org/3/tutorial/datastructures.html)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### 3.2.3 Tuples\n", "\n", "A *ntupla* (*tuple*) è una sequenza (immutable) di oggetti. Le ntuple si comportano in modo molto simile alle liste con l'eccezione che non possono essere modificate.\n", "\n", "Per esempio, qualunque tipo di oggetto vi può comparire:" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "a = (12, 13, 'dog')\n", "a" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "a[0]" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Le parentesi non sono necessarie per definire una tuple: una sequenza di oggetti separati da virgole è sufficiente a definire una tuple:" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "a = 100, 200, 'duck'\n", "a" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "benchè sia buona pratica includere le parantesi per una maggiore leggibilità." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Si può costruire una ntuple con applicando il comando tuple ad una sequenza:" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "tuple([1,'a'])" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "tuple(\"abc\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Tuples possono anche essere usate per assegnare due valori contemporameamente:" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "x, y = 10, 20\n", "x" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "y" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Le ntuple possono essere usate per scambiare due oggetti in una sola riga di codice. Per esempio:" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "x = 1\n", "y = 2\n", "x, y = y, x\n", "x" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "y" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "La ntupla vuota è `()`." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "t = ()\n", "len(t)" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "type(t)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "La notazione per una ntupla contenente un solo valore può, all'inizio, sembrare un po' strana:" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "t = (42,)\n", "type(t)" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "len(t)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "La virgola addizionale è necessaria per distinguere `(42,)` da `(42)`. Nel secondo caso le parentesi indicherebbero solo l'ordine di precedenza delle operazioni: `(42)` si semplifica a `42` che è semplicemente un numero:" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "t = (42)\n", "type(t)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Un esempio dell'immutabilità di una tuple:" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "a = (12, 13, 'dog')\n", "a[2]" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "a[0] = 1" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Operazioni possibili sulle ntuple" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "dir(a)" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "len(a)" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "a.index(13)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "L'immutabilità è la differenza principale fra una tuple e una lista (che è mutable). Le tuples vengono utilizzate quando non si vuole che il contenuto venga modificato.\n", "\n", "Le funzioni Python che ritornano più di un valore, li ritornano in tuples (che è sensato perchè in genere non si vuole che i risultati di una chiamata a una funzione vengano modificati)." ] }, { "cell_type": "markdown", "metadata": { "tags": [] }, "source": [ "
\n", "

Imparare Facendo

\n", "
    \n", "
  1. Costruite la lista dei numeri divisibili per 5 nell'intervallo 130-180, estremi inclusi. Assegnate la lista alla variabile L0. \n", "
      \n", "
    1. Trasformate L0 in una ntupla.\n", "
    2. Determinate l'indice di 145 in L0\n", "
    3. Sommate L0 a sè stessa\n", "
    \n", "
" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Indici in sequenze\n", "\n", "Abbiamo già accennato più volte all'uso degli indici in sequenze introducendo le varie strutture dati. Questa sezione cerca di sistematizzare l'argomento.
 
\n", "I singoli oggetti in una lista/stringa/tuple possono essere indicati con il loro indice fra parentesi quadre(`[` e `]`). Notate che Python (come in C ma diversamente dal Fortran e da Matlab) conta gli indici partendo da zero!" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "a = ['dog', 'cat', 'mouse']\n", "a[0]" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "a[1]" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "a[2]= 'parrot'" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "a" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "L'indice di un oggetto in una sequenza si può trovare con il metodo `index`(oppure `find`, cercate sulla documentazione la differenza fra i due metodi):" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "a.index('cat')" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "b = [0,'pluto',10,3]\n", "b.index(10)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "
\n", " \n", "
" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Python ha un modo semplice per estrarre l'ultimo elemento di una lista: si usa l'indice “-1”, dove il segno meno indica che l'elemento è a *un passo* dal fondo della lista. Nello stesso, l'indice “-2” ritorna il penultimo elemento (2nd last):" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "a = ('dog', 'cat', 'mouse')\n", "a[-1]" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "a[-2]" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Si può anche pensare ad `a[-1]` come una abbreviazione di `a[len(a) - 1]`.\n", "\n", "Ricordate che le stringhe (come le liste) sono delle sequenze e possono essere indicizzate nello stesso modo:" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "a = \"Hello World!\" \n", "a[0]" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "a[1]" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "a[100]" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "a[-1]" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "a[-2]" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "a[3]='u'" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "##### Informazioni ulteriori\n", "\n", "- Introduzione a stringhe e indici [Python tutorial, section 3.1.2](http://docs.python.org/tutorial/introduction.html#strings), la sezione sull'uso degli indici inizia dopo che sono state introdotte le stringhe." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Sezioni di sequenze\n", "\n", "Lo *slicing* di una sequenze può essere utilizzato per estrarre più di un elemento. Per esempio:" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "a = \"Hello World!\"\n", "a[5:10]" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Scrivendo `a[0:3]` richiediamo i primi 3 elementi iniziando dall'elemento 0. Analogamente:" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "a[1:4]" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "a[0:2]" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "a[0:6]" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Si possono usare indici negtivi per riferirsi alla fine della sequenza:" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "a[0:-1]" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Per arrivare fino alla fine della sequenza:" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "a[5:len(a)]" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "È anche possibile omettere l'indice inziale o quello finale e questo restitusce tutti gli elementi a partire dall'inizio oppure fino alla fine della sequenza. Qualche esempio per chiarire:" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "a = \"Hello World!\"\n", "a[:5]" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "a[5:]" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "a[-2:]" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "a[:]" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Per invertire l'ordine degli elementi di una lista possiamo usare:" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "a[::-1]" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Notate che `a[:]` genera una *copia* di `a`. Il modo con cui vengono usati gli indici nello slicing può sembrare controintuitivo. Se vi trovate in difficoltà, ricordate questa spiegazione dal [Python tutorial (section 3.1.2)](http://docs.python.org/tutorial/introduction.html#strings):\n", "\n", "> The best way to remember how slices work is to think of the indices as pointing between characters, with the left edge of the first character numbered 0. Then the right edge of the last character of a string of 5 characters has index 5, for example:\n", ">\n", "> 0 1 2 3 4 <-- use for INDEXING \n", "> -5 -4 -3 -2 -1 <-- use for INDEXING from the end\n", "> +---+---+---+---+---+ \n", "> | H | e | l | l | o |\n", "> +---+---+---+---+---+ \n", "> 0 1 2 3 4 5 <-- use for SLICING\n", "> -6 -5 -4 -3 -2 -1 <-- use for SLICING from the end\n", "> \n", ">\n", "> The first row of numbers gives the position of the slicing indices 0...5 in the string; the second row gives the corresponding negative indices. The slice from i to j consists of all characters between the edges labelled i and j, respectively.\n", "\n", "L'affermazione importante è che nello *slicing* gli indici puntano *fra* i caratteri o elementi.\n", "\n", "Per *indicizzare* è preferibile pensare che gli indici si riferiscano direttamente agli elementi. \n", "\n", "Se non vi ricordate esattamente come funzionano gli indici, potete semplicemente sperimentare con un piccolo esempio usando il Python prompt prima o durante la scrittura del vostro programma." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "a = \"Hello\"\n", "a[-3:-6:-1]" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "La posizione di un elemento in qualunque oggetto di tipo sequenza può essere trovato con il *metodo* index:" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "(1,2,3).index(2)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Se l'elemento cercato non è presente si ha un errore:" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "[1,2,3].index(4)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "
\n", "

Imparare Facendo

\n", "
    \n", "
  1. Assegnate alla variabile L0 la lista di tutti i numeri fra 175 e 227, 175 incluso e 227 escluso.\n", "
      \n", "
    1. Estraete da L0 il penultimo elemento.\n", "
    2. Estraete da L0 gli elementi di indice 13, 14 e 15.\n", "
    3. Estraete da L0 tutti gli elementi salvo il primo e l'ultimo.\n", "
    \n", "
  2. Data la stringa \"Supercalifragilisticexpiralidoso\" costruite la stringa con tutte le lettere in ordine inverso.\n", "
  3. Costruite una funzione reverse che prenda come argomento una lista di numeri reali L e la restituisca ordinata inversamente, dal più grande al più piccolo.\n", "
\n", "
" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "##### Informazioni ulteriori\n", "\n", "- Introduzione a stringhe, indici e sezioni [Python tutorial, section 3.1.2](http://docs.python.org/tutorial/introduction.html#strings)\n", "\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 3.3 Dizionari\n", "\n", "I dizionari sono anche chiamati “associative arrays” o “hash tables”. I dizionari sono insiemi *unordered* di coppie *key-value*. Le keywords devono essere oggetti immutabili mentre i dizionari sono oggetti mutabili.\n", "\n", "Un dizionario vuoto può essere creato usando parentesi graffe (curly braces):" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "d = {}\n", "print(d)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Coppie keyword-value possono essere aggiunti come segue:" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "d['today'] = '22 deg C' # 'today' è la keyword" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "d['yesterday'] = '19 deg C'" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "print(d)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Il valore può essere estratto usando la keyword come indice:" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "d['today']" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Altri modi di riempire un dizionario se i dati sono noti al momento in cui viene creato sono:" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "d2 = {2:4, 3.5:9, 4:16, 5:25} # Notate che sto usando dei numeri interi o reali come chiavi.\n", "d2" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "d2_a = {'p':4, 'q':9, 'r':16, 's':25} # Se uso stringhe come chiavi devo scriverli fra apici\n", "d2_a" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "oppure:" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "d3 = dict(a=1, b=2, c=3) # In questo caso, se uso stringhe come chiavi NON devo scriverli fra apici\n", " # In questo caso, non posso usare numeri interi o reali come chiavi.\n", "d3" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Morale della favola: se esistono più modi di dare un comando non è garantito che ci sia una ovvia coerenza fra i diversi modi." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "La funzione `dict()` crea un dizionario vuoto.
\n", "Per eliminare una coppia key-value da un dizionario si può usare `del` passando la key come argomento:" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "dd = {'p':4, 'q':9, 'r':16, 's':25}\n", "print(dd)" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "del dd['r']\n", "print(dd)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "`d.keys()` restituisce la lista di tutte le keys:" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "d.keys()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Altri metodi utili per i dizionari sono `values()`, `items()` e `get()`. " ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "type(d.values())" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "d.items()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Il metodo `get(key,default)` restituisce il valore corrispondente a una certa `key` se la key esiste, altrimenti restituisce l'oggetto di `default`." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "d.get('today','unknown')" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "d.get('tomorrow','unknown')" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "'today' in d" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "'tomorrow' in d" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Si può usare `in` per controllare se una certa chiave è presente: " ] }, { "cell_type": "code", "execution_count": null, "metadata": { "tags": [] }, "outputs": [], "source": [ "d ={'pippo':'pluto'}" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "'pippo' in d" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "'pluto' in d" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Per controllare se è presente un certo valore si può `in` sulla lista dei valori" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "'pluto' in d.values()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Ulteriori dettagli:\n", "\n", "- La keyword può essere qualsiasi (immutable) oggetto in Python. Questo include:\n", "\n", " - numeri\n", "\n", " - stringhe\n", "\n", " - tuples.\n", "\n", "- i dizionari restituiscono i valori molto velocemente quando viene loro fornita la key." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "vlist = [1.2,-0.3,3.5]" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Componente `y`:" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "vlist[1]" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Rappresentazione con un dizionario:" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "vdict = {'vx':1.2, 'vy':-0.3, 'vz':3.5}" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Componente `y`:" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "vdict['vy']" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "I valori di un dizionario possono essere a loro volte dizionari (oppure liste e ntuple):" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "nazioni = {'Francia':{'capitale':'Parigi','popolazione':67.39e6},\n", " 'Germania':{'capitale':'Berlino','popolazione':83.24e6}}" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "nazioni['Germania']" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "nazioni['Germania']['popolazione']" ] }, { "cell_type": "markdown", "metadata": { "tags": [] }, "source": [ "
\n", "

Imparare Facendo

\n", "
    \n", "
  1. Costruite il dizionario squares che abbia come keys gli interi fra 1 e 5 e come values i corrispondenti quadrati.\n", "
      \n", "
    1. Aggiungete a squares la coppia key:value {6:36}.\n", "
    2. Eliminate da squares la coppia key:value {1:1}.\n", "
    \n", "
  2. Costruite il dizionario mesi che abbia come keys il nome dei mesi e come values il corrispondente numero di giorni\n", " sotto forma di stringa. Per febbraio il value sia \"28 oppure 29\".\n", "
\n", "
" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 3.4 Conversioni fra tipi\n", "\n", "La funzione `type` mostra il tipo di un oggetto. È possibile convertire un oggetto in uno di tipo diverso." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "La funzione `int()` converte in qualunque oggetto trasformabile in un intero:" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "a = '34' # a è una stringa che contiene i caratteri 3 e 4\n", "x = int(a) # x è il numero intero 34" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "print(\"Il type di '34' è\",type(a))\n", "print(\"Il type di\",x,\" è\",type(a))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Ovviamente l'argomento di `int` deve essere interpretabile come un intero" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "int('piripacchio')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Agendo su numeri reali `int()` tronca qualsiasi parte non intera:" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "int(7.0)" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "int(7.9)" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "int(-7.9)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Per arrotondare un numero reale all'intero più vicino usate la funzione `round()`:" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "round(7.9)" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "round(-7.9)" ] }, { "cell_type": "markdown", "metadata": { "tags": [] }, "source": [ "Il tipo di una stringa è `str`. La funzione `str` trasforma un oggetto in stringa:" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "a = \"Hello World\"\n", "type(a)" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "b = \"\"\n", "type(b)" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "num = 5.76\n", "print(type(num))" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "num_as_string = str(num)\n", "print(\"num_as_string is of type\",type(num_as_string))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Il tipo di una lista è `list`:" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "a = [34, 12, 54]\n", "type(a)" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "type([])" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 3.5 Locazione in memoria e copia di oggetti\n", "\n", "Python fornisce la funzione `id()` che restituisce un numero che identifica in modo unico un oggetto, essenzialmente l'indirizzo in memoria. Possiamo utilizzare questa funzione per verificare se due oggeti sono identici, cioè se si riferiscono alla stessa locazione di memoria.
" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "m = 2\n", "print(f'id(m) = {id(m)}')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Quando eseguiamo il comando `n = m`, la variabile `n` punta alla stessa posizione di memoria:" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "n = m\n", "print(f'id(n) = {id(n)}')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Usando `is`" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "In Python, i numeri, le ntuple, le stringhe sono \"immutabili\" cioè non possono essere modificati senza creare una nuova copia dell'oggetto.
\n", "Se cambiamo il valore di n cambia anche la posizione in memoria:" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "n += 1\n", "print(f'n = {n}')\n", "print(f'id(n) = {id(n)}')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "L'indirizzo che è immagazzinato nella variabile m, invece, non cambia:" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "print(f'm = {m}')\n", "print(f'id(m) = {id(m)}')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Copia di liste tramite assegnazione. Qualche esempio:" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "a = list(range(10))\n", "a" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "b = a # shallow copy. b punta allo stesso oggetto a cui punta a\n", "b[0] = 42\n", "a # cambiare b cambia anche a" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "id(a)" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "id(b)" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "id(b[0])" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Per creare una nuova copia indipendente di una sequenza di oggetti (incluse le liste), possiamo usare lo slicing. Se `a` è una lista, allora `a[:]` restituisce una copia indipendente di `a`." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "c = a[:] \n", "id(c) # c è un oggetto diverso" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "c[0] = 100 \n", "a # cambiare c non cambia a" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "c # verifichiamo c" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "La standard library di Python fornisce il modulo `copy`, che contiene funzioni che possono essere utilizzate per creare copie di oggetti. Avremmo potuto usare `import copy; c = copy.deepcopy(a)` invece di `c = a[:]`." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### 3.5.1 Mutabilità, Immutabilità e metodi che modificano oggetti immutabili" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "st = \"abc\"" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Non posso sostitire una lettera in st" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "st[0] = 'A'" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Posso però fare" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "st = st.upper()\n", "st" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Il metodo upper crea una nuova stringa. Quando la assegno a `st` distruggo la referenza all'oggetto originale." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "st = \"abc\"\n", "print(id(st))" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "st = st.upper()\n", "print(id(st))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "La stessa cosa succede con ntuple e numpy.array." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Se modifico un oggetto mutabile la sua locazione in memoria non viene cambiata." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "lst = [1,2,3]\n", "print(lst,id(lst))\n", "lst[0] = 100\n", "print(lst,id(lst))\n", "lst.append(44)\n", "print(lst,id(lst))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "
\n", " \n", "
" ] } ], "metadata": { "hide_input": false, "kernelspec": { "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.9.12" }, "toc": { "base_numbering": 1, "nav_menu": {}, "number_sections": true, "sideBar": true, "skip_h1_title": true, "title_cell": "Table of Contents", "title_sidebar": "Contents", "toc_cell": false, "toc_position": {}, "toc_section_display": true, "toc_window_display": false }, "varInspector": { "cols": { "lenName": 16, "lenType": 16, "lenVar": 40 }, "kernels_config": { "python": { "delete_cmd_postfix": "", "delete_cmd_prefix": "del ", "library": "var_list.py", "varRefreshCmd": "print(var_dic_list())" }, "r": { "delete_cmd_postfix": ") ", "delete_cmd_prefix": "rm(", "library": "var_list.r", "varRefreshCmd": "cat(var_dic_list()) " } }, "types_to_exclude": [ "module", "function", "builtin_function_or_method", "instance", "_Feature" ], "window_display": false } }, "nbformat": 4, "nbformat_minor": 4 }