# CONVENEVOLI
# 1) # identifica le righe con i commenti, che vengono ignorate.
# 2) Le stringhe possono essere inserite indifferentemente tra apici o virgolette.
# 3) Il punto e virgola ";" è usato per separare più comandi che si vogliono mettere sulla stessa riga.
# 4) Python è case sensitive, quindi occhio alle maiuscole.


# OPERATORI
# 1) +,  -, *, /
# 2) ** per la potenza
# 3) % per il resto di una divisione
# 4) // per la divisione senza resto (risultato int)
# 4) + può essere utilizzato anche con le stringhe per unirle
# 5) * può essere utilizzato con le stringhe per moltiplicarle per un numero: "a"*5 = "aaaaa"
# 6) <, >. <=. >=, == (uguale), != (diverso)    utilizzabili anche con le stringhe (ordine alfabetico per <,>)
# 7) operatori logici: and, or, not


# VARIABILI
# Si assegnano con l'uguale:
altezza = 1.80
a = "ciao"


# TIPI
# 1) int, float, str, bool, function
# 2) Type(variabile) per vedere il tipo di una variabile


# STRINGS
Name = 'Cecilia'
Name[0]
'C'
Name[1]
'e'
Name[-1]
'a'
Name[0:4]    # da 0 a 4 escluso
'Ceci'


# TUPLES
# Immutable!
tuple1 = (0,10,2,4)
tuple2 = ('a',1,1.5)
tuple2[0]: 'a'
tuple2[0:2]: ('a',1)
tuple3 = tuple1+tuple2
tuple4 = ('a',(1,2),3,'b',('hard','rock'))
tuple4[1]: (1,2)
tuple4[4][1]: 'rock'
tuple4[4][1][0]: 'r'


# LISTS
# Mutable!
# collezioni di elementi anche di tipo diverso: no differenza tra vettore e lista, come accade con altri linguaggi.
# Parentesi quadre per racchiudere gli elementi in una lista:
["Massy", 1984, 33.1, True]
# Le liste possono essere salvate in una variabile
Massy = ["Max", 1984, "M"]
# Con il + unisco due liste, con * le moltiplico
Ceci = ["Ceci", 1987, "F"]
# Con Ceci+Massy ottengo la lista ["Max", 1984, "M","Ceci", 1987, "F"]
# Con Ceci*3 ottengo ["Ceci", 1987, "F","Ceci", 1987, "F","Ceci", 1987, "F"]
# Una lista può contenere a sua volta un'altra lista (sottolista)
famiglia = [["Papà Angelo", 1948, "M"], ["Mamma Giovanna", 1955, "F"], ["Vale", 1980, "F"], Massy, ["Chicco", 1988, "M"], ["Benny", 1996, "F"]]
# Per selezionare un elemento di una lista si scrive il nome della lista seguito dal numero dell'elemento tra parentesi quadre in base zero.
famiglia[1]  # secondo elemento della lista memorizzata nella variabile famiglia.
# Si può utilizzare anche il numero negativo partendo a contare dall'ultimo elemento della lista (l'ultimo è -1)
famiglia[-1]
# Con i due punti prendiamo l'intervallo, l'elemento iniziale dell'intervallo è incluso, mentre quello finale è escluso dal risultato:
famiglia[3:5]  # solo il quarto e quinto elemento dell'intervallo (elementi 3 e 4 in base 0)
famiglia[-4:-2]    # dal quart'ultimo al terz'ultimo
famiglia[:4]   # elementi dallo 0 al 4 escluso
famiglia[4:]   # dall'elemento 4 fino all'ultimo incluso
# Se una lista è a sua volta composta da sottoliste, possiamo estrarre il valore di una sottolista con:
famiglia[2][1] # secondo elemento (1 in base 0) del terzo elemento (2 in base 0)
# Per modificare un elemento della lista:
Massy[1]=1985  # modifica l'elemento 2 della lista Massy
# Per modificare in un'unica stringa più elementi consecutivi della stessa lista:
Massy[0:2]=["Massy", 1983]
# tenendo sempre presente che il numero iniziale è compreso, quello finale no.
# Come per le stringhe, il segno più può essere usato per unire due liste.
# Per eliminare un elemento della lista si usa il del:
del(famiglia2[-1])  #elimina l'ultimo elemento di famiglia2.
# Operatore in per vedere se un elemento appartiene alla lista (vale anche per tuple e set):
1987 in Ceci  
# mi restituisce True


