├── docs
    ├── assets
    │   └── favicon.png
    ├── Pyllole
    │   ├── assets
    │   │   └── favicon.png
    │   ├── 44_Type_None.md
    │   ├── 00_Install.md
    │   ├── 23_Print.md
    │   ├── 75_List_Comprehension.md
    │   ├── 25_Input.md
    │   ├── 55_Type_Tuple.md
    │   ├── 65_Modules.md
    │   ├── 99_Zen.md
    │   ├── 57_Type_Set.md
    │   ├── 27_If-Else.md
    │   ├── 71_Iterable.md
    │   ├── 41_Type_Number.md
    │   ├── 29_Loops.md
    │   ├── 05_Development_Environment.md
    │   ├── 85_Inheritance_Multiple.md
    │   ├── 61_Try_Except.md
    │   ├── 42_Type_String.md
    │   ├── 43_Type_Boolean.md
    │   ├── 81_Classes.md
    │   ├── 83_Inheritance.md
    │   ├── 59_Type_Dictionary.md
    │   ├── 53_Type_List.md
    │   ├── 01_Use_Python.md
    │   ├── 21_Variables.md
    │   ├── 11_Syntax.md
    │   └── 63_Functions.md
    ├── _config.yml
    ├── _layouts
    │   └── default.html
    └── index.md
├── README.md
├── CONTRIBUTING.md
├── LICENSE
└── CODE_OF_CONDUCT.md


/docs/assets/favicon.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/pythonitalia/python-abc/HEAD/docs/assets/favicon.png


--------------------------------------------------------------------------------
/docs/Pyllole/assets/favicon.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/pythonitalia/python-abc/HEAD/docs/Pyllole/assets/favicon.png


--------------------------------------------------------------------------------
/docs/_config.yml:
--------------------------------------------------------------------------------
1 | theme: jekyll-theme-architect 
2 | title: Python ABC
3 | description: Se vuoi imparare Python parti dall'ABC
4 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # Python ABC
 2 | 
 3 | _Se vuoi imparare Python parti dall'ABC._
 4 | 
 5 | Queste pagine vogliono essere un semplice strumento in grado di fornire un'immediata, unica e chiara risposta alle comuni domande di chi si avvicina per la prima volta al linguaggio Python.
 6 | 
 7 | * Come installo python?
 8 | * Come funziona una lista/dizionario/ciclo/...?
 9 | * Dove posso trovare documentazione, tutorial o corsi?
