Bagaimana cara melihat tipe dari suatu variabel apakah itu unsigned 32-bit, yang ditandatangani 16 bit, dll.?
Bagaimana cara saya melihat itu?
Python doesn't memiliki jenis yang sama seperti C/C++, yang tampaknya menjadi pertanyaan anda.
Coba ini:
>>> 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
Perbedaan antara int dan long hilang di Python 3.0, meskipun.
Anda mungkin akan mencari jenis()
fungsi.
Lihat contoh di bawah ini, tapi ada's tidak ada "unsigned" jenis di Python seperti Jawa.
Bilangan bulat positif:
>>> v = 10
>>> type(v)
<type 'int'>
Besar bilangan bulat positif:
>>> v = 100000000000000
>>> type(v)
<type 'long'>
Bilangan bulat negatif:
>>> v = -10
>>> type(v)
<type 'int'>
Literal urutan karakter:
>>> v = 'hi'
>>> type(v)
<type 'str'>
Floating point bilangan bulat:
>>> v = 3.14159
>>> type(v)
<type 'float'>
Cara menentukan jenis variabel dalam Python?
Jadi jika anda memiliki sebuah variabel, misalnya:
one = 1
Anda ingin tahu jenis?
Ada cara yang benar dan cara yang salah untuk melakukan hampir segala sesuatu di Python. Berikut ini's cara yang tepat:
jenis
>>> type(one)
<type 'int'>
Anda dapat menggunakan __nama__
atribut untuk mendapatkan nama objek. (Ini adalah salah satu dari beberapa atribut khusus yang anda butuhkan untuk menggunakan __ddi bawah__
nama untuk sampai ke sana's bahkan tidak sebuah metode untuk itu dalam memeriksa
modul.)
>>> type(one).__name__
'int'
__kelas__
Di Python, nama-nama yang dimulai dengan menggarisbawahi bersifat redaksional bukan bagian dari API umum, dan itu's best practice bagi pengguna untuk menghindari menggunakan mereka. (Kecuali bila benar-benar diperlukan.)
Sejak jenis
memberi kita satu kelas objek, kita harus menghindari hal ini secara langsung. :
>>> one.__class__
Hal ini biasanya ide pertama yang orang-orang miliki ketika mengakses jenis objek dalam metode - mereka're sudah mencari atribut, sehingga jenis tampaknya aneh. Misalnya:
class Foo(object):
def foo(self):
self.__class__
Don't. Sebaliknya, apakah jenis(self):
class Foo(object):
def foo(self):
type(self)
Bagaimana cara melihat tipe dari suatu variabel apakah itu unsigned 32-bit, yang ditandatangani 16 bit, dll.?
Di Python, ini spesifik adalah rincian pelaksanaan. Jadi, secara umum, kita don't biasanya khawatir tentang hal ini di Python. Namun, untuk memuaskan rasa ingin tahu anda...
Di Python 2, int biasanya integer ditandatangani sama dengan pelaksanaan's kata lebar (dibatasi oleh sistem). It's biasanya diimplementasikan sebagai panjang di C. Ketika bilangan bulat lebih besar dari ini, kita biasanya mengkonversi mereka ke Python rindu (dengan presisi terbatas, tidak menjadi bingung dengan C rindu).
Misalnya, di 32 bit Python 2, kita dapat menyimpulkan bahwa int ditandatangani 32 bit integer:
>>> import sys
>>> format(sys.maxint, '032b')
'01111111111111111111111111111111'
>>> format(-sys.maxint - 1, '032b') # minimum value, see docs.
'-10000000000000000000000000000000'
Di Python 3, tua int pergi, dan kita hanya menggunakan (Python's) panjang seperti int, yang telah unlimited presisi.
Kita juga bisa mendapatkan beberapa informasi tentang Python's mengapung, yang biasanya diimplementasikan sebagai ganda di 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)
Don't menggunakan __kelas__
, yang secara semantik nonpublik API, untuk mendapatkan jenis variabel. Gunakan jenis
sebagai gantinya.
Dan don't khawatir terlalu banyak tentang rincian pelaksanaan dari Python. I've tidak harus berurusan dengan masalah ini sendiri. Anda mungkin tidak't baik, dan jika anda benar-benar melakukannya, anda harus tahu cukup untuk tidak menjadi pilihan yang sempurna untuk ini jawaban untuk apa yang harus dilakukan.
print type(variable_name)
Saya juga sangat merekomendasikan IPython interactive interpreter ketika berhadapan dengan pertanyaan-pertanyaan seperti ini. Hal ini memungkinkan anda mengetik variable_name?
dan akan kembali daftar seluruh informasi tentang objek termasuk jenis dan doc string untuk jenis.
misalnya
In [9]: var = 123
In [10]: var?
Type: int
Base Class: <type 'int'>
String Form: 123
Namespace: Interactive
Docstring:
int(x[, base]) -> integer
Mengkonversi string atau angka ke integer, jika mungkin. Floating point argumen akan terpotong menuju nol (ini tidak termasuk string representasi floating point nomor!) Ketika mengkonversi string, menggunakan basis opsional. Ini adalah kesalahan untuk memasok basis ketika mengkonversi non-string. Jika argumen adalah di luar integer berbagai objek yang panjang akan kembali sebagai gantinya.
Pertanyaannya agak ambigu -- I'm tidak yakin apa yang anda maksud dengan "melihat". Jika anda mencoba untuk query jenis asli objek Python, @atzz's jawaban yang akan mengarahkan anda dalam arah yang benar.
Namun, jika anda mencoba untuk menghasilkan Python benda-benda yang memiliki semantik primitif C-jenis, (seperti uint32_t
, int16_t
), menggunakan struct
modul. Anda dapat menentukan jumlah bit dalam suatu C-tipe primitif thusly:
>>> struct.calcsize('c') # char
1
>>> struct.calcsize('h') # short
2
>>> struct.calcsize('i') # int
4
>>> struct.calcsize('l') # long
4
Hal ini juga tercermin dalam array
modul, yang dapat membuat array ini lebih rendah-tingkat jenis:
>>> array.array('c').itemsize # char
1
Maksimum bilangan bulat yang didukung (Python 2's int
) yang diberikan oleh sys.maxint.
>>> import sys, math
>>> math.ceil(math.log(sys.maxint, 2)) + 1 # Signedness
32.0
Ada juga sys.getsizeof, yang mengembalikan ukuran sebenarnya dari Python objek di sisa memori:
>>> a = 5
>>> sys.getsizeof(a) # Residual memory.
12
Untuk float data dan presisi data, gunakan 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)
Maksud anda di Python atau dengan menggunakan ctypes?
Dalam kasus pertama, anda tidak bisa - karena Python tidak memiliki signed/unsigned, 16/32 bit bilangan bulat.
Dalam kedua kasus, anda dapat menggunakan jenis()
:
>>> import ctypes
>>> a = ctypes.c_uint() # unsigned int
>>> type(a)
<class 'ctypes.c_ulong'>
Untuk lebih mengacu pada ctypes, aplikasi jenis ini, lihat dokumentasi resmi.
Python doesn't memiliki jenis seperti seperti yang anda jelaskan. Ada dua jenis yang digunakan untuk mewakili nilai-nilai integral: int
, yang sesuai dengan platform's int tipe di C, dan panjang
, yang sewenang-wenang precision integer (yaitu tumbuh sebagai dibutuhkan dan doesn't memiliki batas atas). int diam-diam dikonversi ke
panjangjika ekspresi menghasilkan hasil yang tidak dapat disimpan di dalam
int`.
Itu benar-benar tergantung pada tingkat apa yang anda maksud. Di Python 2.x, ada dua tipe integer, int
(dibatasi untuk sys.maxint
) dan panjang
(unlimited presisi), untuk alasan historis. Dalam kode Python, ini seharusnya't membuat sedikit perbedaan karena penerjemah otomatis mengkonversi ke yang lama ketika jumlah terlalu besar. Jika anda ingin tahu tentang sebenarnya jenis data yang digunakan dalam mendasari penerjemah, yang's pelaksanaannya tergantung. (CPython's adalah terletak pada Objek/intobject.c dan benda-Benda/longobject.c.) Untuk mengetahui tentang jenis sistem melihat cdleary jawaban untuk menggunakan struct modul.
Untuk python2.x, menggunakan
print type(variable_name)
Untuk python3.x, menggunakan
print(type(variable_name))
Hanya saja, jangan lakukan itu. Meminta sesuatu yang's jenis yang salah dalam dirinya. Alih-alih menggunakan polimorfisme. Menemukan atau jika perlu menentukan sendiri metode yang melakukan apa yang anda inginkan untuk setiap kemungkinan jenis input dan panggil saja tanpa menanyakan apa-apa. Jika anda perlu untuk bekerja dengan built-in tipe atau jenis yang didefinisikan oleh pihak ketiga perpustakaan, anda selalu dapat mewarisi dari mereka dan menggunakan anda sendiri derivatif sebagai gantinya. Atau anda bisa membungkus mereka di dalam kelas anda sendiri. Ini adalah berorientasi objek cara untuk mengatasi masalah tersebut.
Jika anda bersikeras memeriksa jenis tepat dan menempatkan beberapa kotor jika di sini dan di sana, anda dapat menggunakan
kelasatau
jenisfungsi untuk melakukan itu, tapi segera anda akan menemukan diri anda memperbarui semua ini
jika dengan tambahan kasus setiap dua atau tiga berkomitmen. Lakukan hal OO cara mencegah dan memungkinkan anda hanya mendefinisikan sebuah class baru untuk jenis baru dari input sebaliknya.