builtins — פונקציות וחריגות מובנות

כל הפונקציות והחריגות המובנות מתוארות כאן. הן זמינות גם דרך המודול builtins.

פונקציות וטיפוסים

abs(x: Any) → Any

מחזירה את הערך המוחלט של מספר. הארגומנט יכול להיות מספר שלם, מספר עשרוני, או כל אובייקט שמממש את __abs__().

all(iterable: Iterable[Any]) → bool

מחזירה True אם כל האיברים של iterable הם אמיתיים (truthy) (או אם ה-iterable ריק).

any(iterable: Iterable[Any]) → bool

מחזירה True אם איבר כלשהו של iterable הוא אמיתי (truthy). מחזירה False אם ה-iterable ריק.

bin(x: int) → str

ממירה מספר שלם למחרוזת בינארית עם הקידומת "0b". הארגומנט חייב להיות מספר שלם של Python או לממש את __index__().

class bool(x: Any = False)

מחזירה ערך בוליאני, כלומר אחד מבין True או False. x מומר באמצעות הליך בדיקת האמת הסטנדרטי.

class bytearray(source: int | str | Iterable[int] | bytes = b'', encoding: str = 'utf-8', errors: str = 'strict')

רצף ניתן לשינוי של מספרים שלמים בטווח 0-255. הבנייה עוקבת אחר אותם כללים כמו bytes: ממספר שלם (יצירת חוצץ באורך זה מאופס באפסים), מ-iterable של מספרים שלמים, ממחרוזת עם encoding, או מכל אובייקט התומך בפרוטוקול החוצץ. תומך בפעולות הרצף הסטנדרטיות בתוספת שינוי במקום.

classmethod fromhex(string: str) → bytearray

בונה bytearray ממחרוזת של זוגות ספרות הקסדצימליות. רווחים בין זוגות הספרות מדולגים; תו שאינו הקסדצימלי מעלה ValueError.

append(val: int) → None

מוסיפה ערך יחיד (מספר שלם בטווח 0-255) לסוף ה-bytearray, ומגדילה אותו בבית אחד.

center(width: int, fillbyte: bytes) → bytes

מחזירה עותק של התוכן ממורכז ברצף באורך width, מרופד ב-fillbyte. בניגוד ל-CPython, fillbyte נדרש. הנתונים מוחזרים ללא שינוי כאשר width אינו גדול מהאורך הנוכחי.

count(sub: bytes, start: int = 0, end: int = -1) → int

מחזירה את מספר המופעים הלא-חופפים של sub בפרוסה [start:end].

endswith(suffix: bytes, start: int = 0, end: int = -1) → bool

מחזירה True אם התוכן מסתיים ב-suffix. בניגוד ל-CPython, suffix אינו יכול להיות tuple של ערכים.

extend(iterable: Iterable[int]) → None

מוסיפה את כל הפריטים מ-iterable לסוף ה-bytearray. כהרחבה ל-CPython, ניתן להשתמש בכל אובייקט התומך בפרוטוקול החוצץ.

find(sub: bytes, start: int = 0, end: int = -1) → int

מחזירה את האינדקס הנמוך ביותר שבו נמצא sub בתוך הפרוסה [start:end], או -1 אם לא נמצא.

format(*args: Any, **kwargs: Any) → str

מבצעת פעולת עיצוב מחרוזת באמצעות התוכן כמחרוזת העיצוב, ומחזירה את התוצאה המעוצבת.

hex(sep: str = '') → str

מחזירה מחרוזת של שתי ספרות הקסדצימליות עבור כל בית. אם ניתן ה-sep האופציונלי (מחרוזת באורך 1), הוא משולב בין ערכי בתים עוקבים.

index(sub: bytes, start: int = 0, end: int = -1) → int

כמו find(), אך מעלה ValueError כאשר sub לא נמצא.

isalpha() → bool

מחזירה True אם כל הבתים הם תווי ASCII אלפביתיים ויש לפחות בית אחד, אחרת False.

isdigit() → bool

מחזירה True אם כל הבתים הם ספרות עשרוניות של ASCII ויש לפחות בית אחד, אחרת False.

islower() → bool

מחזירה True אם כל הבתים בעלי האותיות הם אותיות קטנות ויש לפחות בית אחד בעל אות, אחרת False.

isspace() → bool

מחזירה True אם כל הבתים הם תווי רווח לבן של ASCII ויש לפחות בית אחד, אחרת False.

isupper() → bool

מחזירה True אם כל הבתים בעלי האותיות הם אותיות גדולות ויש לפחות בית אחד בעל אות, אחרת False.

join(iterable: Iterable[bytes]) → bytes

מחזירה אובייקט bytes שהוא השרשור של הפריטים ב-iterable, תוך שימוש בתוכן ה-bytearray כמפריד.

lower() → bytes

מחזירה עותק של התוכן עם כל האותיות הגדולות של ASCII מומרות לאותיות קטנות.

lstrip(chars: bytes | None = None) → bytes

מחזירה עותק עם בתים מובילים שהוסרו. chars מציין את קבוצת הבתים להסרה; אם הושמט או None, רווח לבן של ASCII מוסר.

partition(sep: bytes) → tuple

מפצלת במופע הראשון של sep, ומחזירה (head, sep, tail). אם sep לא נמצא, מחזירה את התוכן ואחריו שני אובייקטים ריקים.

replace(old: bytes, new: bytes, count: int = -1) → bytes

מחזירה עותק עם כל המופעים של old מוחלפים ב-new. אם ניתן count, רק count המופעים הראשונים מוחלפים.

