סוגים מובנים¶

Generated Thu 18 Jun 2026 05:00:56 UTC

חריגה¶

לכל החריגות יש מאפיינים קריאים `value` ו-`errno`, לא רק ל-`StopIteration` ול-`OSError`.¶

סיבה: MicroPython מותאם להקטנת גודל הקוד.

עקיפה: השתמש ב-value רק עם חריגות StopIteration, וב-errno רק עם חריגות OSError. אל תשתמש במאפיינים אלה ואל תסמוך עליהם בחריגות אחרות.

קוד לדוגמה:

e = Exception(1)
print(e.value)
print(e.errno)

CPython output:	MicroPython output:
Traceback (most recent call last): File "<stdin>", line 9, in <module> AttributeError: 'Exception' object has no attribute 'value'	1 1

שרשור חריגות אינו מיושם¶

קוד לדוגמה:

try:
    raise TypeError
except TypeError:
    raise ValueError

CPython output:

MicroPython output:

Traceback (most recent call last):
  File "<stdin>", line 9, in <module>
TypeError

During handling of the above exception, another exception occurred:

Traceback (most recent call last):
  File "<stdin>", line 11, in <module>
ValueError

Traceback (most recent call last):
  File "<stdin>", line 11, in <module>
ValueError:

מאפיינים מוגדרי-משתמש עבור חריגות מובנות אינם נתמכים¶

סיבה: MicroPython מותאם במידה גבוהה לצריכת זיכרון.

עקיפה: השתמש בתת-מחלקות חריגה מוגדרות-משתמש.

קוד לדוגמה:

e = Exception()
e.x = 0
print(e.x)

CPython output:	MicroPython output:
0	Traceback (most recent call last): File "<stdin>", line 9, in <module> AttributeError: 'Exception' object has no attribute 'x'

חריגה בתנאי לולאת while עשויה להציג מספר שורה בלתי צפוי¶

סיבה: בדיקות תנאי מותאמות להתרחש בסוף גוף הלולאה, ומספר השורה המדווח הוא של מיקום זה.

קוד לדוגמה:

l = ["-foo", "-bar"]

i = 0
while l[i][0] == "-":
    print("iter")
    i += 1

CPython output:

MicroPython output:

iter
iter
Traceback (most recent call last):
  File "<stdin>", line 11, in <module>
IndexError: list index out of range

iter
iter
Traceback (most recent call last):
  File "<stdin>", line 13, in <module>
IndexError: list index out of range

השיטה Exception.init אינה קיימת.¶

סיבה: יצירת תת-מחלקות ממחלקות מקוריות אינה נתמכת במלואה ב-MicroPython.

עקיפה: קרא באמצעות super() במקום:

class A(Exception):
    def __init__(self):
        super().__init__()

קוד לדוגמה:

class A(Exception):
    def __init__(self):
        Exception.__init__(self)


a = A()

CPython output:	MicroPython output:
	Traceback (most recent call last): File "<stdin>", line 18, in <module> File "<stdin>", line 15, in __init__ AttributeError: type object 'Exception' has no attribute '__init__'

OSError¶

OSError constructor returns a plain OSError for all errno values, rather than a relevant subtype.¶

Cause: MicroPython does not include the CPython-standard OSError subclasses.

Workaround: Catch OSError and use its errno attribute to discriminate the cause.

קוד לדוגמה:

import errno

errno_list = [  # i.e. the set implemented by micropython
    errno.EPERM,
    errno.ENOENT,
    errno.EIO,
    errno.EBADF,
    errno.EAGAIN,
    errno.ENOMEM,
    errno.EACCES,
    errno.EEXIST,
    errno.ENODEV,
    errno.EISDIR,
    errno.EINVAL,
    errno.EOPNOTSUPP,
    errno.EADDRINUSE,
    errno.ECONNABORTED,
    errno.ECONNRESET,
    errno.ENOBUFS,
    errno.ENOTCONN,
    errno.ETIMEDOUT,
    errno.ECONNREFUSED,
    errno.EHOSTUNREACH,
    errno.EALREADY,
    errno.EINPROGRESS,
]


def errno_output_type(n):
    try:
        raise OSError(n, "")
    except OSError as e:
        return f"{type(e).__name__}"
    except Exception as e:
        return f"non-OSError {type(e).__name__}"
    else:
        return "no error"


