Python – Una breve guida

In questo articolo del Blog AIKnow.info rivedremo brevemente Python, un linguaggio di programmazione molto popolare nelle applicazioni di data science. Il nostro interesse è particolarmente legato al machine learning, dove Python è molto utilizzato come conseguenza della disponibilità di un gran numero di librerie dedicate.

Quindi questo articolo è preparatorio per l’implementazione degli algoritmi di machine learning che vedremo nel seguito.

Python è un linguaggio di alto livello interpretato. L’interprete Python può essere utilizzato per eseguire singole linee di codice semplicemente scrivendole dopo il prompt >>> (Fig.1) o come script usando il comando python.exe disponibile nella directory di installazione seguito dal nome dello script (Fig.2).
Le istruzioni in uno script sono eseguite una alla volta, partendo dalla prima, in ordine dall’alto in basso. Se l’istruzione è una chiamata di funzione, il flusso di esecuzione va alla prima istruzione del corpo e quando è completa, il programma ritorna al punto di chiamata.


Fig.1 Interprete Python


Fig. 2 Esecuzione di script Python

Assumendo che il lettore abbia conoscenze basilari di programmazione, nel seguito vedremo le regole sintattiche di base del linguaggio di programmazione Python prendendo come riferimento la versione 3.

Operatori

+, -, *, /, // divisione intera, % modulo, ** elevamento a potenza

Operatori logici

and, or, not

Operatori relazionali

==, !=, >, <, >=, <=

Ordine delle operazioni

Parentesi, elevamento a potenza, moltiplicazione e divisione, addizione e sottrazione

Operatori Stringa

+ concatenazione, * ripetizione

Commenti

Iniziano con il simbolo #

Definizione di Funzioni


def funzione_1(argomento_1,argomento_2):
    concat=argomento_1+argomento_2
    print(concat)
    return concat

L’intestazione della funzione deve finire con i due punti, mentre il corpo deve essere indentato con lo stesso numero di spazi (generalmente 4).

Una funzione pura non modifica alcuno degli oggetti passati come argomenti e non ha altri effetti rispetto a quello di ritornare un valore.

A volte è utile per una funzione modificare gli oggetti ricevuti come parametri. In questo caso i cambiamneti sono visibili al chiamante. Funzioni che lavorano in questo modo sono chiamate modificatori.

Esecuzione condizionale

if int(x)>0:
print (“x positivo”)
elif int(x)==0:
print (“x zero”)
else:
print (“x negativo”)

input da tastiera

x=input(“Scrivi un numero\n”)
Il valore ritornato dalla funzione input() function è di tipo stringa.

Iterazione

while n > 0:
print (n)
n = n-1

for carattere in “Stringa”:
print carattere

Manipolazione di Stringhe

Sottostringhe
>>>s = ‘Una stringa molto lunga’
>>>print (s[12:17])
>>>molto

Le stringhe sono immutabili
>>> s = ‘Una stringa molto lunga’
>>> s[8] = ‘S’
>>>TypeError: ‘str’ object does not support item assignment

Metodi Stringa
>>> s1 = ‘stringa’
>>> s2 = s1.upper()
>>> print (s2)
>>>STRINGA

Operatore In
>>> ‘s’ in ‘stringa’
True
>>> ‘b’ in ‘stringa’
False

Confronto di Stringhe
if s == ‘Verde’:
print (‘Ok puoi andare’)
elif s < ‘Verde’:
print (‘La tua parola,’ + s + ‘, viene prima di Verde.’)

Le lettere maiuscole vengono prima di quelle minuscole.

Liste

Una lista è una sequenza di valori
>>>lista=[‘stringa1’,2.0,[‘sottolista1′,’sottolista2’]]
>>>print (lista[0])
stringa1

>>>lista[0]=2
>>>print (lista)
[2, 2.0, [‘sottolista1’, ‘sottolista2’]]

Scorrere una lista
for elemento in lista:
print (elemento)
2
2.0
[‘sottolista1’, ‘sottolista2’]

for i in range(len(lista)):
lista[i]=lista[i]*2
print (lista[i])
4
4.0
[‘sottolista1’, ‘sottolista2’, ‘sottolista1’, ‘sottolista2’]

Operazioni sulle liste
>>> [1, 2, 3]+[4, 5, 6]
[1, 2, 3, 4, 5, 6]

>>> [1, 2, 3] * 3
>>>[1, 2, 3, 1, 2, 3, 1, 2, 3]

