tester - Comment déterminer le type d'une variable Python?




type none python (10)

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?


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:

Utiliser le type

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

Vous pouvez utiliser l'attribut __name__ pour obtenir le nom de l'objet. (C'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 dans le module inspect .)

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

N'utilisez pas __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.)

Puisque le 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 à la largeur du word l'implémentation (limitée par le système). Il est généralement implémenté comme un long 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, on peut 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 une précision illimitée.

Nous pouvons également obtenir des informations sur les flottants de Python, qui sont généralement implémentés en double dans 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 le type place.

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.


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

print(type(variable_name))

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


Exemples de vérification de type simple en Python:

assert type(variable_name) == int

assert type(variable_name) == bool

assert type(variable_name) == list

Pour python2.x, utilisez

print type(variable_name)

Pour python3.x, utilisez

print(type(variable_name))

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.


Simple, pour python 3.4 et supérieur

print (type(variable_name))

Python 2.7 et supérieur

print type(variable_name)

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

Vous recherchez peut-être la fonction type() .

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

print type(variable_name)

Je recommande également fortement l'interpréteur interactif IPython en traitant de telles questions. 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

    Convert a string or number to an integer, if possible.  A floating point
    argument will be truncated towards zero (this does not include a string
    representation of a floating point number!)  When converting a string, use
    the optional base.  It is an error to supply a base when converting a
    non-string. If the argument is outside the integer range a long object
    will be returned instead.






16-bit