for n in errno_list:
    print(errno.errorcode[n], "=", errno_output_type(n))

CPython output:

MicroPython output:

EPERM = PermissionError
ENOENT = FileNotFoundError
EIO = OSError
EBADF = OSError
EAGAIN = BlockingIOError
ENOMEM = OSError
EACCES = PermissionError
EEXIST = FileExistsError
ENODEV = OSError
EISDIR = IsADirectoryError
EINVAL = OSError
ENOTSUP = OSError
EADDRINUSE = OSError
ECONNABORTED = ConnectionAbortedError
ECONNRESET = ConnectionResetError
ENOBUFS = OSError
ENOTCONN = OSError
ETIMEDOUT = TimeoutError
ECONNREFUSED = ConnectionRefusedError
EHOSTUNREACH = OSError
EALREADY = BlockingIOError
EINPROGRESS = BlockingIOError

EPERM = OSError
ENOENT = OSError
EIO = OSError
EBADF = OSError
EAGAIN = OSError
ENOMEM = OSError
EACCES = OSError
EEXIST = OSError
ENODEV = OSError
EISDIR = OSError
EINVAL = OSError
EOPNOTSUPP = OSError
EADDRINUSE = OSError
ECONNABORTED = OSError
ECONNRESET = OSError
ENOBUFS = OSError
ENOTCONN = OSError
ETIMEDOUT = OSError
ECONNREFUSED = OSError
EHOSTUNREACH = OSError
EALREADY = OSError
EINPROGRESS = OSError

bytearray¶

השמת פרוסת מערך עם ביטוי ימני לא נתמך¶

קוד לדוגמה:

b = bytearray(4)
b[0:1] = [1, 2]
print(b)

CPython output:	MicroPython output:
bytearray(b'\x01\x02\x00\x00\x00')	Traceback (most recent call last): File "<stdin>", line 9, in <module> NotImplementedError: array/bytes required on right side

bytes¶

אובייקטי bytes תומכים בשיטה .format()¶

סיבה: MicroPython שואף להיות מימוש אחיד יותר; אם גם str וגם bytes תומכים ב-__mod__() (אופרטור %), הגיוני לתמוך ב-format() לשניהם. ניתן גם להדיר את תמיכת __mod__ בזמן הידור, ואז format() הוא האפשרות היחידה לעיצוב bytes.

עקיפה: אם חשובה לך תאימות ל-CPython, אל תשתמש ב-.format() על אובייקטי bytes.

קוד לדוגמה:

print(b"{}".format(1))

CPython output:	MicroPython output:
Traceback (most recent call last): File "<stdin>", line 8, in <module> AttributeError: 'bytes' object has no attribute 'format'	b'1'

bytes() עם ארגומנטים לפי שם אינו מיושם¶

עקיפה: העבר את הקידוד כפרמטר מיקומי, למשל print(bytes('abc', 'utf-8'))

קוד לדוגמה:

print(bytes("abc", encoding="utf8"))

CPython output:	MicroPython output:
b'abc'	Traceback (most recent call last): File "<stdin>", line 8, in <module> NotImplementedError: keyword argument(s) not implemented - use normal args instead

הצבה לאינדקס bytes עם צעד שונה מ-1 אינה מיושמת¶

סיבה: MicroPython מותאם במידה גבוהה לצריכת זיכרון.

עקיפה: השתמש בלולאה מפורשת עבור פעולה נדירה זו.

קוד לדוגמה:

print(b"123"[0:3:2])

CPython output:	MicroPython output:
b'13'	Traceback (most recent call last): File "<stdin>", line 8, in <module> NotImplementedError: only slices with step=1 (aka None) are supported

complex¶

MicroPython’s complex() accepts certain incorrect values that CPython rejects¶

סיבה: MicroPython מותאם במידה גבוהה לצריכת זיכרון.

Workaround: Do not use non-standard complex literals as argument to complex()

MicroPython’s complex() function accepts literals that contain a space and no sign between the real and imaginary parts, and interprets it as a plus.

קוד לדוגמה:

try:
    print(complex("1 1j"))
except ValueError:
    print("ValueError")

CPython output:	MicroPython output:
ValueError	(1+1j)

dict¶

תצוגת המפתחות של מילון אינה מתנהגת כקבוצה.¶

סיבה: לא מיושם.

