¿Cómo verificar si una variable es un diccionario en Python?

¿Cómo comprobarías si una variable es un diccionario en Python?

Por ejemplo, me gustaría que recorra los valores del diccionario hasta que encuentre un diccionario. Luego, recorre el que encuentra:

dict = {'abc': 'abc', 'def': {'ghi': 'ghi', 'jkl': 'jkl'}}
for k, v in dict.iteritems():
    if ###check if v is a dictionary:
        for k, v in v.iteritems():
            print(k, ' ', v)
    else:
        print(k, ' ', v)

Podrías usar if type(ele) is dicto usar isinstance(ele, dict)cuál funcionaría si hubieras subclasificado dict:

d = {'abc':'abc','def':{'ghi':'ghi','jkl':'jkl'}}
for ele in d.values():
    if isinstance(ele,dict):
       for k, v in ele.items():
           print(k,' ',v)

¿Cómo comprobarías si una variable es un diccionario en Python?

Esta es una excelente pregunta, pero es lamentable que la mayoría de los clientes potenciales de respuesta upvoted con una mala recomendación, type(obj) is dict.

(Tenga en cuenta que tampoco debe usarlo dictcomo un nombre de variable: es el nombre del objeto integrado).

Si está escribiendo código que será importado y utilizado por otros, no presuma que usarán el dict incorporado directamente, lo que hace que su presunción haga que su código sea más inflexible y, en este caso, cree errores fácilmente ocultos que no confundirían el programa .

Sugiero encarecidamente, a los fines de la corrección, la facilidad de mantenimiento y la flexibilidad para los futuros usuarios, que nunca tengan expresiones unidiomáticas menos flexibles en su código cuando haya expresiones idiomáticas más flexibles.

ises una prueba de identidad de objeto . No admite la herencia, no admite ninguna abstracción y no admite la interfaz.

Así que proporcionaré varias opciones que sí.

Herencia de apoyo:

Esta es la primera recomendación que haría, ya que permite a los usuarios para abastecer a sus propias subclase de dict, o una OrderedDict, defaultdicto Counterdesde el módulo de las colecciones:

if isinstance(any_object, dict):

Pero hay opciones aún más flexibles.

Abstracciones de apoyo:

from collections.abc import Mapping

if isinstance(any_object, Mapping):

Esto permite al usuario de su código usar su propia implementación personalizada de una asignación abstracta, que también incluye cualquier subclase de dict, y aún así obtener el comportamiento correcto.

Usa la interfaz

Comúnmente escuchas el consejo de OOP, "programa a una interfaz".

Esta estrategia aprovecha el polimorfismo de Python o la tipificación de patos.

Entonces, solo intente acceder a la interfaz, capturando los errores esperados específicos ( AttributeErroren caso de que no haya .itemsy TypeErroren caso de itemsque no se pueda llamar ) con un respaldo razonable, y ahora cualquier clase que implemente esa interfaz le dará sus elementos (la nota .iteritems()se ha ido en Python 3):

try:
    items = any_object.items()
except (AttributeError, TypeError):
    non_items_behavior(any_object)
else: # no exception raised
    for item in items: ...

Quizás piense que el uso de tipear pato de esta manera va demasiado lejos al permitir demasiados falsos positivos, y puede ser, dependiendo de sus objetivos para este código.

Conclusión

No lo use ispara verificar los tipos de flujo de control estándar. Use isinstance, considere abstracciones como Mappingo MutableMapping, y considere evitar la verificación de tipos por completo, usando la interfaz directamente.

El OP no excluyó la variable inicial, por lo que para completar aquí es cómo manejar el caso genérico de procesar un supuesto diccionario que puede incluir elementos como diccionarios.

También siguiendo la forma recomendada pura de Python (3.8) para probar el diccionario en los comentarios anteriores.

from collections.abc import Mapping

dict = {'abc': 'abc', 'def': {'ghi': 'ghi', 'jkl': 'jkl'}}

def parse_dict(in_dict): 
    if isinstance(in_dict, Mapping):
        for k, v in in_dict.items():
            if isinstance(v, Mapping):
                for k, v in v.items():
                    print(k, v)
            else:
                print(k, v)

parse_dict(dict)