# TUPLES AND LISTS: NB
# quando creo una lista
x = ["a","b","c"]
# ogni elemento della lista di x viene copiato in una parte di memoria.
# Quindi per creare una lista y uguale alla lista x, è naturale scrivere:
y = x
# Se poi faccio
y[1] = "z"
# vedo naturalmente che digitando y, viene restituito ["a","z","c"].
# Ma se adesso provo a digitare x ricevo anche qui ["a", "z", "c"].
# Questo perché quando copio x in y con x = y, è come se copiassi un link ai valori della lista sulla memoria,
# non i valori stessi.
# Quando poi aggiorno un elemento di y vado ad aggiornare l'elemento in memoria, che è parte sia di y che di x.
# Per copiare una lista in un'altra bisogna usare la funzione list():
y = list(x)
# in questo modo la nuova lista y sarà scritta in un nuovo spazio della memoria del computer, e potrò modificarlo
# senza per questo modificare anche x.
# In alternativa si può anche usare
y = x[:]


# SETS
# collections like tuples and lists but unordered and with unique elements
set1 = {'a',1,2,'a',3}
set1: {1,2,3,'a'}
set2 = {'a',4}
set1 & set2: {'a'}


# DICTIONARIES (KEYS)
# collections with name (no duplicates) for each element
x = {"Massi Figini": "@massyfigini", "Primo Drudi": "@primodrudi"}

Con
x["Massi Figini"]
x.keys()    # get all the keys of x
x.values()    # get all the values of x
x['abacabb'] = 'new'    # aggiungo nuovo elemento a x
del(x['abacabb'])     #elimino elemento da x
Posso anche associare successivamente una key al valore:
x = {"Massi Figini","@massyfigini", "notebook.massimilianofigini.com"}
nome, twitter, blog= x

# FUNZIONI BASE
# 1) print(variabile)
# 2) max(lista), min(lista)
# 3) round(numero, cifre decimali)    senza il secondo elemento arrotonda all'intero
# 4) help(funzione)    documentazione per la funzione
# 5) len(stringa o list)    lunghezza
# 6) sum(list)    somma elementi list
# 7) int(stringa di numeri)    float(numero)    str(numero)    bool(1)    conversione
# 8) complex(real[, imag])   crea un numero complesso unendo un numero reale con uno immaginario
# 9) sorted(numero, reverse=True)    return sorted elements
# 10) split per splittare stringhe o convertirle in list
'Massi Figini'.split(' ')[0]
# restituisce Massi
'Massi Figini'.split()
# restituisce la list ['Massi','Figini']
# 11) str(Variabile)    converte Variabile in string
print('Dybala' + str(21))
# restituisce Dybala21
# 12) set(lista)    converte la list 'lista' in set
# 13) File1 = open("percorso/file.txt","r")     # leggo un txt e lo assegno a File1, "r" sta per reading (posso usare "w" per writing e in questo caso crea un file, "a" per appending)

# Es.
vendita = {
    'prezzo': 10.15,
    'num_palloni': 4,
    'cliente': 'Pogba'}

stringa = '{} compra {} pallone/i al prezzo di {} ciascuno per un totale di {}'

print(stringa.format(vendita['cliente'],
             vendita['num_palloni'],
             vendita['prezzo'],
             vendita['num_palloni']*vendita['prezzo']))

# da come risultato: "Pogba compra 4 pallone/i al prezzo di 10.15 ciascuno per un totale di 40.6".

# Tutte funzioni integrate senza bisogno di pacchetti esterni.
# Se le funzioni hanno più argomenti opzionali, per prenderne uno dobbiamo specificarlo:
# nella 7 il secondo parametro (key) è omesso, quindi dobbiamo specificare reverse=True per l'ordine decrescente


# CREAZIONE DI FUNZIONI
# Function without elements
def yeah():
      print("Yeah!")
# Call the function with:
yeah()
# Creo la funzione addizione:
def add(x,y):
    z = x+y 
    return z
# Ora con il comando 
add(6,7)
# otterremo 13
# Assegnare una funzione a una variabile
a = add
# Ora se digito
a(1,3)
# ottengo 4.
# If I declare a variable inside a function, it exist only in it. If want a global variable define it with the prefix "global".


# CICLO IF
# execute indent lines if condition is true
If [condizione]:
      [comando da eseguire]           
elif [condizione2]:          # else if opzionale
      [comando da eseguire]