עקיפה: המר את המפתחות במפורש לקבוצה לפני ביצוע פעולות קבוצה.

קוד לדוגמה:

print({1: 2, 3: 4}.keys() & {1})

CPython output:	MicroPython output:
{1}	Traceback (most recent call last): File "<stdin>", line 8, in <module> TypeError: unsupported types for __and__: 'dict_view', 'set'

float¶

MicroPython allows implicit conversion of objects in maths operations while CPython does not.¶

עקיפה: עטוף אובייקטים ב-float(obj) לצורך תאימות ל-CPython.

קוד לדוגמה:

class Test:
    def __float__(self):
        return 0.5


print(2.0 * Test())

CPython output:	MicroPython output:
Traceback (most recent call last): File "<stdin>", line 14, in <module> TypeError: unsupported operand type(s) for *: 'float' and 'Test'	1.0

int¶

השיטה `bit_length` אינה קיימת.¶

סיבה: השיטה bit_length אינה מיושמת.

עקיפה: הימנע משימוש בשיטה זו ב-MicroPython.

קוד לדוגמה:

x = 255
print("{} is {} bits long.".format(x, x.bit_length()))

CPython output:	MicroPython output:
255 is 8 bits long.	Traceback (most recent call last): File "<stdin>", line 9, in <module> AttributeError: 'int' object has no attribute 'bit_length'

אין המרת int זמינה לסוגים הנגזרים מ-int¶

עקיפה: הימנע מיצירת תת-מחלקות מסוגים מובנים אלא אם כן הכרחי. העדף https://en.wikipedia.org/wiki/Composition_over_inheritance .

קוד לדוגמה:

class A(int):
    __add__ = lambda self, other: A(int(self) + other)


a = A(42)
print(a + a)

CPython output:	MicroPython output:
84	Traceback (most recent call last): File "<stdin>", line 14, in <module> File "<stdin>", line 10, in <lambda> TypeError: unsupported types for __radd__: 'int', 'int'

השיטה `to_bytes` אינה מיישמת את הפרמטר signed.¶

סיבה: הפרמטר לפי שם signed אינו מיושם עבור int.to_bytes().

כאשר המספר השלם שלילי, MicroPython מתנהג כמו CPython עם int.to_bytes(..., signed=True)

כאשר המספר השלם אי-שלילי, MicroPython מתנהג כמו CPython עם int.to_bytes(..., signed=False).

(ההבדל עדין, אך ב-CPython מספר שלם חיובי שהומר עם signed=True עשוי לדרוש בייט נוסף באורך הפלט, כדי להכיל את ביט הסימן 0.)

עקיפה: היזהר בעת קריאה ל-to_bytes() על ערך שלם שעלול להיות שלילי.

קוד לדוגמה:

x = -1
print(x.to_bytes(1, "big"))

CPython output:	MicroPython output:
Traceback (most recent call last): File "<stdin>", line 16, in <module> OverflowError: can't convert negative int to unsigned	b'\xff'

list¶

מחיקת פרוסת רשימה עם צעד שונה מ-1 אינה מיושמת¶

עקיפה: השתמש בלולאה מפורשת עבור פעולה נדירה זו.

קוד לדוגמה:

l = [1, 2, 3, 4]
del l[0:4:2]
print(l)

CPython output:	MicroPython output:
[2, 4]	Traceback (most recent call last): File "<stdin>", line 9, in <module> NotImplementedError:

אחסון פרוסת רשימה עם ביטוי ימני שאינו ניתן לאיטרציה אינו מיושם¶

סיבה: הביטוי הימני חייב להיות tuple או list

עקיפה: השתמש ב-list(<iter>) בצד הימני כדי להמיר את האיטרבל לרשימה

קוד לדוגמה:

l = [10, 20]
l[0:1] = range(4)
print(l)

CPython output:	MicroPython output:
[0, 1, 2, 3, 20]	Traceback (most recent call last): File "<stdin>", line 9, in <module> TypeError: object 'range' isn't a tuple or list

אחסון פרוסת רשימה עם צעד שונה מ-1 אינו מיושם¶

עקיפה: השתמש בלולאה מפורשת עבור פעולה נדירה זו.

קוד לדוגמה:

l = [1, 2, 3, 4]
l[0:4:2] = [5, 6]
print(l)

CPython output:	MicroPython output:
[5, 2, 6, 4]	Traceback (most recent call last): File "<stdin>", line 9, in <module> NotImplementedError:

memoryview¶

memoryview עלול להפוך לא תקף אם המטרה שלו משנה גודל¶

סיבה: CPython מונע שינוי גודל של אובייקט bytearray או io.bytesIO כל עוד קיים memoryview המפנה אליו. MicroPython דורש מהמתכנת לוודא ידנית שאובייקט אינו משנה גודל כל עוד מפנה אליו memoryview כלשהו.

בתרחיש הגרוע ביותר, שינוי גודל אובייקט שהוא מטרה של memoryview עלול לגרום ל-memoryview/ים להפנות לזיכרון משוחרר לא תקף (באג use-after-free) ולפגוע בסביבת הריצה של MicroPython.

עקיפה: אל תשנה את הגודל של אובייקט bytearray או io.bytesIO שיש לו memoryview המצביע עליו.

קוד לדוגמה:

b = bytearray(b"abcdefg")
m = memoryview(b)
b.extend(b"hijklmnop")
print(b, bytes(m))

CPython output:	MicroPython output:
Traceback (most recent call last): File "<stdin>", line 12, in <module> BufferError: Existing exports of data: object cannot be re-sized	bytearray(b'abcdefghijklmnop') b'abcdefg'

range¶

Range objects with large start or stop arguments misbehave.¶

Cause: Intermediate calculations overflow the C mp_int_t type

Workaround: Avoid using such ranges

קוד לדוגמה:

from sys import maxsize

# A range including `maxsize-1` cannot be created
try:
    print(range(-maxsize - 1, 0))
except OverflowError:
    print("OverflowError")

# A range with `stop-start` exceeding sys.maxsize has incorrect len(), while CPython cannot calculate len().
try:
    print(len(range(-maxsize, maxsize)))
except OverflowError:
    print("OverflowError")

# A range with `stop-start` exceeding sys.maxsize has incorrect len()
try:
    print(len(range(-maxsize, maxsize, maxsize)))
except OverflowError:
    print("OverflowError")

CPython output:	MicroPython output:
range(-9223372036854775808, 0) OverflowError 2	OverflowError 0 0

str¶

MicroPython accepts the ”,“ grouping option with any radix, unlike CPython¶

Cause: To reduce code size, MicroPython does not issue an error for this combination

Workaround: Do not use a format string like {:,b} if CPython compatibility is required.

קוד לדוגמה:

try:
    print("{:,b}".format(99))
except ValueError:
    print("ValueError")
try:
    print("{:,x}".format(99))
except ValueError:
    print("ValueError")
try:
    print("{:,o}".format(99))
except ValueError:
    print("ValueError")

CPython output:	MicroPython output:
ValueError ValueError ValueError	110,0011 63 143

MicroPython accepts but does not properly implement the ”,“ or ”_“ grouping character for float values¶

Cause: To reduce code size, MicroPython does not implement this combination. Grouping characters will not appear in the number’s significant digits and will appear at incorrect locations in leading zeros.

Workaround: Do not use a format string like {:,f} if exact CPython compatibility is required.

קוד לדוגמה:

print("{:,f}".format(3141.159))
print("{:_f}".format(3141.159))
print("{:011,.2f}".format(3141.159))
print("{:011_.2f}".format(3141.159))

CPython output:	MicroPython output:
3,141.159000 3_141.159000 0,003,141.16 0_003_141.16	3141.159000 3141.159000 000,3141.16 0_003141.16

מאפיינים/אינדוקס אינם מיושמים¶

קוד לדוגמה:

print("{a[0]}".format(a=[1, 2]))

CPython output:	MicroPython output:
1	Traceback (most recent call last): File "<stdin>", line 8, in <module> NotImplementedError: attributes not supported

str(…) עם ארגומנטים לפי שם אינו מיושם¶

עקיפה: הזן את פורמט הקידוד ישירות, למשל print(bytes('abc', 'utf-8'))

קוד לדוגמה:

print(str(b"abc", encoding="utf8"))

CPython output:	MicroPython output:
abc	Traceback (most recent call last): File "<stdin>", line 8, in <module> NotImplementedError: keyword argument(s) not implemented - use normal args instead

str.ljust() ו-str.rjust() אינם מיושמים¶

סיבה: MicroPython מותאם במידה גבוהה לצריכת זיכרון. קיימות עקיפות קלות.

