විචල්යයේ වර්ගය බිට් 32, අත්සන් නොකළ 16 බිට් යනාදිය මා දකින්නේ කෙසේද?

මා එය දකින්නේ කෙසේද?

type()බිල්ඩින් ශ්‍රිතය භාවිතා කරන්න :

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

විචල්‍යයක් දී ඇති වර්ගයක් දැයි පරීක්ෂා කිරීමට, භාවිතා කරන්න isinstance:

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

පයිතන්ට C / C ++ හා සමාන වර්ග නොමැති බව සලකන්න, එය ඔබේ ප්‍රශ්නය ලෙස පෙනේ.

ඔබ ගොඩනංවන ලද ශ්‍රිතය සොයමින් සිටිය හැක .type()

පහත උදාහරණ බලන්න, නමුත් ජාවා මෙන් පයිතන් හි "අත්සන් නොකළ" වර්ගයක් නොමැත.

ධනාත්මක නිඛිලය:

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

විශාල ධනාත්මක පූර්ණ සංඛ්‍යාවක්:

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

සෘණ නිඛිලය:

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

අක්ෂරවල වචනාර්ථ අනුක්‍රමය:

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

පාවෙන ලක්ෂ්‍ය නිඛිලය:

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

එය එතරම් සරල ය. ඔබ එය මේ ආකාරයට කරන්න.

print(type(variable_name))

පයිතන් හි විචල්ය වර්ගය තීරණය කරන්නේ කෙසේද?

එබැවින් ඔබට විචල්‍යයක් තිබේ නම්, උදාහරණයක් ලෙස:

one = 1

ඔබට එහි වර්ගය දැන ගැනීමට අවශ්‍යද?

පයිතන් හි සෑම දෙයක්ම කිරීමට නිවැරදි ක්‍රම සහ වැරදි ක්‍රම තිබේ. මෙන්න නිවැරදි මාර්ගය:

භාවිත type

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

__name__වස්තුවේ නම ලබා ගැනීම සඳහා ඔබට ගුණාංගය භාවිතා කළ හැකිය . (මෙය __dunder__ලබා ගැනීම සඳහා ඔබ නම භාවිතා කළ යුතු විශේෂ ලක්ෂණ කිහිපයෙන් එකකි - inspectමොඩියුලය තුළ ඒ සඳහා ක්‍රමයක්වත් නොමැත.)

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

භාවිතා නොකරන්න __class__

පයිතන්හි, යටි ඉරි වලින් ආරම්භ වන නම් අර්ථාන්විතව පොදු API හි කොටසක් නොවන අතර පරිශීලකයින් ඒවා භාවිතා කිරීමෙන් වැළකී සිටීම හොඳ පුරුද්දකි.(අත්‍යවශ්‍ය විට හැර.)

typeඅපට වස්තුවේ පන්තිය ලබා දෙන බැවින් , අපි මෙය කෙලින්ම ලබා ගැනීමෙන් වැළකී සිටිය යුතුය. :

>>> one.__class__

සාමාන්‍යයෙන් වස්තුවක වර්ගයට ප්‍රවේශවීමේදී මිනිසුන්ට ඇති පළමු අදහස මෙයයි - ඔවුන් දැනටමත් ගුණාංග සොයමින් සිටින නිසා වර්ගය අමුතුයි. උදාහරණයක් වශයෙන්:

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

එපා. ඒ වෙනුවට, ටයිප් කරන්න (ස්වයං):

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

තීන්ත සහ පාවෙන විස්තර ක්‍රියාත්මක කිරීම

විචල්යයේ වර්ගය බිට් 32, අත්සන් නොකළ 16 බිට් යනාදිය මා දකින්නේ කෙසේද?

පයිතන්හි, මෙම විශේෂතා ක්‍රියාත්මක කිරීමේ විස්තර වේ. ඉතින්, පොදුවේ ගත් කල, අපි සාමාන්‍යයෙන් පයිතන්හි මේ ගැන කරදර නොවන්නෙමු. කෙසේ වෙතත්, ඔබේ කුතුහලය දුරු කිරීමට ...

පයිතන් 2 හි, int යනු සාමාන්‍යයෙන් ක්‍රියාත්මක කිරීමේ වචන පළලට සමාන වූ අත්සන් කළ පූර්ණ සංඛ්‍යාවක් (පද්ධතියෙන් සීමා වේ). එය සාමාන්‍යයෙන් සී හි දීර් as ලෙස ක්‍රියාත්මක වේ වේ. පූර්ණ සංඛ්‍යා මෙයට වඩා විශාල වූ විට, අපි සාමාන්‍යයෙන් ඒවා පයිතන් දිගු බවට පරිවර්තනය කරමු (අසීමිත නිරවද්‍යතාවයකින්, සී දිගු සමඟ පටලවා නොගත යුතුය).

