Como vejo o tipo de uma variável, seja ela sem assinatura de 32 bits, com assinatura de 16 bits, etc.?

Como eu o vejo?

Use a type()função interna:

>>> i = 123
>>> type(i)
<type 'int'>
>>> type(i) is int
True
>>> i = 123.456
>>> type(i)
<type 'float'>
>>> type(i) is float
True

Para verificar se uma variável é de um determinado tipo, use isinstance:

>>> i = 123
>>> isinstance(i, int)
True
>>> isinstance(i, (float, str, set, dict))
False

Observe que o Python não possui os mesmos tipos de C / C ++, o que parece ser sua pergunta.

Você pode estar procurando a função interna .type()

Veja os exemplos abaixo, mas não há tipo "não assinado" no Python, assim como Java.

Número inteiro positivo:

>>> v = 10
>>> type(v)
<type 'int'>

Inteiro positivo grande :

>>> v = 100000000000000
>>> type(v)
<type 'long'>

Número inteiro negativo:

>>> v = -10
>>> type(v)
<type 'int'>

Sequência literal de caracteres:

>>> v = 'hi'
>>> type(v)
<type 'str'>

Inteiro de ponto flutuante:

>>> v = 3.14159
>>> type(v)
<type 'float'>

É tão simples. Você faz assim.

print(type(variable_name))

Como determinar o tipo de variável em Python?

Então, se você tem uma variável, por exemplo:

one = 1

Você quer saber o seu tipo?

Existem maneiras certas e erradas de fazer praticamente tudo em Python. Aqui está o caminho certo:

Usar type

>>> type(one)
<type 'int'>

Você pode usar o __name__atributo para obter o nome do objeto. (Esse é um dos poucos atributos especiais que você precisa usar __dunder__para obter o nome - não há nem um método para ele no inspectmódulo.)

>>> type(one).__name__
'int'

Não use __class__

No Python, os nomes que começam com sublinhados semanticamente não fazem parte da API pública e é uma prática recomendada para os usuários evitar usá-los. (Exceto quando for absolutamente necessário.)

Como typenos dá a classe do objeto, devemos evitar obtê-lo diretamente. :

>>> one.__class__

Geralmente, essa é a primeira ideia que as pessoas têm ao acessar o tipo de um objeto em um método - elas já estão procurando atributos, portanto, o tipo parece estranho. Por exemplo:

class Foo(object):
    def foo(self):
        self.__class__

Não. Em vez disso, digite (self):

class Foo(object):
    def foo(self):
        type(self)

Detalhes de implementação de entradas e flutuadores

Como vejo o tipo de uma variável, seja ela sem assinatura de 32 bits, com assinatura de 16 bits, etc.?

No Python, essas especificidades são detalhes de implementação. Portanto, em geral, geralmente não nos preocupamos com isso no Python. No entanto, para saciar sua curiosidade ...

No Python 2, int geralmente é um número inteiro assinado igual à largura da palavra da implementação (limitada pelo sistema). É geralmente implementado como um longa em C . Quando os números inteiros ficam maiores que isso, geralmente os convertemos para Python longs (com precisão ilimitada, para não confundir com C longs).

Por exemplo, em um Python 2 de 32 bits, podemos deduzir que int é um inteiro assinado de 32 bits:

>>> import sys

>>> format(sys.maxint, '032b')
'01111111111111111111111111111111'
>>> format(-sys.maxint - 1, '032b') # minimum value, see docs.
'-10000000000000000000000000000000'

No Python 3, o antigo int desaparece, e nós apenas usamos (do Python) desde int, que tem precisão ilimitada.

Também podemos obter algumas informações sobre os carros alegóricos do Python, que geralmente são implementados como um duplo em C:

>>> sys.float_info
sys.floatinfo(max=1.7976931348623157e+308, max_exp=1024, max_10_exp=308, 
min=2.2250738585072014e-308, min_exp=-1021, min_10_exp=-307, dig=15, 
mant_dig=53, epsilon=2.2204460492503131e-16, radix=2, rounds=1)

Conclusão

Não use __class__, uma API semanticamente não pública, para obter o tipo de uma variável. Use em typevez disso.

E não se preocupe muito com os detalhes de implementação do Python. Eu não tive que lidar com problemas em torno disso sozinho. Você provavelmente também não, e se realmente o fizer, deve saber o suficiente para não procurar nesta resposta o que fazer.

print type(variable_name)

Eu também recomendo o interpretador interativo IPython ao lidar com perguntas como esta. Ele permite digitar variable_name?e retornará uma lista completa de informações sobre o objeto, incluindo o tipo e a sequência de documentos para o tipo.

por exemplo

In [9]: var = 123

In [10]: var?
Type:       int
Base Class: <type 'int'>
String Form:    123
Namespace:  Interactive
Docstring:
    int(x[, base]) -> integer