>>> t = [‘a’, ‘b’, ‘c’, ‘d’, ‘e’, ‘f’]
>>> t[1:3]
[‘b’, ‘c’]

>>> t[:4]
[‘a’, ‘b’, ‘c’, ‘d’]

>>> t[3:]
[‘d’, ‘e’, ‘f’]

Metodi su Liste
>>> t = [‘a’, ‘b’, ‘c’]
>>> t.append(‘d’)
>>> print (t)
[‘a’, ‘b’, ‘c’, ‘d’]

>>> t1 = [‘a’, ‘b’, ‘c’]
>>> t2 = [‘d’, ‘e’]
>>> t1.extend(t2)
>>> print (t1)
[‘a’, ‘b’, ‘c’, ‘d’, ‘e’]

>>> t = [‘d’, ‘c’, ‘e’, ‘b’, ‘a’]
>>> t.sort()
>>> print (t)
[‘a’, ‘b’, ‘c’, ‘d’, ‘e’]

>>> t = [‘a’, ‘b’, ‘c’]
>>> del t[1]
>>> print (t)
[‘a’, ‘c’]

>>> t = [‘a’, ‘b’, ‘c’]
>>> t.remove(‘b’)
>>> print (t)
[‘a’, ‘c’]

Liste e stringhe
>>> s = ‘stringa’
>>> t = list(s)
>>> print (t)
[‘s’, ‘t’, ‘r’, ‘i’, ‘n’, ‘g’, ‘a’]

>>> s = ‘stringa-stringa-stringa’
>>> delimiter = ‘-‘
>>> s.split(delimiter)
[‘stringa’, ‘stringa’, ‘stringa’]

>>> t = [‘stringa1’, ‘stringa2’, ‘stringa3’]
>>> delimiter = ‘  ‘
>>> delimiter.join(t)
‘stringa1 stringa2 stringa3’

Dizionari

Un dizionario costituisce una mappatura tra un insieme di indici (chiamati chiavi) e un insieme di valori.

>>> ita2eng = dict()
>>> ita2eng = {‘uno’: ‘one’, ‘due’: ‘two’, ‘tre’: ‘three’}
>>> print (ita2eng[‘due’])
two

Esempio di una funzione per contare la numerosità di lettere in una stringa
def histogram(s):
d = dict()
for c in s:
if c not in d:
d[c] = 1
else:
d[c] += 1
return d

Esempio di una funzione per ottenere una chiave da un valore
def reverse_lookup(d, v):
for k in d:
if d[k] == v:
return k
raise ValueError

Un dizionario è implementato usando una hashtable.

Un hash è una funzione che prende un valore (di qualsiasi tipo) e ritorna un intero. I dizionari usano questi interi, chiamati valori hash, per memorizzare e consulare le coppie chiave-valore.

Questo sistema lavora bene le le chiavi sono immutabili, così le liste e i dizionari non possono essere utilizzate come chiavi (ma possono essere usate come valori).

Tuple

Da un punto di vista sintattico, una tupla è una lista di valori separati da virgola:

>>> t = ‘a’, ‘b’, ‘c’, ‘d’, ‘e’

Una tupla è una sequenza di valori. I valori possono essere di qualsiasi tipo e vengono indicizzati da interi, dunque da questo punto di vista le tuple sono molto simili alle liste. La differenza sostanziale è che le tuple sono immutabili.

>>> t = tuple(‘stringa’)
>>> print (t)
(‘s’, ‘t’, ‘r’, ‘i’, ‘n’, ‘g’, ‘a’)

>>> print (t[0])
‘s’
>>> print (t[1:3])
(‘t’, ‘r’)

>>> t[0] = ‘S’
TypeError: ‘tuple’ object does not support item assignment

Assegnamento di Tuple
>>> a, b = b, a

Funzioni che accettano e ritornano valori multipli
Una funzione può tornare un solo valore, ma se il valore è una tupla, l’effetto è lo stesso di tornare valori multipli.

Le funzioni accettano un numero variabile di argomenti. Un nome di parametro che inizia con * raccoglie gli argumenti in una tupla:

def printall(*args):
print args

Il comportamento complementare è quello della dispersione. Se si ha una sequenza di valori e si vogliono passare a una funzione come argomenti multipli, si può usare l’operatore *

>>> t = (7, 3)
>>> divmod(*t)
(2, 1)

