Comment déterminer le type d'une variable Python?
Comment voir le type d'une variable, qu'elle soit non signée 32 bits, signée 16 bits, etc.?
Comment puis-je le voir?
Python n'a pas les mêmes types que C/C++, ce qui semble être votre question.
Essaye ça:
>>> i = 123
>>> type(i)
<type 'int'>
>>> type(i) is int
True
>>> i = 123456789L
>>> type(i)
<type 'long'>
>>> type(i) is long
True
>>> i = 123.456
>>> type(i)
<type 'float'>
>>> type(i) is float
True
La distinction entre int et long disparaît dans Python 3.0, cependant.
Vous recherchez peut-être la fonction type().
Voir les exemples ci-dessous, mais il n'y a pas de type "unsigned" dans Python comme Java.
Entier positif:
>>> v = 10
>>> type(v)
<type 'int'>
Large 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'>
Nombre entier à virgule flottante:
>>> v = 3.14159
>>> type(v)
<type 'float'>
C'est si 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 manières de faire à peu près tout en Python. Voici la bonne façon:
Utilisez type
>>> type(one)
<type 'int'>
Vous pouvez utiliser l'attribut __name__ pour obtenir le nom de l'objet. (Ceci est l'un des rares attributs spéciaux dont vous avez besoin pour utiliser le nom __dunder__ - il n'y a même pas de méthode pour cela dans le module inspect.)
>>> type(one).__name__
'int'
N'utilisez pas __class__
En Python, les noms commençant par des traits de soulignement ne font sémantiquement pas partie de l'API publique et il est recommandé aux utilisateurs d'éviter de les utiliser. (Sauf lorsque c'est absolument nécessaire.)
Puisque type nous donne la classe de l'objet, nous devrions é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, le type semble donc bizarre. Par exemple:
class Foo(object):
def foo(self):
self.__class__
Ne pas Au lieu de cela, tapez (self):
class Foo(object):
def foo(self):
type(self)
Détails d'implémentation des ints et des floats
Comment voir le type d'une variable si elle est non signée 32 bits, signée 16 bits, etc.?
En Python, ces détails sont des détails d'implémentation. Donc, en général, nous ne nous inquiétons pas de cela en Python. Cependant, pour satisfaire votre curiosité ...
Dans Python 2, int est généralement un entier signé égal à la largeur de l'implémentation Word (limitée par le système). Il est généralement implémenté comme un long en C . Lorsque les entiers deviennent plus grands que cela, nous les convertissons généralement en Python longs (avec une précision illimitée, à ne pas confondre avec C longs).
Par exemple, dans un Python 2 32 bits, nous pouvons en déduire que int est un entier signé sur 32 bits:
>>> import sys
>>> format(sys.maxint, '032b')
'01111111111111111111111111111111'
>>> format(-sys.maxint - 1, '032b') # minimum value, see docs.
'-10000000000000000000000000000000'
Dans Python 3, l'ancien int disparaît et nous utilisons simplement (en Python) tant que int, qui a précision illimitée.
Nous pouvons également obtenir des informations sur les flottants de Python, qui sont généralement implémentés sous la forme 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 type à la place.
Et ne vous inquiétez pas trop des détails d'implémentation de Python. Je n'ai pas eu à traiter de problèmes autour de cela moi-même. 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.
print type(variable_name)
Je recommande également fortement l’interpréteur interactif IPython pour traiter de telles questions. Il vous permet de taper variable_name? et de renvoyer une liste complète d'informations sur l'objet, y compris le type et la chaîne de documentation du 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 de virgule flottante sera tronqué vers zéro (ceci n'inclut pas la 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 chaîne. Si l'argument est en dehors de la plage entière, un objet long sera retourné à la place.
Une autre 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
a = "cool"
type(a)
//result
<class 'str'>
or do `dir(a)` to see the list of inbuilt methods you can have on the variable.
La question est quelque peu ambiguë - je ne suis pas sûr de ce que vous entendez par "vue". Si vous essayez de interroger le type d'un objet Python natif, la réponse de @ atzz vous guidera dans la bonne direction.
Cependant, si vous essayez de générer Python objets ayant la sémantique des types C primitifs (tels que uint32_t, int16_t), utilisez le module struct . Vous pouvez déterminer le nombre de bits dans une primitive de type C donnée comme suit:
>>> 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 module array, qui peut créer des tableaux de ces types de niveau inférieur:
>>> array.array('c').itemsize # char
1
Le nombre entier maximal pris en charge (int de Python 2) 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 renvoie 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)
Cela peut être peu pertinent. mais vous pouvez vérifier les types d'un objet avec isinstance(object, type) comme indiqué ici .
Voulez-vous dire en Python ou en utilisant ctypes ?
Dans le premier cas, vous ne pouvez tout simplement pas - car Python n'a pas d'entiers signé/non signé, 16/32 bits.
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érences sur les ctypes, son type, voir la documentation officielle .
Python n'a pas les types que vous décrivez. Deux types sont utilisés pour représenter les valeurs intégrales: int, 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 limite supérieure). ints sont convertis silencieusement en long si 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 d'entiers, int (contraint à sys.maxint) et long (précision illimitée), pour des raisons historiques. Dans le code Python, cela ne devrait pas faire beaucoup de différence, car l'interpréteur convertit automatiquement en long lorsqu'un nombre trop élevé. Si vous souhaitez connaître les types de données utilisés dans l'interpréteur sous-jacent, cela dépend de la mise en œuvre. (Les CPython sont situés dans Objects/intobject.c et Objects/longobject.c.) Pour en savoir plus sur les types de systèmes, consultez la réponse de cdleary pour l'utilisation du module struct.
Pour python2.x, utilisez
print type(variable_name)
Pour python3.x, utilisez
print(type(variable_name))