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?
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?
Respostas:
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'>
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:
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 inspect
módulo.)
>>> type(one).__name__
'int'
__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 type
nos 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)
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)
Não use __class__
, uma API semanticamente não pública, para obter o tipo de uma variável. Use em type
vez 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.
<type instance>
mas __class__
dá email.message.Message
- o que estou fazendo de errado?
object
?
import email
não usando classes de minha própria invenção.
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.
print type(str)
retorna um erro no Python 3.6. Usetype(str)
print(type(str))
print type(var)
código incorreto.
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'>
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 struct
mó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 array
mó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:, int
que 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). int
s são convertidos silenciosamente para long
se uma expressão produzir resultado no qual não possa ser armazenado int
.
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 if
s sujos aqui e ali, poderá usar a __class__
propriedade ou a type
função para fazê-lo, mas em breve você estará atualizando todos esses if
s 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.