Question Comment déterminer le type d'une variable Python?


Comment est-ce que je vois le type d'une variable si elle est non signée 32 bits, signée 16 bits, etc.?

Comment puis-je le voir?


1031
2017-12-31 07:58


origine


Réponses:


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.


948
2017-12-31 10:43



Vous cherchez peut-être le type() fonction.

Voir les exemples ci-dessous, mais il n'y a pas de type "unsigned" en Python, tout 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'>

Virgule flottante entière:

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

306
2017-10-01 11:02



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

print(type(variable_name))

133
2017-10-07 16:02



Comment déterminer le type de variable dans Python?

Donc, si vous avez une variable, par exemple:

one = 1

Vous voulez connaître son type?

Il y a de bonnes et 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 le __name__ attribut pour obtenir le nom de l'objet. (Ceci est l'un des rares attributs spéciaux dont vous avez besoin pour utiliser le __dunder__ nom pour arriver à - il n'y a même pas une méthode pour cela dans le inspect module.)

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

Ne pas utiliser __class__

En Python, les noms qui commencent par des traits de soulignement ne font pas sémantiquement partie de l'API publique, et il est conseillé aux utilisateurs d'éviter de les utiliser. (Sauf quand c'est absolument nécessaire.)

Depuis 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 quand 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__

Ne pas. Au lieu de cela, tapez (auto):

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

Détails de mise en œuvre des ints et des flotteurs

Comment est-ce que je vois 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 en préoccupons généralement pas en Python. Cependant, pour satisfaire votre curiosité ...

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

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

>>> import sys

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

En Python 3, le vieil int disparaît, et nous utilisons simplement (Python) long comme 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 en tant que 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

Ne pas utiliser __class__, une API sémantiquement non publique, pour obtenir le type d'une variable. Utilisation type au lieu.

Et ne vous inquiétez pas trop des détails d'implémentation de Python. Je n'ai pas eu à faire face à des problèmes autour de moi 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 regarder cette réponse pour savoir quoi faire.


77
2018-03-18 02:48



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'>

36
2017-12-31 08:08



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

Cependant, si vous essayez de produire Les objets Python qui ont la sémantique des C-types 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 array module, qui peut faire des tableaux de ces types de niveau inférieur:

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

L'entier maximal pris en charge (Python 2's int) est donné par sys.maxint.

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

Il y a aussi sys.getsizeof, qui renvoie la taille réelle du Python objet 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)

25
2017-12-31 08:02



print type(variable_name)

Je recommande aussi vivement IPython interprète interactif lorsqu'il s'agit de 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 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 nombre entier, si possible. Un argument à virgule flottante sera tronqué vers zéro (ceci n'inclut pas de chaîne représentation 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'un         non-chaîne Si l'argument est en dehors de la plage des entiers, un objet long         sera retourné à la place.


20
2017-08-14 06:39