Existe uma maneira simples de determinar se uma variável é uma lista, dicionário ou outra coisa? Estou recebendo um objeto de volta que pode ser do tipo e preciso saber a diferença.

Existem duas funções internas que ajudam a identificar o tipo de um objeto. Você pode usar type() se precisar o tipo exato de um objeto, e isinstance()para verificar o tipo de um objeto contra alguma coisa. Geralmente, você deseja usar na isistance()maioria das vezes, uma vez que é muito robusto e também suporta herança de tipo.

Para obter o tipo real de um objeto, use a type()função interna. Passar um objeto como o único parâmetro retornará o objeto de tipo desse objeto:

>>> type([]) is list
True
>>> type({}) is dict
True
>>> type('') is str
True
>>> type(0) is int
True

Obviamente, isso também funciona para tipos personalizados:

>>> class Test1 (object):
        pass
>>> class Test2 (Test1):
        pass
>>> a = Test1()
>>> b = Test2()
>>> type(a) is Test1
True
>>> type(b) is Test2
True

Observe que type()retornará apenas o tipo imediato do objeto, mas não poderá informar sobre a herança do tipo.

>>> type(b) is Test1
False

Para cobrir isso, você deve usar a isinstancefunção Obviamente, isso também funciona para tipos internos:

>>> isinstance(b, Test1)
True
>>> isinstance(b, Test2)
True
>>> isinstance(a, Test1)
True
>>> isinstance(a, Test2)
False
>>> isinstance([], list)
True
>>> isinstance({}, dict)
True

isinstance()geralmente é a maneira preferida de garantir o tipo de um objeto, porque ele também aceita tipos derivados. Portanto, a menos que você realmente precise do objeto de texto (por qualquer motivo), o uso isinstance()é preferível type().

O segundo parâmetro de isinstance()também aceita uma tupla de tipos, portanto, é possível verificar vários tipos de uma só vez. isinstanceretornará true, se o objeto for de um desses tipos:

>>> isinstance([], (tuple, list, set))
True

Você pode fazer isso usando type():

>>> a = []
>>> type(a)
<type 'list'>
>>> f = ()
>>> type(f)
<type 'tuple'>

Pode ser mais Pythonic usar um bloco try... exceptDessa forma, se você tem uma classe que grasna como uma lista, ou grasna como um dicionário, ele irá se comportar corretamente, independentemente do que seu tipo realmente é.

Para esclarecer, o método preferido de "dizer a diferença" entre os tipos de variáveis ​​é com algo chamado tipagem de pato : desde que os métodos (e tipos de retorno) aos quais uma variável responde sejam o que sua sub-rotina espera, trate-a como o esperado. ser estar. Por exemplo, se você tem uma classe que sobrecarrega os operadores de colchete com getattre setattr, mas usa algum esquema interno engraçado, seria apropriado que ele se comporte como um dicionário, se é isso que ele está tentando imitar.

O outro problema com a type(A) is type(B)verificação é que, se Afor uma subclasse de B, ela avalia falsequando, programaticamente, você esperaria que fosse true. Se um objeto é uma subclasse de uma lista, ele deve funcionar como uma lista: a verificação do tipo apresentado na outra resposta impedirá isso. ( isinstancefuncionará, no entanto).

Nas instâncias do objeto, você também tem o:

__class__

atributo. Aqui está um exemplo retirado do console do Python 3.3

>>> str = "str"
>>> str.__class__
<class 'str'>
>>> i = 2
>>> i.__class__
<class 'int'>
>>> class Test():
...     pass
...
>>> a = Test()
>>> a.__class__
<class '__main__.Test'>

Observe que no python 3.xe nas classes New-Style (disponíveis opcionalmente no Python 2.6) a classe e o tipo foram mesclados e isso pode levar a resultados inesperados. Principalmente por esse motivo, minha maneira favorita de testar tipos / classes é a função integrada da instância .

Determinar o tipo de um objeto Python