rfind(sub: bytes, start: int = 0, end: int = -1) → int

מחזירה את האינדקס הגבוה ביותר שבו נמצא sub בתוך הפרוסה [start:end], או -1 אם לא נמצא.

rindex(sub: bytes, start: int = 0, end: int = -1) → int

כמו rfind(), אך מעלה ValueError כאשר sub לא נמצא.

rpartition(sep: bytes) → tuple

מפצלת במופע האחרון של sep, ומחזירה (head, sep, tail). אם sep לא נמצא, מחזירה שני אובייקטים ריקים ואחריהם התוכן.

rsplit(sep: bytes | None = None, maxsplit: int = -1) → list

מפצלת במופעים של sep לרשימה של חלקים, ומבצעת לכל היותר maxsplit פיצולים בספירה מצד ימין. אם sep הוא None או הושמט, מפצלת ברצפים של רווח לבן של ASCII.

rstrip(chars: bytes | None = None) → bytes

מחזירה עותק עם בתים נגררים שהוסרו. chars מציין את קבוצת הבתים להסרה; אם הושמט או None, רווח לבן של ASCII מוסר.

split(sep: bytes | None = None, maxsplit: int = -1) → list

מפצלת במופעים של sep לרשימה של חלקים. אם sep הוא None או הושמט, מפצלת ברצפים של רווח לבן של ASCII ורווח לבן מוביל/נגרר מתעלמים ממנו.

splitlines(keepends: bool = False) → list

מחזירה רשימה של השורות, תוך שבירה ב-\n, ב-\r וב-\r\n. שברי השורות אינם נכללים אלא אם keepends הוא אמת.

startswith(prefix: bytes, start: int = 0, end: int = -1) → bool

מחזירה True אם התוכן מתחיל ב-prefix. בניגוד ל-CPython, prefix אינו יכול להיות tuple, ו-end מתקבל אך מתעלמים ממנו.

strip(chars: bytes | None = None) → bytes

מחזירה עותק עם בתים מובילים ונגררים שהוסרו. chars מציין את קבוצת הבתים להסרה; אם הושמט או None, רווח לבן של ASCII מוסר.

upper() → bytes

מחזירה עותק של התוכן עם כל האותיות הקטנות של ASCII מומרות לאותיות גדולות.

class bytes(source: int | str | Iterable[int] = b'', encoding: str = 'utf-8', errors: str = 'strict')

רצף בלתי-ניתן-לשינוי של מספרים שלמים בטווח 0-255. נוצר ממספר שלם (חוצץ מאופס באפסים), מ-iterable של מספרים שלמים, ממחרוזת עם encoding, או מכל אובייקט התומך בפרוטוקול החוצץ. ליטרלים של bytes משתמשים בתחביר b'...'.

classmethod fromhex(string: str) → bytes

בונה אובייקט bytes ממחרוזת של זוגות ספרות הקסדצימליות. רווחים בין זוגות הספרות מדולגים; תו שאינו הקסדצימלי מעלה ValueError.

center(width: int, fillbyte: bytes) → bytes

מחזירה עותק ממורכז ברצף באורך width, מרופד ב-fillbyte (bytes באורך 1 שנותן את בית הריפוד). בניגוד ל-CPython, fillbyte נדרש. האובייקט המקורי מוחזר ללא שינוי כאשר width אינו גדול מאורכו.

count(sub: bytes, start: int = 0, end: int = -1) → int

מחזירה את מספר המופעים הלא-חופפים של sub בפרוסה [start:end].

decode(encoding: str = 'utf-8') → str

מחזירה str מפוענח מן הבתים. ב-MicroPython הארגומנט encoding מתקבל אך למעשה מתעלמים ממנו (הבתים מתפרשים מחדש כ-UTF-8).

endswith(suffix: bytes, start: int = 0, end: int = -1) → bool

מחזירה True אם הבתים מסתיימים ב-suffix. בניגוד ל-CPython, suffix אינו יכול להיות tuple של ערכים לניסיון.

find(sub: bytes, start: int = 0, end: int = -1) → int

מחזירה את האינדקס הנמוך ביותר שבו נמצאת תת-הסדרה sub בתוך הפרוסה [start:end], או -1 אם לא נמצאה.

format(*args: Any, **kwargs: Any) → str

מבצעת פעולת עיצוב מחרוזת באמצעות הבתים כמחרוזת העיצוב, ומחזירה את התוצאה המעוצבת.

hex(sep: str = '') → str

מחזירה מחרוזת של שתי ספרות הקסדצימליות עבור כל בית. אם ניתן ה-sep האופציונלי (מחרוזת באורך 1), הוא משולב בין ערכי בתים עוקבים.

index(sub: bytes, start: int = 0, end: int = -1) → int

כמו find(), אך מעלה ValueError כאשר sub לא נמצא.

isalpha() → bool

מחזירה True אם כל הבתים הם תווי ASCII אלפביתיים ויש לפחות בית אחד, אחרת False.

isdigit() → bool

מחזירה True אם כל הבתים הם ספרות עשרוניות של ASCII ויש לפחות בית אחד, אחרת False.

islower() → bool

מחזירה True אם כל הבתים בעלי האותיות הם אותיות קטנות ויש לפחות בית אחד בעל אות, אחרת False.

isspace() → bool

מחזירה True אם כל הבתים הם תווי רווח לבן של ASCII ויש לפחות בית אחד, אחרת False.

isupper() → bool

