Làm cách nào để xem loại biến cho dù nó không dấu 32 bit, ký 16 bit, v.v.?
Làm thế nào để tôi xem nó?
Làm cách nào để xem loại biến cho dù nó không dấu 32 bit, ký 16 bit, v.v.?
Làm thế nào để tôi xem nó?
Câu trả lời:
Sử dụng type()
hàm dựng sẵn:
>>> i = 123
>>> type(i)
<type 'int'>
>>> type(i) is int
True
>>> i = 123.456
>>> type(i)
<type 'float'>
>>> type(i) is float
True
Để kiểm tra xem một biến có thuộc loại đã cho hay không, hãy sử dụng isinstance
:
>>> i = 123
>>> isinstance(i, int)
True
>>> isinstance(i, (float, str, set, dict))
False
Lưu ý rằng Python không có cùng loại với C / C ++, dường như là câu hỏi của bạn.
Bạn có thể đang tìm kiếm chức năng tích hợp .type()
Xem các ví dụ bên dưới, nhưng không có loại "không dấu" trong Python giống như Java.
Sô nguyên dương:
>>> v = 10
>>> type(v)
<type 'int'>
Số nguyên dương lớn :
>>> v = 100000000000000
>>> type(v)
<type 'long'>
Số nguyên âm:
>>> v = -10
>>> type(v)
<type 'int'>
Trình tự chữ của các ký tự:
>>> v = 'hi'
>>> type(v)
<type 'str'>
Số nguyên dấu phẩy động:
>>> v = 3.14159
>>> type(v)
<type 'float'>
Làm thế nào để xác định loại biến trong Python?
Vì vậy, nếu bạn có một biến, ví dụ:
one = 1
Bạn muốn biết loại của nó?
Có nhiều cách đúng và sai để làm mọi thứ trong Python. Đây là cách đúng đắn:
type
>>> type(one)
<type 'int'>
Bạn có thể sử dụng __name__
thuộc tính để lấy tên của đối tượng. (Đây là một trong số ít các thuộc tính đặc biệt mà bạn cần sử dụng __dunder__
tên để truy cập - thậm chí không có một phương thức nào cho nó trong inspect
mô-đun.)
>>> type(one).__name__
'int'
__class__
Trong Python, các tên bắt đầu bằng dấu gạch dưới về mặt ngữ nghĩa không phải là một phần của API công khai và đó là cách tốt nhất để người dùng tránh sử dụng chúng. (Trừ khi thật cần thiết.)
Vì type
cung cấp cho chúng ta lớp của đối tượng, chúng ta nên tránh nhận trực tiếp điều này. :
>>> one.__class__
Đây thường là ý tưởng đầu tiên mà mọi người có khi truy cập loại đối tượng trong một phương thức - họ đã tìm kiếm các thuộc tính, vì vậy loại có vẻ kỳ lạ. Ví dụ:
class Foo(object):
def foo(self):
self.__class__
Đừng. Thay vào đó, hãy gõ (tự):
class Foo(object):
def foo(self):
type(self)
Làm cách nào để xem loại biến cho dù nó không dấu 32 bit, ký 16 bit, v.v.?
Trong Python, các chi tiết cụ thể này là chi tiết triển khai. Vì vậy, nói chung, chúng ta thường không lo lắng về điều này trong Python. Tuy nhiên, để kích thích trí tò mò của bạn ...
Trong Python 2, int thường là một số nguyên được ký bằng độ rộng từ của triển khai (được giới hạn bởi hệ thống). Nó thường được thực hiện như một lâu trong C . Khi số nguyên trở nên lớn hơn số này, chúng ta thường chuyển đổi chúng thành Python dài (với độ chính xác không giới hạn, không bị nhầm lẫn với độ dài C).
Ví dụ, trong Python 2 32 bit, chúng ta có thể suy ra int là số nguyên 32 bit đã ký:
>>> import sys
>>> format(sys.maxint, '032b')
'01111111111111111111111111111111'
>>> format(-sys.maxint - 1, '032b') # minimum value, see docs.
'-10000000000000000000000000000000'
Trong Python 3, int cũ biến mất và chúng ta chỉ sử dụng (Python) miễn là int, có độ chính xác không giới hạn.
Chúng tôi cũng có thể nhận được một số thông tin về số float của Python, thường được triển khai như một nhân đôi trong 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)
Không sử dụng __class__
, API không công khai về mặt ngữ nghĩa, để lấy loại biến. Sử dụng type
thay thế.
Và đừng quá lo lắng về các chi tiết triển khai của Python. Tôi đã không phải đối phó với các vấn đề xung quanh này. Bạn có thể sẽ không, và nếu bạn thực sự làm, bạn nên biết đủ để không phải tìm kiếm câu trả lời này để làm gì.
<type instance>
nhưng __class__
cho email.message.Message
- tôi đang làm gì sai?
object
?
import email
không có lớp phát minh của riêng tôi.
print type(variable_name)
Tôi cũng rất khuyến khích trình thông dịch tương tác IPython khi xử lý các câu hỏi như thế này. Nó cho phép bạn gõ variable_name?
và sẽ trả về toàn bộ danh sách thông tin về đối tượng bao gồm loại và chuỗi doc cho loại.
ví dụ
In [9]: var = 123
In [10]: var?
Type: int
Base Class: <type 'int'>
String Form: 123
Namespace: Interactive
Docstring:
int(x[, base]) -> integer
Chuyển đổi một chuỗi hoặc số thành một số nguyên, nếu có thể. Đối số dấu phẩy động sẽ được rút ngắn về 0 (điều này không bao gồm biểu diễn chuỗi của số dấu phẩy động!) Khi chuyển đổi một chuỗi, hãy sử dụng cơ sở tùy chọn. Đó là một lỗi để cung cấp một cơ sở khi chuyển đổi một chuỗi không. Nếu đối số nằm ngoài phạm vi số nguyên, một đối tượng dài sẽ được trả về.
print type(str)
trả về lỗi trong Python 3.6. Sử dụngtype(str)
print(type(str))
print type(var)
mã sai.
Thêm một cách sử dụng __class__
:
>>> a = [1, 2, 3, 4]
>>> a.__class__
<type 'list'>
>>> b = {'key1': 'val1'}
>>> b.__class__
<type 'dict'>
>>> c = 12
>>> c.__class__
<type 'int'>
Nó có thể không liên quan. nhưng bạn có thể kiểm tra các loại đối tượng isinstance(object, type)
như được đề cập ở đây .
Câu hỏi hơi mơ hồ - Tôi không chắc ý của bạn là "xem". Nếu bạn đang cố gắng truy vấn loại đối tượng Python nguyên gốc, câu trả lời của @atzz sẽ điều khiển bạn đi đúng hướng.
Tuy nhiên, nếu bạn đang cố gắng tạo các đối tượng Python có ngữ nghĩa của các loại C nguyên thủy, (chẳng hạn như uint32_t
, int16_t
), hãy sử dụng struct
mô-đun. Do đó, bạn có thể xác định số lượng bit trong một kiểu nguyên thủy loại C đã cho:
>>> struct.calcsize('c') # char
1
>>> struct.calcsize('h') # short
2
>>> struct.calcsize('i') # int
4
>>> struct.calcsize('l') # long
4
Điều này cũng được phản ánh trong array
mô-đun, có thể tạo ra các mảng của các loại mức thấp hơn này:
>>> array.array('c').itemsize # char
1
Số nguyên tối đa được hỗ trợ (Python 2's int
) được đưa ra bởi sys.maxint .
>>> import sys, math
>>> math.ceil(math.log(sys.maxint, 2)) + 1 # Signedness
32.0
Ngoài ra còn có sys.getsizeof , trả về kích thước thực của đối tượng Python trong bộ nhớ còn lại:
>>> a = 5
>>> sys.getsizeof(a) # Residual memory.
12
Đối với dữ liệu nổi và dữ liệu chính xác, hãy sử dụng 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)
Ý bạn là trong Python hay sử dụng ctypes ?
Trong trường hợp đầu tiên, bạn đơn giản là không thể - bởi vì Python không có số nguyên được ký / không dấu, 16/32 bit.
Trong trường hợp thứ hai, bạn có thể sử dụng type()
:
>>> import ctypes
>>> a = ctypes.c_uint() # unsigned int
>>> type(a)
<class 'ctypes.c_ulong'>
Để tham khảo thêm về ctypes, một loại của nó, xem tài liệu chính thức .
Python không có các loại như bạn mô tả. Có hai loại được sử dụng để biểu thị các giá trị tích phân:, int
tương ứng với kiểu int của nền tảng trong C và long
, đó là một số nguyên chính xác tùy ý (nghĩa là nó phát triển khi cần và không có giới hạn trên). int
s được chuyển đổi âm thầm thành long
nếu một biểu thức tạo ra kết quả không thể được lưu trữ trong int
.
Đơn giản, cho python 3,4 trở lên
print (type(variable_name))
Python 2.7 trở lên
print type(variable_name)
Nó thực sự phụ thuộc vào cấp độ của bạn. Trong Python 2.x, có hai loại số nguyên, int
(bị ràng buộc sys.maxint
) và long
(độ chính xác không giới hạn), vì lý do lịch sử. Trong mã Python, điều này không tạo ra một chút khác biệt vì trình thông dịch tự động chuyển thành dài khi một số quá lớn. Nếu bạn muốn biết về các loại dữ liệu thực tế được sử dụng trong trình thông dịch cơ bản, thì việc thực hiện đó phụ thuộc. (CPython được đặt trong Đối tượng / intobject.c và Đối tượng / longobject.c.) Để tìm hiểu về các loại hệ thống, hãy xem câu trả lời cdleary khi sử dụng mô-đun struct.
Đối với python2.x, sử dụng
print type(variable_name)
Đối với python3.x, sử dụng
print(type(variable_name))
Chỉ cần không làm điều đó. Yêu cầu một cái gì đó là loại sai trong chính nó. Thay vào đó sử dụng đa hình. Tìm hoặc nếu cần thiết tự xác định phương thức thực hiện những gì bạn muốn cho bất kỳ loại đầu vào có thể nào và chỉ cần gọi nó mà không hỏi về bất cứ điều gì. Nếu bạn cần làm việc với các loại hoặc loại tích hợp được xác định bởi thư viện bên thứ ba, bạn luôn có thể kế thừa từ chúng và thay vào đó sử dụng các công cụ phái sinh của riêng bạn. Hoặc bạn có thể bọc chúng bên trong lớp học của riêng bạn. Đây là cách hướng đối tượng để giải quyết các vấn đề như vậy.
Nếu bạn khăng khăng kiểm tra loại chính xác và đặt một số if
s bẩn ở đây và đó, bạn có thể sử dụng thuộc __class__
tính hoặc type
chức năng để làm điều đó, nhưng ngay sau đó bạn sẽ thấy mình cập nhật tất cả các if
s này với các trường hợp bổ sung cứ sau hai hoặc ba lần cam kết. Thực hiện theo cách OO sẽ ngăn chặn điều đó và cho phép bạn chỉ xác định một lớp mới cho một kiểu đầu vào mới thay thế.