Jak mogę zobaczyć typ zmiennej, czy jest ona 32-bitowa bez znaku, 16-bitowa z podpisem itp.?

Jak mogę to zobaczyć?

Użyj type()wbudowanej funkcji:

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

Aby sprawdzić, czy zmienna jest danego typu, użyj isinstance:

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

Zauważ, że Python nie ma tego samego typu co C / C ++, który wydaje się być Twoim pytaniem.

Być może szukasz wbudowanej funkcji .type()

Zobacz poniższe przykłady, ale w Pythonie nie ma typu „bez znaku”, takiego jak Java.

Dodatnia liczba całkowita:

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

Duża dodatnia liczba całkowita:

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

Ujemna liczba całkowita:

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

Dosłowna sekwencja znaków:

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

Liczba całkowita zmiennoprzecinkowa:

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

To takie proste. Robisz to w ten sposób.

print(type(variable_name))

Jak określić typ zmiennej w Pythonie?

Więc jeśli masz zmienną, na przykład:

one = 1

Chcesz poznać jego typ?

Istnieją dobre i złe sposoby robienia wszystkiego w Pythonie. Oto właściwy sposób:

Posługiwać się type

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

Możesz użyć tego __name__atrybutu, aby uzyskać nazwę obiektu. (Jest to jeden z niewielu specjalnych atrybutów, do którego musisz użyć __dunder__nazwy, aby uzyskać do niej dostęp - w inspectmodule nie ma nawet metody ).

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

Nie używaj __class__

W Pythonie nazwy zaczynające się od podkreślników semantycznie nie są częścią publicznego interfejsu API i najlepszym rozwiązaniem dla użytkowników jest unikanie ich używania. (Z wyjątkiem absolutnie niezbędnych).

Ponieważ typedaje nam klasę obiektu, powinniśmy unikać bezpośredniego uzyskania tego. :

>>> one.__class__

Jest to zwykle pierwszy pomysł, jaki ludzie mają podczas uzyskiwania dostępu do typu obiektu w metodzie - już szukają atrybutów, więc typ wydaje się dziwny. Na przykład:

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

Nie rób Zamiast tego wpisz (self):

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

Szczegóły implementacji ints i pływaków

Jak mogę zobaczyć typ zmiennej, czy jest ona 32-bitowa bez znaku, 16-bitowa z podpisem itp.?

W Pythonie te szczegóły to szczegóły implementacji. Ogólnie rzecz biorąc, zwykle nie martwimy się tym w Pythonie. Jednak, aby zaspokoić swoją ciekawość ...

W Pythonie 2 liczba int jest zwykle liczbą całkowitą ze znakiem równą szerokości słowa implementacji (ograniczona przez system). To zazwyczaj realizowane jak długo w C . Kiedy liczby całkowite stają się większe, zwykle konwertujemy je na długości Pythona (z nieograniczoną precyzją, nie mylić z długimi literami C).

Na przykład w 32-bitowym Pythonie 2 możemy wywnioskować, że int jest 32-bitową liczbą całkowitą ze znakiem:

>>> import sys

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

W Pythonie 3 stary int zniknął, a my po prostu używamy (Python's) jako int, który ma nieograniczoną precyzję.

Możemy również uzyskać informacje o pływakach Pythona, które zwykle są zaimplementowane jako podwójne w 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)

Wniosek

Nie używaj __class__semantycznie niepublicznego interfejsu API, aby uzyskać typ zmiennej. Użyj typezamiast tego.

I nie przejmuj się zbytnio szczegółami implementacji Pythona. Sam nie musiałem sobie z tym radzić. Prawdopodobnie też tego nie zrobisz, a jeśli tak, powinieneś wiedzieć wystarczająco dużo, aby nie szukać odpowiedzi na pytanie, co robić.

print type(variable_name)

Polecam również interaktywny interpreter IPython podczas rozwiązywania takich pytań. Pozwala pisać variable_name?i zwraca całą listę informacji o obiekcie, w tym typ i ciąg doc dla danego typu.

na przykład

In [9]: var = 123

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

Jeśli to możliwe, przekonwertuj ciąg lub liczbę na liczbę całkowitą. Argument zmiennoprzecinkowy zostanie obcięty w kierunku zera (nie obejmuje ciągu reprezentującego liczbę zmiennoprzecinkową!) Podczas konwersji łańcucha użyj opcjonalnej podstawy. Błędem jest podanie bazy podczas konwertowania nie-ciągu. Jeśli argument znajduje się poza zakresem liczb całkowitych, zostanie zwrócony długi obiekt.

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.