מחזירה True אם כל הבתים בעלי האותיות הם אותיות גדולות ויש לפחות בית אחד בעל אות, אחרת False.

join(iterable: Iterable[bytes]) → bytes

מחזירה אובייקט bytes שהוא השרשור של הפריטים ב-iterable, תוך שימוש באובייקט ה-bytes עצמו כמפריד.

lower() → bytes

מחזירה עותק עם כל האותיות הגדולות של ASCII מומרות לאותיות קטנות.

lstrip(chars: bytes | None = None) → bytes

מחזירה עותק עם בתים מובילים שהוסרו. chars מציין את קבוצת הבתים להסרה; אם הושמט או None, רווח לבן של ASCII מוסר.

partition(sep: bytes) → tuple

מפצלת במופע הראשון של sep, ומחזירה (head, sep, tail). אם sep לא נמצא, מחזירה את הבתים ואחריהם שני אובייקטי bytes ריקים.

replace(old: bytes, new: bytes, count: int = -1) → bytes

מחזירה עותק עם כל המופעים של old מוחלפים ב-new. אם ניתן count, רק count המופעים הראשונים מוחלפים.

rfind(sub: bytes, start: int = 0, end: int = -1) → int

מחזירה את האינדקס הגבוה ביותר שבו נמצא sub בתוך הפרוסה [start:end], או -1 אם לא נמצא.

rindex(sub: bytes, start: int = 0, end: int = -1) → int

כמו rfind(), אך מעלה ValueError כאשר sub לא נמצא.

rpartition(sep: bytes) → tuple

מפצלת במופע האחרון של sep, ומחזירה (head, sep, tail). אם sep לא נמצא, מחזירה שני אובייקטי bytes ריקים ואחריהם הבתים.

rsplit(sep: bytes | None = None, maxsplit: int = -1) → list

מפצלת במופעים של sep לרשימה של חלקים, ומבצעת לכל היותר maxsplit פיצולים בספירה מצד ימין. אם sep הוא None או הושמט, מפצלת ברצפים של רווח לבן של ASCII.

rstrip(chars: bytes | None = None) → bytes

מחזירה עותק עם בתים נגררים שהוסרו. chars מציין את קבוצת הבתים להסרה; אם הושמט או None, רווח לבן של ASCII מוסר.

split(sep: bytes | None = None, maxsplit: int = -1) → list

מפצלת במופעים של sep לרשימה של חלקים. אם sep הוא None או הושמט, מפצלת ברצפים של רווח לבן של ASCII ורווח לבן מוביל/נגרר מתעלמים ממנו.

splitlines(keepends: bool = False) → list

מחזירה רשימה של השורות, תוך שבירה ב-\n, ב-\r וב-\r\n. שברי השורות אינם נכללים אלא אם keepends הוא אמת.

startswith(prefix: bytes, start: int = 0, end: int = -1) → bool

מחזירה True אם הבתים מתחילים ב-prefix. בניגוד ל-CPython, prefix אינו יכול להיות tuple, ו-end מתקבל אך מתעלמים ממנו.

strip(chars: bytes | None = None) → bytes

מחזירה עותק עם בתים מובילים ונגררים שהוסרו. chars מציין את קבוצת הבתים להסרה; אם הושמט או None, רווח לבן של ASCII מוסר.

upper() → bytes

מחזירה עותק עם כל האותיות הקטנות של ASCII מומרות לאותיות גדולות.

callable(obj: Any) → bool

מחזירה True אם obj נראה ניתן-לקריאה (callable), אחרת False.

chr(i: int) → str

מחזירה מחרוזת של תו אחד שנקודת הקוד שלו ב-Unicode היא המספר השלם i.

classmethod(func: Callable[..., Any]) → classmethod

הופכת מתודה למתודת מחלקה. בדרך כלל משמשת כדקורטור.

compile(source: str | bytes, filename: str, mode: str) → Any

מהדרת את source לאובייקט קוד שניתן להריצו באמצעות exec() או eval(). mode הוא אחד מבין "exec", "eval" או "single".

class complex(real: float | str = 0, imag: float = 0)

יוצרת מספר מרוכב מחלק ממשי ומדומה, או ממחרוזת.

delattr(obj, name: str) → None

הארגומנט name צריך להיות מחרוזת, ופונקציה זו מוחקת את המאפיין הנקוב מן האובייקט הנתון על ידי obj.

class dict(*args, **kwargs)

יוצרת מילון חדש. שקול ל-dict של CPython.

classmethod fromkeys(iterable: Iterable[Any], value: Any = None) → dict

יוצרת מילון חדש עם מפתחות הלקוחים מ-iterable, כל אחד ממופה ל-value (ברירת המחדל היא None). נקראת על הטיפוס, למשל dict.fromkeys(...).

clear() → None

מסירה את כל הפריטים מן המילון, ומותירה אותו ריק. מעלה TypeError אם המילון קבוע (לקריאה בלבד).

copy() → dict

מחזירה עותק שטחי של המילון. לאובייקט המוחזר יש אותו טיפוס כמו למקור (dict או OrderedDict) אך הוא אינו קבוע.

get(key: Any, default: Any = None) → Any

מחזירה את הערך עבור key אם הוא במילון, אחרת מחזירה את default (שברירת המחדל שלו עצמו היא None, כך שזה לעולם אינו מעלה KeyError). המילון אינו משתנה.

items() → Any

מחזירה אובייקט תצוגה דינמי על פני זוגות ה-(key, value) המשקף שינויים מאוחרים יותר במילון ותומך באיטרציה, ב-len(), באופרטור in ובאופרטורי השוואת קבוצות.