උදාහරණයක් ලෙස, බිට් 32 පයිතන් 2 හි, අපට අත්සන් කළ බිට් 32 පූර්ණ සංඛ්‍යාවක් බව අනුමාන කළ හැකිය:

>>> import sys

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

Python 3 හි, පැරණි int ඉවතට යන අතර, අපි int (Python's) int භාවිතා කරන තාක් කල් භාවිතා කරමු අසීමිත නිරවද්‍යතාවයක් ඇත.

සාමාන්‍යයෙන් 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)

නිගමනය

__class__විචල්‍යයක වර්ගය ලබා ගැනීම සඳහා අර්ථාන්විත නොවන රාජ්‍ය නොවන API භාවිතා නොකරන්න . typeඒ වෙනුවට භාවිතා කරන්න .

පයිතන් ක්‍රියාත්මක කිරීමේ තොරතුරු ගැන ඕනෑවට වඩා කරදර නොවන්න. මට මේ වටා ඇති ගැටළු සමඟ කටයුතු කිරීමට සිදු වී නැත. ඔබ බොහෝ විට එසේ නොවනු ඇති අතර, ඔබ සැබවින්ම එසේ කරන්නේ නම්, කළ යුතු දේ සඳහා මෙම පිළිතුර දෙස නොබැලීමට ඔබ දැන සිටිය යුතුය.

print type(variable_name)

මෙවැනි ප්‍රශ්න සමඟ කටයුතු කිරීමේදී IPython අන්තර්ක්‍රියාකාරී පරිවර්තකය ද මම තරයේ නිර්දේශ කරමි . එය ඔබට ටයිප් කිරීමට ඉඩ දෙන variable_name?අතර වර්ගය සහ ඩොක් ස්ට්‍රිං ඇතුළු වස්තුව පිළිබඳ සම්පූර්ණ තොරතුරු ලැයිස්තුවක් නැවත ලබා දෙනු ඇත.

උදා

In [9]: var = 123

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

හැකි නම්, නූලක් හෝ අංකයක් පූර්ණ සංඛ්‍යාවක් බවට පරිවර්තනය කරන්න. පාවෙන ලක්ෂ්‍ය තර්කයක් ශුන්‍ය දෙසට කපා දමනු ඇත (මෙයට පාවෙන ලක්ෂ්‍ය අංකයක තන්තු නිරූපණයක් ඇතුළත් නොවේ!) නූලක් පරිවර්තනය කිරීමේදී විකල්ප පදනම භාවිතා කරන්න. නූල් නොවන බවට පරිවර්තනය කිරීමේදී පදනමක් සැපයීම දෝෂයකි. තර්කය පූර්ණ සංඛ්‍යා පරාසයෙන් පිටත නම් ඒ වෙනුවට දිගු වස්තුවක් ආපසු ලබා දෙනු ඇත.

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.

භාවිතා කළ හැකි තවත් ක්‍රමයක් __class__:

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

පයිතන්හි සරල වර්ග පරීක්ෂා කිරීම සඳහා උදාහරණ:

assert type(variable_name) == int

assert type(variable_name) == bool

assert type(variable_name) == list

එය සුළු වශයෙන් අදාළ නොවේ. නමුත් මෙහිisinstance(object, type) සඳහන් පරිදි ඔබට වස්තුවක වර්ග පරීක්ෂා කළ හැකිය .

ප්‍රශ්නය තරමක් අපැහැදිලි ය - ඔබ "දැක්ම" යන්නෙන් අදහස් කරන්නේ කුමක්දැයි මට විශ්වාස නැත. ඔබ උත්සාහ කරන්නේ නම් විමසීමට ස්වදේශික Python වස්තුව වර්ගය, @atzz ගේ පිළිතුර නිවැරදි දිශාව ඔබ ගතියකට.

කෙසේ වෙතත්, ඔබ ප්‍රාථමික සී වර්ගවල අර්ථකථන ඇති පයිතන් වස්තු උත්පාදනය කිරීමට උත්සාහ කරන්නේ නම් (වැනි)uint32_t , int16_t), භාවිතා structමොඩියුලය. ලබා දී ඇති සී වර්ගයේ ප්‍රාථමිකයක බිටු ගණන ඔබට තීරණය කළ හැකිය:

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

මෙය arrayමොඩියුලයේ ද පිළිබිඹු වන අතර එමඟින් මෙම පහළ මට්ටමේ වර්ගවල අරා සෑදිය හැකිය:

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

සහය දක්වන උපරිම නිඛිල (පයිතන් 2 ගේ int) විසින් දෙනු ලැබේ sys.maxint .

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

Sys.getsizeof ද ඇත , එය සත්‍ය ප්‍රමාණය ලබා දෙයි පයිතන් වස්තුවේ අවශේෂ මතකයේ ලබා දෙයි:

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

පාවෙන දත්ත සහ නිරවද්‍ය දත්ත සඳහා, 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)