Jeszcze jeden sposób, używając __class__:

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

Przykłady prostego sprawdzania typów w Pythonie:

assert type(variable_name) == int

assert type(variable_name) == bool

assert type(variable_name) == list

To może być trochę nieistotne. ale możesz sprawdzać typy obiektów za pomocą, isinstance(object, type)jak wspomniano tutaj .

Pytanie jest nieco dwuznaczne - nie jestem pewien, co rozumiesz przez „widok”. Jeśli próbujesz zapytać o typ rodzimego obiektu Python, odpowiedź @atzz poprowadzi cię we właściwym kierunku.

Jednakże, jeśli starają się generować obiektów Pythona, które mają semantyki C prymitywnych typów (takich jak uint32_t, int16_t), użyj structmodułu. W ten sposób można określić liczbę bitów w danej operacji podstawowej typu C:

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

Znajduje to również odzwierciedlenie w arraymodule, który może tworzyć tablice tych typów niższego poziomu:

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

Maksymalna obsługiwana liczba całkowita (Python 2's int) jest podana przez sys.maxint .

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

Istnieje również sys.getsizeof , który zwraca rzeczywisty rozmiar obiektu Python w pozostałej pamięci:

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

W przypadku danych zmiennoprzecinkowych i precyzyjnych użyj 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)

Masz na myśli w Pythonie lub używasz ctypów ?

W pierwszym przypadku po prostu nie możesz - ponieważ Python nie ma podpisanych / niepodpisanych liczb całkowitych 16/32 bitowych.

W drugim przypadku możesz użyć type():

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

Więcej informacji na temat ctypów i ich typów można znaleźć w oficjalnej dokumentacji .

Python nie ma takich typów, jakie opisujesz. Istnieją dwa typy reprezentujące wartości całkowite:, intktóra odpowiada typowi int platformy w C, i longktóra jest liczbą całkowitą o dowolnej precyzji (tzn. Rośnie w razie potrzeby i nie ma górnej granicy). ints są po cichu konwertowane, longjeśli wyrażenie daje wynik, którego nie można zapisać int.

Prosty, dla Pythona 3.4 i nowszych

print (type(variable_name))

Python 2.7 i nowszy

print type(variable_name)

To naprawdę zależy od tego, jaki poziom masz na myśli. W Pythonie 2.x istnieją dwa typy liczb całkowitych int(ograniczone do sys.maxint) i long(nieograniczona precyzja) ze względów historycznych. W kodzie Python nie powinno to mieć większego znaczenia, ponieważ interpreter automatycznie konwertuje na długi, gdy liczba jest zbyt duża. Jeśli chcesz wiedzieć o rzeczywistych typach danych używanych w tłumaczu bazowym, zależy to od implementacji. (CPython znajdują się w Objects / intobject.c i Objects / longobject.c.) Aby dowiedzieć się o typach systemów, spójrz na cdleary odpowiedź dotyczącą korzystania z modułu struct.

W przypadku python2.x użyj

print type(variable_name)

W przypadku python3.x użyj

print(type(variable_name))

Po prostu tego nie rób. Pytanie o typ czegoś jest samo w sobie złe. Zamiast tego użyj polimorfizmu. Znajdź lub, jeśli to konieczne, samodzielnie zdefiniuj metodę, która robi to, co chcesz dla każdego możliwego rodzaju danych wejściowych i po prostu wywołaj ją, nie pytając o nic. Jeśli musisz pracować z wbudowanymi typami lub typami zdefiniowanymi przez bibliotekę innej firmy, zawsze możesz dziedziczyć po nich i używać własnych pochodnych. Lub możesz owinąć je w swoją klasę. Jest to zorientowany obiektowo sposób rozwiązywania takich problemów.

Jeśli nalegasz na sprawdzenie dokładnego typu i umieszczenie niektórych brudnych ifplików tu i tam, możesz użyć __class__właściwości lub typefunkcji, aby to zrobić, ale wkrótce przekonasz się, że aktualizujesz te wszystkie ifdodatkowe przypadki co dwa lub trzy zatwierdzenia. Wykonanie tego w sposób OO zapobiega temu i pozwala tylko zdefiniować nową klasę dla nowego typu danych wejściowych.