Como verificar se uma variável é um dicionário em Python?

Como você verificaria se uma variável é um dicionário em python?

Por exemplo, eu gostaria que ele repetisse os valores no dicionário até encontrar um dicionário. Em seguida, faça um loop pelo que encontrar:

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)

Você poderia usar if type(ele) is dictou usar o isinstance(ele, dict)que funcionaria se você tivesse subclassificado 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)

Como você verificaria se uma variável é um dicionário em Python?

Essa é uma excelente pergunta, mas é lamentável que a resposta mais votada leve a uma recomendação ruim type(obj) is dict.

(Observe que você também não deve usar dictcomo um nome de variável - é o nome do objeto interno.)

Se você estiver escrevendo um código que será importado e usado por outras pessoas, não presuma que eles usarão o dict diretamente - tornando essa suposição mais flexível e, nesse caso, crie bugs facilmente ocultos que não prejudicariam o programa. .

Eu sugiro fortemente, para fins de correção, manutenção e flexibilidade para usuários futuros, nunca ter expressões unidiomatic menos flexíveis em seu código quando houver expressões idiomáticas mais flexíveis.

isé um teste para a identidade do objeto . Não suporta herança, não suporta abstração e não suporta a interface.

Então, vou fornecer várias opções que o fazem.

Herança de suporte:

Esta é a primeira recomendação gostaria de fazer, porque permite que os usuários forneçam seus próprios subclasse de dict, ou uma OrderedDict, defaultdictou Counterdas coleções módulo:

if isinstance(any_object, dict):

Mas existem opções ainda mais flexíveis.

Abstrações de suporte:

from collections.abc import Mapping

if isinstance(any_object, Mapping):

Isso permite que o usuário do seu código use sua própria implementação personalizada de um mapeamento abstrato, que também inclui qualquer subclasse de dict, e ainda obtenha o comportamento correto.

Use a interface

Você geralmente ouve os conselhos do OOP, "programa para uma interface".

Essa estratégia aproveita o polimorfismo do Python ou a digitação de patos.

Então, basta tentar acessar a interface, pegando os erros específicos esperado ( AttributeErrorno caso, não há .itemse TypeErrorno caso itemsnão é resgatável) com um fallback razoável - e agora qualquer classe que implementa essa interface vai lhe dar os seus itens (nota .iteritems()é ido em Python 3):

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

Talvez você pense que usar a digitação de pato dessa maneira vá longe demais ao permitir muitos falsos positivos, e pode ser, dependendo dos seus objetivos para este código.

Conclusão

Não use ispara verificar os tipos quanto ao fluxo de controle padrão. Use isinstance, considere abstrações como Mappingou MutableMappinge evite a verificação de tipo completamente, usando a interface diretamente.

O OP não excluiu a variável inicial, portanto, para completar, veja como lidar com o caso genérico de processar um suposto dicionário que pode incluir itens como dicionários.

Também seguindo a maneira recomendada pura de Python (3.8) para testar o dicionário nos comentários acima.

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)