Comment puis-je voir le type d'une variable, qu'elle soit non signée 32 bits, signée 16 bits, etc.?

Comment le voir?

Utilisez la type()fonction intégrée:

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

Pour vérifier si une variable est d'un type donné, utilisez isinstance:

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

Notez que Python n'a pas les mêmes types que C / C ++, ce qui semble être votre question.

Vous recherchez peut-être la fonction intégrée .type()

Voir les exemples ci-dessous, mais il n'y a pas de type "non signé" en Python comme Java.

Entier positif:

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

Grand entier positif:

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

Entier négatif:

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

Séquence littérale de caractères:

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

Entier à virgule flottante:

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

C'est tellement simple. Vous le faites comme ça.

print(type(variable_name))

Comment déterminer le type de variable en Python?

Donc, si vous avez une variable, par exemple:

one = 1

Vous voulez connaître son type?

Il existe de bonnes et de mauvaises façons de faire à peu près tout en Python. Voici la bonne façon:

Utilisation type

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

Vous pouvez utiliser l' __name__attribut pour obtenir le nom de l'objet. (C'est l'un des rares attributs spéciaux dont vous avez besoin pour utiliser le __dunder__nom - il n'y a même pas de méthode pour cela dans le inspectmodule.)

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

Ne pas utiliser __class__

En Python, les noms commençant par des traits de soulignement ne font pas sémantiquement partie de l'API publique, et il est recommandé aux utilisateurs d'éviter de les utiliser. (Sauf lorsque cela est absolument nécessaire.)

Puisque typenous donne la classe de l'objet, nous devons éviter de l'obtenir directement. :

>>> one.__class__

C'est généralement la première idée que les gens ont lorsqu'ils accèdent au type d'un objet dans une méthode - ils recherchent déjà des attributs, donc le type semble bizarre. Par exemple:

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

Non. Au lieu de cela, tapez (self):

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

Détails d'implémentation des entiers et flotteurs

Comment puis-je voir le type d'une variable, qu'elle soit non signée 32 bits, signée 16 bits, etc.?

En Python, ces spécificités sont des détails d'implémentation. Donc, en général, nous ne nous inquiétons généralement pas de cela en Python. Cependant, pour rassasier votre curiosité ...

En Python 2, int est généralement un entier signé égal à la largeur de mot de l'implémentation (limité par le système). Il est généralement mis en œuvre en tant que longue en C . Lorsque les entiers deviennent plus grands que cela, nous les convertissons généralement en longs Python (avec une précision illimitée, à ne pas confondre avec les longs C).

Par exemple, dans un Python 2 32 bits, nous pouvons déduire que int est un entier signé 32 bits:

>>> import sys

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

En Python 3, l'ancien int disparaît, et nous utilisons juste (Python) tant que int, qui a une précision illimitée.

Nous pouvons également obtenir des informations sur les flotteurs de Python, qui sont généralement implémentés en double en 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)

Conclusion

N'utilisez pas __class__, une API sémantiquement non publique, pour obtenir le type d'une variable. Utilisez typeplutôt.

Et ne vous inquiétez pas trop des détails d'implémentation de Python. Je n'ai pas eu à régler moi-même les problèmes à ce sujet. Vous ne le ferez probablement pas non plus, et si vous le faites vraiment, vous devriez en savoir assez pour ne pas chercher cette réponse pour savoir quoi faire.

print type(variable_name)

Je recommande également fortement l' interpréteur interactif IPython lorsque vous traitez des questions comme celle-ci. Il vous permet de taper variable_name?et retournera toute une liste d'informations sur l'objet, y compris le type et la chaîne de doc pour le type.

par exemple

In [9]: var = 123

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

Convertissez une chaîne ou un nombre en entier, si possible. Un argument à virgule flottante sera tronqué vers zéro (cela n'inclut pas une représentation sous forme de chaîne d'un nombre à virgule flottante!) Lors de la conversion d'une chaîne, utilisez la base facultative. C'est une erreur de fournir une base lors de la conversion d'une non-chaîne. Si l'argument est en dehors de la plage entière, un objet long sera renvoyé à la place.

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.

