Come stampare un dizionario riga per riga in Python?

Questo è il dizionario

cars = {'A':{'speed':70,
        'color':2},
        'B':{'speed':60,
        'color':3}}

Usando questo for loop

for keys,values in cars.items():
    print(keys)
    print(values)

Stampa quanto segue:

B
{'color': 3, 'speed': 60}
A
{'color': 2, 'speed': 70}

Ma voglio che il programma lo stampi in questo modo:

B
color : 3
speed : 60
A
color : 2
speed : 70

Ho appena iniziato a studiare dizionari, quindi non sono sicuro di come farlo.

for x in cars:
    print (x)
    for y in cars[x]:
        print (y,':',cars[x][y])

produzione:

A
color : 2
speed : 70
B
color : 3
speed : 60

È possibile utilizzare il jsonmodulo per questo. La dumpsfunzione in questo modulo converte un oggetto JSON in una stringa correttamente formattata che è quindi possibile stampare.

import json

cars = {'A':{'speed':70, 'color':2},
        'B':{'speed':60, 'color':3}}

print(json.dumps(cars, indent = 4))

L'output è simile

{
    "A": {
        "colore": 2,
        "velocità": 70
    },
    "B": {
        "colore": 3,
        "velocità": 60
    }
}

La documentazione specifica anche un mucchio di opzioni utili per questo metodo.

Una soluzione più generalizzata che gestisce elenchi e elenchi nidificati in modo arbitrario sarebbe:

def dumpclean(obj):
    if isinstance(obj, dict):
        for k, v in obj.items():
            if hasattr(v, '__iter__'):
                print k
                dumpclean(v)
            else:
                print '%s : %s' % (k, v)
    elif isinstance(obj, list):
        for v in obj:
            if hasattr(v, '__iter__'):
                dumpclean(v)
            else:
                print v
    else:
        print obj

Questo produce l'output:

A
color : 2
speed : 70
B
color : 3
speed : 60

Mi sono imbattuto in un'esigenza simile e ho sviluppato una funzione più solida come esercizio per me stesso. Lo sto includendo qui nel caso in cui possa essere utile per un altro. Nell'esecuzione di nosetest, ho anche trovato utile poter specificare il flusso di output nella chiamata in modo da poter utilizzare sys.stderr.

import sys

def dump(obj, nested_level=0, output=sys.stdout):
    spacing = '   '
    if isinstance(obj, dict):
        print >> output, '%s{' % ((nested_level) * spacing)
        for k, v in obj.items():
            if hasattr(v, '__iter__'):
                print >> output, '%s%s:' % ((nested_level + 1) * spacing, k)
                dump(v, nested_level + 1, output)
            else:
                print >> output, '%s%s: %s' % ((nested_level + 1) * spacing, k, v)
        print >> output, '%s}' % (nested_level * spacing)
    elif isinstance(obj, list):
        print >> output, '%s[' % ((nested_level) * spacing)
        for v in obj:
            if hasattr(v, '__iter__'):
                dump(v, nested_level + 1, output)
            else:
                print >> output, '%s%s' % ((nested_level + 1) * spacing, v)
        print >> output, '%s]' % ((nested_level) * spacing)
    else:
        print >> output, '%s%s' % (nested_level * spacing, obj)

Usando questa funzione, l'output dell'OP è simile al seguente:

{
   A:
   {
      color: 2
      speed: 70
   }
   B:
   {
      color: 3
      speed: 60
   }
}

che ho trovato personalmente più utile e descrittivo.

Dato l'esempio leggermente meno banale di:

{"test": [{1:3}], "test2":[(1,2),(3,4)],"test3": {(1,2):['abc', 'def', 'ghi'],(4,5):'def'}}

La soluzione richiesta dall'OP produce questo:

test
1 : 3
test3
(1, 2)
abc
def
ghi
(4, 5) : def
test2
(1, 2)
(3, 4)

mentre la versione "migliorata" produce questo:

{
   test:
   [
      {
         1: 3
      }
   ]
   test3:
   {
      (1, 2):
      [
         abc
         def
         ghi
      ]
      (4, 5): def
   }
   test2:
   [
      (1, 2)
      (3, 4)
   ]
}

Spero che questo offra un valore alla prossima persona che cerca questo tipo di funzionalità.

Hai una struttura nidificata, quindi devi anche formattare il dizionario nidificato:

for key, car in cars.items():
    print(key)
    for attribute, value in car.items():
        print('{} : {}'.format(attribute, value))

Questo stampa:

A
color : 2
speed : 70
B
color : 3
speed : 60

pprint.pprint() è un buon strumento per questo lavoro:

>>> import pprint
>>> cars = {'A':{'speed':70,
...         'color':2},
...         'B':{'speed':60,
...         'color':3}}
>>> pprint.pprint(cars, width=1)
{'A': {'color': 2,
       'speed': 70},
 'B': {'color': 3,
       'speed': 60}}

for car,info in cars.items():
    print(car)
    for key,value in info.items():
        print(key, ":", value)

Funzionerà se sai che l'albero ha solo due livelli:

for k1 in cars:
    print(k1)
    d = cars[k1]
    for k2 in d
        print(k2, ':', d[k2])

Controllare il seguente one-liner:

print('\n'.join("%s\n%s" % (key1,('\n'.join("%s : %r" % (key2,val2) for (key2,val2) in val1.items()))) for (key1,val1) in cars.items()))

Produzione:

A
speed : 70
color : 2
B
speed : 60
color : 3

Preferisco la formattazione pulita di yaml:

import yaml
yaml.dump(cars)

produzione:

A:
  color: 2
  speed: 70
B:
  color: 3
  speed: 60

###newbie exact answer desired (Python v3):
###=================================
"""
cars = {'A':{'speed':70,
        'color':2},
        'B':{'speed':60,
        'color':3}}
"""

for keys, values in  reversed(sorted(cars.items())):
    print(keys)
    for keys,values in sorted(values.items()):
        print(keys," : ", values)

"""
Output:
B
color  :  3
speed  :  60
A
color  :  2
speed  :  70

##[Finished in 0.073s]
"""

# Declare and Initialize Map
map = {}

map ["New"] = 1
map ["to"] = 1
map ["Python"] = 5
map ["or"] = 2

# Print Statement
for i in map:
  print ("", i, ":", map[i])

#  New : 1
#  to : 1
#  Python : 5
#  or : 2

Ecco la mia soluzione al problema. Penso che sia simile nell'approccio, ma un po 'più semplice di alcune delle altre risposte. Permette anche un numero arbitrario di sotto-dizionari e sembra funzionare per qualsiasi tipo di dati (l'ho persino testato su un dizionario che aveva funzioni come valori):

def pprint(web, level):
    for k,v in web.items():
        if isinstance(v, dict):
            print('\t'*level, f'{k}: ')
            level += 1
            pprint(v, level)
            level -= 1
        else:
            print('\t'*level, k, ": ", v)

Modifica del codice MrWonderful

import sys

def print_dictionary(obj, ident):
    if type(obj) == dict:
        for k, v in obj.items():
            sys.stdout.write(ident)
            if hasattr(v, '__iter__'):
                print k
                print_dictionary(v, ident + '  ')
            else:
                print '%s : %s' % (k, v)
    elif type(obj) == list:
        for v in obj:
            sys.stdout.write(ident)
            if hasattr(v, '__iter__'):
                print_dictionary(v, ident + '  ')
            else:
                print v
    else:
        print obj