Dizionari

Una delle strutture dati più utili che offre Python sono i 'dizionari'. Essi possono essere immaginati come Liste indicizzate non da numeri interi che partono da 0, ma indicizzate da oggetti non modificabili. Ciò implica che possiamo indicizzarle con numeri, stringhe e tuple! Possiamo quindi immaginarle come associazioni di chiave:valore (key:value). I dizionari vengono definiti e inizializzati con le parentesi graffe. Per esempio

>>> d={} # define empty dictionary
>>> type(d)
<type 'dictionary'>
>>> d
{}
>>> d={'key1':23, 'key2':13.01} # redefine the dictionary
>>> d
{'key1': 23, 'key2': 13.01}

Esistono poi alcune funzioni particolarmente importanti che permettono di estrarre le chiavi, i valori o entrambi da un dizionario

>>> d.keys() # return the list of the keys
['key1', 'key2']
>>> d.values() # return the list of the values
[23, 13.01]
>>> d.items()  #  return the list of tuples (key,value)
[('key1', 23), ('key2', 13.01)]
>>>

Un elemento del dizionario può essere eliminato con la funzione del e una nuova coppia chiave/valore può essere ottenuta utilizzando il nome del dizionario e le parentesi quadre, come negli esempi

>>> d # content
{'key1': 23, 'key2': 13.01}
>>> d[(1,3)]=[1,2,3] # new item
>>> d # content
{(1, 3): [1, 2, 3], 'key1': 23, 'key2': 13.01}
>>> d['key2'] # the element whose keys is 'key2'
13.01
>>> del d['key2'] # delete element whose keys is 'key2
>>> d # content
{(1, 3): [1, 2, 3], 'key1': 23}
>>> d[(1,3)]='substitute' # overwrite element
>>> d
{(1, 3): 'substitute', 'key1': 23}

Si potrebbe inoltre avere bisogno di sapere se un elemento appartine alle chiavi di un dizionario. Esistono due modi

>>> 'key1' in d.keys() # usual way
1
>>> 'xxx' in d.keys() # usual way
0
>>> d.has_key('key1') # using the method has_key
1
>>> d.has_key('xxx') # using the method has_key
0

Esiste inoltre una comoda funzione che ritorna l'elemento indicizzato da una chiave oppure se la chiave richiesta non esiste, ritorna un'alternativa come possiamo verificare dall'esempio seguente

>>> freq={'a':0.35, 'c':0.15, 'g':0.20, 't':0.30}
>>> freq['a']
0.34999999999999998
>>> freq.get('a')
0.34999999999999998
>>> freq['u']
Traceback (most recent call last):
  File "<stdin>", line 1, in ?
KeyError: u
>>> freq.get('u','unknown')
'unknown'

In quest'ultimo caso abbiamo utilizzato la restituzione alternativa.

Un dizionario diviene la struttura più adatta per esempio per la conversione da un codice ad un altro, come nel caso del codice genetico oppure la rappresentazione a 3 lettere o ad una lettera degli amminoacidi. In quest'ultimo caso per esempio potremmo definire il dizionario che ha come chiavi il codice a 3 lettere e come valore quello ad una lettera usando il dizionario three2one

>>> three2one = {"GLY" : "G", "ALA" : "A", "LEU" : "L", "ILE" : "I",
...                  "ARG" : "R", "LYS" : "K", "MET" : "M", "CYS" : "C",
...                  "TYR" : "Y", "THR" : "T", "PRO" : "P", "SER" : "S",
...                  "TRP" : "W", "ASP" : "D", "GLU" : "E", "ASN" : "N",
...                  "GLN" : "Q", "PHE" : "F", "HIS" : "H", "VAL" : "V"}
>>> three2one
{'TYR': 'Y', 'GLU': 'E', 'ASP': 'D', 'TRP': 'W', 'HIS': 'H', 
'ARG': 'R', 'LEU': 'L', 'MET': 'M', 'ALA': 'A', 'GLY': 'G', 
'THR': 'T', 'ASN': 'N', 'PHE': 'F', 'PRO': 'P', 'VAL': 'V', 
'LYS': 'K', 'GLN': 'Q', 'SER': 'S', 'ILE': 'I', 'CYS': 'C'}
>>> three2one['THR']
'T'

e generare automaticamente il dizionario inverso one2three nel modo seguente

>>> one2three={}
>>> for (k,v) in three2one.items():
...    one2three[v]=k
... 
>>> one2three
{'Y': 'TYR', 'V': 'VAL', 'W': 'TRP', 'T': 'THR', 'R': 'ARG', 
'S': 'SER', 'P': 'PRO', 'Q': 'GLN', 'N': 'ASN', 'L': 'LEU', 
'M': 'MET', 'K': 'LYS', 'H': 'HIS', 'I': 'ILE', 'F': 'PHE', 
'G': 'GLY', 'D': 'ASP', 'E': 'GLU', 'C': 'CYS', 'A': 'ALA'}
>>> one2three['T']
'THR'
>>>

Per poter utilizzare in modo generale three2one potremmo scrivere una funzione a3_to_a1(seq) su di un file (a3a1.py)

''' filename is a3a1.py '''
def a3_to_a1(seq):
    """ translate a protein sequence from 3 to 1 letter code
    """
    three2one = {"GLY" : "G", "ALA" : "A", "LEU" : "L", "ILE" : "I",
                 "ARG" : "R", "LYS" : "K", "MET" : "M", "CYS" : "C",
                 "TYR" : "Y", "THR" : "T", "PRO" : "P", "SER" : "S",
                 "TRP" : "W", "ASP" : "D", "GLU" : "E", "ASN" : "N",
                 "GLN" : "Q", "PHE" : "F", "HIS" : "H", "VAL" : "V"}

    newseq = ""
    for aa in seq.split():
        newseq += three2one.get(aa, "x") # not found return 'x'
    return newseq

che permette di tradurre una sequenza nel formato a 3 lettere in quella ad una lettera come

>>> from a3a1 import * # from module import everything
>>> import a3a1 # import module
>>> chain = 'ALA ALA  SER THR CYS UNK '
>>> a3_to_a1(chain) 
'AASTCx'
>>> a3a1.a3_to_a1(chain)
'AASTCx'