עקיפה: במקום s.ljust(10) השתמש ב-"%-10s" % s; במקום s.rjust(10) השתמש ב-"% 10s" % s. לחלופין, "{:<10}".format(s) או "{:>10}".format(s).

קוד לדוגמה:

print("abc".ljust(10))

CPython output:	MicroPython output:
abc	Traceback (most recent call last): File "<stdin>", line 8, in <module> AttributeError: 'str' object has no attribute 'ljust'

None כארגומנט ראשון ל-rsplit כגון str.rsplit(None, n) אינו מיושם¶

קוד לדוגמה:

print("a a a".rsplit(None, 1))

CPython output:	MicroPython output:
['a a', 'a']	Traceback (most recent call last): File "<stdin>", line 8, in <module> NotImplementedError: rsplit(None,n)

אינדוקס עם צעד שונה מ-1 טרם מיושם¶

קוד לדוגמה:

print("abcdefghi"[0:9:2])

CPython output:	MicroPython output:
acegi	Traceback (most recent call last): File "<stdin>", line 8, in <module> NotImplementedError: only slices with step=1 (aka None) are supported

tuple¶

קריאת פרוסת tuple עם צעד שונה מ-1 אינה מיושמת¶

קוד לדוגמה:

print((1, 2, 3, 4)[0:4:2])

CPython output:	MicroPython output:
(1, 3)	Traceback (most recent call last): File "<stdin>", line 8, in <module> NotImplementedError: only slices with step=1 (aka None) are supported

סוגים מובנים¶

חריגה¶

לכל החריגות יש מאפיינים קריאים value ו-errno, לא רק ל-StopIteration ול-OSError.¶

שרשור חריגות אינו מיושם¶

מאפיינים מוגדרי-משתמש עבור חריגות מובנות אינם נתמכים¶

חריגה בתנאי לולאת while עשויה להציג מספר שורה בלתי צפוי¶

השיטה Exception.__init__ אינה קיימת.¶

OSError¶

OSError constructor returns a plain OSError for all errno values, rather than a relevant subtype.¶

bytearray¶

השמת פרוסת מערך עם ביטוי ימני לא נתמך¶

bytes¶

אובייקטי bytes תומכים בשיטה .format()¶

bytes() עם ארגומנטים לפי שם אינו מיושם¶

הצבה לאינדקס bytes עם צעד שונה מ-1 אינה מיושמת¶

complex¶

MicroPython’s complex() accepts certain incorrect values that CPython rejects¶

dict¶

תצוגת המפתחות של מילון אינה מתנהגת כקבוצה.¶

float¶

MicroPython allows implicit conversion of objects in maths operations while CPython does not.¶

int¶

השיטה bit_length אינה קיימת.¶

אין המרת int זמינה לסוגים הנגזרים מ-int¶

השיטה to_bytes אינה מיישמת את הפרמטר signed.¶

list¶

מחיקת פרוסת רשימה עם צעד שונה מ-1 אינה מיושמת¶

אחסון פרוסת רשימה עם ביטוי ימני שאינו ניתן לאיטרציה אינו מיושם¶

אחסון פרוסת רשימה עם צעד שונה מ-1 אינו מיושם¶

memoryview¶

memoryview עלול להפוך לא תקף אם המטרה שלו משנה גודל¶

range¶

Range objects with large start or stop arguments misbehave.¶

str¶

MicroPython accepts the ”,“ grouping option with any radix, unlike CPython¶

MicroPython accepts but does not properly implement the ”,“ or ”_“ grouping character for float values¶

מאפיינים/אינדוקס אינם מיושמים¶

str(…) עם ארגומנטים לפי שם אינו מיושם¶

str.ljust() ו-str.rjust() אינם מיושמים¶

None כארגומנט ראשון ל-rsplit כגון str.rsplit(None, n) אינו מיושם¶

אינדוקס עם צעד שונה מ-1 טרם מיושם¶

tuple¶

קריאת פרוסת tuple עם צעד שונה מ-1 אינה מיושמת¶

לכל החריגות יש מאפיינים קריאים `value` ו-`errno`, לא רק ל-`StopIteration` ול-`OSError`.¶

השיטה Exception.init אינה קיימת.¶

השיטה `bit_length` אינה קיימת.¶

השיטה `to_bytes` אינה מיישמת את הפרמטר signed.¶