Encore une façon d'utiliser __class__:

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

Exemples de vérification de type simple en Python:

assert type(variable_name) == int

assert type(variable_name) == bool

assert type(variable_name) == list

Cela peut être peu pertinent. mais vous pouvez vérifier les types d'un objet avec isinstance(object, type)comme mentionné ici .

La question est quelque peu ambiguë - je ne suis pas sûr de ce que vous entendez par «vue». Si vous essayez d' interroger le type d'un objet Python natif, la réponse de @atzz vous orientera dans la bonne direction.

Cependant, si vous essayez de générer des objets Python qui ont la sémantique des types C primitifs, (tels que uint32_t, int16_t), utilisez le structmodule. Vous pouvez ainsi déterminer le nombre de bits dans une primitive de type C donnée:

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

Cela se reflète également dans le arraymodule, qui peut créer des tableaux de ces types de niveau inférieur:

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

Entier maximal pris en charge (Python 2 int ) est donné par sys.maxint .

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

Il existe également sys.getsizeof , qui retourne la taille réelle de l' objet Python dans la mémoire résiduelle:

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

Pour les données flottantes et les données de précision, utilisez 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)

Vous voulez dire en Python ou en utilisant des ctypes ?

Dans le premier cas, vous ne pouvez tout simplement pas - car Python n'a pas d'entiers 16/32 bits signés / non signés.

Dans le second cas, vous pouvez utiliser type():

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

Pour plus de référence sur les ctypes, et son type, consultez la documentation officielle .

Python n'a pas les types que vous décrivez. Il existe deux types utilisés pour représenter les valeurs intégrales:, intce qui correspond au type int de la plate-forme en C, et long, qui est un entier de précision arbitraire (c'est-à-dire qu'il croît au besoin et n'a pas de limite supérieure). intles s sont convertis en silence longsi une expression produit un résultat qui ne peut pas être stocké dans int.

Simple, pour python 3.4 et supérieur

print (type(variable_name))

Python 2.7 et supérieur

print type(variable_name)

Cela dépend vraiment de quel niveau vous voulez dire. Dans Python 2.x, il existe deux types entiers, int(contraint à sys.maxint) et long(précision illimitée), pour des raisons historiques. Dans le code Python, cela ne devrait pas faire une petite différence car l'interpréteur se convertit automatiquement en long lorsqu'un nombre est trop grand. Si vous souhaitez connaître les types de données réels utilisés dans l'interpréteur sous-jacent, cela dépend de l'implémentation. (Les CPython se trouvent dans Objects / intobject.c et Objects / longobject.c.) Pour en savoir plus sur les types de systèmes, consultez cdleary answer pour l'utilisation du module struct.

Pour python2.x, utilisez

print type(variable_name)

Pour python3.x, utilisez

print(type(variable_name))

Juste, ne le fait pas. Demander le type de quelque chose est mauvais en soi. Utilisez plutôt le polymorphisme. Trouvez ou si nécessaire définissez par vous-même la méthode qui fait ce que vous voulez pour tout type d'entrée possible et appelez-la simplement sans rien demander. Si vous devez travailler avec des types intégrés ou des types définis par une bibliothèque tierce, vous pouvez toujours en hériter et utiliser vos propres dérivés à la place. Ou vous pouvez les envelopper dans votre propre classe. Il s'agit de la méthode orientée objet pour résoudre ces problèmes.

Si vous insistez pour vérifier le type exact et placer des ifs sales ici et là, vous pouvez utiliser une __class__propriété ou une typefonction pour le faire, mais bientôt vous vous retrouverez à mettre à jour tous ces ifs avec des cas supplémentaires tous les deux ou trois commits. Le faire de la manière OO empêche cela et vous permet de définir uniquement une nouvelle classe pour un nouveau type d'entrée à la place.