else:                                     # else opzionale
     [comando da eseguire]
Es creazione funzione con IF e parametro opzionale:
def addizione(x,y,z=None):
    if (z==None):
        return x+y
    else:
        return x+y+z


# FOR LOOP
# Example 1
for i in range(1,11):
    print(i)
# Example 2
years = [1983,1987,2014]
for i in years:
    print(years)
# Example 3
years = [1983,1987,2014]
for i,years in enumerate(years):
    print(i,years)


# WHILE LOOP
# Example
dates = [1972,1982,1987]
i = 0
year = 0
while year != 1982:
    year = dates[i]
    i = i+1
    print(year)

print(i, "loops")


# WITH STATEMENT
# Useful example 1: read a file, do something, then close it
with open('/documents/Example1.txt', 'r') as file1:
    FileContent = file1.read()
    print(FileContent)
# Useful example 2: write something i a new file, then close it
with open('/documents/Example2.txt', 'w') as writefile:
    writefile.write("This is line 1\n")

    writefile.write("This is line 2\n")
# Useful example 3: copy Example 2 to Example 3
with open('Example2.txt','r') as readfile:
    with open('Example3.txt','w') as writefile:
          for line in readfile:
                writefile.write(line)


# METODI
# funzioni che "appartengono" agli oggetti. A seconda del tipo di oggetto ci sono metodi diversi.
famiglia.index("Massy") 
# restituisce la posizione della stringa "Massy" al'interno della lista famiglia.
# index() si può usare sia con liste che con stringhe (in questo caso dà la posizione della/e lettera/e).
famiglia.count("Massy") 
# restituisce quanti "Massy" ci sono nella lista famiglia.
famiglia.append(["Ceci", 1987, "F"]) 
# va ad aggiungere la sottolista indicata alla lista famiglia.
famiglia.extend(["Ceci"]) 
# va ad aggiungere uno o più elementi alla lista famiglia.
# Altri metodi:
a.capitalize()     # converte l'iniziale della variabile stringa a in maiuscolo
a.upper()           # converte tutte le lettere in maiuscolo
a.find('a')           # posizione di una o più lettere in una stringa
a.count("o")      # conta quante o ci sono nella variabile stringa a
a.sort()    # sort elements of a list
# Ci sono anche metodi che modificano gli oggetti che li chiamano:
a.replace("o","ops")     # converte tutte le lettere "o" presenti nella variabile stringa a in "ops"
a.remove("c")     # rimuove il primo elemento "c" presente nella lista
a.reverse()          #gira al contrario gli elementi di una lista (dall'ultimo al primo)
set1.add('b')          #aggiunge un elemento a un set
set1.remove('b')          #elimina un elemento a un set
set1.union(set2)          #tutti gli elementi di set1 e set2
set1.intersection(set2)          #tutti gli elementi di set1 che sono anche in set2
set1.difference(set2)          #in set1 ma non in set2
set1.issubset(set2)          #vero se set2 è sottoinsieme di set1
File1.name    # nome del file assegnato alla variabile File1
File1.mode    # modalità File1 ("r" read, "w" write, "a" append)
File1.close    # chiudo connessione a File1


# CLASSE

Python class example:
class Persona:
    lavoro = 'Data Scientist'    # variabile di classe
    def set_p(self, nome, luogo):   # metodo
        self.nome = nome
        self.luogo= luogo

persona = Persona()
persona.set_p('Massi','Milano')
print('{} vive a {} e di lavoro fa il {}'.format(persona.nome, persona.luogo, persona.lavoro))

# Example 2
# Import the library
import matplotlib.pyplot as plt

# Define the class:
class Circle(object):   
    # Constructor
    def __init__(self, radius=3, color='blue'):
        self.radius = radius
        self.color = color     
    # Method
    def add_radius(self, r):
        self.radius = self.radius + r
        return(self.radius)    
    # Method
    def drawCircle(self):
        plt.gca().add_patch(plt.Circle((0, 0), radius=self.radius, fc=self.color))
        plt.axis('scaled')
        plt.show()

# Create an instance of the class:
RedCircle = Circle(10, 'red')
# FInd methods of the class:
dir(RedCircle)
# print radius and color:
RedCircle.radius
RedCircle.color
# Set the object attribute radius
RedCircle.radius = 1
RedCircle.radius
# Call the method drawCircle
RedCircle.drawCircle()
# Use method to change the object attribute radius
print('Radius of object:',RedCircle.radius)
RedCircle.add_radius(2)
print('Radius of object of after applying the method add_radius(2):',RedCircle.radius)
RedCircle.add_radius(5)

