{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Ricapitolazione Lez 3\n",
    "- esercizi valore assoluto, numeri divisibili e triangolo\n",
    "- while: condizione iniziale, ordine delle istruzioni, cicli infiniti\n",
    "- attenzione all'and \n",
    "- inserimento pogramma esterno"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Lez 4\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# leggere un file attenzione al path dove avete salvato il file\n",
    "exec(open('/Users/lauretta/Desktop/Sol_Ex_triangolo.py').read())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "chetriangolo()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "!!! notare che vale solo se scrivi 'sì'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Ex conto alla rovescia con il while"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Scansione di una stringa"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "stringa = 'disegno'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "i=0\n",
    "while i < len(stringa):\n",
    "    print(stringa[i])\n",
    "    i=i+1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## in\n",
    "La parola in è un operatore booleano che confronta due stringhe e restituisce True se la prima è una sottostringa della seconda."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "s = '+748'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "'4' in s "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "s.isdecimal() or (s[0] in '+-' and s[1:].isdecimal() )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### For\n",
    "for i in sequenza di elementi:\n",
    "    \n",
    "    istruzioni eseguite"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in 'disegno' :\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in [1,45,78] :\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Posso scrivere qualsiasi tipo di elenco di oggetti, sequenza di elementi (lista, stringa,file, oggetti più complessi); questo in Java è impossibile!!!!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in [1,'ciao',4/5] :\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Non è pulito, non è un linguaggio tipato ma è comodo da morire"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# cerco il carattere più \"grande\" dell'alfabeto in una stringa\n",
    "# itero sui caratteri (gli elementi) della stringa\n",
    "s ='ciao'\n",
    "cmax=s[0]  \n",
    "for c in s[1:] :\n",
    "    if c >= cmax:\n",
    "        cmax=c\n",
    "print(cmax)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# cerco la posizione del carattere più \"grande\" dell'alfabeto in una stringa\n",
    "# itero sulla posizione (sugli indici) della stringa\n",
    "s ='ciao'\n",
    "imax=0\n",
    "for i in [1,2,3] :\n",
    "    if s[i]>=s[imax]:\n",
    "        imax=i\n",
    "print(imax)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in range(4):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "list(range(3,5))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "type(range(5))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in range(10):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "s ='ciaoo'\n",
    "for i in range(len(s)) :\n",
    "    print(s[i])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Ex conto alla rovescia con il for"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Ricorsione\n",
    "Abbiamo visto che è del tutto normale che una funzione ne chiami un’altra, ma è anche consentito ad una funzione di chiamare se stessa."
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "def Ricorsione(): \n",
    "  Ricorsione()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def contoallarovesciaRic(n):\n",
    "    if n <= 0:\n",
    "        print('Via!')\n",
    "    else:\n",
    "        print(n)\n",
    "        contoallarovesciaRic(n-1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "contoallarovesciaRic(10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def contoallarovesciaWhile(n):\n",
    "    while n > 0:\n",
    "        print(n)\n",
    "        n = n-1\n",
    "    print('Via!')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "contoallarovesciaWhile(4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def contoallarovesciaFor(n):\n",
    "    for i in range(n):\n",
    "        print(n - i)\n",
    "    print('Via!')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "contoallarovesciaFor(4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Ex fibonacci\n",
    "# F(1)=1, \n",
    "# F(2)=1, \n",
    "# F(n)=F(n-1)+F(n-2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# stampa un triangolo rettangolo\n",
    "#h = int(input(\"inserisci l'altezza del triangolo: \"))\n",
    "h = 5\n",
    "for i in range(h):\n",
    "        print(' '*(h-i-1),end='')\n",
    "        print('-'*(i+1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# stampa un quadrato\n",
    "#l = int(input('inserisci il lato del quadrato: '))\n",
    "l = 5\n",
    "for i in range(l):\n",
    "    if i==0 or i==l-1:\n",
    "        print('* '*l)\n",
    "    else:\n",
    "        print('*  '+' '*(l-2)+'  *')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# stampa uno snake\n",
    "l = int(input('altezza cammino: '))\n",
    "for i in range(l):\n",
    "        print('-'*i+'**'+'-'*(l+1-2-i))"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "Se avete voglia di divertirvi XD\n",
    "\n",
    "Esercizio: fate un programma che costruisce un albero di asterischi prendendo in input l'altezza dell'albero(triangolo), l'altezza del tronco e la larghezza del tronco. \n",
    "Hint: fate due cicli diversi per il tronco ed il triangolo.\n",
    "      \n",
    "Albero facile: senza spazi, base triangolo e tronco dispari, numero * in ogni riga dispari\n",
    "\n",
    "     *\n",
    "    ***\n",
    "   *****\n",
    "  *******\n",
    " *********\n",
    "    ***\n",
    "    ***\n",
    "    ***\n",
    "    \n",
    "\n",
    "\n",
    "Albero difficile: c'è uno spazio tra ogni asterisco\n",
    "    *\n",
    "   * *\n",
    "  * * * \n",
    " * * * *\n",
    "* * * * *\n",
    "   * *\n",
    "   * *\n",
    "   * *"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "Esercizio: scrivere un programma che converte un numero in una base da 2 a 10 ad un numero in base 10"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "Se voglio cercare se in una parola c'è un certo carattere che ciclo uso?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Liste\n",
    "\n",
    "Comodissime, potentissime!!! Non ha equivalenti con altri linguaggi di programmazione per come è fatta in python. La lista è un insieme di elementi eterogenei e mutabili!!!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "l=['ciao',19,3.1]"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "!!!! Le liste possono essere cambiate le stringhe no!!!!!"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "!!!! Attenzione !!!! se assegno ad un'altra variabile l, eg. lbis=l non sto creando un nuovo elemento come nelle stringhe, è sempre lo stesso elemento, le tue variabili puntano alla stessa lista!!!!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "lbis=l\n",
    "l[0]='domani'\n",
    "l"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "lbis"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "Le variabili sono puntatori all'oggetto di riferimento!!!!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# per aggiungere elementi ad una lista\n",
    "l.append(3)\n",
    "l"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "lbis"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "### !!!! il comando qui sotto non modifica la lista ma ne crea una nuova ###\n",
    "\n",
    "l = l+['ciao']\n",
    "\n",
    "##### Ora lbis ed l puntatno a due cose diverse"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "l"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "lbis"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "s='oggi è una bella giornata'\n",
    "l = s.split()     # split ritorna una lista di parole, per separare usa di default lo spazio\n",
    "l"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "s='oggi è una bella giornata'\n",
    "l = s.split(sep='i')     # posso cambiare il separatore!!! \n",
    "l                        # il separatore non farà parte della lista!!!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Esercizio: \n",
    "fare una funzione che prende in input una lista di interi e li ordina usando un insertionsort algorithm"
   ]
  }
 ],
 "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.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}