Python: Dizionari (Soluzioni)ΒΆ

  1. Soluzioni:

    1. Soluzione:

      diz_vuoto = {}
      print diz_vuoto
      print len(diz_vuoto)                        # 0
      
    2. Soluzione:

      pronomi = {}
      pronomi[1] = "io"
      pronomi[2] = "tu"
      pronomi[3] = "egli"
      pronomi[4] = "noi"
      pronomi[5] = "voi"
      pronomi[6] = "essi"
      

      oppure:

      pronomi = {
          1: "io", 2: "tu", 3: "egli",
          4: "noi", 5: "voi", 6: "essi",
      }
      
    3. Soluzione:

      decuplo_di = {1: 10, 2: 20, 3: 30, 4: 40, 5: 50}
      
      print [decuplo_di[n] for n in range(2, 5)]
      
      print [decuplo_di[chiave] for chiave in decuplo_di.keys()]
      
    4. Soluzione:

      info_2TMV = {
          "pdb_id": "2TMV",
          "uniprot_id": "P69687 (CAPSD_TMV)",
          "numero_domini_scp": 1,
          "numero_domini_pfam": 1,
      }
      
    5. Soluzione:

      parenti_di = {
          "GIULIA": ["FRANCO", "BENEDETTA"],
          "FRANCO": ["GIULIA", "MATTEO"],
          "MATTEO": ["FRANCO", "BENEDETTA"],
          "BENEDETTA": ["GIULIA", "MATTEO"],
      }
      
      num_parenti_di_giulia = len(parenti_di["GIULIA"])
      print num_parenti_di_giulia
      
    6. Soluzione:

      da_2_bit_a_intero = {
          (0, 0): 0,
          (0, 1): 1,
          (1, 0): 2,
          (1, 1): 3,
      }
      

      Occhio che non posso usare delle liste come chiavi: le liste non sono immutabili!

      Scelgo di stampare il valore corrispondente a 1, 0:

      print da_2_bit_a_intero[(1, 0)]
      #                       ^^^^^^
      #                        tupla
      
  2. Soluzione:

    rapporti = {
        ("A", "T"): 10.0 / 3.0,
        ("A", "C"): 10.0 / 7.0,
        ("A", "G"): 10.0 / 6.0,
        ("T", "C"): 3.0 / 7.0,
        ("T", "G"): 3.0 / 6.0,
        ("C", "G"): 7.0 / 6.0,
    }
    
    
    print len(rapporti)                             # 6
    print len(rapporti.keys())                      # 6
    print len(rapporti.values())                    # 6
    print len(rapporti.items())                     # 6
    # tutti contano il numero di coppie chiave-valore!
    
    
    # stampo le chiavi del dizionario per farmi un'idea
    print rapporti.keys()                           # e' una lista di tuple!
    print type(rapporti.keys())                     # list
    print type(rapporti.keys()[0])                  # tuple
    
    contiene_T_A = ("T", "A") in rapporti.keys()
    print contiene_T_A                              # False
    
    contiene_C_G = ("C", "G") in rapporti.keys()
    print contiene_C_G                              # True
    
    # faccio la stessa cosa con has_key()
    print rapporti.has_key(("T", "A"))              # False
    print rapporti.has_key(("C", "G"))              # True
    
    
    # stampo i valori del dizionario per farmi un'idea
    print rapporti.values()                         # e' una lista di interi!
    print type(rapporti.values()[0])                # int
    
    contiene_2 = 2 in rapporti.values()
    print contiene_2                                # True
    
    contiene_3 = 3 in rapporti.values()
    print contiene_3                                # False
    
    
    # stampo le coppie chiave-valore per farmi un'idea
    print rapporti.items()
    # e' una lista di coppie (tuple): il primo elemento, la chiave, e'
    # una coppia esso stesso, il secondo e' un intero
    
    print (("A", "T"), 2) in rapporti.items()       # True
    print (("C", "G"), 1000) in rapport.items()     # False
    
    
    # le list comprehension sono
    chiavi = [chiave_valore[0]
              for chiave_valore in rapporti.items()]
    valori = [chiave_valore[-1]
              for chiave_valore in rapporti.items()]
    
  3. Soluzione:

    mappa = {
        "zero": 1,
        "uno": 2,
        "due": 4,
        "tre": 8,
        "quattro": 16,
        "cinque": 32,
    }
    
    
    # le chiavi di mappa sono tutte stringhe, quindi keys() mi
    # restituisce una lista di stringhe: posso usare
    # direttamente join()
    stringa_delle_chiavi = " ".join(mappa.keys())
    
    
    # i valori di mappa sono interi, quindi non posso usare
    # join() direttamente: devo prima trasformare tutti i
    # valori da interi a stringhe
    stringa_dei_valori = " ".join(str(valore)
                                  for valore in mappa.values())
    
    
    lista_delle_chiavi = mappa.keys()
    print lista_delle_chiavi                        # non e' ordinata
    
    
    lista_ordinata_delle_chiavi = mappa.keys()
    lista_ordinata_delle_chiavi.sort()
    print lista_ordinata_delle_chiavi               # ora e' ordinata
    
    
    lista_dei_valori_ordinati_per_chiavi = \
        [mappa[chiave] for chiave in lista_ordinata_delle_chiavi]
    
  4. Soluzione:

    # usando una list comprehension posso applicare il dizionario
    # alla lista: qui e' necessario usare lower() *prima* di
    # usare un aminoacido come chiave di traduzione_di!
    traduzione = [traduzione_di[aa.lower()] for aa in lista]
    print traduzione
    
    # a questo punto posso usare join() per concatenare le varie
    # parti
    risultato = " ".join(traduzione)
    print risultato
    

    oppure, in un solo comando:

    print " ".join([traduzione_di[aa.lower()] for aa in lista])