10 | 
11 | Prima di voler scrivere un qualunque programma con Python è necessario conoscere le basi.
12 | 
13 | [Vai alla pagina principale di Python-ABC](https://pythonitalia.github.io/python-abc/)
14 | 
15 | Ogni contributo è ben accetto, leggi il [codice di condotta](CODE_OF_CONDUCT.md) e la pagina con le [linee guida alla collaborazione](CONTRIBUTING.md).
16 | 
17 | Questa guida è è pubblicata con licenza Creative Commons Attribution 4.0 International [leggi qui](LICENSE) i dettagli.
18 | 


--------------------------------------------------------------------------------
/docs/Pyllole/44_Type_None.md:
--------------------------------------------------------------------------------
 1 | # Tipi: None 
 2 | 
 3 | `None` è un particolare tipo di dato che indica un valore nullo, l'assenza di dati. 
 4 | `None` non è uguale a `False`, non è `0` e non è una string vuota. 
 5 | 
 6 | ```python
 7 | >>> type(None) 
 8 | <class 'NoneType'>
 9 | ```
10 | 
11 | ```python
12 | >>> None == '' 
13 | False
14 | >>> '' == None
15 | False
16 | >>> 0 == None
17 | False
18 | >>> False == None
19 | False
20 | >>> None is None
21 | True
22 | ```
23 | 
24 | È possibile assegnare `None` a qualsiasi variabile ma non si possono creare altri oggetti di tipo `NoneType`. 
25 | Ogni varibile il cui valore è `None` punta allo stesso, ed unico, oggetto `None`.
26 | Per comparare un oggetto a `None` si deve quindi utilizzare `is`, non `==`.
27 | 
28 | ```python
29 | >>> "etc" is None
30 | False
31 | >>> None is None
32 | True
33 | ```
34 | 
35 | In una valutazione booleana `None` viene considerato `False`.
36 | 
37 | ```python
38 | >>> bool(None) 
39 | False
40 | >>> not None
41 | True
42 | ```
43 | 
44 | ---
45 | 
46 | _This content is a derivative of ["Learn X in Y minutes"](https://github.com/adambard/learnxinyminutes-docs) by [adambard](https://github.com/adambard), used under a CC BY-SA 3.0 license._
47 | 


--------------------------------------------------------------------------------
/docs/Pyllole/00_Install.md:
--------------------------------------------------------------------------------
 1 | # Installare  Python
 2 | 
 3 | Per poter eseguire un programma scritto in Python è necessario aver installato sul proprio computer l'interprete Python.
 4 | 
 5 | Le più diffuse distribuzioni Linux hanno Python pre-installato, poiché viene utilizzato per alcuni processi del sistema operativo. 
 6 | Le versioni di OSX uguale o successiva alla 10.3 (Panther) è molto probabile che già abbiano Python installato.
 7 | 
 8 | Il modo più semplice per sapere se il tuo sistema ha già installato Python è quello di provare ad eseguire il comando __python__ dalla linea di comando del tuo sistema operativo.
 9 | 
10 | Per installare Python scarica la versione più recente dal sito ufficiale: [https://www.python.org/downloads/](https://www.python.org/downloads/)
11 | 
12 | **Ricorda, Python 2 non è più supportato dal 1° gennaio 2020, maggiori informazioni i [qui](https://www.python.org/doc/sunset-python-2/).**
13 | 
14 | ---
15 | 
16 | ## Ulteriori guide 
17 | 
18 |   * [Installare Python - html.it](http://www.html.it/pag/15609/installare-python/)
19 |   * [Come installare e usare Python su Windows](https://gist.github.com/ricpol/2ca0ae46f02bfddf08036fa85519aa97)
20 |   * [Come installare pacchetti Python in Windows](https://gist.github.com/ricpol/2ca0ae46f02bfddf08036fa85519aa97)
21 | 
22 | 
23 | 


--------------------------------------------------------------------------------
/docs/Pyllole/23_Print.md:
--------------------------------------------------------------------------------
 1 | # Print
 2 | 
 3 | La funzione `print()` permette di scrivere sulla vostra console delle stringhe (sequenze di caratteri).
 4 | 
 5 | ```python
 6 | >>> print("Ciao, questa è una stringa.")               
 7 | Ciao, questa è una stringa.
 8 | ```
 9 | 
10 | Gli argomenti passati alla funzione `print()` vengono scritti in successione. Questi argomenti possono essere stringhe o risultati di funzioni o elaborazioni dirette.
11 | 
12 | ```python
13 | >>> print("La risposta è", 7*6)                        
14 | La risposta è 42
15 | ```
16 | 
17 | Tra ogni argomento viene stampato automaticamente il carattere spazio. E' possibile cambiare il carattere separatore impostando l'argomento `sep`.
18 | 
19 | ```python
20 | >>> print("La risposta è", 7*6, sep=": ")              
21 | La risposta è: 42
22 | ```
23 | 
24 | Ogni chiamata alla funzione print termina andando a capo. 
25 | È possibile evitarlo cambiando il carattere di fine riga con l'argomento `end`. 
26 | 
27 | ```python
28 | >>>> print("Ciao", end="")                             
29 | Ciao>>>
30 | ```
31 | 
32 | Sequenze speciali di caratteri indicano a print di compiere azioni particolari. La sequenza `\n` manda a capo, `\t` scrive una tabulazione.
33 | 
34 | ```python
35 | >>> print("Ciao!\nCome stai?")                        
36 | Ciao!
37 | Come stai?
38 | ```
39 | 
40 | ```python
41 | >>> print("UNO\tDUE\tTRE")                             
42 | UNO     DUE     TRE
43 | ```
44 | 
45 | 
46 | 


--------------------------------------------------------------------------------
/docs/Pyllole/75_List_Comprehension.md:
--------------------------------------------------------------------------------
 1 | # List Comprehension
 2 | 
 3 | _Prima di approfondire le "List Comprehension" assicurati di conoscere le [liste](53_Type_List.md), [set](57_Type_Set.md) e [dizionari](59_Type_Dictionary.md)._
 4 | 
 5 | La sintassi per le _list comprehension_ consente, in modo semplice ed elegante, di costruire sequenze da altre sequenze. 
 6 | 
 7 | Limitatamente alle loro possibilità sono un semplice, e più comprensibile, sostituto alla funzione lambda e alle funzioni `map()`, `filter()` e `reduce()`. 
 8 | 
 9 | Una _list comprehension_ è formata da:
10 | 
11 | * Una sequenza (oggetto iterabile)
12 | * Una variabile che rappresenti ogni elemento nella sequenza
13 | * Un'espressione opzionale di controllo/elaborazione
14 | * Un'espressione di output che produce elementi dell'elenco di output dai membri della sequenza di input che soddisfano il predicato.
15 | 
16 | Nel seguente esempio data una lista si trasformerà in una lista in cui ogni elemento è moltiplicato per due, ma solo se è un numero intero
17 | 
18 | ```python
19 | >>> sequenza=[1,2,3,'a',4, 3.2]                                                    
20 | >>> nuova_lista=[elemento*2 for elemento in sequenza if isinstance(elemento,int)]
21 | >>> print(nuova_lista)
22 | [2, 4, 6, 8]
23 | ```
24 | 
25 | In cui:
26 | 
27 | * `sequenza` è l'oggetto iterabile
28 | * `elemento` assume di volta in volta il valore di ogni elemento nella lista
29 | * `if isinstance(elemento,int)` è l'espressione opzionale di controllo/elaborazione
30 | * `elemento\*2` è l'espressione di output
31 | 


--------------------------------------------------------------------------------
/docs/Pyllole/25_Input.md:
--------------------------------------------------------------------------------
 1 | # Input
 2 | 
 3 | La funzione `input()` permette di interagire con la console e fornire dei dati, tramite tastiera, al programma.
 4 | 
 5 | L'argomento passato alla funzione `input(prompt)` è la stringa che viene mostrata sulla console in attesa dell'inserimento dei dati.
 6 | 
 7 | ```python
 8 | >>> input("Inserisci la tua età: ")
 9 | Inserisci la tua età: 
10 | ```
11 | 
12 | Il programma resterà in attesa dell'inserimento di un dato finché non verrà premuto il tasto invio.
13 | 
14 | La funzione restituisce ciò che è stato inserito tramite tastiera.
15 | 
16 | ```python
17 | >>> age=input("Inserisci la tua età: ")
18 | Inserisci la tua età: 42
19 | >>> print(age)
20 | 42
21 | ```
22 | 
23 | ### Valore restituito
24 | 
25 | La funzione `input()` restituisce sempre una stringa, se si vuole utilizzare il risultato come dato numerico è necessario convertirlo utilizzando le funzioni [int() o float()](41_Type_Number.md).
26 | 
27 | ```python
28 | >>> stringa = input("Inserisci un numero intero: ")
29 | Inserisci un numero intero: 42
30 | >>> numero=int(stringa)
31 | ```
32 | **Importante**: se la stringa passata a `int()` non è convertibile in un intero, Python genererà un'errore, è quindi consigliabile gestire l'eccezione con [try/except](61_Try_Except.md)
33 | 
34 | **Nota**: nelle versioni 2.x l'attuale funzione input() si chiamava raw_input(). La funzione input() di Python2 esiste ma ha un comportamento differente da quello qui descritto.
35 | 
36 | Vedi l'esempio pratico nella pagina [try/except](61_Try_Except.md) per come gestire l'errata conversione.
37 | 
38 | Vedi l'esempio pratico nella pagina [cicli](29_Loops.md) per come ripetere input() finché il valore è corretto.
39 | 


--------------------------------------------------------------------------------
/CONTRIBUTING.md:
--------------------------------------------------------------------------------
 1 | # Contributor License Agreement
 2 | 
 3 | Chiunque contribuisca a questo repository accetta implicitamente le regole descritte nel [codice di condotta](/CODE_OF_CONDUCT.md).
 4 | 
 5 | ## Regole di pubblicazione
 6 | 
 7 | **Assicurarsi sempre che il materiale sia gratuito.**
 8 | Un link per scaricare facilmente un libro non è sempre un link a un contenuto gratuito.
 9 | Si è pregati di contribuire solo con contenuti che abbiano una chiare licenza d'uso indicante la libera distribuzione dell'opera .
10 | 
11 | **Segnalazione di contenuti**
12 | Non è necessario conoscere ed utilizzare git, se hai trovato qualcosa di utile per questo progetto è possibile semplicemente aprire una segnalazione tramite la funzionalità _issue_ di github.
13 | 
14 | **Pyllole**
15 | 
16 |  * Ricordarsi che ci si rivolge a novizi non solo di Python ma anche di programmazione in generale.
17 |  * Approfondire troppo potrebbe rendere meno comprensibili i concetti di base.
18 |  * Omettere concetti basilari, d'altro canto, potrebbe creare "fondamenta poco solide".
19 |  * Inserire link quando si citano concetti già descritti in altre Pyllole .
20 | 
21 | **Quale documentazione consigliare?**
22 | 
23 |  * eBook, Corsi, Tutorial in formato testo, video o interattivi
24 |  * Ricordarsi che l'obiettivo è quello di dare strumenti a chi sta iniziando a programmare, questo è l'ABC. Inutile pubblicare link a eBook o tutorial per librerie o framework specifici.
25 |  * Non si vogliono linkare tutti i contenuti online su Python ma solo "i migliori".
26 |  * Contenuti recenti, vista la velocità a cui cambiano le cose nel mondo della programmazione è sempre meglio privilegiare contenuti recenti
27 |  * Risalire sempre alla fonte ufficiale, un link ad un eBook pubblicato all'interno di una conversazione di un forum non è un buon link.
28 | * Non verranno accettati link contenuti su google drive, dropbox, mega, scribd, issuu e altre piattaforme simili.
29 | 


--------------------------------------------------------------------------------
/docs/Pyllole/55_Type_Tuple.md:
--------------------------------------------------------------------------------
 1 | # Tipi: Tuple 
 2 | 
 3 | _Prima di studiare le tuple assicurati di conoscere le [liste](53_Type_List.md)._
 4 | 
 5 | Le tuple sono come le [liste](53_Type_List.md) ma immutabili.
 6 | 
 7 | ```python
 8 | >>> tup = (1, 2, 3)                                    
 9 | >>> tup
10 | (1, 2, 3)
11 | >>> type(tup)
12 | <class 'tuple'>
13 | ```
14 | 
15 | Puoi fare tutte queste operazione, che fai con le liste, anche sulle tuple
16 | 
17 | ```python
18 | >>> len(tup)                                           
19 | 3
20 | >>> tup + (4, 5, 6)
21 | (1, 2, 3, 4, 5, 6)
22 | >>> tup[:2]
23 | (1, 2)
24 | >>> 2 in tup
25 | True
26 | ```
27 | 
28 | Puoi scompattare le tuple (o liste) in variabili
29 | 
30 | ```python
31 | >>> a, b, c = (1, 2, 3)                                
32 | >>> a
33 | 1
34 | >>> b
35 | 2
36 | >>> c
37 | 3
38 | ```
39 | 
40 | puoi anche omettere le parentesi
41 | 
42 | ```python
43 | >>> d, e, f = 4, 5, 6                                  
44 | 4
45 | >>> e
46 | 5
47 | >>> f
48 | 6
49 | ```
50 | 
51 | Le tuple sono create di default se non usi le parentesi
52 | 
53 | ```python
54 | >>> g = 4, 5, 6                                        
55 | >>> g
56 | (4, 5, 6)
57 | >>> type(g)
58 | <class 'tuple'>
59 | ```
60 | 
61 | Guarda come è facile scambiare due valori
62 | 
63 | ```python
64 | >>> e, d = d, e                                        
65 | >>> e
66 | 4
67 | >>> d
68 | 5
69 | ```
70 | 
71 | **Importante**: Si noti che una tupla di lunghezza uno deve avere una virgola dopo l'ultimo elemento ma tuple di altre lunghezze, anche zero, no.
72 | 
73 | ```python
74 | >>> type((1))
75 | <class 'int'>
76 | >>> type((1,))
77 | <class 'tuple'>
78 | >>> type(())
79 | <class 'tuple'>
80 | ```
81 | 
82 | 
83 | ---
84 | 
85 | _This content is a derivative of ["Learn X in Y minutes"](https://github.com/adambard/learnxinyminutes-docs) by [adambard](https://github.com/adambard), used under a CC BY-SA 3.0 license._
86 | 


--------------------------------------------------------------------------------
/docs/Pyllole/65_Modules.md:
--------------------------------------------------------------------------------
 1 | # Moduli
 2 | 
 3 | Quando si creano programmi complessi per migliorarne leggibilità, manutenzione e riusabilità è preferibile suddividerlo in diversi file. 
 4 | Python utilizza i moduli proprio per permetterti di utilizzare ciò che hai definito in un file all'interno di un altro script.
 5 | 
 6 | Un modulo è un file contenente dichiarazioni e definizioni Python, ciò che viene definito in un modulo può essere importato in altri moduli o dal modulo principale.
 7 | 
 8 | Il nome del modulo sarà il file (senza il suffisso `.py`). 
 9 | 
10 | All'interno di un modulo, il nome del modulo (come stringa) è disponibile come valore della variabile globale `__name__`. 
11 | 
12 | Per importare un modulo:
13 | 
14 | ```python
15 | >>> import math                                        
16 | >>> print(math.sqrt(16))
17 | 4.0
18 | ```
19 | 
20 | Puoi ottenere specifiche funzione da un modulo
21 | 
22 | ```python
23 | >>> from math import ceil, floor                       
24 | >>> print(ceil(3.7))
25 | 4.0
26 | >>> print(floor(3.7))
27 | 3.0
28 | ```
29 | 
30 | Puoi importare tutte le funzioni da un modulo
31 | Attenzione: questo non è raccomandato
32 | 
33 | ```python
34 | >>> from math import *
35 | ```
36 | 
37 | Puoi abbreviare i nomi dei moduli
38 | 
39 | ```python
40 | >>> import math as m                                   
41 | >>> math.sqrt(16) == m.sqrt(16)
42 | True
43 | ```
44 | 
45 | Potete scoprire quali funzioni e attributi sono definiti in un modulo
46 | 
47 | ```python
48 | >>> import math                                        
49 | >>> dir(math)
50 | ['__doc__', '__loader__', '__name__', '__package__', ...]
51 | ```
52 | 
53 | **Attenzione**: Se nella cartella corrente hai uno script chiamato math.py, Python caricherà quello invece del modulo math. Questo succede perchè la cartella corrente ha priorità sulle librerie standard di Python
54 | 
55 | 
56 | ---
57 | 
58 | _This content is a derivative of ["Learn X in Y minutes"](https://github.com/adambard/learnxinyminutes-docs) by [adambard](https://github.com/adambard), used under a CC BY-SA 3.0 license._
59 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | "Python ABC" di Dario Cassina e Python Italia APS è pubblicato con licenza Creative Commons Attribution 4.0 International.
 2 | Per visualizzare una copia di questa licenza visitare https://creativecommons.org/licenses/by/4.0/ 
 3 | 
 4 | Parti di questo lavoro, dove indicato, sono derivate da altri progetti pubblicati sotto _licenza CC BY-SA_
 5 | Di seguito la lista dei progetti condivisi o adattati:
 6 | - "Learn X in Y minutes di adambard" disponibile presso l'indirizzo https://github.com/adambard/learnxinyminutes-docs, pubblicato sotto licenza CC BY-SA 3.0.
 7 | - "The Contributor Covenant - version 1.3.0" disponibile presso l'indirizzo https://www.contributor-covenant.org/version/1/3/0/code-of-conduct.html, pubblicato sotto licenza CC BY 4.0.
 8 | 
 9 | Nota sui contenuti condivisi o adattati:
10 | I contenuti condivisi o adattati da altri progetti con una versione precedente di CC BY-SA possono essere pubblicati come indicato al punto 4b del codice legale CC dalla versione 2.0 (https://creativecommons.org/licenses/by-nc-sa/2.0 / legalcode).
11 | 
12 | - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 
13 | English version
14 | 
15 | "Python ABC" by Dario Cassina and Python Italia APS is licensed under the Creative Commons Attribution 4.0 International License.
16 | To view a copy of this license, visit https://creativecommons.org/licenses/by/4.0/ 
17 | 
18 | Parts of this work, where indicated, are derived from other projects published under the CC BY-SA_license
19 | Below is the list of this shared or adapted projects:
20 | - "Learn X in Y minutes of adambard" available at https://github.com/adambard/learnxinyminutes-docs, published under CC BY-SA 3.0.
21 | - "The Covenant Contributor - version 1.3.0" available at https://www.contributor-covenant.org/version/1/3/0/code-of-conduct.html, published under CC BY 4.0 license .
22 | 
23 | Note on shared or adapted contents:
24 | Contents shared or adapted from other projects with a prior version of  CC BY-SA may be published as indicated in point 4b of the CC legal code since version 2.0 (https://creativecommons.org/licenses/by-nc-sa/2.0/legalcode).


--------------------------------------------------------------------------------
/CODE_OF_CONDUCT.md:
--------------------------------------------------------------------------------
 1 | # Codice di condotta
 2 | 
 3 | Ogni collaboratore e manutentore di questo progetto, nell'interesse di promuovere una comunità aperta e accogliente, si impegna a rispettare tutte le persone che contribuiscono attraverso segnalazioni, aggiornamenti, pubblicazioni e richieste di funzionalità.
 4 | 
 5 | Ci si impegna a rendere la partecipazione a questo progetto un'esperienza piacevole per tutti, indipendentemente da: livello di esperienza, sesso, identità di genere ed espressione, orientamento sessuale, disabilità, aspetto personale, razza, etnia, età, religione, o nazionalità.
 6 | 
 7 | Esempi di comportamenti inaccettabili da parte dei partecipanti sono:
 8 | 
 9 | * L'uso di linguaggio o immagini sessuali
10 | * L'uso di linguaggio o immagini violenti o materiale sessualmente esplicito
11 | * Attacchi personali
12 | * Commenti offensivi / sprezzanti / trolling
13 | * Molestie pubbliche o private
14 | * Pubblicazione di informazioni private, come gli indirizzi fisici o elettronici, senza il permesso esplicito
15 | * Altri comportamenti non etici o non professionali
16 | 
17 | I Manutentori del progetto hanno il diritto e la responsabilità di rimuovere, modificare o rifiutare commenti, codice, modifiche wiki, messaggi e altri contributi che non sono allineati a questo codice di comportamento, o di rimuovere o _bannare_ qualsiasi collaboratore per comportamenti che ritengano inadeguato, minaccioso, offensivo, o dannoso.
18 | 
19 | Con l'adozione di questo Codice di Condotta, i manutentori del progetto si impegnano ad applicare in modo equo e coerente questi principi in ogni aspetto della gestione di questo progetto.
20 | Manutentori del progetto che non seguono o non fanno rispettare il codice di condotta possono essere rimossi in modo permanente dal team di progetto.
21 | 
22 | Questo codice di condotta vale sia online che nella vita reale nel momento in cui un individuo sta rappresentando il progetto o la sua comunità.
23 | 
24 | Questo codice di condatta è stato tradotto e adattato da:
25 | The Contributor Covenant, version 1.3.0, available at [https://www.contributor-covenant.org/version/1/3/0/code-of-conduct.html](https://www.contributor-covenant.org/version/1/3/0/code-of-conduct.html) released under the [CC BY 4.0 License](https://github.com/ContributorCovenant/contributor_covenant/blob/release/LICENSE.md).
26 | 
27 | 


--------------------------------------------------------------------------------
/docs/Pyllole/99_Zen.md:
--------------------------------------------------------------------------------
 1 | # Lo Zen di Python
 2 | 
 3 | _Zen of Python_ è una raccolta di 20 principi che hanno influenzato, e continuano ad influenzare, lo sviluppo del linguaggio Python.
 4 | 
 5 | ## Lo Zen di Python, di Tim Peters
 6 | 
 7 | * Bello è meglio di brutto.
 8 | * Esplicito è meglio di implicito.
 9 | * Semplice è meglio di complesso.
10 | * Complesso è meglio di complicato.
11 | * Lineare è meglio di nidificato.
12 | * Rado è meglio di denso.
13 | * La leggibilità è importante.
14 | * I casi speciali non sono abbastanza speciali per infrangere le regole.
15 | * Anche se la praticità batte la purezza.
16 | * Gli errori non dovrebbero mai accadere in silenzio.
17 | * Salvo esplicitamente silenziati.
18 | * Davanti all'ambiguità, rifiuta la tentazione di indovinare.
19 | * Ci dovrebbe essere un - e preferibilmente solo uno - modo ovvio per farlo.
20 | * Anche se all'inizio potrebbe non essere un modo ovvio, a meno che tu non sia olandese.
21 | * Adesso è meglio che mai.
22 | * Anche se "mai" è spesso meglio di "proprio adesso".
23 | * Se l'implementazione è difficile da spiegare, è una cattiva idea.
24 | * Se l'implementazione è facile da spiegare, potrebbe essere una buona idea.
25 | * I namespace sono una delle grandi idee - facciamone di più!
26 | 
27 | Puoi vedere l'originale in inglese tramite l'interprete Python importando il modulo `this`.
28 | 
29 | ```
30 | >>> import this
31 | The Zen of Python, by Tim Peters
32 | 
33 | Beautiful is better than ugly.
34 | Explicit is better than implicit.
35 | Simple is better than complex.
36 | Complex is better than complicated.
37 | Flat is better than nested.
38 | Sparse is better than dense.
39 | Readability counts.
40 | Special cases aren't special enough to break the rules.
41 | Although practicality beats purity.
42 | Errors should never pass silently.
43 | Unless explicitly silenced.
44 | In the face of ambiguity, refuse the temptation to guess.
45 | There should be one-- and preferably only one --obvious way to do it.
46 | Although that way may not be obvious at first unless you're Dutch.
47 | Now is better than never.
48 | Although never is often better than *right* now.
49 | If the implementation is hard to explain, it's a bad idea.
50 | If the implementation is easy to explain, it may be a good idea.
51 | Namespaces are one honking great idea -- let's do more of those!
52 | ```
53 | 


--------------------------------------------------------------------------------
/docs/Pyllole/57_Type_Set.md:
--------------------------------------------------------------------------------
  1 | # Tipi: Set
  2 | 
  3 | _Prima di studiare i set assicurati di conoscere le [liste](53_Type_List.md)._
  4 | 
  5 | I set sono come le liste ma non possono contenere doppioni.
  6 | 
  7 | Un set si inizializza in questo modo:
  8 | 
  9 | ```python
 10 | >>> empty_set = set()  
 11 | >>> empty_set
 12 | set()
 13 | >>> type(empty_set)
 14 | <class 'set'>
 15 | ```
 16 | 
 17 | Inizializzare un set con un dei valori ha una sintassi molto simile all'inizializzazione di un dizionario.
 18 | 
 19 | ```python
 20 | >>> some_set = {1, 1, 2, 2, 3, 4}  
 21 | >>> some_set
 22 | {1, 2, 3, 4}
 23 | ```
 24 | 
 25 | Come le chiavi di un dizionario, gli elementi di un set devono essere di tipo immutabile
 26 | 
 27 | ```python
 28 | >>> invalid_set = {[1], 1} 
 29 | Traceback (most recent call last):
 30 |   File "<stdin>", line 1, in <module>
 31 | TypeError: unhashable type: 'list'
 32 | >>> valid_set = {(1,), 1}
 33 | ```
 34 | 
 35 | 
 36 | Aggiungere uno o più elementi ad un set con il metodo `.add()`
 37 | 
 38 | ```python
 39 | >>> some_set.add(5)
 40 | >>> some_set
 41 | {1, 2, 3, 4, 5}
 42 | ```
 43 | 
 44 | Fai intersezioni su un set con `&`
 45 | 
 46 | ```python
 47 | >>> other_set = {3, 4, 5, 6}   
 48 | >>> some_set & other_set  
 49 | {3, 4, 5}
 50 | ```
 51 | 
 52 | Fai unioni su set con `|`
 53 | 
 54 | ```python
 55 | >>> some_set | other_set   
 56 | {1, 2, 3, 4, 5, 6}
 57 | ```
 58 | 
 59 | Fai differenze su set con `-`
 60 | 
 61 | ```python
 62 | >>> {1, 2, 3, 4} - {2, 3, 5}   
 63 | {1, 4}
 64 | ```
 65 | 
 66 | 
 67 | Effettua la differenza simmetrica con `^`
 68 | 
 69 | ```python
 70 | >>> {1, 2, 3, 4} ^ {2, 3, 5}   
 71 | {1, 4, 5}
 72 | ```
 73 | 
 74 | Controlla se il set a sinistra contiene quello a destra
 75 | 
 76 | ```python
 77 | >>> {1, 2} >= {1, 2, 3}
 78 | False
 79 | ```
 80 | 
 81 | Controlla se il set a sinistra è un sottoinsieme di quello a destra
 82 | 
 83 | ```python
 84 | >>> {1, 2} <= {1, 2, 3}
 85 | True
 86 | ```
 87 | 
 88 | 
 89 | Controlla l'esistenza in un set con `in`
 90 | 
 91 | ```python
 92 | >>> 2 in some_set  
 93 | True
 94 | >>> 10 in some_set
 95 | False
 96 | ```
 97 | 
 98 | 
 99 | ---
100 | 
101 | _This content is a derivative of ["Learn X in Y minutes"](https://github.com/adambard/learnxinyminutes-docs) by [adambard](https://github.com/adambard), used under a CC BY-SA 3.0 license._
102 | 


--------------------------------------------------------------------------------
/docs/Pyllole/27_If-Else.md:
--------------------------------------------------------------------------------
 1 | # If - Else
 2 | 
 3 | In un programma le istruzioni vengono eseguite nell'ordine in cui sono scritte nel codice. 
 4 | 
 5 | Per poter eseguire una parte di questo codice solo in alcuni casi si utilizza l'istruzione di controllo  `if`/`else`.
 6 | 
 7 | _Ricorda, in python [l'indentazione](11_Syntax.md#indentazione) è molto importante!_
 8 | 
 9 | La sintassi di base di `if` è:
10 | 
11 | ```python
12 | if condizione:                                         
13 |     comandi_da_eseguire
14 | ```
15 | 
16 | Esiste poi la possibilità di eseguire altri comandi se la condizione non risulta soddisfatta aggiungendo l'istruzione `else`.
17 | 
18 | ```python
19 | if condizione:                                         
20 |     comandi_da_eseguire
21 | else:
22 |     diversi_comandi_da_eseguire
23 | ```
24 | 
25 | Nel caso in cui ci siano più condizioni da valutare è possibile aggiungere `elif` (contrazione di "else if").
26 | 
27 | ```
28 | if condizione_1:                                         
29 |     comandi_da_eseguire
30 | elif condizione_2:                                         
31 |     comandi_da_eseguire
32 | elif condizione_3:                                         
33 |     comandi_da_eseguire
34 | else:
35 |     diversi_comandi_da_eseguire
36 | ```
37 | 
38 | In quest'ultimo caso il "ramo" di comandi in `else` verrà eseguito solo se nessuna delle condizioni precedentemente valutate risulterà positiva.
39 | 
40 | Un esempio in Python:
41 | 
42 | ```python
43 | numero=5                                         
44 | if numero > 10:
45 |     print("numero è maggiore di 10")
46 | elif numero < 10:
47 |     print("numero è minore di 10")
48 | else:
49 |     print("numero è uguale a 10.")
50 | ```
51 | 
52 | Darà come risultato:
53 | 
54 | ```python
55 | numero è minore di 10                                
56 | ```
57 | 
58 | ## Espressioni condizionali 
59 | 
60 | Un'espressione condizionale, conosciuta in altri linguaggi tramite gli operatori ternari, è la possibilità di eseguire un determinato comando solo se una condizione risulta vera, altrimenti eseguirne un altro.
61 | 
62 | La sintassi è: `<expression1> if <condition> else <expression2>`
63 | 
64 | Un tipico esempio è l'assegnazione condizionale. Nel seguente esempio alla variabile `isApple` verrà assegnata las stringa `'Yes'` solo se la condizione `fruit == 'Apple'` sarà `True`, altrimenti sarà assegnata la stringa  `'No'`
65 | 
66 | ```python
67 | fruit = 'Apple'
68 | isApple = 'Yes' if fruit == 'Apple' else 'No'
69 | ```
70 | 
71 | ---
72 | 
73 | _This content is a derivative of ["Learn X in Y minutes"](https://github.com/adambard/learnxinyminutes-docs) by [adambard](https://github.com/adambard), used under a CC BY-SA 3.0 license._
74 | 


--------------------------------------------------------------------------------
/docs/Pyllole/71_Iterable.md:
--------------------------------------------------------------------------------
  1 | 
  2 | # Iterabili e Iteratori
  3 | 
  4 | _Prima di approfondire gli oggetti iterabili assicurati di conoscere le [liste](53_Type_List.md), [set](57_Type_Set.md) e [dizionari](59_Type_Dictionary.md)._
  5 | 
  6 | **In Python qualunque oggetto in grado di essere trattato come una sequenza è definito un oggetto iterable (iterabile)**.
  7 | 
  8 | L'oggetto restituito dalla funzione `range()` è un iterabile.
  9 | 
 10 | ```python
 11 | >>> for a in range(3):
 12 | ...   print(a)
 13 | 0
 14 | 1
 15 | 2
 16 | 3
 17 | ```
 18 | 
 19 | Una lista, un set o le chiavi di un dizionario sono iterabili:
 20 | 
 21 | ```python
 22 | >>> our_iterable=('alpha', 'beta', 'gamma')
 23 | >>> for i in our_iterable:
 24 | ...     print(i)
 25 | ...
 26 | alpha
 27 | beta
 28 | gamma
 29 | ```
 30 | 
 31 | ```python
 32 | >>> filled_dict = {"uno": 1, "due": 2, "tre": 3}
 33 | >>> our_iterable = filled_dict.keys()
 34 | >>> for i in our_iterable:
 35 | ...     print(i)
 36 | due
 37 | uno
 38 | tre
 39 | ```
 40 | 
 41 | Nel caso del dizionario è possibile utilizzare anche la forma compatta:
 42 | 
 43 | ```python
 44 | >>> for i in filled_dict:
 45 | ...     print(i)
 46 | due
 47 | uno
 48 | tre
 49 | ```
 50 | 
 51 | Tuttavia non è possibile recuperarne i valori di un iterabile tramite indice
 52 | 
 53 | ```python
 54 | >>> our_iterable[0]
 55 | Traceback (most recent call last):
 56 |   File "<stdin>", line 1, in <module>
 57 | TypeError: 'dict_keys' object does not support indexing
 58 | ```
 59 | 
 60 | **Un oggetto iterabile è in grado di generare un iteratore**
 61 | 
 62 | ```python
 63 | >>> our_iterator = iter(our_iterable)
 64 | >>> type(our_iterator)
 65 | <class 'dict_keyiterator'>
 66 | ```
 67 | 
 68 | L'iteratore è un oggetto che ricorda il suo stato mentro lo si "attraversa".
 69 | 
 70 | Possiamo accedere al successivo elemento con `next()`.
 71 | 
 72 | ```python
 73 | >> next(our_iterator) 
 74 | "uno"
 75 | ```
 76 | 
 77 | Un iteratore mantiene il suo stato mentro eseguiamo l'iterazione
 78 | 
 79 | ```python
 80 | next(our_iterator)
 81 | "due"
 82 | next(our_iterator)
 83 | "tre"
 84 | ```
 85 | 
 86 | Dopo che un iteratore ha restituito tutti i suoi dati, genera un'eccezione `StopIteration`
 87 | 
 88 | ```python
 89 | >>> next(our_iterator)
 90 | Traceback (most recent call last):
 91 |   File "<stdin>", line 1, in <module>
 92 | StopIteration
 93 | ```
 94 | 
 95 | 
 96 | Puoi "prendere" tutti gli elementi di un iteratore utilizzando `list()`.
 97 | 
 98 | ```python
 99 | >>> list(filled_dict.keys())
100 | ["one", "two", "three"]
101 | ```
102 | 
103 | ---
104 | 
105 | _This content is a derivative of ["Learn X in Y minutes"](https://github.com/adambard/learnxinyminutes-docs) by [adambard](https://github.com/adambard), used under a CC BY-SA 3.0 license._
106 | 


--------------------------------------------------------------------------------
/docs/Pyllole/41_Type_Number.md:
--------------------------------------------------------------------------------
  1 | # Tipi: Numeri
  2 | 
  3 | I numeri possono essere interi `int` o decimali `float`, i decimali vengono rappresentati con il punto come separazione tra la parte intera e quella decimale.
  4 | Python 3 ha anche altri tipi numerici, come le frazione e i numeri complessi, ma in questa breve introduzione non verranno trattati.
  5 | 
  6 | 
  7 | ```python
  8 | >>> type(3)
  9 | <class 'int'>
 10 | ```
 11 | 
 12 | ```python
 13 | >>> type(3.0)
 14 | <class 'float'>
 15 | ```
 16 | 
 17 | Le **operazione matematiche di base** si fanno come ci si aspetta
 18 | 
 19 | ```python
 20 | >>> 1 + 1 
 21 | 2
 22 | >>> 8 - 1
 23 | 7
 24 | >>> 10 * 2
 25 | 20
 26 | >>> 35 / 5
 27 | 7.0
 28 | ```
 29 | 
 30 | Il risultato di una divisione è sempre un numero decimale `float`
 31 | 
 32 | ```python
 33 | >>> 10.0 / 3
 34 | 3.3333333333333335
 35 | ```
 36 | 
 37 | L'**operatore `//` esegue una divisione tra interi** restituendo un risultato intero. 
 38 | I valori della divisione possono essere sia interi che decimali. 
 39 | Il risultato, nonostante possa essere sia di tipo intero che decimale, sarà sempre arrotondato ad un intero.
 40 | 
 41 | ```python
 42 | >>> 5 // 3 
 43 | 1
 44 | >>> 5.0 // 3.0
 45 | 1.0
 46 | ```
 47 | 
 48 | I valori della divisione tra interi possono essere sia positivi che negativi. 
 49 | È importante però sapere che nel caso di numeri negativi il risultato sarà arrotondato per eccesso.
 50 | 
 51 | ```python
 52 | >>> 10 / 1.45 
 53 | 6.8965517241379315
 54 | >>> 10 // 1.45
 55 | 6.0
 56 | >>> 10 // -1.45
 57 | -7.0
 58 | ```
 59 | 
 60 | 
 61 | L'**operatore `%` restituisce il resto** (modulo) di una divisione
 62 | 
 63 | ```python
 64 | >>> 7 % 3 
 65 | 1
 66 | ```
 67 | 
 68 | L'**operatore `**` esegue un elevamento a potenza** (x alla y-esima potenza)
 69 | 
 70 | ```python
 71 | >>> 2**3 
 72 | 8
 73 | ```
 74 | 
 75 | Le parentesi, come in matematica, indicano la precedenza nell'elaborazione dei calcoli
 76 | 
 77 | 
 78 | ```python
 79 | >>> (1 + 3) * 2
 80 | 8
 81 | >>> 1 + (3 * 2)
 82 | 7
 83 | ```
 84 | 
 85 | È possbile convertire una stringa in numero tramite le funzioni cast `int()` e `float()`.
 86 | Python genererà un'eccezione nel caso si passi alle funzioni cast una stringa non convertibile in numero.
 87 | 
 88 | ```python
 89 | >>> a="323"
 90 | >>> type(a)
 91 | <class 'str'>
 92 | >>> a=int(a)
 93 | >>> a
 94 | 323
 95 | >>> type(a)
 96 | <class 'int'>
 97 | >>> a="pippo"
 98 | >>> int(a)
 99 | Traceback (most recent call last):
100 |  File "<stdin>", line 1, in <module>
101 | ValueError: invalid literal for int() with base 10: 'pippo'
102 | ```
103 | 
104 | ---
105 | 
106 | _This content is a derivative of ["Learn X in Y minutes"](https://github.com/adambard/learnxinyminutes-docs) by [adambard](https://github.com/adambard), used under a CC BY-SA 3.0 license._
107 | 


--------------------------------------------------------------------------------
/docs/Pyllole/29_Loops.md:
--------------------------------------------------------------------------------
  1 | # Cicli
  2 | 
  3 | _Prima di studiare i cicli e gli iteratori assicurati di conoscere le [liste](53_Type_List.md)._
  4 | 
  5 | Per ripetere una determinata azione più volte e/o su più elementi si utilizzano le istruzioni `for` e `while` per costruire dei _"cicli"_.
  6 | 
  7 | Il programma ripeterà il codice all'interno del ciclo per un numero di volte determinato da una determinata condizione.
  8 | 
  9 | _Ricorda, in python [l'indentazione](11_Syntax.md#indentazione) è molto importante!_
 10 | 
 11 | 
 12 | ## For
 13 | 
 14 | I cicli `for` iterano sulle liste, cioé ripetono un codice per ogni elemento all'interno di una lista.
 15 | 
 16 | Il seguente codice:
 17 | 
 18 | ```python
 19 | for animale in ["cane", "gatto", "topo"]:              
 20 |     print ("{0} è un mammifero".format(animale))
 21 | ```
 22 | 
 23 | Genera il seguente risultato:
 24 | 
 25 | ```python
 26 | cane è un mammifero                                    
 27 | gatto è un mammifero
 28 | topo è un mammifero
 29 | ```
 30 | 
 31 | I cicli for posso iterare anche dal risultato di una funzione `range()`.
 32 | 
 33 | Infatti `range(numero)` restituisce una lista di numeri da zero al numero dato
 34 | 
 35 | Il codice:
 36 | 
 37 | ```python
 38 | for i in range(4):
 39 |     print (i)
 40 | ```
 41 | Scriverà:
 42 | 
 43 | ```python
 44 | 0                                                      
 45 | 1
 46 | 2
 47 | 3
 48 | ```
 49 | 
 50 | La funzione `range()` ha anche altri paramentri opzionali.
 51 | 
 52 | `range(lower, upper)` restituisce una lista di numeri dal più piccolo `lower` al più grande `upper`.
 53 | 
 54 | `range(lower, upper, step)` restituisce una lista di numeri dal più piccolo `lower` al più grande `upper` incrementando del valore `step`.
 55 | 
 56 | Il codice: 
 57 | 
 58 | ```python
 59 | for i in range(10,30,5):
 60 |     print (i)
 61 | ```
 62 | 
 63 | Scriverà:
 64 | 
 65 | ```python
 66 | 10                                                      
 67 | 15
 68 | 20
 69 | 25
 70 | ```
 71 | 
 72 | ## While
 73 | 
 74 | I cicli `while` vengono eseguiti finchè la condizione indicata viene a mancare.
 75 | 
 76 | ```python
 77 | x = 0                                               
 78 | while x < 4:
 79 |     print(x)
 80 |     x += 1  
 81 | ```
 82 | 
 83 | **Nota**: La sintassi `x += 1` è la versione compatta di `x = x+1`
 84 | 
 85 | ### Esempio pratico
 86 | **Ciclo while per riproporre la richiesta di dati in caso di errore di immissione**
 87 | 
 88 | La funzione `input()` acquisisce un valore inserito da tastiera in formato stringa. A volte è necessario che il dato acquisito sia un numero, in questi casi si utilizzano le funzioni `int()` o `float()` per convertirlo. 
 89 | 
 90 | Si può quindi  utilizzare `try`/`except` per controllare che sia stato inserito un dato valido, ma per riproporre la domanda in caso di errore è necessario creare un ciclo.
 91 | 
 92 | Nel seguente esempio ripetiamo la richiesta finché a `numero` non viene assegnato un valore.
 93 | 
 94 | ```python
 95 | numero=None                                                                        
 96 | while not numero:
 97 |     try:
 98 |         numero=int(input("Inserisci un numero intero: "))
 99 |     except:
100 |         print("Il dato inserito non è un numero intero")
101 | ```
102 | 
103 | ---
104 | 
105 | _This content is a derivative of ["Learn X in Y minutes"](https://github.com/adambard/learnxinyminutes-docs) by [adambard](https://github.com/adambard), used under a CC BY-SA 3.0 license._
106 | 


--------------------------------------------------------------------------------
/docs/Pyllole/05_Development_Environment.md:
--------------------------------------------------------------------------------
 1 | 
 2 | # Ambiente di sviluppo
 3 | 
 4 | ## L'editor di testo
 5 | 
 6 | Il fondamentale, e più usato, strumento di ogni programmatore è l'_editor di testo_, un programma in grado di creare e modificare file,  testuali appunto, contenenti il codice sorgente dei programmi.
 7 | Un file testuale è un file che contiente solo ed esclusivamente byte che verranno interpretati come caratteri di testo. 
 8 | 
 9 | Un editori di testo non è un [IDE](#IDE), inizia a programmare con un semplice editor di testo e passa ad un [IDE](#IDE) solo quando avrai più esperienza.
10 | 
11 | **Nota**: Un _editor di testo_ non è un programma per il _word processing_, programmi come _MS-Word_ non scrivono file testuali ma file con un formato proprietario contenenti i dati relativi alla formattazione del testo (font, dimensioni, colori, ...). Un file di testo contenente una "a" avrà una lunghezza di 1 byte, l'equivalente testo in un file di _MS-Word_ genererà un file intorno ai 9.000 byte.
12 | 
13 | ### Funzionalità
14 | 
15 | Naturalmente qualunque editor di testo in grado semplicemente di creare, aprire e modificare un file di testo ti permetterà di scrivere il tuo codice.
16 | Ci sono poi altre caratteristiche che ti renderanno la vita più semplice nelle ore che passerai a scrivere.
17 | 
18 | * Funzioni di ricerca e sostituzione 
19 | * Funzioni per tagliare, copiare e incollare
20 | vRappresentazione a colori ([syntax highlighting](https://it.wikipedia.org/wiki/Syntax_highlighting)) del codice
21 | * Possibilità di aggiungere funzionalità dell'editor tramite _plugin_ 
22 | * Personalizzazione (dimensione del carattere, combinazioni di colori, ecc)
23 | 
24 | **Nota**: oggi è quasi obbligatorio che un editor di testo supporti la  [codifica UTF-8](https://it.wikipedia.org/wiki/UTF-8).
25 | 
26 | 
27 | ### Linea di comando
28 | 
29 | Se si programma per lavoro prima o poi Linux si dovrà utilizzare, per questo è fondamentale conoscere i suoi editor testuali da linea di comando: `vim` e `nano`.
30 | 
31 | Entrambi, funzionando in modalità testuale (non grafica) e possono sembrare un po' ostici. Tutti i comandi (esci, salva, cerca, ...) vengono attivati tramite combinazioni di tasti, il mouse, se siete fortunati, può essere utilizzato per selezionare un testo e copiarlo.
32 | 
33 | Tra i due `nano` è probabilmente il più semplice, si scrive direttamente sul "foglio" e in una barra vengono indicati i comandi principali, con `^` che indica il tasto `ctrl` (`ctrl+x` esce, `ctrl+o` salva, `ctrl+w` cerca).
34 | 
35 | 
36 | ### I più diffusi editor di testo (ambiente grafico) 
37 | 
38 | * [Sublime Text](https://www.sublimetext.com/)
39 | * [Atom](https://atom.io)
40 | * [Visual Studio Code](https://code.visualstudio.com)
41 | 
42 | ## IDE
43 | 
44 | Il processo di creazione del programma parte dalla scrittura del codice ma continua poi nelle fasi, ad esempio, di compilazione e [debug](https://it.wikipedia.org/wiki/Debugging). A seconda del linguaggio utilizzato, queste fasi vengono eseguite dal programmatore con vari singoli strumenti a sua disposizione.
45 | 
46 | Un IDE (Integrated Development Environment), conosciuto anche come _ambiente di sviluppo integrato_, è un unico programma dal quale è possibile gestire tutte le fasi dello sviluppo di un software. Un IDE permette da un unica interfaccia di scrivere, controllare, compilare, eseguire, testare e distribuire un programma.
47 | 
48 | * [PyCharm](https://www.jetbrains.com/pycharm/)
49 | * [PyDev (Eclipse for Python)](http://www.pydev.org/)
50 | * [WingIDE](https://wingware.com/)
51 | * [Komodo IDE](https://www.activestate.com/komodo-ide)
52 | 


--------------------------------------------------------------------------------
/docs/Pyllole/85_Inheritance_Multiple.md:
--------------------------------------------------------------------------------
  1 | # Ereditarietà multipla
  2 | 
  3 | È possibile ereditare metodi e proprietà da più di un genitore.
  4 | 
  5 | Creaimo una nuova classe `Bat`:
  6 | 
  7 | ```python
  8 | # bat.py
  9 | class Bat:
 10 | 
 11 | species = 'Baty'
 12 | 
 13 | def __init__(self, can_fly=True):
 14 |     self.fly = can_fly
 15 | 
 16 | # Questa classe ha anche un metodo "say"
 17 | def say(self, msg):
 18 |     msg = '... ... ...'
 19 |     return msg
 20 | 
 21 | # E anche un suo metodo personale
 22 | def sonar(self):
 23 |     return '))) ... ((('
 24 | 
 25 | if __name__ == '__main__':
 26 |     b = Bat()
 27 |     print(b.say('hello'))
 28 |     print(b.fly)
 29 | ```
 30 | 
 31 | Definiamo una classe che erediti da `Superhero` e `Bat` e proviamola
 32 | 
 33 | ```python
 34 | # superhero.py
 35 | from superhero import Superhero
 36 | from bat import Bat
 37 | 
 38 | # Definisci Batman come classe figlia che eredita sia
 39 | # da Superhero che da Bat
 40 | class Batman(Superhero, Bat):
 41 | 
 42 |     def __init__(self, *args, **kwargs):
 43 |     # In genere per ereditare gli attributi devi chiamare super:
 44 |     # super(Batman, self).__init__(*args, **kwargs)
 45 |     # Ma qui abbiamo a che fare con l'ereditarietà multipla, 
 46 |     # e super() funziona solo con la successiva classe 
 47 |     # nell'elenco MRO.
 48 |     # Quindi, invece, chiamiamo esplicitamente __init__ per 
 49 |     # tutti gli antenati. L'uso di *args e **kwargs consente 
 50 |     # di passare in modo pulito gli argomenti, con ciascun 
 51 |     # genitore che "sbuccia un livello della cipolla".
 52 |         Superhero.__init__(self, 'anonymous', movie=True, 
 53 |                            superpowers=['Wealthy'], *args, **kwargs)
 54 |         Bat.__init__(self, *args, can_fly=False, **kwargs)
 55 |         # sovrascrivere il valore per l'attributo name
 56 |         self.name = 'Sad Affleck'
 57 | 
 58 |     def sing(self):
 59 |         return 'nan nan nan nan nan batman!'
 60 | 
 61 | if __name__ == '__main__':
 62 |     sup = Batman()
 63 | 
 64 |     # Ottieni il "Method Resolution search Order" 
 65 |     # utilizzato da getattr() e super().
 66 |     # Questo attributo è dinamico e può essere aggiornato
 67 |     print(Batman.__mro__)       # => (<class '__main__.Batman'>, 
 68 |                                 # => <class 'superhero.Superhero'>, 
 69 |                                 # => <class 'human.Human'>, 
 70 |                                 # => <class 'bat.Bat'>, <class 'object'>)
 71 | 
 72 |     # Esegui il metodo del genitore ma utilizza il proprio 
 73 |     # attributo di classe
 74 |     print(sup.get_species())    # => Superhuman
 75 | 
 76 |     # Esegui un metodo che è stato sovrascritto
 77 |     print(sup.sing())           # => nan nan nan nan nan batman!
 78 | 
 79 |     # Esegui un metodo da Human, perché l'ordine di 
 80 |     # ereditarietà è importante 
 81 |     sup.say('I agree')          # => Sad Affleck: I agree
 82 | 
 83 |     # Esegui un metodo che esiste solo nel 2o antenato
 84 |     print(sup.sonar())          # => ))) ... (((
 85 | 
 86 |     # Attributo di classe ereditato
 87 |     sup.age = 100
 88 |     print(sup.age)              # => 100
 89 | 
 90 |     # Attributo ereditato dal secondo antenato il cui valore 
 91 |     # predefinito è stato ignorato.
 92 |     print('Can I fly? ' + str(sup.fly)) # => Can I fly? False
 93 | ```
 94 | 
 95 | 
 96 | 
 97 | 
 98 | 
 99 | ---
100 | 
101 | _This content is a derivative of ["Learn X in Y minutes"](https://github.com/adambard/learnxinyminutes-docs) by [adambard](https://github.com/adambard), used under a CC BY-SA 3.0 license._
102 | 


--------------------------------------------------------------------------------
/docs/Pyllole/61_Try_Except.md:
--------------------------------------------------------------------------------
 1 | # Try - Except
 2 | 
 3 | _Ricorda, in python [l'indentazione](11_Syntax.md#indentazione) è molto importante!_
 4 | 
 5 | Le eccezioni (exception) sono errori rilevati durante l'esecuzione di un programma.
 6 | 
 7 | Puoi pensare ad un'eccezione come ad un allarme che avvisa di una determinata condizione o evento e, se non gestisto, ferma l'esecuzione del programma.
 8 | 
 9 | Nell'esempio qui sotto viene generata un'eccezione `NameError`, questo accade poiché la variabile riga non è stata inizializzata prima di essere utilizzata.
10 | 
11 | ```python
12 | >>> 4 + (riga*3)   
13 | Traceback (most recent call last):
14 |   File "<stdin>", line 1, in <module>
15 | NameError: name 'riga' is not defined
16 | ```
17 | 
18 | Gestire le eccezioni significa "intercettare" gli errori e applicare le giuste contromisure affinché il programma continui la sua corretta esecuzione. 
19 | Per far questo si utilizza `try`/`except`,  puoi semplicemente immaginarlo come _"prova del codice e, a seconda dell'errore, esegui un codice riparatore"_.
20 | 
21 | Se cerco di aprire un file che non esiste Python generarà un'eccezione:
22 | 
23 | ```python
24 | >>> filename="myfile.txt"  
25 | >>> f = open(filename, 'r')
26 | Traceback (most recent call last):
27 |   File "<stdin>", line 1, in <module>
28 | FileNotFoundError: [Errno 2] No such file or directory: 'test.txt'
29 | ```
30 | 
31 | Con `try`/`except` provo ad aprire il file e in caso di errore comunico il problema all'utente finale in modo più chiaro.
32 | 
33 | ```python
34 | filename="myfile.txt"  
35 | try:
36 |     f = open(filename, 'r')
37 | except:
38 |     print('Impossibile aprire il file ', filename)
39 | ```
40 | 
41 | È possibile anche definire diversi casi a seconda del tipo di eccezione che è stata generata. Inoltre, con `else`, è possibile definire un codice da eseguire solo nel caso in cui non avvenga nessun errore. Infine con `finally` si può indicare un codice da eseguire in qualunque caso.
42 | 
43 | Nel seguente esempio si cerca di aprire un file, leggerne il contenuto e convertirlo in un numero intero (nota: quando si legge da un file si leggono stringhe).
44 | Si controlleranno poi due eccezioni, una relativa all'apertura del file e una relativa alla conversione in numero intero.
45 | Un `except` senza indicata una determinata eccezione intercetterà tutti gli altri errori.
46 | Il codice in `else` verrà eseguito solo se non sono state generate eccezioni.
47 | Infine, in qualunque caso, si scriverà "Fine" sulla console.
48 | 
49 | ```python
50 | try:
51 |     f = open('myfile.txt')
52 |     s = f.readline()
53 |     i = int(s.strip())
54 | except OSError as err:
55 |     print("OS error: {0}".format(err))
56 | except ValueError:
57 |     print("Errore: il file non contiene un numero intero!")
58 | except:
59 |     print("Errore inaspettato!")
60 | else:
61 |     print("Il file contiente il numero "+str(i))
62 |     f.close()
63 | finally: 
64 |     print("Fine")
65 | ```
66 | 
67 | ### Esempio pratico
68 | **Conversione e controllo risultato di input()**
69 | 
70 | Se si vuole utilizzare il risultato della funzione `input()`, che è sempre una stringa, come dato numerico è necessario convertirlo utilizzando le funzioni [int() o float()](41_Type_Number.md). Il valore immesso potrebbe però non essere convertibile in un numero, in questo caso la funzione di conversione usata genererà un'errore che è meglio gestire.
71 | 
72 | ```python
73 | stringa = input("Inserisci un numero intero: ") 
74 | try:
75 |     numero=int(stringa)
76 | except:
77 |     print("Il dato inserito non è un numero intero")
78 | ```
79 | 
80 | Vedi l'esempio pratico nella pagina [cicli](29_Loops.md) per come ripetere il controllo finché il valore è corretto.
81 | 


--------------------------------------------------------------------------------
/docs/Pyllole/42_Type_String.md:
--------------------------------------------------------------------------------
  1 | 
  2 | # Tipi: Stringhe
  3 | 
  4 | Le stringhe sono insiemi di caratterie, frasi, racchiuse tra apici `'` o doppi apici `"`.
  5 | 
  6 | `"Questa è una stringa"`
  7 | `'Anche questa è una stringa'`
  8 | 
  9 | ```python
 10 | >>> type("Questa è una stringa")
 11 | <class 'str'>
 12 | >>> type('Anche questa è una stringa.')
 13 | <class 'str'>
 14 | ```
 15 | 
 16 | Le stinghe possono essere unite tramite l'operatore della somma `+`. Ma cerca di non farlo.
 17 | 
 18 | ```python
 19 | >>> "Hello "+"world!"
 20 | 'Hello world!'
 21 | ```
 22 | 
 23 | Le stringhe (ma non le variabili contenenti stringhe) possono essere unite anche senza l'operatore `+`
 24 | 
 25 | ```python
 26 | >>> "Hello " "world!"  
 27 | 'Hello world!'
 28 | ```
 29 | 
 30 | Una stringa può essere considerata come una lista di caratteri, in quanto tale ogni carattere può essere raggiunto tramite un indice.
 31 | 
 32 | ```python
 33 | >>> "Questa è una stringa"[0]  
 34 | 'Q'
 35 | ```
 36 | 
 37 | È possibile conoscere la lunghezza di una stringa grazie alla funzione `len()`
 38 | 
 39 | ```python
 40 | >>> len("Questa è una stringa")
 41 | 20
 42 | ```
 43 | 
 44 | ## Formattazione delle stringhe
 45 | 
 46 | In Python esistono differenti modi per formattare le stringhe.
 47 | 
 48 | ### Il metodo .format()
 49 | 
 50 | Il tipo stringa ha un metodo `format()` per formattare le stringhe.
 51 | In questo esempio le variabili `name` e `food` vanno a completare la stringa riempiendo i campi (segnalati dalle parentesi grafe) nell'ordine in cui vengono passate al metodo `.format()`.
 52 |    
 53 | ```python
 54 | >>> name="John"
 55 | >>> food="le lasagne"
 56 | >>> "{} vuole mangiare {}".format(name, food)
 57 | 'John vuole mangiare le lasagne'
 58 | ```
 59 | 
 60 | È possibile dare un numero ai "campi" da riempire e ripetere così all'interno della stringa gli argomenti passati a `.format()`:
 61 | 
 62 | ```python
 63 | >>> "{0} be nimble, {0} be quick, {0} jump over the {1}".format("Jack", "candle stick")
 64 | 'Jack be nimble, Jack be quick, Jack jump over the candle stick'
 65 | ```
 66 | 
 67 | È possibile usare dei nomi al posto dei numeri degli argomenti
 68 | 
 69 | ```python
 70 | >>> "{nome} vuole mangiare {cibo}".format(nome="Bob", cibo="le lasagne") 
 71 | 'Bob vuole mangiare le lasagne'
 72 | ```
 73 | 
 74 | ### L'operatore di interpolazione `%`
 75 | 
 76 | Un altro stile di formattazione delle stringhe è dato dall'operatore `%` in grado di mettere in relazione una formattazione (in formato stringa) e dei valori. 
 77 | 
 78 | ```python
 79 | >>> "%s possono essere %s" % ("Le stringhe", "interpolate") 
 80 | 'Le stringhe possono essere interpolate'
 81 | ```
 82 | 
 83 | Quosto modo è al momento meno utilizzato, per saperne di più si può consultare la pagina [string-formatting](https://docs.python.org/3/library/stdtypes.html?highlight=string%20interpolation#printf-style-string-formatting) della guida ufficiale.
 84 | 
 85 | ### Formatted string literals - f-string
 86 | 
 87 | Da Python 3.6 sono state aggiunte le _Formatted string literals_ o più semplicemente _f-string_, vengono indicate con una `f` prima della stringa vera e propria e permettono una formattazione in stile template.
 88 | 
 89 | ```python
 90 | >>> name = 'John'
 91 | >>> food = 'le lasagne'
 92 | >>> f'Si chiama {name} e ama {food}.'
 93 | Si chiama John e ama le lasagne.
 94 | ```
 95 | 
 96 | Con le _f-string_ è possibile anche eseguire delle espressioni all'interno del template.
 97 | 
 98 | ```python
 99 | >>> name = 'John'
100 | >>> seven = 7
101 | >>> f'''Il suo nome è {name.upper()}
102 | ...ed ha {6 * seven} anni.'''
103 | 'Il suo nome è JOHN ed ha 42 anni.'
104 | ```
105 | 
106 | 
107 | 
108 | ---
109 | 
110 | _This content is a derivative of ["Learn X in Y minutes"](https://github.com/adambard/learnxinyminutes-docs) by [adambard](https://github.com/adambard), used under a CC BY-SA 3.0 license._
111 | 


--------------------------------------------------------------------------------
/docs/Pyllole/43_Type_Boolean.md:
--------------------------------------------------------------------------------
  1 | # Tipi: Boolean
  2 | 
  3 | I valori booleani `True` e `False` sono primitive del linguaggio e si scrivono sempre con la prima lettera maiuscola.
  4 | 
  5 | ```python
  6 | >>> type(True)
  7 | <class 'bool'>
  8 | >>> type(False)
  9 | <class 'bool'>
 10 | ```
 11 | 
 12 | L'operatore `not` restituisce il valore inverso a quello in entrata
 13 | 
 14 | ```python
 15 | >>> not True
 16 | False
 17 | >>> not False
 18 | True
 19 | ```
 20 | 
 21 | L'operatore `and` restituisce True se tutti gli operandi sono True,
 22 | 
 23 | ```python
 24 | >>> True and False
 25 | False
 26 | >>> True and True
 27 | True
 28 | ```
 29 | 
 30 | L'operatore `or` restituisce True se almeno uno degli elementi è True
 31 | 
 32 | ```python
 33 | >>> True or False
 34 | True
 35 | >>> False or False
 36 | False
 37 | ```
 38 | 
 39 | Le primitive booleane `True` e `False` hanno come corrispettivo i numeri interi `0` e `1`.
 40 | 
 41 | ```python
 42 | >>> 0 == False
 43 | True
 44 | >>> 1 == True
 45 | True
 46 | >>> 7 == True
 47 | False
 48 | >>> 7 == False
 49 | False
 50 | ```
 51 | 
 52 | Attenzione a non confondere le operazioni booleane tra interi con le operazioni bit a bit (bitwise) and/or che invece utilizzano come operatori `&` e `|`.
 53 | 
 54 | 
 55 | L'operatore di uguaglianza `==` restituisce True se i valori confrontati sono uguali
 56 | 
 57 | ```python
 58 | >>> 1 == 1
 59 | True
 60 | >>> 2 == 1
 61 | False
 62 | ```
 63 | 
 64 | L'operatore di disuguaglianza `!=` restituisce True se i valori confrontati sono diversi
 65 | 
 66 | ```python
 67 | >>> 1 != 1
 68 | False
 69 | >>> 2 != 1
 70 | True
 71 | ```
 72 | 
 73 | L'operatore di confronto `<` restituisce True se il primo valore è minore del secondo
 74 | 
 75 | ```python
 76 | >>> 1 < 10
 77 | True
 78 | ```
 79 | 
 80 | L'operatore di confronto `<=` restituisce True se il primo valore è minore o uguale al secondo
 81 | 
 82 | ```python
 83 | >>> 1 > 10
 84 | False
 85 | ```
 86 | 
 87 | L'operatore di confronto `>` restituisce True se il primo valore è maggiore del secondo
 88 | 
 89 | ```python
 90 | >>> 2 <= 2
 91 | True
 92 | ```
 93 | 
 94 | L'operatore di confronto `>=` restituisce True se il primo valore è maggiore o uguale al secondo
 95 | 
 96 | ```python
 97 | >>> 2 >= 2
 98 | True
 99 | ```
100 | 
101 | I confronti possono essere concatenati!
102 | 
103 | ```python
104 | >>> 1 < 2 < 3
105 | True
106 | >>> 2 < 3 < 2
107 | False
108 | ```
109 | 
110 | L'operatore `is` restituisce `True` se due variabili si riferiscono allo stesso oggetto. Spesso si confonde `is` con `==`, ma quest'ultimo confronta invece solo il valore contenuto nelle variabili. 
111 | 
112 | ```python
113 | >>> alpha = [1, 2, 3, 4] # alpha punta ad una nuova lista [1, 2, 3, 4]
114 | >>> beta = alpha         # beta punta a ciò a cui punta alpha
115 | >>> beta is alpha
116 | True                     # True poiché alpha e beta puntano allo stesso oggeto
117 | >>> beta == alpha
118 | True                     # True poiché alpha e beta indicano lo stesso oggeetto
119 | >>> beta = [1, 2, 3, 4]  # beta ora punta ad una nuova lista [1, 2, 3, 4]
120 | >>> beta is alpha
121 | False                    # False poiché alpha e beta non puntano allo stesso oggetto 
122 | >>> beta == alpha
123 | True                     # True poiché il contenuto degli oggetti è uguale
124 | ```
125 | 
126 | In una valutazione booleana `None`, `0` e `str`/`list`/`dict`/`tuple` vuoti 
127 | vengono considerati `False`. Tutti gli altri valori sono considerati `True`.
128 | 
129 | ```python
130 | >>> bool(None)
131 | False
132 | >>> bool(0)
133 | False
134 | >>> bool("")
135 | False
136 | >>> bool([])
137 | False
138 | >>> bool({})
139 | False
140 | >>> bool(())
141 | False
142 | ```
143 | 
144 | ---
145 | 
146 | _This content is a derivative of ["Learn X in Y minutes"](https://github.com/adambard/learnxinyminutes-docs) by [adambard](https://github.com/adambard), used under a CC BY-SA 3.0 license._
147 | 


--------------------------------------------------------------------------------
/docs/Pyllole/81_Classes.md:
--------------------------------------------------------------------------------
  1 | # Classi
  2 | 
  3 | Per creare una classe si utilizza l'istruzione `class`
  4 | 
  5 | ```python
  6 | class Human: 
  7 |     # Un attributo della classe. E' condiviso tra tutte 
  8 |     # le istanze delle classe
  9 |     species = "H. sapiens"
 10 | 
 11 |     # Si noti che i doppi underscore iniziali e finali denotano 
 12 |     # gli oggetti o attributi utilizzati da Python ma che vivono 
 13 |     # nel namespace controllato dall'utente.
 14 |     # Metodi, oggetti o attributi come: __init__, __str__, 
 15 |     # __repr__, etc. sono chiamati metodi speciali (o talvolta 
 16 |     # chiamati "dunder methods").
 17 |     # Non dovresti inventare tali nomi da solo.
 18 | 
 19 |     def __init__(self, name):
 20 |         # Assegna l'argomento all'attributo name dell'istanza
 21 |         self.name = name
 22 | 
 23 |         # Inizializza una proprietà
 24 |         self._age = 0
 25 | 
 26 |     # Un metodo dell'istanza. Tutti i metodi prendono "self"
 27 |     # come primo argomento
 28 |     def say(self, msg):
 29 |         print("{name}: {message}".format(name=self.name, message=msg))
 30 | 
 31 |     # Un altro metodo dell'istanza
 32 |     def sing(self):
 33 |         return 'yo... yo... microphone check... one two... '
 34 | 
 35 |     # Un metodo della classe è condiviso fra tutte le istanze
 36 |     # Sono chiamati con la classe chiamante come primo argomento
 37 |     @classmethod
 38 |     def get_species(cls):
 39 |         return cls.species
 40 | 
 41 |     # Un metodo statico è chiamato senza classe o istanza 
 42 |     # di riferimento
 43 |     @staticmethod
 44 |     def grunt():
 45 |         return "*grunt*"
 46 | 
 47 |     # Una property è come un metodo getter.
 48 |     # Trasforma il metodo age() in un attributo in sola lettura,
 49 |     # che ha lo stesso nome 
 50 |     @property
 51 |     def age(self):
 52 |         return self._age
 53 | 
 54 |     # Questo metodo permette di modificare una property
 55 |     @age.setter
 56 |     def age(self, age):
 57 |         self._age = age
 58 | 
 59 |     # Questo metodo permette di cancellare una property
 60 |     @age.deleter
 61 |     def age(self):
 62 |         del self._age
 63 | ```
 64 | 
 65 | Quando l'interprete Python legge un sorgente esegue tutto il suo codice.
 66 | Il controllo su `__name__` assicura che questo blocco di codice venga eseguito solo quando questo modulo è il programma principale.
 67 | 
 68 | ```python
 69 | if __name__ == '__main__':
 70 |     # Crea un'istanza della classe
 71 |     i = Human(name="Ian")
 72 |     i.say("hi")                     # "Ian: hi"
 73 |     j = Human("Joel")
 74 |     j.say("hello")                  # "Joel: hello"
 75 |     # i e j sono istanze del tipo Human, o in altre 
 76 |     # parole sono oggetti Human
 77 | 
 78 |     # Chiama un metodo della classe
 79 |     i.say(i.get_species())          # "Ian: H. sapiens"
 80 |     # Cambia l'attributo condiviso
 81 |     Human.species = "H. neanderthalensis"
 82 |     i.say(i.get_species())          # => "Ian: H. neanderthalensis"
 83 |     j.say(j.get_species())          # => "Joel: H. neanderthalensis"
 84 | 
 85 |     # Chiama un metodo statico 
 86 |     print(Human.grunt())            # => "*grunt*"
 87 |      
 88 |     # I metodi statici possono essere chiamati anche dalle istanze
 89 |     print(i.grunt())                # => "*grunt*"
 90 |                                     
 91 |     # Aggiorna la property (age) di questa istanza
 92 |     i.age = 42
 93 |     # Leggi la property
 94 |     i.say(i.age)                    # => "Ian: 42"
 95 |     j.say(j.age)                    # => "Joel: 0"
 96 |     # Cancella la property
 97 |     del i.age
 98 |     i.age                           # => questo genererà un AttributeError
 99 | ```
100 | 
101 | 
102 | ---
103 | 
104 | _This content is a derivative of ["Learn X in Y minutes"](https://github.com/adambard/learnxinyminutes-docs) by [adambard](https://github.com/adambard), used under a CC BY-SA 3.0 license._
105 | 


--------------------------------------------------------------------------------
/docs/Pyllole/83_Inheritance.md:
--------------------------------------------------------------------------------
 1 | 
 2 | 
 3 | 
 4 | # Ereditarietà  (Inheritance)
 5 | 
 6 | L'ereditarietà consente di definire nuove classi figlio che ereditano metodi e variabili dalla loro classe genitore.
 7 | 
 8 | Usando la classe `Human` definita sopra come classe base o genitore, possiamo definire una classe figlia, `Superhero`, che erediterà le variabili di classe come `species`, `name` e `age`, così come i metodi, come `sing` e `grunt`, dalla classe `Human`, ma potrà anche avere le sue proprietà uniche.
 9 | 
10 | Per importare le funzioni da altri file usa il seguente formato from "nomefile-senza-estensione" import "funzione-o-classe"
11 | 
12 | ```python
13 | >>> from human import Human
14 | ```
15 | 
16 | Specificare le classi genitore come parametri della definizione della classe
17 | 
18 | ```python
19 | class Superhero(Human):
20 |     # Se la classe figlio deve ereditare tutte le definizioni del 
21 |     # genitore  senza alcuna modifica, puoi semplicemente usare 
22 |     # la parola chiave "pass" (e nient'altro)
23 |     # Le classi figlio possono sovrascrivere gli attributi dei loro genitori
24 |     species = 'Superhuman'
25 | 
26 |     # Le classi figlie ereditano automaticamente il costruttore della classe 
27 |     # genitore, inclusi i suoi argomenti, ma possono anche definire ulteriori 
28 |     # argomenti o definizioni e sovrascrivere i suoi metodi (compreso  il 
29 |     # costruttore della classe).
30 |     # Questo costruttore eredita l'argomento "nome" dalla classe "Human" e 
31 |     # aggiunge gli argomenti "superpowers" e "movie":
32 |     def __init__(self, name, movie=False,
33 |          superpowers=["super strength", "bulletproofing"]):
34 | 
35 |     # aggiungi ulteriori attributi della classe
36 |     self.fictional = True
37 |     self.movie = movie
38 |     self.superpowers = superpowers
39 | 
40 |     # La funzione "super" ti consente di accedere ai metodi della classe 
41 |     # genitore che sono stati sovrascritti dalla classe figlia,  
42 |     # in questo caso il metodo __init__.
43 |     # Il seguente codice esegue il costruttore della classe genitore:
44 |     super().__init__(name)
45 | 
46 |     # Sovrascrivere il metodo "sing"
47 |     def sing(self):
48 |         return 'Dun, dun, DUN!'
49 | 
50 |     # Aggiungi un ulteriore metodo dell'istanza
51 |     def boast(self):
52 |         for power in self.superpowers:
53 |             print("I wield the power of {pow}!".format(pow=power))
54 | ```
55 | 
56 | Proviamo la classe `Superhero`:
57 | 
58 | ```python
59 | if __name__ == '__main__':
60 |     sup = Superhero(name="Tick")
61 | 
62 | # Controllo del tipo di istanza
63 | if isinstance(sup, Human):
64 |     print('I am human')
65 | if type(sup) is Superhero:
66 |     print('I am a superhero')
67 | 
68 | # Ottieni il "Method Resolution search Order" usato sia da getattr () 
69 | # che da super (). Questo attributo è dinamico e può essere aggiornato
70 | print(Superhero.__mro__)    # => (<class '__main__.Superhero'>,
71 |                             # => <class 'human.Human'>, <class 'object'>)
72 | 
73 | # Esegui il metodo principale ma utilizza il proprio attributo di classe
74 | print(sup.get_species())    # => Superhuman
75 | 
76 | # Esegui un metodo che è stato sovrascritto
77 | print(sup.sing())           # => Dun, dun, DUN!
78 | 
79 | # Esegui un metodo di Human
80 | sup.say('Spoon')            # => Tick: Spoon
81 | 
82 | # Esegui un metodo che esiste solo in Superhero
83 | sup.boast()                 # => I wield the power of super strength!
84 |                                 # => I wield the power of bulletproofing!
85 | 
86 | # Attributo di classe ereditato
87 | sup.age = 31
88 | print(sup.age)              # => 31
89 | 
90 | # Attributo che esiste solo in Superhero
91 | print('Am I Oscar eligible? ' + str(sup.movie))
92 | ```
93 | 
94 | 
95 | ---
96 | 
97 | _This content is a derivative of ["Learn X in Y minutes"](https://github.com/adambard/learnxinyminutes-docs) by [adambard](https://github.com/adambard), used under a CC BY-SA 3.0 license._
98 | 


--------------------------------------------------------------------------------
/docs/_layouts/default.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <html lang="{{ site.lang | default: "en-US" }}">
 3 |   <head>
 4 |     <meta charset='utf-8'>
 5 |     <meta http-equiv="X-UA-Compatible" content="chrome=1">
 6 |     <meta name="viewport" content="width=device-width, initial-scale=1, maximum-scale=1">
 7 |     <link rel="shortcut icon" type="image/png" href="assets/favicon.png">
 8 |     <link href='https://fonts.googleapis.com/css?family=Architects+Daughter' rel='stylesheet' type='text/css'>
 9 |     <link rel="stylesheet" href="{{ '/assets/css/style.css?v=' | append: site.github.build_revision | relative_url }}" media="screen" type="text/css">
10 |     <link rel="stylesheet" href="{{ '/assets/css/print.css' | relative_url }}" media="print" type="text/css">
11 | 
12 |     <!--[if lt IE 9]>
13 |     <script src="//html5shiv.googlecode.com/svn/trunk/html5.js"></script>
14 |     <![endif]-->
15 | 
16 | {% seo %}
17 |   </head>
18 | 
19 |   <body>
20 |     <header>
21 |       <div class="inner">
22 |         <a href="{{ '/' | absolute_url }}">
23 |           <h1>{{ site.title | default: site.github.repository_name }}</h1>
24 |         </a>
25 |         <h2>{{ site.description | default: site.github.project_tagline }}</h2>
26 |         {% if site.github.is_project_page %}
27 |           <a href="{{ site.github.repository_url }}" class="button"><small>View project on</small> GitHub</a>
28 |         {% endif %}
29 |         {% if site.github.is_user_page %}
30 |           <a href="{{ site.github.owner_url }}" class="button"><small>Follow me on</small> GitHub</a>
31 |         {% endif %}
32 |       </div>
33 |     </header>
34 | 
35 |     <div id="content-wrapper">
36 |       <div class="inner clearfix">
37 |         <section id="main-content">
38 |           {{ content }}
39 |         </section>
40 | 
41 |         <aside id="sidebar">
42 |         
43 |         <strong><a href="{{ '/' | absolute_url }}">Python ABC</a></strong>
44 |         <ul>
45 |          <li><a href="{{ '/' | absolute_url }}#principali-riferimenti-online">Principali Riferimenti Online</a></li>
46 |          <li><a href="{{ '/' | absolute_url }}#per-iniziare">Per iniziare</a></li>
47 |          <li><a href="{{ '/' | absolute_url }}#pyllole">Pyllole</a>
48 |            <ul style="margin-bottom: 0px;">  
49 |            {%- for page in site.pages -%}
50 |             {%- if page.title %}
51 |              <li><a href="{{ '/' | absolute_url }}{{page.url}}">{{page.title}}</a></li>
52 |             {%- endif -%}
53 |            {%- endfor -%}
54 |            </ul>
55 |          </li>
56 |          <li><a href="{{ '/' | absolute_url }}#strumenti-online">Strumenti Online</a></li>
57 |          <li><a href="{{ '/' | absolute_url }}#documentazione-gratuita">Documentazione Gratuita</a></li>
58 |         </ul>  
59 |           {% if site.show_downloads %}
60 |             <a href="{{ site.github.zip_url }}" class="button">
61 |               <small>Download</small>
62 |               .zip file
63 |             </a>
64 |             <a href="{{ site.github.tar_url }}" class="button">
65 |               <small>Download</small>
66 |               .tar.gz file
67 |             </a>
68 |           {% endif %}
69 | 
70 |           {% if site.github.is_project_page %}
71 |             <p class="repo-owner"><a href="{{ site.github.repository_url }}">{{ site.github.repository_name }}</a> is maintained by <a href="{{ site.github.owner_url }}">{{ site.github.owner_name }}</a>.</p>
72 |           {% endif %}
73 | 
74 |           <p>This page was generated by <a href="https://pages.github.com">GitHub Pages</a>.</p>
75 |         </aside>
76 |       </div>
77 |     </div>
78 | 
79 |     {% if site.google_analytics %}
80 |       <script type="text/javascript">
81 |         (function(i,s,o,g,r,a,m){i['GoogleAnalyticsObject']=r;i[r]=i[r]||function(){
82 |         (i[r].q=i[r].q||[]).push(arguments)},i[r].l=1*new Date();a=s.createElement(o),
83 |         m=s.getElementsByTagName(o)[0];a.async=1;a.src=g;m.parentNode.insertBefore(a,m)
84 |         })(window,document,'script','//www.google-analytics.com/analytics.js','ga');
85 |         ga('create', '{{ site.google_analytics }}', 'auto');
86 |         ga('send', 'pageview');
87 |       </script>
88 |     {% endif %}
89 | 
90 |   </body>
91 | </html>
92 | 


--------------------------------------------------------------------------------
/docs/Pyllole/59_Type_Dictionary.md:
--------------------------------------------------------------------------------
  1 | # Tipi: Dizionari
  2 | 
  3 | _Prima di studiare i dizionari assicurati di conoscere le [liste](53_Type_List.md)._
  4 | 
  5 | Un dizionario è come una lista che ha un nome al posto dell'indice, è un insieme di coppie chiave-valore. 
  6 | 
  7 | **Importante**: le coppie chiave-valore in un dizionario non sono ordinate o ordinabili.
  8 | 
  9 | Se in una lista è possibile accedere ad un dato in questo modo:
 10 | 
 11 | ```python
 12 | >>> li[3]
 13 | 4
 14 | ```
 15 | 
 16 | In un dizionario potrò accedervi così:
 17 | 
 18 | ```python
 19 | >>> persona['nome']
 20 | Pippo
 21 | ```
 22 | 
 23 | Un variabile di tipo dizionario di crea in questo:
 24 | 
 25 | ```python
 26 | >>> empty_dict= {}
 27 | ```
 28 | 
 29 | Si può anche definire direttamente un dizionario pre-caricato
 30 | 
 31 | ```python
 32 | >>> filled_dict = {"uno": 1, "due": 2, "tre": 3}
 33 | ```
 34 | 
 35 | **Importante**: le chiavi  dei dizionari devono essere di tipo immutabile. Questo per assicurare che le chiavi possano essere convertite in chiavi hash costanti per un risposta più veloce.
 36 | 
 37 | ```python
 38 | >>> invalid_dict = {[1,2,3]: "123"}
 39 | Traceback (most recent call last):
 40 |   File "<stdin>", line 1, in <module>
 41 | TypeError: unhashable type: 'list'
 42 | ```
 43 | 
 44 | I valori, invece, possono essere di qualunque tipo
 45 | 
 46 | ```python
 47 | >>> valid_dict = {(1,2,3):[1,2,3]}
 48 | ```
 49 | 
 50 | Si accede ai valori indicando la chiave tra `[]`
 51 | 
 52 | ```python
 53 | >>> filled_dict["uno"]
 54 | 1 
 55 | ```
 56 | 
 57 | Puoi ottenere tutte le chiavi di un dizionario con `keys()` (come oggetto iterabile). Per averle in formato lista è necessario  utilizzare `list()`.
 58 | 
 59 | **Importante**: Nei dizionari l'ordine delle chiavi non è garantito. Il tuo risultato potrebbe non essere uguale a questo.
 60 | 
 61 | ```python
 62 | >> list(filled_dict.keys())
 63 | ['uno', 'tre', 'due']
 64 | ```
 65 | 
 66 | Puoi ottenere tutti i valori di un dizionario con `values()` (come oggetto iterabile). 
 67 | Anche in questo caso, per averle in formato lista, è necessario utilizzare `list()`. Anche in questo caso, come per le chiavi, l'ordine non è garantito
 68 | 
 69 | ```python
 70 | list(filled_dict.values())
 71 | [1, 3, 2]
 72 | ```
 73 | 
 74 | Controlla l'esistenza delle chiavi in un dizionario con `in`
 75 | 
 76 | ```python
 77 | >>> "uno" in filled_dict
 78 | True 
 79 | >>> 1 in filled_dict
 80 | False
 81 | ```
 82 | 
 83 | Cercando una chiave non esistente genera un `KeyError`
 84 | 
 85 | ```python
 86 | >>> filled_dict["quattro"]
 87 | Traceback (most recent call last):
 88 |   File "<stdin>", line 1, in <module>
 89 | KeyError: 'quattro'
 90 | ```
 91 | 
 92 | 
 93 | sa il metodo `get()` per evitare `KeyError`
 94 | 
 95 | ```python
 96 | >>> filled_dict.get("uno")
 97 | 1
 98 | >>> filled_dict.get("quattro")
 99 | ```
100 | 
101 | 
102 | Il metodo `get` supporta un argomento di default quando il valore è mancante
103 | 
104 | ```python
105 | >>> filled_dict.get("uno", 4)
106 | 1
107 | >>> filled_dict.get("quattro", 4)
108 | 4
109 | ```
110 | 
111 | `setdefault()` inserisce un valore per una chiave in un dizionario solo se la chiave data non è già presente
112 | 
113 | ```python
114 | >>> filled_dict.setdefault("cinque", 5)
115 | 5
116 | >>> filled_dict.setdefault("cinque", 6)
117 | 5
118 | ```
119 | 
120 | Aggiungere una coppia chiave->valore a un dizionario
121 | 
122 | ```python
123 | >>> filled_dict.update({"quattro":4})
124 | >>> filled_dict
125 | {'uno': 1, 'tre': 3, 'quattro': 4, 'cinque': 5, 'due': 2}
126 | ```
127 | 
128 | Un altro modo:
129 | 
130 | ```python
131 | >>> filled_dict["sette"] = 7
132 | >>> filled_dict
133 | {'sette': 7, 'tre': 3, 'cinque': 5, 'due': 2, 'uno': 1, 'quattro': 4}
134 | ```
135 | 
136 | Rimuovi una chiave da un dizionario con `del`
137 | 
138 | ```python
139 | >>> del filled_dict["uno"]
140 | >>> filled_dict
141 | {'sette': 7, 'tre': 3, 'cinque': 5, 'due': 2, 'quattro': 4}
142 | ```
143 | 
144 | Da Python 3.5 puoi anche usare ulteriori opzioni di spacchettamento
145 | 
146 | ```python
147 | >>> {'a': 1, **{'b': 2}}
148 | {'a': 1, 'b': 2}
149 | ```
150 | 
151 | ---
152 | 
153 | _This content is a derivative of ["Learn X in Y minutes"](https://github.com/adambard/learnxinyminutes-docs) by [adambard](https://github.com/adambard), used under a CC BY-SA 3.0 license._
154 | 


--------------------------------------------------------------------------------
/docs/Pyllole/53_Type_List.md:
--------------------------------------------------------------------------------
  1 | # Tipi: Liste
  2 | 
  3 | Se immagini una variabile come una scatola in cui puoi mettere un contenuti, una lista la puoi immaginare come una fila di box.
  4 | 
  5 | Una lista vuota si crea utilizzando le parentesi quadre
  6 | 
  7 | ```python
  8 | >>> li = []
  9 | ```
 10 | 
 11 | Ora la nostra variabile `li` è un oggetto di tipo `list`
 12 | 
 13 | ```python
 14 | >>> type(li)
 15 | <class 'list'>
 16 | ```
 17 | 
 18 | È possibile anche inizializzare una lista già contenente dei dati
 19 | 
 20 | ```python
 21 | >>> other_li = [4, 5, 6]
 22 | ```
 23 | 
 24 | Si può aggiungere un valore alla fine della lista con append
 25 | 
 26 | ```python
 27 | >>> li.append(10)
 28 | >>> li
 29 | [7]
 30 | >>> li.append(20)
 31 | >>> li.append(30)
 32 | >>> li.append(40)
 33 | >>> li.append(50)
 34 | >>> li
 35 | [10, 20, 30, 40, 50]
 36 | ```
 37 | 
 38 | Si può rimuovere un valore dalla fine della lista con pop
 39 | 
 40 | ```python
 41 | >>> li.pop()
 42 | 50
 43 | >>> li
 44 | [10, 20, 30, 40]
 45 | ```
 46 | 
 47 | In questo momento abbiamo una lista con tre valori, ognuno di questi dati è in una posizione specifica. Nelle liste si comincia a contare da zero, quindi avremo il numero `10` nella posizione zero, il numero `20` nella posizione uno e così via.
 48 | 
 49 | Per accedere ai dati si usa la sintassi `nome_lista[indice]` 
 50 | 
 51 | ```python
 52 | >>> li[0]
 53 | 10
 54 | >>> li[1]
 55 | 20
 56 | ```
 57 | 
 58 | Per guardare l'ultimo elemento della lista:
 59 | 
 60 | ```python
 61 | >>> li[-1]
 62 | 40
 63 | ```
 64 | 
 65 | Guardare al di fuori dei limiti genera un `IndexError`
 66 | 
 67 | ```python
 68 | >>> li[8]
 69 | Traceback (most recent call last):
 70 |   File "<stdin>", line 1, in <module>
 71 | IndexError: list index out of range
 72 | ```
 73 | 
 74 | ## Notazione slice
 75 | 
 76 | La **notazione slice**, a fetta, permette di "guardare" un intervallo di dati nelle liste.
 77 | 
 78 | La sintassi della notazione è `lista[from:to:step]`
 79 | 
 80 |  * `from` è l'elemento da cui cominciare a estrapolare gli elementi, ricorda che inizia da zero.
 81 |  * `to` è quello a cui arrivare -1 
 82 |  * `step` indica ogni quanti elementi restituirne uno
 83 | 
 84 | Slice | Descrizione | Esempio con `li=[10,20,30,40]`
 85 | ------------ | ------------- | -------------
 86 | `lista[from:to]`      | gli elementi da `from` fino a `to`-1  |  `li[1:3]` -> `[20,30]`
 87 | `lista[from:]`        | gli elementi da `from` fino alla fine della lista |  `li[2:]` -> `[30,40]`
 88 | `lista[:to]`          | gli elementi dall'inizio fino all'elemento `to`-1 |  `li[:3]` -> `[10, 20,30]`
 89 | `lista[:]`            | tutti gli elementi |  `li[:]` -> `[10,20,30,40]`
 90 | `lista[from:to:step]` | un elemento ogni `step` da `from` fino a `to`-1  |  `li[0:3:2]` -> `[10,30]`
 91 | `lista[from::step]`   | un elemento ogni `step` da `from `fino alla fine della lista |  `li[1::2]` -> `[20,40]`
 92 | `lista[:to:step]`     | un elemento ogni `step` dall'inizio fino all'elemento `to`-1 |  `li[:3:2]` -> `[10,30]`
 93 | `lista[::step]`       | un elemento ogni `step` |  `li[::2]` -> `[10,30]`
 94 | 
 95 | 
 96 | Si può usare `passo` negativo per scorrere in modo inverso la lista
 97 | 
 98 | ```python
 99 | >>> li[::-1]
100 | [40, 30, 20, 10]
101 | ```
102 | 
103 | E' possibile creare una copia della lista (one layer deep copy) usando la sintassi slices
104 | 
105 | ```python
106 | >>> li2 = li[:]
107 | >>> li2
108 | [10, 20, 30, 40]
109 | ```
110 | 
111 | ## Rimozione di elementi 
112 | 
113 | Rimuovi arbitrariamente elementi da una lista con `del`
114 | 
115 | ```python
116 | >>> del li[2]
117 | >>> li
118 | [10, 20, 40]
119 | ```
120 | 
121 | Rimuove la prima occorrenza di un valore
122 | 
123 | ```python
124 | >>> li.remove(20)
125 | >>> li
126 | [10, 40]
127 | ```
128 | 
129 | Cercare di rimuovere un valore non contenuto nella lista genera un `ValueError`
130 | 
131 | ```python
132 | >>> li.remove(20)
133 | Traceback (most recent call last):
134 |   File "<stdin>", line 1, in <module>
135 | ValueError: list.remove(x): x not in list
136 | ```
137 | 
138 | ## Inserimento elementi
139 | 
140 | Inserisce un elemento all'indice specificato
141 | 
142 | ```python
143 | >>> li.insert(1, 20)
144 | >>> li
145 | [10, 20, 40]
146 | ```
147 | 
148 | ## Index
149 | 
150 | Restituisce l'indice della prima occorrenza dell'elemento fornito
151 | 
152 | ```python
153 | >>> li.index(40)
154 | 2
155 | ```
156 | 
157 | Richiedere l'indice di un valore non presente nella lista genera un `ValueError`
158 | 
159 | ```python
160 | >>> li.index(240)
161 | Traceback (most recent call last):
162 |   File "<stdin>", line 1, in <module>
163 | ValueError: 240 is not in list
164 | ```
165 | 
166 | ## Unire le liste
167 | 
168 | È possibile unire due o più liste
169 | 
170 | ```python
171 | >>> li + other_li
172 | [10, 20, 40, 4, 5, 6]
173 | ```
174 | 
175 | È possibile concatenare una lista ad un'altra con il metodo `extend`
176 | 
177 | ```python
178 | >>> li.extend(other_li)
179 | >>> li
180 | [10, 20, 40, 4, 5, 6]
181 | ```
182 | 
183 | ## Controlli
184 | 
185 | Controlla l'esistenza di un valore in una lista con l'operatore `in`
186 | 
187 | ```python
188 | >>> 4 in li
189 | True
190 | >>> 22 in li
191 | False
192 | ```
193 | 
194 | Esamina la lunghezza con la funzione `len()`
195 | 
196 | ```python
197 | >>> len(li)
198 | 6
199 | ```
200 | 
201 | 
202 | ---
203 | 
204 | _This content is a derivative of ["Learn X in Y minutes"](https://github.com/adambard/learnxinyminutes-docs) by [adambard](https://github.com/adambard), used under a CC BY-SA 3.0 license._
205 | 


--------------------------------------------------------------------------------
/docs/Pyllole/01_Use_Python.md:
--------------------------------------------------------------------------------
  1 | # Come usare Python
  2 | 
  3 | Una volta installato Python ci sono due fondamentali modi per utilizzarlo:
  4 | 
  5 | * Tramite l'interprete Python
  6 | * Creando uno script
  7 | 
  8 | ---
  9 | 
 10 | ## Interprete Python
 11 | 
 12 | Eseguendo direttamente Python viene attivata la modalità intereattiva dell'interprete (REPL), un'interfaccia per scrivere ed eseguire immediatamente i comandi del linguaggio Python. Il REPL si presenta semplicemente con un _prompt_ `>>>` in attesa di un comando.
 13 | 
 14 | A seconda di come, cosa e dove è stato installato Python, potrebbe essere necessario specificare quale versione si vuole eseguire. 
 15 | In alcuni sistemi obsoleti potresti trovar installato Python 2, in questi casi è necessario specificare `python3` per eseguire l'ultima versione.
 16 | 
 17 | ```
 18 | $ python
 19 | Python 2.7.13 (default, Nov 24 2017, 17:33:09)
 20 | [GCC 6.3.0 20170516] on linux2
 21 | Type "help", "copyright", "credits" or "license" for more information.
 22 | >>>
 23 | ```
 24 | 
 25 | ```
 26 | $ python3
 27 | Python 3.5.3 (default, Jan 19 2017, 14:11:04)
 28 | [GCC 6.3.0 20170118] on linux
 29 | Type "help", "copyright", "credits" or "license" for more information.
 30 | >>>
 31 | ```
 32 | **Ricorda, Python 2 non è più supportato dal  1° gennaio 2020, maggiori informazioni [qui](https://www.python.org/doc/sunset-python-2/).**
 33 | 
 34 | All'interno dell'interprete è possibile inviare comandi Python che vengono eseguiti man mano che vengono scritti (riga per riga).
 35 | 
 36 | ```python
 37 | >>> salve="Ciao"
 38 | >>> print(salve)
 39 | Ciao
 40 | ```
 41 | 
 42 | Se si utilizzano istruzioni che prevedono più linee di codice, come i cicli o la definizione di funzione, l'interprete segnalerà che non ha ancora iniziato a interpretare i comandi forniti cambiando il prompt in `...`.
 43 | 
 44 | Naturalmente, in questi casi, si deve fare molta attenzione all'[indentazione](11_Syntax.md#indentazione).
 45 | 
 46 | ```python
 47 | >>> for a in range(3):
 48 | ...   print(a)
 49 | ...
 50 | 0
 51 | 1
 52 | 2
 53 | ```
 54 | 
 55 | All'interno dell'interprete tutti i valori restituiti da funzioni e metodi vengono scritti sulla console.
 56 | 
 57 | Prendiamo come esempio un'ipotetica funzione che dati due dati scrive sullo schermo una frase e restituisce la loro somma.
 58 | 
 59 | ```python
 60 | >>> def miei_dati(x,y):
 61 | ...     print("I miei dati sono {} e {}".format(x,y))
 62 | ...     return x+y
 63 | ```
 64 | 
 65 | Eseguendo questa funzione dall'interprete si vedrà quanto segue:
 66 | 
 67 | ```python
 68 | >>> miei_dati(20,30)
 69 | I miei dati sono 20 e 30
 70 | 50
 71 | ```
 72 | 
 73 | Giustamente viene scritta la frase con i due valori, ma in più l'interprete scrive anche ciò che la funzione restituisce.
 74 | Questo valore, nella normale esecuzione di uno script, o viene volontariamente utilizzato (assegnandolo ad una variabile o come argomento per un'altra funzione), o viene semplicemente ignorato. 
 75 | 
 76 | 
 77 | ### Aiuto e documentazione 
 78 | 
 79 | Direttamente dall'interprete è possibile richiedere "aiuto" relativamente ad ogni tipo, metodo o funzione (nota: per uscire dall'help premere `q`).
 80 | 
 81 | ```python
 82 | >>> help(print)
 83 | 
 84 | Help on built-in function print in module builtins:
 85 | 
 86 | print(...)
 87 |     print(value, ..., sep=' ', end='\n', file=sys.stdout, flush=False)
 88 | 
 89 |     Prints the values to a stream, or to sys.stdout by default.
 90 |     Optional keyword arguments:
 91 |     file:  a file-like object (stream); defaults to the current sys.stdout.
 92 |     sep:   string inserted between values, default a space.
 93 |     end:   string appended after the last value, default a newline.
 94 |     flush: whether to forcibly flush the stream.
 95 | (END)
 96 | 
 97 | ```
 98 | 
 99 | Un'altro aiuto diretto nell'interprete è dato dalla funzione `dir()`, in grado di elencare i metodi disponibili per un determinato oggetto.
100 | 
101 | ```python
102 | >>> dir(int)
103 | ['__abs__', '__add__', '__and__', '__bool__', '__ceil__', ...]
104 | ```
105 | 
106 | ---
107 | 
108 | ## Creare uno script
109 | 
110 | Creare uno script significa creare un file contenente un programma Python. Questo file/programma potrà poi essere eseguito direttamente o importato da altri programmi.
111 | 
112 | Per creare un file script **basta un semplice [editor di testo](05_Development_Environment.md)**, nulla di più. Studiando Python è meglio evitare complessi ambienti di sviluppo (IDE), quando si conoscerà il linguaggio e si svilupperanno veri programmi, si potrà decidere di utilizzarli per ottimizzare il proprio lavoro.
113 | 
114 | Il file script di python hanno estensione _.py_, crea un tuo file, chiamiamolo _prova.py_ e comincia a programmare.
115 | 
116 | La prima riga di uno script è chiamata _shebang_ (ma anche _sha-bang_ o _hashbang_) e indica quale inteprete utilizzare (la cartella e l'eseguibile Python).
117 | 
118 | ```python
119 | #! /usr/bin/python3
120 | print('Hello, world!')
121 | ```
122 | 
123 | Una volta salvato il tuo file python.py puoi eseguirlo richiamandolo con python.
124 | 
125 | ```bash
126 | $ python3 ./prova.py
127 | Hello, world!
128 | ```
129 | 
130 | Se al file sono stati dati i permessi di esecuzione, è anche possibile eseguirlo direttamente.
131 | 
132 | ```bash
133 | $ ./prova.py
134 | Hello, world!
135 | ```
136 | 
137 | *Attenzione*: per eseguire direttamente un file _.py_ in Linux si devono prima assegnare al file i permessi di esecuzione con `chmod +x ./prova.py`. Windows e macOs necessitano che i file _.py_ siano associati all'interprete Python.
138 | 
139 | Eseguendo il file `prova.py` viene generato il file `prova.pyc` che, per spiegarla semplicemente, è una versione del programma trasformata in _bytecode_ pronta per essere eseguita dall'interprete Python.
140 | 
141 | ### Sintassi e stile di scrittura
142 | 
143 | Consulta la pagina relativa alla [sintassi di base](11_Syntax.md) per cominciare a conoscere il linguaggio python.
144 | 
145 | Anche se al momento è prematuro, sappi che in Python anche lo stile di scritture del codice è importante ed è definito nel [PEP 8 - Style Guide for Python Code](https://www.python.org/dev/peps/pep-0008/).
146 | 
147 | 


--------------------------------------------------------------------------------
/docs/Pyllole/21_Variables.md:
--------------------------------------------------------------------------------
  1 | # Variabili
  2 | 
  3 | ## Dati
  4 | 
  5 | **Alla fine puoi realizzare un programma per il disegno o un videogioco ma, fondamentalmente, un programma è solo elaborazione di dati.**
  6 | 
  7 | La sintassi dei linguaggi di programmazione permette di spostare ed elaborare dati in infiniti modi, ma prima di tutto devi sapere cosa sono i dati.
  8 | 
  9 | All'interno della memoria del tuo PC tutti i dati sono _byte_, gruppetti di 8 _bit_, che possono assumere un valore tra 0 e 255. Naturalmente se utilizzo due byte insieme posso rappresentare un numero più grande (da 0 a 65535).
 10 | 
 11 | A seconda di come i byte vengono utilizzati e interpretati è possibile rappresentare sia numeri più grandi sia altri tipi di dati, per esempio un testo o una immagine.
 12 | 
 13 | Potremmo decidere che i numeri da 65 a 90 indicano le lettere dell'alfabeto, così per memorizzare un testo mi basterà scrivere i byte relativi ad ogni sua lettera. Potremmo altresì decidere che il nero è 0 e il bianco è 255, in mezzo tutte le sfumature di grigio e così poter memorizzare un'immagine.
 14 | 
 15 | Così nascono gli standard, dall'ASCII a UTF-8, dalle GIF alle PNG, tutti i modi per rappresentare testo, immagini e suoni sono fondamentalmente byte interpretati da algoritmi.
 16 | 
 17 | Ogni linguaggio di programmazione ha i suoi tipi di dati con le proprie particolari caratteristiche, ma in generale i tipi di base sono:
 18 | 
 19 | * [Booleani](43_Type_Boolean.md): 0 o 1, chiamati anche False o True
 20 | * [Numeri interi](41_Type_Number.md): in grado di rappresentare, a seconda del numero di byte utilizzati, i numeri interi da -N a +N
 21 | * [Numeri decimali](41_Type_Number.md): numero in virgola mobile, indica il metodo di rappresentazione approssimata dei numeri reali
 22 | * [Stringhe](42_Type_String.md): sequenze di caratteri (lettere, numeri e simboli) che formano un testo
 23 | 
 24 | Esistoni inoltre molti tipi di dati complessi, dagli array agli oggetti, ma per il momento è meglio fermarsi a questi.
 25 | 
 26 | 
 27 | ## Le variabili
 28 | 
 29 | A livello astratto una variabile è un contenitore in cui puoi inserire valori, e modificarli, durante l'esecuzione del tuo programma.
 30 | 
 31 | Più o meno in tutti i linguaggi di programmazione, per assegnare un valore ad una variabile, si utilizza una sintassi tipo:
 32 | 
 33 | ```python
 34 | nome="Pippo"
 35 | ```
 36 | 
 37 | In realtà **una variabile non è _il contenitore_ ma solo un soprannome che si dà ad una zona di memoria**. 
 38 | 
 39 | In Python, per gran parte dei tipi, assegnare un nuovo valore ad una variabile non vuol dire modificare il valore di una zona di memoria, ma far "puntare" il nostro "soprannome" ad una nuova zona di memoria con un nuovo contenuto.  
 40 | Questa operazione è del tutto trasparente per il programmatore, ma è una cosa molto importante da sapere quando si realizzano programmi in cui le performance contano.
 41 | 
 42 | _Per uteriori informazioni su questo argomento cercare in rete "[Python immutable types](https://www.google.it/search?q=python+immutable+types)"_
 43 | 
 44 | ### Nomi e convenzioni delle variabili
 45 | 
 46 | In Python i nomi delle variabili possono essere di qualsiasi lunghezza e possono usare lettere maiuscole o minuscole, il carattere di sottolineatura `_`  e le cifre da 0 a 9. 
 47 | I nomi delle variabili non possono iniziare con una cifra e non possono essere uguali alla parole riservate del linguaggio Python, come ad esempio `if`, `else`, `and`.
 48 | I nomi delle variabili sono case sensitive, cioé i caratteri maiuscoli e quelli minuscoli sono considerati come se fossere due lettere differenti. Quindi `nome` e `Nome` sono considerate due variabili differenti.
 49 | 
 50 | Infine, come convenzione per migliorare la leggibilità del codice, si suggerisce di dare alle variabili un **nome minuscolo con le eventuali parole separate dal carattere di sottolineatura `_`**. 
 51 | 
 52 | 
 53 | ### Tipizzazione
 54 | 
 55 | Il programma, quando viene eseguito, deve sapere quanto spazio di memoria dovrà "assegnare" ad una variabile. Lo spazio utilizzato da un numero intero è differente da quello utilizzato da una stringa. 
 56 | Per questo molti linguaggi di programmazione necessitano che una variabile sia inizializzata, prima di essere utilizzata, assegnandogli un determinato tipo. Questi linguaggi si definiscono _tipizzati_.
 57 | 
 58 | **Python è un linguaggio tipizzato dinamicamente**, non c'é bisogno di inizializzare una variabile prima di utilizzarla, è possibile cambiare tipo alla variabile in qualunque momento semplicemente assegnandogli un differente valore.
 59 | 
 60 | Di seguito assegnamo valori differenti alla variabile nome ed utiliziamo la funzione `type()` per vedere che cambia tipo senza alcun problema.
 61 | 
 62 | ```python
 63 | >>> nome="Pippo"
 64 | >>> type(nome)
 65 | <class 'str'>
 66 | >>> nome=7
 67 | >>> type(nome)
 68 | <class 'int'>
 69 | ```
 70 | 
 71 | 
 72 | È comunque necessario che una variabile sia stata "creata", assegnandogli un valore, prima di utilizzarla all'interno del programma.
 73 | 
 74 | ```python
 75 | >>> if (my_var==2):
 76 | ...    print("my_var è uguale a 2")
 77 | ...
 78 | Traceback (most recent call last):
 79 |   File "<stdin>", line 1, in <module>
 80 | NameError: name 'a' is not defined
 81 | ```
 82 | 
 83 | **Importante**: qui sopra abbiamo anticipato un esempio di controllo `if` in cui c'é `my_var==2`. 
 84 | Il doppio carattere uguale `==` è sempre un operatore di uguaglianza, non una assegnazione (vedere [operatori booleani]()).
 85 | 
 86 | ### Casting
 87 | 
 88 | Il _casting_ in programmazione è la conversione di un dato da un tipo ad un altro.
 89 | 
 90 | Potremmo avere una variabile a cui è assegnato il valore `"123", anche se sembra un numero, come già suggeriscono le virgolette, in realtà si tratta di una stringa (magari acquisita tramite [input](25_Input.md).
 91 | 
 92 | Se volessi trattare questo `"123"` come se fosse un numero, e sommargline ad esempio un altro, dovrei prima trasformalo in un intero. 
 93 | Per convertire in intero una stringa, o un float, si utilizza la funzione `int()`.
 94 | 
 95 | ```
 96 | >>> my_var="123"
 97 | >>> print(int(my_var)+20)
 98 | 143
 99 | ```
100 | 
101 | C'è una funzione di casting per ogni tipo di dato, molto usate sono, ad esempio, `str()`, `float()`, `list()` o `dict()`.
102 | 
103 | ## Tutto è un oggetto
104 | 
105 | Senza voler anticipare concetti troppo avanzati, sappi solo che in Python ogni tipo è un oggetto.
106 | Se in altri linguaggi una stringa è solo uno spazio contenente i byte relativi ai caratteri che la compongono, in Python è un oggetto più complesso con relativi medoti e proprietà.
107 | 
108 | 


--------------------------------------------------------------------------------
/docs/Pyllole/11_Syntax.md:
--------------------------------------------------------------------------------
  1 | # Sintassi
  2 | 
  3 | * `Bello è meglio di brutto`
  4 | * `Esplicito è meglio di implicito`
  5 | * `Semplice è meglio di complesso`
  6 | * `Complesso è meglio di complicato`
  7 | * `La leggibilità è importante`
  8 | 
  9 | Questi cinque principi, presi da [Lo Zen di Python](99_Zen.html), fanno capire quanto in Python la forma sia importante tanto quanto la sintassi.
 10 | 
 11 | In Python ogni comando si scrive su una singola riga e non necessita di particolari caratteri di termine (altri linguaggi necessitano, per esempio, di `;`). 
 12 | Se si vogliono scrivere più comandi sulla stessa riga è possibile dividerli utilizzando il `;`, ma non farlo.
 13 | 
 14 | ## Identificatori
 15 | 
 16 | I nomi utilizzati per identificare variabili, funzioni, classi e moduli devono iniziare con una lettera o con un trattino basso `_`, può poi contenere lettere, cifre e caratteri di sottolineatura. Python è un linguaggio di programmazione case sensitive, cioé i caratteri maiuscoli e quelli minuscoli sono considerati come se fossere due lettere differenti. Quindi `nome` e `Nome` sono considerate due variabili differenti.
 17 | 
 18 | Ci sono delle convenzioni relative alla denominazione degli identificatori di Python:
 19 | 
 20 | * I nomi delle classi iniziano con una lettera maiuscola, tutti gli altri identificatori iniziano con una lettera minuscola
 21 | * Un identificatore che inizi con un trattino basso indica che si tratta di un identificatore privato
 22 | * Un identificatore che inizi con due trattini bassi indica che si tratta di un identificatore fortemente privato
 23 | * Se l'identificatore inizia e finisce con due trattini bassi allora è un nome speciale definito nel linguaggio.
 24 | 
 25 | 
 26 | ## Indentazione
 27 | 
 28 | In Python la forma è così importante che per delimitare i blocchi di codice, al posto di utilizzare negli altri linguaggi le parentesi, si utilizza l'indentazione.
 29 | 
 30 | L'indentazione è l'inserimento di spazi vuoti all'inizio di una riga, normalmente si utilizza per far capire, a chi legge un programma, che certe parti di codice fanno riferimento ad un ciclo (`for`, `while`) o ad un controllo condizionale (`if`/`else`).
 31 | 
 32 | Questo è un esempio di funzione in C:
 33 | 
 34 | ```C
 35 | int fattoriale(int x) {
 36 |     if (x == 0) {
 37 |         return(1);                   
 38 |     } else {
 39 |         return(x * fattoriale(x-1));
 40 |     }
 41 |  }
 42 | ```
 43 | 
 44 | La stessa funzione in Python:
 45 | 
 46 | ```Python
 47 | def fattoriale(x):
 48 |     if x == 0:
 49 |         return 1
 50 |     else:
 51 |         return x * fattoriale(x-1)
 52 | ```
 53 | 
 54 | Sbagliare l'indentazione genera un `IndentationError`, le linee guida indicano che l'indentazione va fatta utilizzando 4 spazi, non tabulature. 
 55 | 
 56 | ## Istruzioni multilinea
 57 | 
 58 | L'interprete considera ogni riga come un'istruzione intera, è possibile tuttavia usare il carattere `\` per indicare che l'istruzione continua anche sulla linea successiva. 
 59 | 
 60 | Questo:
 61 | 
 62 | ```Python
 63 | totale = primo + secondo + terzo
 64 | ```
 65 | 
 66 | Può anche essere scritto così:
 67 | 
 68 | ```Python
 69 | totale = primo + \
 70 |          secondo + \
 71 |          terzo
 72 | ```
 73 | 
 74 | Le istruzioni contenute nelle parentesi [], {} o () non necessitano del carattere `\` per continuare sulle righe successive:
 75 | 
 76 | ```Python
 77 | frutta = ['Arancia', 'Pesca', 'Ananas',
 78 |         'Fragole', 'Albicocca']
 79 | ```        
 80 | 
 81 | ## Virgolette
 82 | 
 83 | Le virgolette, o apici, servono per definire stringhe di caratteri.
 84 | Python accetta indistintamente virgolette singole ('), doppie ("), basta che si utilizzino le stesse per l'inizio e la fine della stringa. Inoltre le virgolette triple (''' o """) vengono utilizzate per definire una stringa su più righe. 
 85 | 
 86 | ```Python
 87 | parola = 'gatto'
 88 | frase = "Questa è una frase."
 89 | paragrafo = """ Questo è un paragrafo
 90 | composto da più righe e frasi."""
 91 | ```
 92 | 
 93 | ## Commenti e documentazione
 94 | 
 95 | I commenti all'interno del codice, parti testuali descrittive che vengono ignorate dall'interprete, sono molto utili e si scrivono facendoli precedere da `#`.
 96 | 
 97 | I commenti vanno scritti su allo stesso livello di indentazione del codice che si sta commentando. È meglio evitare i commenti sulla stessa linea del codice.
 98 | 
 99 | 
100 | ```python
101 | #! /usr/bin/python3
102 | 
103 | import os
104 | 
105 | # Qui assegno un nome a una variabile
106 | mia_var="pippo"
107 | ```
108 | 
109 | È possibile scrivere documentazione, più lunga di una singola riga di commento, scrivendo il testo racchiuso tra `"""`.
110 | 
111 | ```python
112 | #! /usr/bin/python3
113 | 
114 | def mia_funzione(*args)
115 |     """ Questa funzione restituisce ...
116 |         Gli argomenti ...   
117 |     """
118 | ```
119 | 
120 | ## Moduli e importazione 
121 | 
122 | Un modulo è un file Python contenente definizioni di variabili, funzioni e classi, che possono essere importati in altri programmi.
123 | 
124 | Ci sono due distinti modi, e sintassi, per importa i moduli, il primo, `import module` permette di importare un intero modulo.
125 | 
126 | ```python
127 | >>> import math
128 | >>> math.pow(2,10)
129 | 1024.0
130 | ```
131 | 
132 | Il secondo permette di importare da un modulo solo alcune determinate definizioni:
133 | 
134 | ```python
135 | >>> from math import pow, log
136 | >>> pow(2,10)
137 | 1024.0
138 | ```
139 | 
140 | è inoltre possibile "rinominare" un modulo o una definizione importata in questo modo:
141 | 
142 | ```python
143 | >>> import math as m
144 | >>> m.pow(2,10)
145 | 1024.0
146 | ```
147 | 
148 | ```python
149 | >>> from math import pow as potenza
150 | >>> potenza(2,10)
151 | 1024.0
152 | ```
153 | 
154 | I moduli sono oggetti, ognuno ha un attributo built-in `__name__` il cui contenuto dipende da come state utilizzando il modulo. 
155 | 
156 | * Se si importa un modulo, allora `__name__` sarà il nome del file senza l'estensione `.py`.  
157 | * Se eseguite il modulo come un programma indipendente, `__name__` avrà il valore default speciale `__main__`.
158 | 
159 | ### Stile di imporazione
160 | 
161 | Le importazioni dei moduli dovrebbero essere all'inizio del file e suddivise su più righe, un import distinto per ogni modulo.
162 | Dovrebbero anche essere importante seguendo l'ordine: librerie standard, importazioni da terzi e infine applicazioni locali.
163 | 
164 | 
165 | ## Convenzioni nella scrittura del codice
166 | 
167 | Esistono delle linee guida per la scrittura del Codice python definite nel [PEP 8 - Style Guide for Python Code](https://www.python.org/dev/peps/pep-0008/).
168 | 
169 | 


--------------------------------------------------------------------------------
/docs/Pyllole/63_Functions.md:
--------------------------------------------------------------------------------
  1 | # Funzioni
  2 | 
  3 | Puoi considerare una funzione come un piccolo programma contenuto nel tuo codice che può essere richiamato più volte per eseguire operazioni ripetitive.
  4 | 
  5 | Ad una funzione è possibile passare degli "argomenti" variabili ad ogni chiamata.
  6 | 
  7 | Infine, una funzione, può restituire un valore con `return`.
  8 | Se si sta utilizzando python dal suo prompt questo valore verrà scritto sulla console. 
  9 | Se si sta eseguendo un programma il risultato di una funzione può essere assegnato ad una variabile o utilizzato come argomento per altre funzioni.
 10 | 
 11 | In Python si utilizza `def` per creare le funzioni.
 12 | 
 13 | Il seguente esempio crea una funzione con due argomenti chiamati `x` e `y`. Scrive sulla console il loro valore e restituisce la loro somma.
 14 | 
 15 | ```python
 16 | def aggiungi(x, y):                                    
 17 |     print("x è {} e y è {}".format(x, y))
 18 |     return x + y  
 19 | ```
 20 | 
 21 | Eseguendo la funzione appena creata si avrà il seguente risultato:
 22 | 
 23 | ```python
 24 | >>> risultato_1 = aggiungi(2, 3)                          
 25 | x è 2 e y è 3
 26 | >>> risultato_2 = aggiungi(100, 50)
 27 | x è 100 e y è 50
 28 | >>> print(risultato_1)
 29 | 5
 30 | >>> print(risultato_2)
 31 | 150
 32 | ```
 33 | 
 34 | ## Argomenti 
 35 | 
 36 | Se eseguo `aggiungi(5,6)`, `x` avrà valore 5 e `y` sarà 6, poiché questo è l'ordine definito alla creazione della funzione.
 37 | È possibile però cambiare l'ordine degli argomenti specificando direttamente chiave e valore durante la chiamata ad una funzione.
 38 | 
 39 | ```python
 40 | >>> aggiungi(y=6, x=5)                                 
 41 | x è 5 e y è 6
 42 | 11
 43 | ```
 44 | 
 45 | Puoi definire funzioni che accettino un numero non definito di argomenti definindo la funzione con un argomento preceduto da un asterisco:
 46 | 
 47 | ```python
 48 | def varargs(*args):                                    
 49 |     return args
 50 | ```
 51 | 
 52 | All'interno della funzione la variabile `args` sarà di un tipo particolare chiamato tupla.
 53 | Questa variabile conterrà tutti i parametri passati alla funzione (leggi la pagine relativa alle [liste](53_Type_List.md) e alle [tuple](55_Type_Tuple.md)).
 54 | 
 55 | ```python
 56 | >>> varargs(1, 2, 3)                                   
 57 | (1, 2, 3)
 58 | ```
 59 | 
 60 | Puoi definire funzioni che accettino un numero variabile di coppie chiave/valere come argomento devi definire la funzione con un argomento preceduto da due asterischi:
 61 | 
 62 | ```python
 63 | def keyword_args(**kwargs):                           
 64 |     return kwargs
 65 | ```
 66 | 
 67 | All'interno della funzione la variabile `kwargs` sarà di un tipo particolare dizionario.
 68 | Questa variabili conterrà tutti i paramentri inviati come coppie chiave/valore  (leggi la pagine relativa ai [dizionari](59_Type_Dictionary.md)).
 69 | 
 70 | ```python
 71 | >>> keyword_args(alpha=40, beta=50)                  
 72 | {'beta': 50, 'alpha': 40}
 73 | ```
 74 | 
 75 | Puoi utilizzare entrambi i metodi in una volta: 
 76 | 
 77 | ```python
 78 | def all_the_args(*args, **kwargs):
 79 |     print(args)
 80 |     print(kwargs)
 81 | 
 82 | >>> all_the_args(10, 20, alpha=40, beta=50 )          
 83 | (10, 20)
 84 | {'beta': 50, 'alpha': 40}
 85 | ```
 86 | 
 87 | Quando chiami una funzione, puoi fare l'opposto di `args`/`kwargs`.
 88 | Usa \* per sviluppare gli argomenti posizionale ed usa \*\* per espandere gli argomenti parola chiave.
 89 | 
 90 | ```python
 91 | >>> args = (1, 2, 3, 4)                                
 92 | >>> kwargs = {"a": 3, "b": 4}
 93 | >>> all_the_args(*args)
 94 | >>> all_the_args(**kwargs)
 95 | >>> all_the_args(*args, **kwargs)
 96 | ```
 97 | 
 98 | ## Return di valori multipli
 99 | 
100 | Una funzione può restituire valori multipli, tutte le variabili indicate dopo il return verranno restituite in un singolo oggetto tupla (le parentesi sono opzionali). 
101 | 
102 | ```python
103 | def swap(x, y):                                        
104 |     return y, x
105 | 
106 | >>> swap(1, 2)                                         
107 | (2, 1)
108 | ```
109 | 
110 | ## Visibilità delle variabili 
111 | 
112 | La visibilità di una variabile, o "variable scope", è la parte di un programma in cui una variabile può essere utilizzata. 
113 | Una variabile definita all'interno di una funzione, detta variabile locale, può essere utilizzata solo all'interno di quella funzione.
114 | Una variabile definita all'esterno della funzione, variabile globale, potrà essere utilizzata all'interno di una funzione solo se richiamata tramite `global`.
115 | 
116 | ```python
117 | x = 5                                                  
118 | 
119 | def set_x(num):                                        
120 |     # La variabile locale x non è la variabile globale x 
121 |     x = num    # => 43
122 |     print(x)   # => 43
123 | 
124 | def set_global_x(num):                                 
125 |     global x
126 |     print(x)   # => 5
127 |     x = num    # la variabile globable x è ora 6
128 |     print(x)   # => 6
129 | 
130 | >>> print(x)
131 | 5
132 | >>> set_x(43)
133 | 43
134 | >>> print(x)
135 | 5
136 | >>> set_global_x(6)
137 | 5
138 | 6
139 | >>> print(x)
140 | 6
141 | ```
142 | 
143 | ## Funzioni anonime
144 | 
145 | Le funzioni anonime sono funzioni senza nome create in fase di esecuzione del programma.
146 | Per creare una funzione anonima si utilizza il costrutto `lambda`.
147 | 
148 | Un esempio di funzione (elevamento alla seconda) definita con un nome:
149 | 
150 | ```python
151 | def pow(x):                                            
152 |      return x**2
153 | 
154 | >>> pow(8)                                             
155 | 64
156 | ```
157 | 
158 | Equivalente funzione ma anonima con `lambda`:
159 | 
160 | ```python
161 | >>> pow = lambda x: x**2                               
162 | >>> pow(8)
163 | 64
164 | ```
165 | 
166 | La definizione lambda non include un `return`, è l'espressione stessa definita in lambda che viene restituita. 
167 | 
168 | È possibile inserire una definizione `lambda` ovunque sia prevista una funzione e non è necessario assegnarla a una variabile.
169 | 
170 | Di seguito un esempio di `lambda` utilizzato per creare funzioni durante, l'esecuzione del programma, ognuna con caretteristiche differenti.
171 | 
172 | ```python
173 | >>> def crea_incrementatore (n):                       
174 | ...     return lambda x: x + n
175 | ...
176 | >>> incr10 = crea_incrementatore(2)
177 | >>> incr5 = crea_incrementatore(5)
178 | >>>
179 | >>> incr10(30)
180 | 32
181 | >>> incr5(30)
182 | 35
183 | ```
184 | 
185 | Spesso le funzioni anonime trovano il loro miglior utilizzo con `map`, `filter` e `reduce`.
186 | 
187 | Esempio utilizzando una lista e il precendete esempio di funzione anonima (elevamente alla seconda)
188 | 
189 | ```python
190 | >>> lista = [1,2,3,4]                                    
191 | >>> list(map(lambda x: x**2, lista))
192 | [1, 4, 9, 16]
193 | ```
194 | 
195 | Un esempio di un filtro che lascia passare solo valori maggiori di 5:
196 | 
197 | ```python
198 | >>> list(filter(lambda x: x > 5, [3, 4, 5, 6, 7])) 
199 | [6, 7]
200 | ```
201 | 
202 | ---
203 | 
204 | _This content is a derivative of ["Learn X in Y minutes"](https://github.com/adambard/learnxinyminutes-docs) by [adambard](https://github.com/adambard), used under a CC BY-SA 3.0 license._
205 | 


--------------------------------------------------------------------------------
/docs/index.md:
--------------------------------------------------------------------------------
  1 | Queste pagine vogliono essere un semplice strumento in grado di fornire un'immediata, unica e chiara risposta alle comuni domande di chi si avvicina per la prima volta al linguaggio Python.
  2 | 
  3 | * Come installo python?
  4 | * Come funziona una lista/dizionario/ciclo/...?
  5 | * Dove posso trovare documentazione, tutorial o corsi?
  6 | 
  7 | Prima di voler scrivere un qualunque programma con Python è necessario conoscere le basi.
  8 | 
  9 | **Nota**: in questo documento si fa riferimento principalmente a Python3
 10 | 
 11 | 
 12 | ## Principali Riferimenti Online
 13 | * **Python.org**: [il sito ufficiale in inglese](https://docs.python.org)
 14 | * **Python.it** : [sito ufficiale italiano](http://www.python.it/) - [Forum](http://www.python.it/forum) - [Telegram](https://t.me/python_ita) - [Mailing list](http://www.python.it/comunita/mailing-list/)
 15 | 
 16 | **Nello studio e nelle ricerche fai sempre riferimento a Python 3.x**, Python 2 non è più supportato dal  1° gennaio 2020, maggiori informazioni [qui](https://www.python.org/doc/sunset-python-2/).
 17 | 
 18 | ## Per iniziare
 19 | 
 20 |   * Documentazione ufficiale
 21 |      * [Cos'è Python - FAQ](http://python.it/doc/faq/)
 22 |      * [Punto di partenza per principianti](http://python.it/doc/newbie/)
 23 | 
 24 | ## Pyllole
 25 | 
 26 | Le Pyllole sono brevi e semplici spiegazioni relative al linguaggio Python 3.
 27 | 
 28 | * [Installare Python](Pyllole/00_Install.md)
 29 | * [Come usare Python](Pyllole/01_Use_Python.md) - [Ambiente di sviluppo](Pyllole/05_Development_Environment.md)
 30 | * [Sintassi di base](Pyllole/11_Syntax.md)
 31 | * [Le variabili](Pyllole/21_Variables.md)
 32 | * [Print](Pyllole/23_Print.md) - [Input](Pyllole/25_Input.md) - [If/Else](Pyllole/27_If-Else.md) - [Cicli](Pyllole/29_Loops.md)
 33 | * [Numeri](Pyllole/41_Type_Number.md) - [Stringhe](Pyllole/42_Type_String.md) - [Booleani](Pyllole/43_Type_Boolean.md) - [None](Pyllole/44_Type_None.md)
 34 | * [Liste](Pyllole/53_Type_List.md) - [Tuple](Pyllole/55_Type_Tuple.md) - [Set](Pyllole/57_Type_Set.md) - [Dizionari](Pyllole/59_Type_Dictionary.md)
 35 | * [Try/Except](Pyllole/61_Try_Except.md)
 36 | * [Funzioni](Pyllole/63_Functions.md) - [Moduli](Pyllole/65_Modules.md)
 37 | * [Iterabili](Pyllole/71_Iterable.md) - [List Comprehension](Pyllole/75_List_Comprehension.md)
 38 | * [Classi](Pyllole/81_Classes.md) - [Ereditarietà](Pyllole/83_Inheritance.md) - [Ereditarietà Multipla](Pyllole/85_Inheritance_Multiple.md)
 39 | 
 40 | 
 41 | ## Strumenti online
 42 | 
 43 |   * Per condividere il tuo codice, in un forum o chat, usa un servizio per la condivisione del codice
 44 |      * [hastebin](https://hastebin.com) - [arin.ga](https://arin.ga) - [dpaste.de](https://dpaste.de)
 45 |   * Puoi provare il tuo codice, senza installare nulla sul tuo PC, usando un compilatore online
 46 |      * [Judge0 IDE](https://ide.judge0.com) - [trinket.io](https://trinket.io) - [repl.it](https://repl.it/)
 47 | 
 48 | ## Documentazione Gratuita
 49 | 
 50 | * ### Tutorial, eBook e Guide Online
 51 |   * ITALIANO
 52 |       * [Documentazione ufficiale](http://python.it/doc/)
 53 |       * Tutorial e guide online:
 54 |         * [Tutorial Python di Nicola Cassetta (base e intermedio)](http://ncassetta.altervista.org/materiali-didattici.html)
 55 |         * [Tutorial Python di CodingCreativo.it](https://www.codingcreativo.it/tutorial-python/)
 56 |         * [Guida Python di HTML.IT](http://www.html.it/guide/guida-python/)
 57 |       * eBook: 
 58 |         * [Immersione in Python 3](http://gpiancastelli.altervista.org/dip3-it/) - [PDF](http://gpiancastelli.altervista.org/dip3-it/d/diveintopython3-it-pdf-latest.zip)
 59 |         * [ThinkPython](https://github.com/AllenDowney/ThinkPythonItalian/) -[PDF](https://github.com/AllenDowney/ThinkPythonItalian/blob/master/thinkpython_italian.pdf)
 60 | 
 61 |   * INGLESE
 62 | 
 63 |       * Python 3 Official Documentation 
 64 |           * [Documentation](https://www.python.org/doc/)
 65 |           * [Tutorial](https://docs.python.org/3/tutorial/index.html)
 66 |       * E-book
 67 |           * [Automate the Boring Stuff with Python](https://automatetheboringstuff.com/)
 68 |           * [Dive Into Python 3](http://getpython3.com/diveintopython3/)
 69 |           * [Fundamentals of Programming Python](http://python.cs.southern.edu/pythonbook/pythonbook.pdf)
 70 |           * [O’Reilly Media: A Whirlwind Tour of Python](http://www.oreilly.com/programming/free/files/a-whirlwind-tour-of-python.pdf)
 71 |           * Packt Publishing
 72 |               * [Learning Python](https://www.packtpub.com/free-ebooks/learning-python)
 73 |               * [Mastering Python](https://www.packtpub.com/free-ebooks/mastering-python)
 74 |           * [Python Practice Book](https://anandology.com/python-practice-book/index.html)
 75 |           * [Python Programming](https://upload.wikimedia.org/wikipedia/commons/9/91/Python_Programming.pdf)
 76 |           * [Syncfusion: Python Succinctly](https://www.syncfusion.com/ebooks/python)
 77 |           * [The Coder's Apprentice: Learning Programming with Python 3](http://www.spronck.net/pythonbook/)
 78 |           * [The Hitchhiker’s Guide to Python!](http://docs.python-guide.org/en/latest/)
 79 |           * [Python 101](https://leanpub.com/python_101)  
 80 |           * [Intermediate Python](https://leanpub.com/intermediatepython)
 81 |           * [Think Python 2 edition](http://greenteapress.com/wp/think-python-2e/)
 82 |           * [30 Python Language Features and Tricks You May Not Know About](http://sahandsaba.com/thirty-python-language-features-and-tricks-you-may-not-know.html)
 83 |           * [Building Skills in Python](http://www.itmaybeahack.com/book/python-2.6/latex/BuildingSkillsinPython.pdf)
 84 |       * Cheatsheet
 85 |         * [Python Cheatsheet](https://www.pythoncheatsheet.org/)
 86 |         * [Comprehensive Python Cheatsheet](https://gto76.github.io/python-cheatsheet/)
 87 |       * Tutorial
 88 |         * [A Beginner's Python Tutorial](https://en.wikibooks.org/wiki/A_Beginner%27s_Python_Tutorial)
 89 |         * [Python 3 Module of the Week](https://pymotw.com)
 90 |         * [A Byte of Python](https://python.swaroopch.com/first_steps.html)
 91 | 
 92 | * ### Video Corsi e Tutorial
 93 |   * ITALIANO
 94 |       * [Video Corso Python 3 - Impara a Programmare in Python 3.6](https://www.youtube.com/playlist?list=PLHUQL6-_n9Zes1VLMgJbLa8IIOHT9x4Nu)
 95 |       * [Python 3.6 Tutorial Italiano - Programmazione a Oggetti - Classi e Istanze](https://www.youtube.com/watch?v=nmoJf-Ei4TA&list=PLHUQL6-_n9ZdD3JMKg4On4NFh8bBg3Ckn)
 96 |       * [ProgrammareInPython.it - Video Corsi e Esercizi](https://www.programmareinpython.it/programmare-in-python/)
 97 |       * [Amazing Python - Marco Beri](https://www.youtube.com/watch?v=O0DLSD5o5VU&list=PLu-RPGHOxmPVN7WbrlmO6Vc2gb8djB3_n)
 98 |   * INGLESE
 99 |       * [Python for Beginners - Microsoft](https://www.youtube.com/playlist?list=PLlrxD0HtieHhS8VzuMCfQD4uJ9yne1mE6)
100 |       * [Automate the Boring Stuff with Python](https://www.youtube.com/playlist?list=PL0-84-yl1fUnRuXGFe_F7qSH1LEnn9LkW)
101 |       * [Python 3.4 Programming Tutorials](https://www.youtube.com/playlist?list=PL6gx4Cwl9DGAcbMi1sH6oAMk4JHw91mC_)
102 |       * [Python Programming Tutorials](https://www.youtube.com/playlist?list=PLEA1FEF17E1E5C0DA)
103 |       * [Python Tips](https://www.youtube.com/playlist?list=PLP8GkvaIxJP3ignHY_Dq7bFsvwzAcqZ1i)
104 |       * [Build applications with Python](https://www.youtube.com/playlist?list=PL41psiCma00wwvtQyLFMFpzWxUYmSZwZy)
105 | 
106 | 
107 | ## Altre Raccolte
108 | Di seguito sono elencate altre raccolte di link a documentazione relativa a Python.
109 | In questi elenchi possono essere trovati approfondimenti e documentazione relativa a specifiche librerie o framework (Django, Flask, Kivy, Pandas, Pyramid. Tornado, ...)
110 | 
111 | * ### eBook, Guide e Tutorial
112 |   * ITALIANO
113 |       * [Python.it - I libri su Python](http://www.python.it/doc/libri/)
114 |   * INGLESE
115 |       * [Python projects for beginners](https://beginnerpythonprojects.com/)
116 |       * [Free Programming Books](https://github.com/EbookFoundation/free-programming-books/blob/main/casts/free-podcasts-screencasts-en.md#python)
117 |       * [Packt Publishing: Free Learning - Free Programming Ebooks](https://www.packtpub.com/free-learning)
118 |       * [O’Reilly: Open Books](https://www.oreilly.com/openbook/) 
119 |       * [Syncfusion: Succinctly free eBooks](https://www.syncfusion.com/ebooks)
120 |       * [Awesome Python](https://github.com/vinta/awesome-python) - una lista di frameworks, librerie e software
121 | 
122 | *  ### Video Corsi e Tutorial
123 |    * ITALIANO
124 |        * [Python.it - Media](http://python.it/doc/media/)
125 |    * INGLESE
126 |       * [Free Python Podcasts and Screencasts](https://github.com/EbookFoundation/free-programming-books/blob/main/casts/free-podcasts-screencasts-en.md)
127 | 
128 | ---
129 | 
130 | Ogni contributo è ben accetto, leggi il [codice di condotta](https://github.com/pythonitalia/python-abc/blob/master/CODE_OF_CONDUCT.md) e la pagina con le [linee guida alla collaborazione](https://github.com/pythonitalia/python-abc/blob/master/CONTRIBUTING.md).
131 | 
132 | Questa guida è è pubblicata con licenza [CC BY 4.0](https://creativecommons.org/licenses/by/4.0/) (Creative Commons Attribution 4.0 International)  - [leggi qui  i dettagli](https://github.com/pythonitalia/python-abc/blob/master/LICENSE).
133 | 
134 | ---
135 | 
136 | 


--------------------------------------------------------------------------------