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?
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?
Réponses:
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'>
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:
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 inspect
module.)
>>> type(one).__name__
'int'
__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 type
nous 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)
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)
N'utilisez pas __class__
, une API sémantiquement non publique, pour obtenir le type d'une variable. Utilisez type
plutô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.
<type instance>
mais __class__
donne email.message.Message
- qu'est-ce que je fais mal?
object
?
import email
aucune classe de ma propre invention.
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.
print type(str)
renvoie une erreur dans Python 3.6. Utilisationtype(str)
print(type(str))
print type(var)
code erroné.
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'>
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 struct
module. 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 array
module, 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:, int
ce 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). int
les s sont convertis en silence long
si une expression produit un résultat qui ne peut pas être stocké dans int
.
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 if
s sales ici et là, vous pouvez utiliser une __class__
propriété ou une type
fonction pour le faire, mais bientôt vous vous retrouverez à mettre à jour tous ces if
s 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.