Liste e tuple
>>> s = ‘abc’
>>> t = [0, 1, 2]
>>> zip(s, t)
[(‘a’, 0), (‘b’, 1), (‘c’, 2)]

Dictionari e tuple
I dizionari hanno un metodo chiamato items che ritorna una lista di tuple dove ogni tupla è una coppia chiave-valore.

>>> d = {‘a’:0, ‘b’:1, ‘c’:2}
>>> t = d.items()
>>> print (t)
[(‘a’, 0), (‘c’, 2), (‘b’, 1)]

Le tuple possono essere utilizzate per inizializare un nuovo dizionario:

>>> t = [(‘a’, 0), (‘c’, 2), (‘b’, 1)]
>>> d = dict(t)
>>> print (d)
{‘a’: 0, ‘c’: 2, ‘b’: 1}

E’ comune utilizzare tuple come chiavi di dizionari (principalmente perchè non è possibile utilizzare liste).

elenco[nome,cognome] = numero
for nome, cognome in elenco:
print nome, cognome, elenco[nome,cognome]

Confrontare tuple
Gli operatori relazionali lavorano con tuple e altre sequenze; Python inizia confrontando il primo elemento di ogni sequenza. Se gli elementi sono uguali, si procede con gli elementi successivi, finchè non vengono trovati elementi che differiscono.

File

Leggere da un file
>>>fp = open(‘C:/file.txt’)
>>>for linea in fp:
>>>    print(linea)

Scrivere in un file
>>>fp = open(‘C:/file.txt’,’w’)
>>>fout.write(‘linea1\n’)
>>>fout.close()

Gestire le eccezioni
Molte cose possono andare male quando si cerca di leggere o scrivere in un file, per questo è preferibile gestire i problemi nel caso in cui avvengano, che è quanto viene fatto dalla dichiarazione try.

try:
fin = open(‘file_danneggiato’)
for linea in fin:
print linea
fin.close()
except:
print ‘Something went wrong.’

Classi e Oggetti

Una classe è un tipo definito dall’utente. Una definizione di classe crea un nuovo oggetto classe.

>>>class Punto(object):
>>>    “””Rappresenta un punto nello spazio a due dimensioni.”””
>>>p1=Punto()
>>>p1.x=3.0
>>>p1.y=4.0

>>>print (p1.y)
4.0

Copiare oggetti
import copy
p2 = copy.deepcopy(p1)

Metodi delle classi
class Tempo(object):
def stampa_tempo(tempo):
print ‘%.2d:%.2d:%.2d’ % (tempo.ore, tempo.minuti, tempo.secondi)
def incremento(self, secondi):
secondi += self.time_to_int()
return int_to_time(secondi)
def e_dopo(self, altro):
return self.time_to_int() > altro.time_to_int()

>>> inizio = Tempo()
>>> inizio.ore = 9
>>> inizio.minuti = 45
>>> inizio.secondi = 00
>>> stampa_tempo(inizio)
09:45:00
>>> fine = inizio.incremento(1337)
>>> fine.stampa_tempo()
10:07:17

Si noti che inizio viene assegnato al primo parametro di incremento, self. L’argomento 1337, viene assegnato al secondo parametro, secondi.

>>> fine.e_dopo(inizio)
True

Il metodo init (abbreviazione di “initialization” inizializzazione) è un metodo speciale che viene invocato quando un oggetto viene istanziato.

# inside class Time:
def __init__(self, hour=0, minute=0, second=0):
self.hour = hour
self.minute = minute
self.second = second

__str__ is a special method, like __init__, that is supposed to return a string representation of an object.

# dentro la classe Tempo:
def __str__(self):
return ‘%.2d:%.2d:%.2d’ % (self.ora, self.minuti, self.secondi)

Definendo altri metodi speciali, è possibile specificare il comportamento di operatori o tipi definiti dall’utente.

Polimorfismo
Il Polimorfismo è la capacità di alcune funzioni di lavorare con differenti tipi, questo può facilitare il riuso del codice. Ad esempio la funzione primitiva sum, che esegue l’addizione degli elementi di una sequenza, è in grado di operare su tutti quegli elementi che supportano l’addizione.

Parole chiave

Le parole chiave del linguaggio Python sono:

and del from not while as elif global or with assert else if pass yield break except import print class exec in raise continue finally is return def for lambda try

Lascia un commento

Il tuo indirizzo email non sarà pubblicato. I campi obbligatori sono contrassegnati *