Determine o tipo de um objeto com type

>>> obj = object()
>>> type(obj)
<class 'object'>

Embora funcione, evite atributos de sublinhado duplo como __class__- eles não são semanticamente públicos e, embora talvez não seja o caso, as funções internas geralmente têm um comportamento melhor.

>>> obj.__class__ # avoid this!
<class 'object'>

verificação de tipo

Existe uma maneira simples de determinar se uma variável é uma lista, dicionário ou outra coisa? Estou recebendo um objeto de volta que pode ser do tipo e preciso saber a diferença.

Bem, essa é uma pergunta diferente, não use type - use isinstance:

def foo(obj):
    """given a string with items separated by spaces, 
    or a list or tuple, 
    do something sensible
    """
    if isinstance(obj, str):
        obj = str.split()
    return _foo_handles_only_lists_or_tuples(obj)

Isso cobre o caso em que o usuário pode estar fazendo algo inteligente ou sensível ao subclassificar str- de acordo com o princípio da Substituição de Liskov, você deseja usar instâncias de subclasse sem quebrar seu código - e isinstancesuporta isso.

Usar abstrações

Ainda melhor, você pode procurar uma Classe Base Abstrata específica de collectionsou numbers:

from collections import Iterable
from numbers import Number

def bar(obj):
    """does something sensible with an iterable of numbers, 
    or just one number
    """
    if isinstance(obj, Number): # make it a 1-tuple
        obj = (obj,)
    if not isinstance(obj, Iterable):
        raise TypeError('obj must be either a number or iterable of numbers')
    return _bar_sensible_with_iterable(obj)

Ou simplesmente não verifique explicitamente o tipo

Ou, talvez o melhor de tudo, use digitação de pato e não verifique explicitamente seu código. A digitação de pato suporta a substituição de Liskov com mais elegância e menos verbosidade.

def baz(obj):
    """given an obj, a dict (or anything with an .items method) 
    do something sensible with each key-value pair
    """
    for key, value in obj.items():
        _baz_something_sensible(key, value)

Conclusão

• Use typepara realmente obter a classe de uma instância.
• Use isinstancepara verificar explicitamente subclasses reais ou abstrações registradas.
• E evite a verificação de tipo onde faz sentido.

Você pode usar type()ou isinstance().

>>> type([]) is list
True

Esteja avisado de que você pode refogar listou qualquer outro tipo atribuindo uma variável no escopo atual do mesmo nome.

>>> the_d = {}
>>> t = lambda x: "aight" if type(x) is dict else "NOPE"
>>> t(the_d) 'aight'
>>> dict = "dude."
>>> t(the_d) 'NOPE'

Acima, vemos que dicté reatribuído a uma string, portanto, o teste:

type({}) is dict

... falha.

Para contornar isso e usar com type()mais cautela:

>>> import __builtin__
>>> the_d = {}
>>> type({}) is dict
True
>>> dict =""
>>> type({}) is dict
False
>>> type({}) is __builtin__.dict
True

Embora as perguntas sejam bastante antigas, eu me deparei com isso enquanto descobria uma maneira adequada, e acho que ainda precisa ser esclarecida, pelo menos para o Python 2.x (não checou o Python 3, mas como o problema surge com as classes clássicas que foram lançadas nessa versão, provavelmente não importa).

Aqui, estou tentando responder à pergunta do título: como posso determinar o tipo de um objeto arbitrário ? Outras sugestões sobre o uso ou não do isinstance são boas em muitos comentários e respostas, mas não estou abordando essas preocupações.

O principal problema da type()abordagem é que ela não funciona corretamente com instâncias de estilo antigo :

class One:
    pass

class Two:
    pass


o = One()
t = Two()

o_type = type(o)
t_type = type(t)

print "Are o and t instances of the same class?", o_type is t_type

A execução desse snippet renderia:

Are o and t instances of the same class? True

O que, argumento, não é o que a maioria das pessoas esperaria.

