`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#: מועלית כאשר הארגומנט השני של פעולת חילוק או מודולו הוא אפס.

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

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

חריגות#

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