{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Ricapitolazione Lez 4\n",
    "- scansione di una stringa con il while o con il for\n",
    "- for: i in elenco, indicizza su un elenco di oggetti, non tipato\n",
    "- for su elementi di una stringa vs for su indici di una stringa\n",
    "- funzione range\n",
    "- ricorsione\n",
    "- disegni con asterischi\n",
    "- liste"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Soluzione Esercizi"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### strig.format() "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print('ciao sono {} e vivo a {}'.format('Marco','Trieste'))\n",
    "print('ciao sono {} ed ho {} anni'.format('Luigi',25))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Esercizio (Soluzione): insertionSort"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Passi dell'insertionSort:\n",
    "\n",
    "**input:** [29,  3, 71, 34, 8, 55, 91, 5, 27]  \n",
    "1 -> [**3**, 29, 71, 34, 8, 55, 91, 5, 27]  \n",
    "2 -> [**3, 29**, 71, 34, 8, 55, 91, 5, 27]  \n",
    "3 -> [**3, 29, 34**, 71, 8, 55, 91, 5, 27]  \n",
    "4 -> [**3,  8, 29, 34, 71**, 55, 91, 5, 27]  \n",
    "5 -> [**3,  8, 29, 34, 55, 71**, 91, 5, 27]  \n",
    "6 -> [**3,  8, 29, 34, 55, 71, 91**, 5, 27]  \n",
    "7 -> [**3,  5, 8, 29, 34, 55, 71, 91**, 27]  \n",
    "8 -> [**3,  5, 8, 27, 29, 34, 55, 71, 91**]  \n",
    "**output:** [3, 5, 8, 27, 29, 34, 55, 71, 91] "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def insertionSort(lista):\n",
    "    for indice in range(1,len(lista)):\n",
    "        valoreCorrente = lista[indice]\n",
    "        posizione = indice\n",
    "        while posizione>0 and lista[posizione-1]>valoreCorrente:\n",
    "            lista[posizione]=lista[posizione-1]\n",
    "            posizione = posizione-1\n",
    "        lista[posizione]=valoreCorrente\n",
    "        ##print('{} -> {}'.format(indice,lista)) #stampa i passi dell'algoritmo\n",
    "\n",
    "miaLista = [29,3,71,34,8,55,91,5,27]\n",
    "print(miaLista)\n",
    "insertionSort(miaLista)\n",
    "print(miaLista)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Esercizio (Soluzione): basi diverse"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#### Esercizio\n",
    "#Scrivere un programma che converte un numero in una base da 2 a 10 ad un numero in base 10\n",
    "\n",
    "base=int(input(\"inserisci la base (2..10): \"))\n",
    "  \n",
    "s=input(\"inserisci il numero in base \"+str(base)+\": \")\n",
    "valore=0\n",
    "polinomio=''\n",
    "for i in range(len(s)):\n",
    "    valore=valore+int(s[i])*base**(len(s)-(i+1))\n",
    "    polinomio = polinomio+'+'+s[i]+'*'+str(base)+'^'+str((len(s)-(i+1)))\n",
    "print(\"{} (base {}), in base 10 vale {} = {}\".format(s,base,polinomio,valore))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#f(0)=1\n",
    "#f(1)=1\n",
    "#f(n)=f(n-1)+f(n-2)\n",
    "def fibonacci(n):\n",
    "    if n<=2:\n",
    "        return 1\n",
    "    return fibonacci(n-1)+fibonacci(n-2)\n",
    "\n",
    "fibonacci(7)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def fattoriale(n):\n",
    "    if n==0:\n",
    "        print('fattoriale(0)=1')\n",
    "        return 1\n",
    "    ##print('fattoriale({})={}*fattoriale({})'.format(n,n,n-1)) #stampa le iterazioni\n",
    "    return n*fattoriale(n-1)\n",
    "\n",
    "fattoriale(10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "# Lez 5\n",
    "## Liste\n",
    "\n",
    "Torniamo alle liste.\n",
    "\n",
    "La lista è una sequenza ordinata di elementi eterogenei e **mutabili**!!!\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#le liste sono mutabili\n",
    "lista = ['a',5,'b']\n",
    "print('lista='+str(lista))\n",
    "lista[0] = 'f'\n",
    "print('lista='+str(lista))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#le stringe sono immutabili!! \n",
    "parola = \"ciao\"\n",
    "parola[0]='3'\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#le liste possono contenere elementi di tipo diverso.   \n",
    "lista = [\"ciao\", 2.0, 5, [10, 20]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#posso generare la lista vuola\n",
    "lista = []"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "lista= list()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#posso costruire una lista partendo range.\n",
    "list(range(5))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "list(range(1,5))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "list(range(2,10,2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "list(range(10,0,-2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#posso costruire una lista partendo da una stringa.\n",
    "list(\"ciao\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#posso costruire una lista partendo da una stringa e applicando la funzione split.\n",
    "s1 = 'ciao come stai?'\n",
    "s2 = s1.split(' ') # equivalemente s1.split(\" \")\n",
    "print(s2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "s1 = 'anshd#sdsda#asddd#dfdf#3233#ss?'\n",
    "s2 = s1.split('#') # equivalemente s1.split(\" \")\n",
    "print(s2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Osservazione: in Python virgolette ' ' e doppie-virgolette \" \"  per riferirsi a stringhe sono intercambiabili. \n",
    "#Sopra infatti abbiamo usato a volte '', altre volte \"\"."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Accedere a un elemento: **x[ indice ]**\n",
    "(tutto quello che diremo fino agli Esercizi vale anche per le stringhe)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = [23,3,2,65]\n",
    "print('il primo elemento vale:'+str(x[0])) # <-- Python e molti altri linguaggi cominciano a contare da zero. \n",
    "print('l\\'ultimo elemento vale:'+str(x[-1]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Slicing: x[init : end : step]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = [23,3,2,65]\n",
    "x[1:3] #seleziona gli elementi di indice 1 e 3 (escluso)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x[2:] #dall'elemento di indice 2 fino alla fine. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x[:3] #dall'inizio fino all'elemento di indice 3 escluso. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "y = x + [6,7,8,9,10] #concatenazione"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "y[1:6:2] #dall'elemento di indice 1 fino all'elemento di indice 6 (escluso), con step 2  . "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "y[::2] #dall'inizio alla fine, con step 2. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "y[::-1] #dall'inizio alla fine, con step -1 (quindi parte dalla fine e va verso l'inizio con step 1 ) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "y[::-3] #dall'inizio alla fine, con step -1 (quindi parte dalla fine e va verso l'inizio con step 3 ) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Esercizi (insieme)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "parola = 'anna'\n",
    "isPalindromo = (parola[::-1]==parola)\n",
    "print('\"{}\" è un palindromo? {} '.format(parola,isPalindromo))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#palindromo\n",
    "frase = 'i topi non avevano nipoti' \n",
    "frase = frase.replace(\" \",\"\") #eliminiamo gli spazi bianchi\n",
    "isPalindromo = (frase[::-1]==frase) \n",
    "print('\"{}\" è un palindromo? {} '.format(frase,isPalindromo))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#ordinamento tra char\n",
    "'a'<'b'"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "ord\n",
    "Signature: ord(c, /)\n",
    "Docstring: Return the Unicode code point for a one-character string.\n",
    "Type:      builtin_function_or_method"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ord('a')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ord('b')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#anagramma\n",
    "a1 = 'no more stars'\n",
    "a2 = 'astronomers'\n",
    "a1 = a1.replace(\" \",\"\") #eliminiamo gli spazi bianchi\n",
    "print('insertionSort: {}'.format(insertionSort(list(a1))==insertionSort(list(a2))))\n",
    "print('sorted function : {}'.format(sorted(a1)==sorted(a2)))"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "sorted?\n",
    "Signature: sorted(iterable, /, *, key=None, reverse=False)\n",
    "Docstring:\n",
    "Return a new list containing all items from the iterable in ascending order.\n",
    "\n",
    "A custom key function can be supplied to customize the sort order, and the\n",
    "reverse flag can be set to request the result in descending order.\n",
    "Type:      builtin_function_or_method"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Lunghezza di una lista\n",
    "Per sapere la lunghezza di una lista uso _len()_. Importante quando si deve ciclare sugli elementi di una lista!!!"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "len?\n",
    "Signature: len(obj, /)\n",
    "Docstring: Return the number of items in a container.\n",
    "Type:      builtin_function_or_method"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "i=0\n",
    "while i < len(x):\n",
    "    print(x[i]) \n",
    "    i = i + 1 "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "L'operatore **in** serve per vedere se un elemento è in una lista e per ciclare sulla lista con il for"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "1 in x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in x:\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#classico ciclo for\n",
    "for i in range(len(x)):\n",
    "    print(x[i])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#range e intervalli\n",
    "for i in range(0,10,2):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Operazioni sulle liste"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "[1,2]+[4,5]      # concatenazione"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "[1,2]*3          # ripetizione  concatenata"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x= [1,2,3,4,5,6,7,8]\n",
    "print('prima: '+str(x))\n",
    "x[1:3]=[] #elimino gli elementi dall'indice 1 all'indice 3 (escluso)\n",
    "print('dopo: '+str(x))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x= [1,2,3,4,5,6,7,8]\n",
    "print('prima: '+str(x))\n",
    "x[1:3]=['ciccia','casa','pluto'] #sostituisco gli elementi dall'indice 1 all'indice 3 (escluso) con altri elementi. \n",
    "print('dopo: '+str(x))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x= [1,2,3,4,5,6,7,8]\n",
    "print('x='+str(x))\n",
    "print('cancello il primo elemento')\n",
    "del x[0]\n",
    "print('x='+str(x))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Attenzione all'operatore di assegnazione ('=') quando lavorate con oggetti mutabili. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "list1 = ['carlo','magno']\n",
    "print('prima: list1='+str(list1))\n",
    "list2=list1 # list2 ed list1 puntano alla stesso oggetto in memoria. \n",
    "list2[0]='alessandro' #tutte le modifiche che faccio su list2 le sto facendo anche su list1!!!!\n",
    "print('dopo: list1='+str(list1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"fig/assegnazione.png\" width=\"400\">"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "list1 = ['a',7,'ciao']\n",
    "list2=l1\n",
    "list2[1]=123\n",
    "print('list1:'+str(list1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Copiare una lista: list.copy()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"fig/copy.png\" width=\"400\">"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "list1 = ['a',7,'pippo']\n",
    "list2=list1.copy() # oppure list2=list1[:]\n",
    "list2[0]='b'\n",
    "print('list1[0]='+str(list1[0]))\n",
    "print('list2[0]='+str(list2[0]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#quando si effettua la copia \n",
    "list3 = ['11',7,23]\n",
    "list4 = list3.copy()\n",
    "# list4 punta a un oggetto diverso da list3\n",
    "print('list3 e list4  puntano allo stesso oggetto? '+str( id(list4)==id(list3)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# tuttavia al loro interno ci sono delle variabili list3[0],list3[1],list3[3], list4[0],list4[1],list4[3]\n",
    "#che puntano ai medesimi oggetti... bisogna fare attenzione se alcuni di questi oggetti sono oggetti mutabili\n",
    "# per esempio delle liste.... (vedi liste annidate!)\n",
    "for i in range(len(l3)):\n",
    "    print('list3[{}] e list4[{}] puntano allo stesso oggetto? {}'.format(i,i,id(list3[i])==id(list4[i])))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Attenzione alla copia di liste annidate."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"fig/annidate.png\" width=\"450\">"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#occhio alle liste annidate!!! \n",
    "list1 = ['a','b',['c','d']]\n",
    "list2= list1.copy()\n",
    "print('prima: list1: '+str(list1))\n",
    "print('prima: list2: '+str(list2))\n",
    "#list1 e list2 puntano ad oggetti diversi. \n",
    "print('list1 e list2 puntano ad oggetti diversi? '+str(id(list1)!=id(list2))) \n",
    "#tuttavia visto che list1[2] e list2[2] puntano a un oggetto mutabile se io lo modifico tramite list2...\n",
    "list2[2][0]='q'\n",
    "print('assegno \"q\" a list2[2][0]')\n",
    "#...la modifica la vedrò anche su list1\n",
    "print('dopo: list1: '+str(list1))\n",
    "print('dopo: list2: '+str(list2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### per copiare liste  annidate posso usare il deepcopy()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"fig/deepcopy.png\" width=\"450\">"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import copy\n",
    "\n",
    "list1 = ['a','b',['c','d']]\n",
    "list2= copy.deepcopy(list1)\n",
    "print('prima: list1: '+str(list1))\n",
    "print('prima: list2: '+str(list2))\n",
    "#list1 e list2 puntano ad oggetti diversi. \n",
    "print('list1 e list2 puntano ad oggetti diversi? '+str(id(list1)!=id(list2))) \n",
    "list2[2][0]='k'\n",
    "print('assegno \"k\" a list1[2][0]')\n",
    "#visto che ho usato il deepcopy la modifica la vedrò solo su list2 \n",
    "print('dopo: list1: '+str(list1))\n",
    "print('dopo: list2: '+str(list2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "l1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Metodi delle liste"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "!!!!! I metodi delle liste modificano l'oggetto di partenza, i metodi delle stringhe non modificano la lista stessa !!!!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "l3=list()\n",
    "l3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "l4 = l3.append('casa')  ### modifica l3 ma non restituisce nessun valore"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "l3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "l3.append(9)    # ho modificato la lista\n",
    "l3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "l2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "l2=l2*2         # ho creato una nuova lista"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "l2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "l2[0]='ciao'\n",
    "l2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "l2[2][0]='giuseppe'\n",
    "l2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "l4=['a','b','c']\n",
    "l4\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ele1= l4.pop()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ele1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "l4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ele2 = l4.pop(0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "l4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "l5 = [1,2,3]\n",
    "l6=[4,5,6]\n",
    "l5=l5+l6\n",
    "l5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "l5 = [1,2,3]\n",
    "l6=[4,5,6]\n",
    "l5.extend(l6)\n",
    "l5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "l5.extend(l6)\n",
    "l5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x=[3,4,67,88,900,2,1,124,5]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x.sort()\n",
    "x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Esercizio (insieme): trova errore"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import random \n",
    "random.randint?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#generare un numero intero randomico tra 0 e 9 (incluso)\n",
    "random.randint(0,9)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in range(30):\n",
    "    print(str(random.randint(0,9))+' ',end=\"\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#scrivere la funzione randomNumber che accetta come input un numero intero (n) tra 0 e 9 e genera una stringa di numeri\n",
    "#random che devono contenere n solo in ultima posizione. Se n non è in [0,9] la funzione deve ritornare 'fail'.\n",
    "#Esempio: \n",
    "#randomNumber(3) può generare 124573, oppure 14587413 ma non deve generare 13245783 (perchè c'è un 3\n",
    "#in posizione 2), 124574 (perchè non c'è il 3) etc. \n",
    "#randomNumber(57) ritorna 'fail' perchè 57 non è in [0,9]\n",
    "import random\n",
    "def randomNumber(n):\n",
    "    s = str(n)\n",
    "    condition = s in '0123456789' # ERRORE: controlla se esiste una sottostringa di '0123456789' uguale a s,\n",
    "    if not condition:             # quindi anche 12 23 45 sono in '0123456789' .... \n",
    "        res= 'fail'\n",
    "    else:\n",
    "        exit = 'p'\n",
    "        res = ''\n",
    "        while exit!= s:\n",
    "            exit=str(random.randint(0,9))\n",
    "            res =res+exit\n",
    "    return res"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# randomNumber(12) entra in un ciclo infinito"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import random\n",
    "def randomNumberCorrect(n):\n",
    "    s = str(n)\n",
    "    condition = s in list('0123456789') # ERRORE: controlla se esiste una sottostringa di '0123456789' uguale a s,\n",
    "    if not condition:             # quindi anche 12 23 45 sono in '0123456789' .... \n",
    "        res= 'fail'\n",
    "    else:\n",
    "        exit = 'p'\n",
    "        res = ''\n",
    "        while exit!= s:\n",
    "            exit=str(random.randint(0,9))\n",
    "            res =res+exit\n",
    "    return res"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "randomNumberCorrect(8)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Esercizio (a casa)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"fig/esercizio.png\" width=\"500\">"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.6.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}