print('Radius of object of after applying the method add_radius(5):',RedCircle.radius)

# Create a blue circle with a given radius
BlueCircle = Circle(radius=100)
# Print the object attribute radius
BlueCircle.radius
# Print the object attribute color
BlueCircle.color
# Call the method drawCircle
BlueCircle.drawCircle()



# LA FUNZIONE MAP
# Esempio per mappare la funzione min tra due liste
lista1 = [10.00, 11.00, 12.34, 2.34]
lista2 = [9.00, 11.10, 12.34, 2.01]
minimo = map(min, lista1, lista2)
# minimo è una variabile map. Per confrontare ogni elemento della lista:
for i in minimo:
    print(i)


# FUNZIONI LAMBDA
# Le funzioni Lambda sono funzioni anonime che possiamo creare a condizione che abbiano un'unica espressione e senza valori di default. Funzione lambda che dati 3 parametri somma i primi due:
funzione = lambda a, b, c : a + b
# funzione(1,2,3) dà come risultato 3.


# LIST COMPREHENSIONS
# Per costruire liste in modo più leggibile che usando la sintassi normale.
# Es: funzione per mettere in una lista solo i valori pari da 1 a 1000
lista = []
for i in range(1, 1000):
    if i % 2 == 0:
        lista .append(i)
# Stessa funzione scritta con la list comprehension:
lista = [i for i in range(0,1000) if i % 2 == 0]


# DATE & TIME
import datetime as dt
import time as tm
tm.time()   # secondi passati adesso dal 1/1/1970
# converto il timestamp in datetime
ora = dt.datetime.fromtimestamp(tm.time())
# Funzioni per prendere parte di una datetime:
ora.year, ora.month, ora.day, ora.hour, ora.minute, ora.second
# timedelta è una durata che misura la differenza tra due date.
delta = dt.timedelta(days = 100)
oggi = dt.date.today()
oggi - delta   # restituisce la data di 100 giorni fa
oggi > today-delta   # restituisce TRUE



# FILE CSV
# il file che uso nell'esempio è qui
# Importa un csv
import csv
with open('C:/mpg.csv') as csvfile:
        mpg = list(csv.DictReader(csvfile))
# Guarda le prime cinque righe:
mpg[:5]
# Quanti record:
len(mpg)
# Nomi dei campi:
mpg[0].keys()
# Calcolo consumo medio in città (cty)
sum(float(d['cty']) for d in mpg) / len(mpg)
# In tipo metto le diverse tipologie di auto
tipo = set(d['class'] for d in mpg)
# Ora guardo il consumo medio in città in base al tipo di veicolo
CtyMpgByTipo = []
for t in tipo: 
    summpg = 0
    tipocount = 0
    for d in mpg: 
        if d['class'] == t: 
            summpg += float(d['cty']) 
            tipocount += 1 
    CtyMpgByTipo.append((t, round(summpg / tipocount,2))) 
CtyMpgByTipo.sort(key=lambda x: x[0])
CtyMpgByTipo

# PACCHETTI
# Tra i pacchetti più utilizzati per l'analisi dei dati ci sono:
# Numpy (ottimo per lavorare con gli array),
# Matplotlib (grafici),
# Scikit-learn (machine learning).
# Per installare pacchetti non presenti di default su Python, il modo più semplice è scaricare da qui il file "get-pip.py".
# Successivamente da Python:
python3 get-pip.py
# Ora è possibile usare il pacchetto pip per installare altri pacchetti. Con:
pip3 install numpy
# diciamo che stiamo usando la versione 3 di Python, e che vogliamo installare il pacchetto Numpy.
# Dopo di questo potremo usare le funzioni di Numpy importando prima il pacchetto, con:
install numpy
# Per usare una funzione del pacchetto dobbiamo far precedere il nome del pacchetto a quello della funzione:
numpy.array([1,2,3])
# Durante l'importazione possiamo utilizzare un alias per il pacchetto:
import numpy as np
np.array([1,2,3])  # possiamo usare l'alias al posto del nome del pacchetto
# E' possibile anche importare solo una specifica funzione di un pacchetto:
from numpy import array 
# In questo caso sarà possibile chiamare direttamente la funzione senza il nome del pacchetto:
array([1,2,3])