keys() → Any

מחזירה אובייקט תצוגה דינמי על פני המפתחות המשקף שינויים מאוחרים יותר במילון ותומך באיטרציה, ב-len(), באופרטור in ובאופרטורי השוואת קבוצות.

pop(key: Any, default: Any = None) → Any

מסירה את key מן המילון ומחזירה את ערכו. אם key אינו קיים, מחזירה את default אם סופק; אחרת מעלה KeyError. מעלה TypeError אם המילון קבוע.

popitem() → tuple

מסירה ומחזירה זוג (key, value) שרירותי כ-tuple בן 2 איברים. עבור dict רגיל הזוג הנבחר אינו מוגדר; עבור OrderedDict מוסר הזוג שהוכנס אחרון (LIFO). מעלה KeyError אם המילון ריק, או TypeError אם הוא קבוע.

setdefault(key: Any, default: Any = None) → Any

אם key במילון, מחזירה את ערכו. אחרת מכניסה את key עם ערך של default (ברירת המחדל None) ומחזירה ערך זה. מעלה TypeError אם המילון קבוע.

update(*args: Any, **kwargs: Any) → None

מעדכנת את המילון במקום. מתקבל לכל היותר ארגומנט מיקומי אחד: או מילון אחר, או iterable של זוגות בני שני איברים (key, value) (כל אחד חייב להניב בדיוק שני פריטים אחרת מועלה ValueError). ארגומנטים של מילות מפתח מתווספים לאחר מכן כרשומות עם מפתחות מחרוזת. מפתחות קיימים נדרסים. מעלה TypeError אם המילון קבוע.

values() → Any

מחזירה אובייקט תצוגה דינמי על פני הערכים המשקף שינויים מאוחרים יותר במילון ותומך באיטרציה וב-len().

__getitem__(key: Any) → Any

מחזירה self[key]. מממשת את אופרטור האינדוקס d[key]; מעלה KeyError אם key אינו קיים.

__setitem__(key: Any, value: Any) → None

מגדירה את self[key] ל-value. מממשת את d[key] = value.

__delitem__(key: Any) → None

מוחקת את self[key]. מממשת את del d[key]; מעלה KeyError אם key אינו קיים.

dir(obj: Any = None) → list

ללא ארגומנטים, מחזירה את רשימת השמות בתחום המקומי הנוכחי. עם ארגומנט, מחזירה רשימה של מאפיינים תקפים עבור אותו אובייקט.

divmod(a: Any, b: Any) → tuple