Converta uma sequência ou número em um número inteiro, se possível. Um argumento de ponto flutuante será truncado em direção a zero (isso não inclui uma representação de string de um número de ponto flutuante!) Ao converter uma string, use a base opcional. É um erro fornecer uma base ao converter uma não-string. Se o argumento estiver fora do intervalo inteiro, um objeto longo será retornado.

a = "cool"
type(a)

//result 'str'
<class 'str'>
or 
do 
`dir(a)` 
to see the list of inbuilt methods you can have on the variable.

Mais uma maneira de usar __class__:

>>> a = [1, 2, 3, 4]
>>> a.__class__
<type 'list'>
>>> b = {'key1': 'val1'}
>>> b.__class__
<type 'dict'>
>>> c = 12
>>> c.__class__
<type 'int'>

Exemplos de verificação de tipo simples no Python:

assert type(variable_name) == int

assert type(variable_name) == bool

assert type(variable_name) == list

Pode ser pouco irrelevante. mas você pode verificar os tipos de um objeto isinstance(object, type)como mencionado aqui .

A pergunta é um tanto ambígua - não sei ao certo o que você quer dizer com "visualizar". Se você está tentando consultar o tipo de um objeto Python nativo, a resposta do @atzz o direcionará na direção certa.

No entanto, se você estiver tentando gerar objetos Python que tenham a semântica de tipos C primitivos (como uint32_t, int16_t), use o structmódulo Você pode determinar o número de bits em uma dada primitiva do tipo C da seguinte maneira:

>>> struct.calcsize('c') # char
1
>>> struct.calcsize('h') # short
2
>>> struct.calcsize('i') # int
4
>>> struct.calcsize('l') # long
4

Isso também se reflete no arraymódulo, que pode criar matrizes desses tipos de nível inferior:

>>> array.array('c').itemsize # char
1

O número máximo máximo suportado (Python 2 int) é dado por sys.maxint .

>>> import sys, math
>>> math.ceil(math.log(sys.maxint, 2)) + 1 # Signedness
32.0

Há também sys.getsizeof , que retorna o tamanho real do objeto Python na memória residual:

>>> a = 5
>>> sys.getsizeof(a) # Residual memory.
12

Para dados flutuantes e dados de precisão, use sys.float_info :

>>> sys.float_info
sys.floatinfo(max=1.7976931348623157e+308, max_exp=1024, max_10_exp=308, min=2.2250738585072014e-308, min_exp=-1021, min_10_exp=-307, dig=15, mant_dig=53, epsilon=2.2204460492503131e-16, radix=2, rounds=1)

Você quer dizer em Python ou usando ctypes ?

No primeiro caso, você simplesmente não pode - porque o Python não possui números inteiros de 16/32 bits assinados / não assinados.

No segundo caso, você pode usar type():

>>> import ctypes
>>> a = ctypes.c_uint() # unsigned int
>>> type(a)
<class 'ctypes.c_ulong'>

Para obter mais referências sobre ctypes e seu tipo, consulte a documentação oficial .

Python não possui esses tipos que você descreve. Existem dois tipos usados ​​para representar valores integrais:, intque corresponde ao tipo int da plataforma em C e long, que é um número inteiro de precisão arbitrário (ou seja, cresce conforme necessário e não possui um limite superior). ints são convertidos silenciosamente para longse uma expressão produzir resultado no qual não possa ser armazenado int.

Simples, para python 3.4 e superior

print (type(variable_name))

Python 2.7 e superior

print type(variable_name)

Realmente depende de qual nível você quer dizer. No Python 2.x, existem dois tipos de números inteiros int(restritos a sys.maxint) e long(precisão ilimitada), por razões históricas. No código Python, isso não deve fazer muita diferença, porque o intérprete é convertido automaticamente em longo quando um número é muito grande. Se você deseja saber sobre os tipos de dados reais usados ​​no interpretador subjacente, isso depende da implementação. (Os CPython estão localizados em Objects / intobject.c e Objects / longobject.c.) Para saber mais sobre os tipos de sistemas, consulte a resposta do cdleary para usar o módulo struct.

Para python2.x, use

print type(variable_name)

Para python3.x, use

print(type(variable_name))

Não faça isso. Pedir o tipo de algo é errado por si só. Em vez disso, use polimorfismo. Encontre ou, se necessário, defina por si mesmo o método que faz o que você deseja para qualquer tipo de entrada possível e chame-o sem perguntar nada. Se você precisar trabalhar com tipos internos ou definidos por uma biblioteca de terceiros, sempre poderá herdar deles e usar seus próprios derivados. Ou você pode envolvê-los em sua própria classe. Essa é a maneira orientada a objetos para resolver esses problemas.

Se você insistir em verificar o tipo exato e colocar alguns ifs sujos aqui e ali, poderá usar a __class__propriedade ou a typefunção para fazê-lo, mas em breve você estará atualizando todos esses ifs com casos adicionais a cada dois ou três commits. Fazer isso da maneira OO evita isso e permite definir apenas uma nova classe para um novo tipo de entrada.