ඔබ අදහස් කළේ පයිතන් වලද නැත්නම් සයිටයිප් භාවිතා කරනවාද?

පළමු අවස්ථාවේ දී, ඔබට සරලවම කළ නොහැකිය - පයිතන් අත්සන් නොකළ / අත්සන් නොකළ, බිට් 16/32.

දෙවන අවස්ථාවේදී, ඔබට භාවිතා කළ හැකිය type():

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

එහි වර්ගයක් වන ctypes පිළිබඳ වැඩි විස්තර සඳහා නිල ලියකියවිලි බලන්න .

ඔබ විස්තර කරන ආකාරයට පයිතන්ට එවැනි වර්ග නොමැත. සමෝධානික අගයන් නිරූපණය කිරීම සඳහා වර්ග දෙකක් තිබේ: intඑය C හි වේදිකාවේ int වර්ගයට අනුරූප longවන අතර එය අත්තනෝමතික නිරවද්‍ය නිඛිලයකි (එනම් එය අවශ්‍ය පරිදි වර්ධනය වන අතර ඉහළ සීමාවක් නොමැත). ප්‍රකාශනයක් ගබඩා කළ නොහැකි ප්‍රති result intලයක් ලබා longදෙන්නේ නම් ඒවා නිහ ly ව පරිවර්තනය වේ int.

සරල, පයිතන් 3.4 සහ ඊට වැඩි

print (type(variable_name))

පයිතන් 2.7 සහ ඊට වැඩි

print type(variable_name)

එය සැබවින්ම රඳා පවතින්නේ ඔබ අදහස් කරන මට්ටම මත ය. පයිතන් 2.x හි, පූර්ණ සංඛ්‍යා වර්ග දෙකක් ඇත, int(සීමා කර ඇත sys.maxint) සහlong historical තිහාසික හේතූන් මත (අසීමිත නිරවද්‍යතාව). පයිතන් කේතයේ, මෙය සුළු වෙනසක් නොකළ යුතුය, මන්දයත් පරිවර්තකය සංඛ්‍යාවක් විශාල වූ විට ස්වයංක්‍රීයව දිගු බවට පරිවර්තනය වේ. යටින් පවතින පරිවර්තකයේ භාවිතා වන සත්‍ය දත්ත වර්ග ගැන දැන ගැනීමට ඔබට අවශ්‍ය නම්, එය ක්‍රියාත්මක කිරීම මත රඳා පවතී. (CPython's පිහිටා ඇත්තේ Objects / inbject.c සහ Objects / longobject.c.) පද්ධති වර්ග ගැන දැන ගැනීමට ව්‍යුහාත්මක මොඩියුලය භාවිතා කිරීම සඳහා පැහැදිලි පිළිතුර බලන්න.

Python2.x සඳහා, භාවිතා කරන්න

print type(variable_name)

Python3.x සඳහා, භාවිතා කරන්න

print(type(variable_name))

එය නොකරන්න. යමක් වර්ගයක් ඉල්ලීමම වැරදිය. ඒ වෙනුවට බහුමාපකය භාවිතා කරන්න. සොයා ගත හැකි හෝ අවශ්‍ය නම් ඕනෑම ආකාරයක ආදානය සඳහා ඔබට අවශ්‍ය දේ කරන ක්‍රමය ඔබ විසින්ම නිර්වචනය කර කිසිවක් ගැන විමසීමෙන් තොරව එය අමතන්න. තෙවන පාර්ශවීය පුස්තකාලයක් මගින් නිර්වචනය කර ඇති බිල්ට් වර්ග හෝ වර්ග සමඟ වැඩ කිරීමට ඔබට අවශ්‍ය නම්, ඔබට සැමවිටම ඒවායින් උරුම විය හැකි අතර ඒ වෙනුවට ඔබේම ව්‍යුත්පන්නයන් භාවිතා කළ හැකිය. නැතහොත් ඔබට ඒවා ඔබේ පන්තිය තුළම ඔතා ගත හැකිය. එවැනි ගැටළු විසඳීම සඳහා වස්තු-නැඹුරු මාර්ගය මෙයයි.

නිශ්චිත වර්ගය පරීක්ෂා කර අපිරිසිදු දෑ ifමෙහි සහ එහි තැබීමට ඔබ අවධාරනය කරන්නේ නම් , ඔබට එය කිරීමට __class__දේපළ හෝ typeක්‍රියාකාරිත්වය භාවිතා කළ හැකිය , නමුත් ඉතා ඉක්මණින් ඔබ මේ ifසෑම දෙයක්ම දෙවරක් හෝ තුනකට වරක් අතිරේක අවස්ථා සමඟ යාවත්කාලීන කරනු ඇත . OO ක්‍රමය කිරීමෙන් එය වළක්වන අතර ඒ වෙනුවට නව වර්ගයක ආදානයක් සඳහා නව පන්තියක් නිර්වචනය කිරීමට ඔබට ඉඩ සලසයි.