מחזירה את הזוג (a // b, a % b) כ-tuple, עבור שני מספרים (לא-מרוכבים).

enumerate(iterable: Iterable[Any], start: int = 0) → Iterator[tuple]

מחזירה אובייקט enumerate המניב זוגות (index, value) מ-iterable, כאשר האינדקס מתחיל ב-start.

eval(expression: str | bytes, globals: dict | None = None, locals: dict | None = None) → Any

מעריכה ביטוי Python הנתון כמחרוזת (או אובייקט קוד מהודר) ומחזירה את התוצאה.

exec(object: str | bytes, globals: dict | None = None, locals: dict | None = None) → None

מריצה באופן דינמי קוד Python המסופק כמחרוזת או כאובייקט קוד מהודר.

filter(function: Callable[[Any], Any] | None, iterable: Iterable[Any]) → Iterator[Any]

בונה איטרטור מתוך אותם איברים של iterable שעבורם function מחזירה אמת. אם function היא None, מונחת פונקציית הזהות.

class float(x: str | bytes | int | float = 0.0)

מחזירה מספר עשרוני שנבנה ממספר או ממחרוזת x.

class frozenset(iterable: Iterable[Any] = ())

מחזירה אובייקט frozenset חדש, אופציונלית עם איברים הלקוחים מ-iterable. frozenset הוא וריאנט בלתי-ניתן-לשינוי וניתן-לגיבוב (hashable) של set.

copy() → frozenset

מחזירה עותק שטחי של ה-frozenset.

difference(*others: Iterable[Any]) → frozenset

מחזירה frozenset חדש עם איברים מן ה-frozenset שאינם באף אחד מ-others. כל ארגומנט יכול להיות iterable כלשהו.

intersection(other: Iterable[Any]) → frozenset

מחזירה frozenset חדש עם איברים המשותפים ל-frozenset ול-other. ב-MicroPython מתקבל רק ארגומנט other יחיד (CPython מקבל מספר רב).

isdisjoint(other: Iterable[Any]) → bool

מחזירה True אם ל-frozenset אין איברים משותפים עם other.

issubset(other: Iterable[Any]) → bool

מחזירה True אם כל איבר של ה-frozenset נמצא ב-other.

issuperset(other: Iterable[Any]) → bool

מחזירה True אם כל איבר של other נמצא ב-frozenset.

symmetric_difference(other: Iterable[Any]) → frozenset

מחזירה frozenset חדש עם איברים הנמצאים ב-frozenset או ב-other אך לא בשניהם. ב-MicroPython מתקבל רק ארגומנט other יחיד.

union(other: Iterable[Any]) → frozenset

מחזירה frozenset חדש עם איברים מן ה-frozenset ומ-other. ב-MicroPython מתקבל רק ארגומנט other יחיד (CPython מקבל מספר רב).

getattr(obj: Any, name: str, default: Any = None) → Any

מחזירה את ערכו של המאפיין הנקוב של obj. אם המאפיין אינו קיים, default מוחזר אם סופק, אחרת מועלה AttributeError.

globals() → dict

מחזירה מילון המייצג את טבלת הסמלים הגלובלית של המודול הנוכחי.

hasattr(obj: Any, name: str) → bool

מחזירה True אם ל-obj יש מאפיין בעל ה-name הנתון, אחרת False.

hash(obj: Any) → int

מחזירה את ערך הגיבוב (hash) של obj (אם יש לו כזה). ערכי גיבוב הם מספרים שלמים המשמשים להשוואה מהירה של מפתחות מילון במהלך חיפוש במילון.

hex(x: int) → str

ממירה מספר שלם למחרוזת הקסדצימלית באותיות קטנות עם הקידומת "0x".

id(obj: Any) → int

מחזירה את זהות האובייקט. זהו מספר שלם שמובטח שיהיה ייחודי וקבוע עבור אובייקט זה במהלך חייו.

input(prompt: str = '') → str

קוראת שורה מן הקלט הסטנדרטי ומחזירה אותה כמחרוזת (ללא תו שורה חדשה נגרר). אם ניתן prompt, הוא נכתב לפלט הסטנדרטי ללא תו שורה חדשה נגרר תחילה.

class int(x: str | bytes | int | float = 0, base: int = 10)

classmethod from_bytes(bytes: bytes, byteorder: str) → int

ב-MicroPython, הפרמטר byteorder חייב להיות מיקומי (זה תואם ל-CPython).

to_bytes(size: int, byteorder: str) → bytes

ב-MicroPython, הפרמטר byteorder חייב להיות מיקומי (זה תואם ל-CPython).

הערה

ה-kwarg האופציונלי signed מ-CPython אינו נתמך. MicroPython כרגע ממיר מספרים שלמים שליליים כמסומנים (signed), וחיוביים כלא-מסומנים (unsigned). (פרטים.)

isinstance(obj: Any, classinfo: type | tuple) → bool

מחזירה True אם obj הוא מופע של classinfo או של אחת ממחלקות המשנה שלו. classinfo יכול להיות מחלקה או tuple של מחלקות.

issubclass(cls: type, classinfo: type | tuple) → bool

מחזירה True אם cls הוא מחלקת משנה (ישירה, עקיפה, או וירטואלית) של classinfo.

iter(obj: Any, sentinel: Any = None) → Iterator[Any]

מחזירה אובייקט איטרטור. עם ארגומנט אחד, obj חייב לתמוך בפרוטוקול האיטרציה. עם שני ארגומנטים, obj חייב להיות ניתן-לקריאה (callable) והאיטרציה נעצרת כאשר הוא מחזיר sentinel.

len(obj: Any) → int

מחזירה את מספר הפריטים במכל.

class list(iterable: Iterable[Any] = ())

בונה רשימה חדשה, אופציונלית מאוכלסת מפריטים ב-iterable.

append(object: Any) → None

מוסיפה את object לסוף הרשימה.

clear() → None

מסירה את כל הפריטים מן הרשימה, ומותירה אותה ריקה.

copy() → list

מחזירה עותק שטחי של הרשימה.

count(value: Any) → int

מחזירה את מספר האיברים ברשימה השווים ל-value.

extend(iterable: Iterable[Any]) → None

מוסיפה את כל הפריטים מ-iterable לסוף הרשימה. אם iterable הוא עצמו רשימה, פריטיו מועתקים ישירות; אחרת עוברים עליו באיטרציה.

index(value: Any, start: int = 0, stop: int = -1) → int

מחזירה את האינדקס של האיבר הראשון השווה ל-value, תוך חיפוש בפרוסה [start:stop]. מעלה ValueError אם value אינו קיים.

insert(index: int, object: Any) → None

מכניסה את object לפני המיקום index. index שלילי מתפרש ביחס לסוף הרשימה, והאינדקס מוצמד לטווח התקף (כך שערכים שמעבר לכל קצה מכניסים בתחילה או בסוף).

pop(index: int = -1) → Any

מסירה ומחזירה את הפריט ב-index (הפריט האחרון כברירת מחדל). מעלה IndexError אם הרשימה ריקה או index מחוץ לטווח.

remove(value: Any) → None

מסירה את האיבר הראשון השווה ל-value. מעלה ValueError אם value אינו קיים.

reverse() → None

הופכת את סדר הפריטים של הרשימה במקום.

sort(*, key: Callable[[Any], Any] | None = None, reverse: bool = False) → None

ממיינת את פריטי הרשימה במקום. key ו-reverse הם מילות-מפתח-בלבד. key, אם ניתן, היא פונקציה המופעלת על כל איבר כדי להפיק את ערך ההשוואה; reverse ממיין בסדר יורד.

הערה

בניגוד ל-CPython, מיון הרשימה של MicroPython אינו יציב.

locals() → dict

מחזירה מילון המייצג את טבלת הסמלים המקומית הנוכחית.

map(function: Callable[..., Any], *iterables: Iterable[Any]) → Iterator[Any]

מחזירה איטרטור המפעיל את function על כל פריט של iterables, ומניב את התוצאות.

max(*args: Any, key: Callable[[Any], Any] | None = None, default: Any = None) → Any

עם ארגומנט iterable יחיד, מחזירה את הפריט הגדול ביותר שלו. עם שני ארגומנטים או יותר, מחזירה את הארגומנט הגדול ביותר.

class memoryview(obj: Any)

יוצרת memoryview המפנה אל obj, אשר חייב לתמוך בפרוטוקול החוצץ (למשל bytes, bytearray, array.array). מאפשר גישה ופריסה (slicing) ללא העתקה של הזיכרון הבסיסי; פריסה של memoryview מחזירה memoryview אחר במקום עותק.

min(*args: Any, key: Callable[[Any], Any] | None = None, default: Any = None) → Any

עם ארגומנט iterable יחיד, מחזירה את הפריט הקטן ביותר שלו. עם שני ארגומנטים או יותר, מחזירה את הארגומנט הקטן ביותר.

next(iterator: Iterator[Any], default: Any = None) → Any

מאחזרת את הפריט הבא מ-iterator. אם ניתן default והאיטרטור מוצה, default מוחזר במקום העלאת StopIteration.

class object

מחזירה אובייקט חדש ללא תכונות. object היא מחלקת הבסיס של כל המחלקות.

oct(x: int) → str

ממירה מספר שלם למחרוזת אוקטלית עם הקידומת "0o".

open(file: str, mode: str = 'r', **kwargs) → Any

פותחת את file ומחזירה אובייקט קובץ מתאים. mode מוגדר כברירת מחדל ל-"r" לקריאת טקסט.

ord(c: str) → int

מחזירה את נקודת הקוד ב-Unicode של מחרוזת בעלת תו יחיד c כמספר שלם.

pow(base: Any, exp: Any, mod: Any | None = None) → Any

מחזירה את base בחזקת exp. אם ניתן mod, מחזירה base ** exp % mod (מחושב ביעילות רבה יותר מן הצורה המפורשת).

print(*objects: Any, sep: str = ' ', end: str = '\n', file: Any = None) → None

מדפיסה את objects לזרם הטקסט file, מופרדים ב-sep ובסופם end.

property(fget: Callable[[Any], Any] | None = None, fset: Callable[[Any, Any], None] | None = None, fdel: Callable[[Any], None] | None = None, doc: str | None = None) → property

מחזירה מאפיין property. בדרך כלל משמש כדקורטור להגדרת מאפיינים מנוהלים על מחלקה.

range(*args: int) → range

מחזירה רצף בלתי-ניתן-לשינוי של מספרים שלמים. נקראת כ-range(stop), range(start, stop) או range(start, stop, step).

repr(obj: Any) → str

מחזירה מחרוזת המכילה ייצוג ניתן-להדפסה של obj.

reversed(seq: Any) → Iterator[Any]

מחזירה איטרטור הפוך על פני הערכים של הרצף הנתון.

round(number: Any, ndigits: int | None = None) → Any

מחזירה את number מעוגל ל-ndigits מקומות עשרוניים. אם ndigits הושמט, מחזירה את המספר השלם הקרוב ביותר.

class set(iterable: Iterable[Any] = ())

מחזירה אובייקט set חדש, אופציונלית עם איברים הלקוחים מ-iterable.

add(elem: Any) → None

מוסיפה את האיבר elem ל-set.

clear() → None

מסירה את כל האיברים מן ה-set.

copy() → set

מחזירה עותק שטחי של ה-set.

difference(*others: Iterable[Any]) → set

מחזירה set חדש עם איברים מן ה-set שאינם באף אחד מ-others. כל ארגומנט יכול להיות iterable כלשהו.

difference_update(*others: Iterable[Any]) → None

מסירה מן ה-set את כל האיברים הנמצאים באחד מ-others (במקום).

discard(elem: Any) → None

מסירה את האיבר elem מן ה-set אם הוא קיים. בניגוד ל-remove(), זה אינו מעלה שגיאה אם elem נעדר.

intersection(other: Iterable[Any]) → set

מחזירה set חדש עם איברים המשותפים ל-set ול-other. ב-MicroPython מתקבל רק ארגומנט other יחיד (CPython מקבל מספר רב).

intersection_update(other: Iterable[Any]) → None

מעדכנת את ה-set, ומשאירה רק איברים הנמצאים גם ב-other (במקום). ב-MicroPython מתקבל רק ארגומנט other יחיד.

isdisjoint(other: Iterable[Any]) → bool

מחזירה True אם ל-set אין איברים משותפים עם other.

issubset(other: Iterable[Any]) → bool

מחזירה True אם כל איבר של ה-set נמצא ב-other.

issuperset(other: Iterable[Any]) → bool

מחזירה True אם כל איבר של other נמצא ב-set.

pop() → Any

מסירה ומחזירה איבר שרירותי מן ה-set. מעלה KeyError אם ה-set ריק.

remove(elem: Any) → None

מסירה את האיבר elem מן ה-set. מעלה KeyError אם elem אינו כלול ב-set.

symmetric_difference(other: Iterable[Any]) → set

מחזירה set חדש עם איברים הנמצאים ב-set או ב-other אך לא בשניהם. ב-MicroPython מתקבל רק ארגומנט other יחיד.

symmetric_difference_update(other: Iterable[Any]) → None

מעדכנת את ה-set, ומשאירה רק איברים הנמצאים ב-set או ב-other אך לא בשניהם (במקום). ב-MicroPython מתקבל רק ארגומנט other יחיד.

union(other: Iterable[Any]) → set

מחזירה set חדש עם איברים מן ה-set ומ-other. ב-MicroPython מתקבל רק ארגומנט other יחיד (CPython מקבל מספר רב).

update(*others: Iterable[Any]) → None

מעדכנת את ה-set, ומוסיפה איברים מכל others (במקום).

setattr(obj: Any, name: str, value: Any) → None

מגדירה את המאפיין הנקוב על obj ל-value. המקבילה של getattr().

class slice

המובנה slice הוא הטיפוס שיש לאובייקטי slice.

sorted(iterable: Iterable[Any], key: Callable[[Any], Any] | None = None, reverse: bool = False) → list

מחזירה רשימה ממוינת חדשה מן הפריטים ב-iterable.

staticmethod(func: Callable[..., Any]) → staticmethod

הופכת מתודה למתודה סטטית. בדרך כלל משמשת כדקורטור.

class str(object: Any = '', encoding: str = 'utf-8', errors: str = 'strict')

מחזירה גרסת מחרוזת של object. אם object הוא אובייקט דמוי-bytes, הארגומנטים encoding ו-errors שולטים בפענוח.

center(width: int) → str

מחזירה עותק של המחרוזת ממורכז בשדה באורך width, מרופד ברווחים. ב-MicroPython משמש רק רווח כתו הריפוד (אין ארגומנט תו-ריפוד), והמחרוזת המקורית מוחזרת ללא שינוי כאשר width אינו גדול מאורכה.

count(sub: str, start: int = 0, end: int = -1) → int

מחזירה את מספר המופעים הלא-חופפים של sub בפרוסה [start:end]. sub ריק סופר כל מרווח בין תווים.

encode(encoding: str = 'utf-8', errors: str = 'strict') → bytes

מחזירה אובייקט bytes המקודד את המחרוזת. MicroPython למעשה מתעלם מן הארגומנטים ומשתמש ב-UTF-8; errors מתקבל אך לא פועלים לפיו. שקול ל-bytes(s, "utf-8").

endswith(suffix: str | tuple, start: int = 0, end: int = -1) → bool

מחזירה True אם המחרוזת מסתיימת ב-suffix הנתון, שיכול להיות מחרוזת יחידה או tuple של מחרוזות לניסיון. start ו-end האופציונליים מגבילים את ההשוואה לפרוסה [start:end].

find(sub: str, start: int = 0, end: int = -1) → int

מחזירה את האינדקס הנמוך ביותר במחרוזת שבו נמצאת תת-המחרוזת sub בתוך הפרוסה [start:end], או -1 אם לא נמצאה.

format(*args: Any, **kwargs: Any) → str

מבצעת פעולת עיצוב מחרוזת, מחליפה שדות החלפה התחומים בסוגריים מסולסלים {} בערכים מ-args ומ-kwargs. תומכת בשפת-המיני הסטנדרטית של מפרטי העיצוב.

index(sub: str, start: int = 0, end: int = -1) → int

כמו find(), אך מעלה ValueError כאשר תת-המחרוזת sub לא נמצאה בפרוסה [start:end].

isalpha() → bool

מחזירה True אם כל התווים במחרוזת הם אלפביתיים והמחרוזת אינה ריקה, אחרת False.

isdigit() → bool

מחזירה True אם כל התווים במחרוזת הם ספרות והמחרוזת אינה ריקה, אחרת False.

islower() → bool

מחזירה True אם המחרוזת מכילה לפחות תו אלפביתי אחד וכל התווים מסוג זה הם אותיות קטנות, אחרת False.

isspace() → bool

מחזירה True אם כל התווים במחרוזת הם רווח לבן והמחרוזת אינה ריקה, אחרת False.

isupper() → bool

מחזירה True אם המחרוזת מכילה לפחות תו אלפביתי אחד וכל התווים מסוג זה הם אותיות גדולות, אחרת False.

join(iterable: Iterable[str]) → str

משרשרת את המחרוזות ב-iterable, ומשלבת מחרוזת זו כמפריד בין האיברים. הפריטים חייבים להיות מחרוזות, אחרת מועלה TypeError.

lower() → str

מחזירה עותק של המחרוזת עם כל התווים מומרים לאותיות קטנות.

lstrip(chars: str | None = None) → str

מחזירה עותק של המחרוזת עם תווים מובילים שהוסרו. אם chars הושמט או None, רווח לבן מוסר; אחרת chars מטופל כקבוצת תווים להסרה.

partition(sep: str) → tuple

מפצלת את המחרוזת במופע הראשון של sep ומחזירה tuple בן 3 איברים (head, sep, tail). אם sep לא נמצא, מחזירה (self, "", ""). sep ריק מעלה ValueError.

replace(old: str, new: str, count: int = -1) → str

מחזירה עותק של המחרוזת עם כל המופעים של תת-המחרוזת old מוחלפים ב-new. אם ניתן count והוא אי-שלילי, רק count המופעים הראשונים מוחלפים.

rfind(sub: str, start: int = 0, end: int = -1) → int

מחזירה את האינדקס הגבוה ביותר במחרוזת שבו נמצאת תת-המחרוזת sub בתוך הפרוסה [start:end], או -1 אם לא נמצאה.

rindex(sub: str, start: int = 0, end: int = -1) → int

כמו rfind(), אך מעלה ValueError כאשר תת-המחרוזת sub לא נמצאה בפרוסה [start:end].

rpartition(sep: str) → tuple

מפצלת את המחרוזת במופע האחרון של sep ומחזירה tuple בן 3 איברים (head, sep, tail). אם sep לא נמצא, מחזירה ("", "", self). sep ריק מעלה ValueError.

rsplit(sep: str | None = None, maxsplit: int = -1) → list

מפצלת את המחרוזת מצד ימין לרשימה של תת-מחרוזות תוך שימוש ב-sep כמפריד, ומבצעת לכל היותר maxsplit פיצולים. ללא maxsplit (או עם שלילי) היא מתנהגת זהה ל-split(); ב-MicroPython rsplit(None, n) עם n אי-שלילי מעלה NotImplementedError.

rstrip(chars: str | None = None) → str

מחזירה עותק של המחרוזת עם תווים נגררים שהוסרו. אם chars הושמט או None, רווח לבן מוסר; אחרת chars מטופל כקבוצת תווים להסרה.

split(sep: str | None = None, maxsplit: int = -1) → list

מפצלת את המחרוזת לרשימה של תת-מחרוזות תוך שימוש ב-sep כמפריד, ומבצעת לכל היותר maxsplit פיצולים. אם sep הושמט או None, מפצלת ברצפים של רווח לבן עם התעלמות מרווח לבן מוביל; אחרת sep ריק מעלה ValueError.

splitlines(keepends: bool = False) → list

מחזירה רשימה של השורות במחרוזת, תוך שבירה ב-\n, ב-\r וב-\r\n. שברי השורות אינם נכללים אלא אם keepends הוא אמת.

startswith(prefix: str | tuple, start: int = 0, end: int = -1) → bool

מחזירה True אם המחרוזת מתחילה ב-prefix הנתון, שיכול להיות מחרוזת יחידה או tuple של מחרוזות לניסיון. start ו-end האופציונליים מגבילים את ההשוואה לפרוסה [start:end].

strip(chars: str | None = None) → str

מחזירה עותק של המחרוזת עם תווים מובילים ונגררים שהוסרו. אם chars הושמט או None, רווח לבן מוסר; אחרת chars מטופל כקבוצת תווים להסרה.

upper() → str

מחזירה עותק של המחרוזת עם כל התווים מומרים לאותיות גדולות.

sum(iterable: Iterable[Any], start: Any = 0) → Any

מסכמת את start ואת הפריטים של iterable משמאל לימין, ומחזירה את הסך הכל.

super(type: type | None = None, obj_or_type: Any | None = None) → Any

מחזירה אובייקט proxy המאציל קריאות מתודה למחלקת אב או למחלקה אחות של type. שימושי לגישה למתודות שעברו בירושה ונדרסו במחלקה.

class tuple(iterable: Iterable[Any] = ())

בונה tuple חדש, אופציונלית מאוכלס מפריטים ב-iterable. tuples הם רצפים בלתי-ניתנים-לשינוי.

count(value: Any) → int

מחזירה את מספר האיברים ב-tuple השווים ל-value.

index(value: Any, start: int = 0, stop: int = -1) → int

מחזירה את האינדקס של האיבר הראשון השווה ל-value, תוך חיפוש בפרוסה [start:stop]. מעלה ValueError אם value אינו קיים.

type(obj: Any) → type

עם ארגומנט אחד, מחזירה את הטיפוס של obj. הערך המוחזר הוא אובייקט טיפוס.

zip(*iterables: Iterable[Any]) → Iterator[tuple]

מחזירה איטרטור של tuples, כאשר ה-tuple ה-i מכיל את האיבר ה-i מכל אחד מן ה-iterables הניתנים כארגומנטים. האיטרציה נעצרת כאשר ה-iterable הקצר ביותר מוצה.

חריגות

exception AssertionError

מועלית כאשר משפט assert נכשל.

exception AttributeError

מועלית כאשר הפניה למאפיין או השמה לו נכשלות.

exception Exception

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

exception ImportError

מועלית כאשר משפט import אינו מצליח למצוא את הגדרת המודול.

exception IndexError

מועלית כאשר תחתי (subscript) של רצף מחוץ לטווח.

exception KeyboardInterrupt

מועלית כאשר המשתמש מפסיק את ביצוע התוכנית, בדרך כלל על ידי לחיצה על Ctrl+C ב-REPL.

ראו גם בהקשר של הלבנה רכה (כשל באתחול).

exception KeyError

מועלית כאשר מפתח של מיפוי (מילון) לא נמצא בקבוצת המפתחות הקיימים.

exception MemoryError

מועלית כאשר פעולה אוזלת מזיכרון.

exception NameError

מועלית כאשר שם מקומי או גלובלי לא נמצא.

exception NotImplementedError

מועלית כאשר מופעלת מתודה מופשטת או מאפיין שאינו ממומש.

exception OSError

מועלית כאשר פונקציית מערכת מחזירה שגיאה הקשורה למערכת.

exception RuntimeError

מועלית כאשר מתגלה שגיאה שאינה נופלת באף אחת מן הקטגוריות האחרות.

exception StopIteration

מועלית על ידי next() ועל ידי מתודת __next__() של איטרטור כדי לאותת שאין פריטים נוספים.

exception SyntaxError

מועלית כאשר המנתח (parser) נתקל בשגיאת תחביר.

exception SystemExit

מועלית על ידי sys.exit() כדי לבקש סיום של המפרש. בניגוד לרוב החריגות, היא אינה מפיקה traceback כאשר אינה נתפסת.

ב-OpenMV Cam, SystemExit שאינו מטופל גורם כרגע ל-איפוס רך של MicroPython.

exception TypeError

מועלית כאשר פעולה או פונקציה מופעלת על אובייקט מטיפוס שאינו מתאים.

exception ValueError

מועלית כאשר פעולה או פונקציה מובנית מקבלת ארגומנט מן הטיפוס הנכון אך בעל ערך שאינו מתאים.

exception ZeroDivisionError

מועלית כאשר הארגומנט השני של פעולת חילוק או מודולו הוא אפס.