A __class__abordagem é a mais próxima da correção, mas não funcionará em um caso crucial: quando o objeto passado é uma classe de estilo antigo (não uma instância!), Pois esses objetos não possuem esse atributo.

Este é o menor trecho de código que eu poderia pensar que satisfaz essa pergunta legítima de uma maneira consistente:

#!/usr/bin/env python
from types import ClassType
#we adopt the null object pattern in the (unlikely) case
#that __class__ is None for some strange reason
_NO_CLASS=object()
def get_object_type(obj):
    obj_type = getattr(obj, "__class__", _NO_CLASS)
    if obj_type is not _NO_CLASS:
        return obj_type
    # AFAIK the only situation where this happens is an old-style class
    obj_type = type(obj)
    if obj_type is not ClassType:
        raise ValueError("Could not determine object '{}' type.".format(obj_type))
    return obj_type

tenha cuidado usando isinstance

isinstance(True, bool)
True
>>> isinstance(True, int)
True

mas digite

type(True) == bool
True
>>> type(True) == int
False

Como um aparte das respostas anteriores, vale a pena mencionar a existência, collections.abcque contém várias classes básicas abstratas (ABCs) que complementam a digitação de patos.

Por exemplo, em vez de verificar explicitamente se algo é uma lista com:

isinstance(my_obj, list)

você poderia, se estiver interessado apenas em ver se o objeto que você possui permite obter itens, use collections.abc.Sequence:

from collections.abc import Sequence
isinstance(my_obj, Sequence) 

se você estiver estritamente interessado em objetos que permitem obter, configurar e excluir itens (por exemplo, seqüências mutáveis ), você optaria collections.abc.MutableSequence.

Muitos outros ABCs são definidas lá, Mappingpara objetos que podem ser usados como mapas, Iterable, Callable, et cetera. Uma lista completa de tudo isso pode ser vista na documentação para collections.abc.

Em geral, você pode extrair uma string do objeto com o nome da classe,

str_class = object.__class__.__name__

e usá-lo para comparação,

if str_class == 'dict':
    # blablabla..
elif str_class == 'customclass':
    # blebleble..

Em muitos casos práticos, em vez de usar typeou isinstancevocê também pode usar @functools.singledispatch, que é usado para definir funções genéricas ( função composta de várias funções implementando a mesma operação para tipos diferentes ).

Em outras palavras, você gostaria de usá-lo quando tiver um código como o seguinte:

def do_something(arg):
    if isinstance(arg, int):
        ... # some code specific to processing integers
    if isinstance(arg, str):
        ... # some code specific to processing strings
    if isinstance(arg, list):
        ... # some code specific to processing lists
    ...  # etc

Aqui está um pequeno exemplo de como funciona:

from functools import singledispatch


@singledispatch
def say_type(arg):
    raise NotImplementedError(f"I don't work with {type(arg)}")


@say_type.register
def _(arg: int):
    print(f"{arg} is an integer")


@say_type.register
def _(arg: bool):
    print(f"{arg} is a boolean")

>>> say_type(0)
0 is an integer
>>> say_type(False)
False is a boolean
>>> say_type(dict())
# long error traceback ending with:
NotImplementedError: I don't work with <class 'dict'>

Adicionalmente, podemos usar classes abstratas para cobrir vários tipos de uma só vez:

from collections.abc import Sequence


@say_type.register
def _(arg: Sequence):
    print(f"{arg} is a sequence!")

>>> say_type([0, 1, 2])
[0, 1, 2] is a sequence!
>>> say_type((1, 2, 3))
(1, 2, 3) is a sequence!

type()é uma solução melhor do que isinstance(), especialmente para booleans:

Truee Falsesão apenas palavras-chave que significam 1e 0em python. Portanto,

isinstance(True, int)

e

isinstance(False, int)

ambos retornam True. Ambos os booleanos são uma instância de um número inteiro. type(), no entanto, é mais inteligente:

type(True) == int

retorna False.