`builtins` — inbyggda funktioner och undantag#

Alla inbyggda funktioner och undantag beskrivs här. De är även tillgängliga via modulen builtins.

Funktioner och typer#

abs(x: Any) → Any#: Returnerar absolutvärdet av ett tal. Argumentet kan vara ett heltal, ett flyttal eller något objekt som implementerar __abs__().

all(iterable: Iterable[Any]) → bool#: Returnerar True om alla element i iterable är sanna (eller om iterabeln är tom).

any(iterable: Iterable[Any]) → bool#: Returnerar True om något element i iterable är sant. Returnerar False om iterabeln är tom.

bin(x: int) → str#: Konverterar ett heltal till en binär sträng med prefixet "0b". Argumentet måste vara ett Python-heltal eller implementera __index__().

class bool(x: Any = False)#: Returnerar ett booleskt värde, dvs. antingen True eller False. x konverteras med standardproceduren för sanningsvärdetestning.

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

Föränderlig sekvens av heltal i intervallet 0-255. Konstruktionen följer samma regler som bytes: från ett heltal (skapar en nollfylld buffert av den storleken), en iterabel av heltal, en sträng med encoding eller något objekt som följer buffertprotokollet. Stöder standardsekvensoperationerna plus ändring på plats.

classmethod fromhex(string: str) → bytearray#: Konstruerar en bytearray från en sträng av hexadecimala siffepar. Blanksteg mellan siffepar hoppas över; ett tecken som inte är hexadecimalt ger upphov till ValueError.

append(val: int) → None#: Lägger till ett enstaka värde (ett heltal i intervallet 0-255) i slutet av byte-arrayen och utökar den med en byte.

center(width: int, fillbyte: bytes) → bytes#: Returnerar en kopia av innehållet centrerat i en sekvens av längd width, utfyllt med fillbyte. Till skillnad från CPython är fillbyte obligatorisk. Datat returneras oförändrat när width inte är större än den aktuella längden.

count(sub: bytes, start: int = 0, end: int = -1) → int#: Returnerar antalet icke-överlappande förekomster av sub i utsnittet [start:end].

endswith(suffix: bytes, start: int = 0, end: int = -1) → bool#: Returnerar True om innehållet slutar med suffix. Till skillnad från CPython kan suffix inte vara en tupel av värden.

extend(iterable: Iterable[int]) → None#: Lägger till alla element från iterable i slutet av byte-arrayen. Som en utökning av CPython kan vilket objekt som helst som stöder buffertprotokollet användas.

find(sub: bytes, start: int = 0, end: int = -1) → int#: Returnerar det lägsta indexet där sub hittas inom utsnittet [start:end], eller -1 om det inte hittas.

format(*args: Any, **kwargs: Any) → str#: Utför en strängformateringsoperation med innehållet som formatsträng och returnerar det formaterade resultatet.

hex(sep: str = '') → str#: Returnerar en sträng med två hexadecimala siffror för varje byte. Om den valfria sep (en sträng av längd 1) anges infogas den mellan på varandra följande byte-värden.

index(sub: bytes, start: int = 0, end: int = -1) → int#: Som find(), men ger upphov till ValueError när sub inte hittas.

isalpha() → bool#: Returnerar True om alla byte är alfabetiska ASCII-tecken och det finns minst en byte, annars False.

isdigit() → bool#: Returnerar True om alla byte är decimala ASCII-siffror och det finns minst en byte, annars False.

islower() → bool#: Returnerar True om alla byte med skiftläge är gemener och det finns minst en byte med skiftläge, annars False.

isspace() → bool#: Returnerar True om alla byte är ASCII-blanksteg och det finns minst en byte, annars False.

isupper() → bool#: Returnerar True om alla byte med skiftläge är versaler och det finns minst en byte med skiftläge, annars False.

join(iterable: Iterable[bytes]) → bytes#: Returnerar ett bytes-objekt som är sammanfogningen av elementen i iterable, med byte-arrayens innehåll som avgränsare.

lower() → bytes#: Returnerar en kopia av innehållet med alla ASCII-versaler konverterade till gemener.

lstrip(chars: bytes | None = None) → bytes#: Returnerar en kopia med inledande byte borttagna. chars anger uppsättningen byte som ska tas bort; om utelämnad eller None tas ASCII-blanksteg bort.

partition(sep: bytes) → tuple#: Delar vid den första förekomsten av sep och returnerar (head, sep, tail). Om sep inte hittas returneras innehållet följt av två tomma objekt.

replace(old: bytes, new: bytes, count: int = -1) → bytes#: Returnerar en kopia med alla förekomster av old ersatta av new. Om count anges ersätts endast de första count förekomsterna.

rfind(sub: bytes, start: int = 0, end: int = -1) → int#: Returnerar det högsta indexet där sub hittas inom utsnittet [start:end], eller -1 om det inte hittas.

rindex(sub: bytes, start: int = 0, end: int = -1) → int#: Som rfind(), men ger upphov till ValueError när sub inte hittas.

rpartition(sep: bytes) → tuple#: Delar vid den sista förekomsten av sep och returnerar (head, sep, tail). Om sep inte hittas returneras två tomma objekt följt av innehållet.

rsplit(sep: bytes | None = None, maxsplit: int = -1) → list#: Delar vid förekomster av sep till en lista av delar och utför som mest maxsplit delningar räknat från höger. Om sep är None eller utelämnas delas det vid serier av ASCII-blanksteg.

rstrip(chars: bytes | None = None) → bytes#: Returnerar en kopia med efterföljande byte borttagna. chars anger uppsättningen byte som ska tas bort; om utelämnad eller None tas ASCII-blanksteg bort.

split(sep: bytes | None = None, maxsplit: int = -1) → list#: Delar vid förekomster av sep till en lista av delar. Om sep är None eller utelämnas delas det vid serier av ASCII-blanksteg och inledande/efterföljande blanksteg ignoreras.

splitlines(keepends: bool = False) → list#: Returnerar en lista över raderna, med radbrytning vid \n, \r och \r\n. Radbrytningar utesluts om inte keepends är sant.

startswith(prefix: bytes, start: int = 0, end: int = -1) → bool#: Returnerar True om innehållet börjar med prefix. Till skillnad från CPython kan prefix inte vara en tupel, och end accepteras men ignoreras.

strip(chars: bytes | None = None) → bytes#: Returnerar en kopia med inledande och efterföljande byte borttagna. chars anger uppsättningen byte som ska tas bort; om utelämnad eller None tas ASCII-blanksteg bort.

upper() → bytes#: Returnerar en kopia av innehållet med alla ASCII-gemener konverterade till versaler.

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

Oföränderlig sekvens av heltal i intervallet 0-255. Skapas från ett heltal (nollfylld buffert), en iterabel av heltal, en sträng med encoding eller något objekt som följer buffertprotokollet. Bytes-literaler använder syntaxen b'...'.

classmethod fromhex(string: str) → bytes#: Konstruerar ett bytes-objekt från en sträng av hexadecimala siffepar. Blanksteg mellan siffepar hoppas över; ett tecken som inte är hexadecimalt ger upphov till ValueError.

center(width: int, fillbyte: bytes) → bytes#: Returnerar en kopia centrerad i en sekvens av längd width, utfyllt med fillbyte (ett bytes av längd 1 som anger utfyllnadsbyten). Till skillnad från CPython är fillbyte obligatorisk. Det ursprungliga objektet returneras oförändrat när width inte är större än dess längd.

count(sub: bytes, start: int = 0, end: int = -1) → int#: Returnerar antalet icke-överlappande förekomster av sub i utsnittet [start:end].

decode(encoding: str = 'utf-8') → str#: Returnerar en str avkodad från byten. I MicroPython accepteras argumentet encoding men ignoreras i praktiken (byten omtolkas som UTF-8).

endswith(suffix: bytes, start: int = 0, end: int = -1) → bool#: Returnerar True om byten slutar med suffix. Till skillnad från CPython kan suffix inte vara en tupel av värden att prova.

find(sub: bytes, start: int = 0, end: int = -1) → int#: Returnerar det lägsta indexet där delsekvensen sub hittas inom utsnittet [start:end], eller -1 om den inte hittas.

format(*args: Any, **kwargs: Any) → str#: Utför en strängformateringsoperation med byten som formatsträng och returnerar det formaterade resultatet.

hex(sep: str = '') → str#: Returnerar en sträng med två hexadecimala siffror för varje byte. Om den valfria sep (en sträng av längd 1) anges infogas den mellan på varandra följande byte-värden.

index(sub: bytes, start: int = 0, end: int = -1) → int#: Som find(), men ger upphov till ValueError när sub inte hittas.

isalpha() → bool#: Returnerar True om alla byte är alfabetiska ASCII-tecken och det finns minst en byte, annars False.

isdigit() → bool#: Returnerar True om alla byte är decimala ASCII-siffror och det finns minst en byte, annars False.

islower() → bool#: Returnerar True om alla byte med skiftläge är gemener och det finns minst en byte med skiftläge, annars False.

isspace() → bool#: Returnerar True om alla byte är ASCII-blanksteg och det finns minst en byte, annars False.

isupper() → bool#: Returnerar True om alla byte med skiftläge är versaler och det finns minst en byte med skiftläge, annars False.

join(iterable: Iterable[bytes]) → bytes#: Returnerar ett bytes-objekt som är sammanfogningen av elementen i iterable, med själva bytes-objektet som avgränsare.

lower() → bytes#: Returnerar en kopia med alla ASCII-versaler konverterade till gemener.

lstrip(chars: bytes | None = None) → bytes#: Returnerar en kopia med inledande byte borttagna. chars anger uppsättningen byte som ska tas bort; om utelämnad eller None tas ASCII-blanksteg bort.

partition(sep: bytes) → tuple#: Delar vid den första förekomsten av sep och returnerar (head, sep, tail). Om sep inte hittas returneras byten följt av två tomma bytes-objekt.

replace(old: bytes, new: bytes, count: int = -1) → bytes#: Returnerar en kopia med alla förekomster av old ersatta av new. Om count anges ersätts endast de första count förekomsterna.

rfind(sub: bytes, start: int = 0, end: int = -1) → int#: Returnerar det högsta indexet där sub hittas inom utsnittet [start:end], eller -1 om det inte hittas.

rindex(sub: bytes, start: int = 0, end: int = -1) → int#: Som rfind(), men ger upphov till ValueError när sub inte hittas.

rpartition(sep: bytes) → tuple#: Delar vid den sista förekomsten av sep och returnerar (head, sep, tail). Om sep inte hittas returneras två tomma bytes-objekt följt av byten.

rsplit(sep: bytes | None = None, maxsplit: int = -1) → list#: Delar vid förekomster av sep till en lista av delar och utför som mest maxsplit delningar räknat från höger. Om sep är None eller utelämnas delas det vid serier av ASCII-blanksteg.

rstrip(chars: bytes | None = None) → bytes#: Returnerar en kopia med efterföljande byte borttagna. chars anger uppsättningen byte som ska tas bort; om utelämnad eller None tas ASCII-blanksteg bort.

split(sep: bytes | None = None, maxsplit: int = -1) → list#: Delar vid förekomster av sep till en lista av delar. Om sep är None eller utelämnas delas det vid serier av ASCII-blanksteg och inledande/efterföljande blanksteg ignoreras.

splitlines(keepends: bool = False) → list#: Returnerar en lista över raderna, med radbrytning vid \n, \r och \r\n. Radbrytningar utesluts om inte keepends är sant.

startswith(prefix: bytes, start: int = 0, end: int = -1) → bool#: Returnerar True om byten börjar med prefix. Till skillnad från CPython kan prefix inte vara en tupel, och end accepteras men ignoreras.

strip(chars: bytes | None = None) → bytes#: Returnerar en kopia med inledande och efterföljande byte borttagna. chars anger uppsättningen byte som ska tas bort; om utelämnad eller None tas ASCII-blanksteg bort.

upper() → bytes#: Returnerar en kopia med alla ASCII-gemener konverterade till versaler.

callable(obj: Any) → bool#: Returnerar True om obj verkar anropbart, annars False.

chr(i: int) → str#: Returnerar en sträng med ett tecken vars Unicode-kodpunkt är heltalet i.

classmethod(func: Callable[..., Any]) → classmethod#: Omvandlar en metod till en klassmetod. Används vanligtvis som en dekorator.

compile(source: str | bytes, filename: str, mode: str) → Any#: Kompilerar source till ett kodobjekt som kan exekveras av exec() eller eval(). mode är en av "exec", "eval" eller "single".

class complex(real: float | str = 0, imag: float = 0)#: Skapar ett komplext tal från en real- och en imaginärdel, eller från en sträng.

delattr(obj, name: str) → None#: Argumentet name ska vara en sträng, och denna funktion tar bort det namngivna attributet från objektet som anges av obj.

class dict(*args, **kwargs)#

Skapar en ny ordbok. Motsvarar CPythons dict.

classmethod fromkeys(iterable: Iterable[Any], value: Any = None) → dict#: Skapar en ny ordbok med nycklar tagna från iterable, var och en kopplad till value (som standard None). Anropas på typen, t.ex. dict.fromkeys(...).

clear() → None#: Tar bort alla element från ordboken så att den blir tom. Ger upphov till TypeError om ordboken är fixerad (skrivskyddad).

copy() → dict#: Returnerar en ytlig kopia av ordboken. Det returnerade objektet har samma typ som originalet (dict eller OrderedDict) men är inte fixerat.

get(key: Any, default: Any = None) → Any#: Returnerar värdet för key om det finns i ordboken, annars returneras default (vars eget standardvärde är None, så detta ger aldrig upphov till KeyError). Ordboken modifieras inte.

items() → Any#: Returnerar ett dynamiskt vyobjekt över (key, value)-paren som återspeglar efterföljande ändringar i ordboken och stöder iteration, len(), operatorn in och mängdjämförelseoperatorer.

keys() → Any#: Returnerar ett dynamiskt vyobjekt över nycklarna som återspeglar efterföljande ändringar i ordboken och stöder iteration, len(), operatorn in och mängdjämförelseoperatorer.

pop(key: Any, default: Any = None) → Any#: Tar bort key från ordboken och returnerar dess värde. Om key inte finns returneras default om det angavs; annars ges upphov till KeyError. Ger upphov till TypeError om ordboken är fixerad.

popitem() → tuple#: Tar bort och returnerar ett godtyckligt (key, value)-par som en 2-tupel. För en vanlig dict är det valda paret ospecificerat; för en OrderedDict tas det senast infogade paret bort (LIFO). Ger upphov till KeyError om ordboken är tom, eller TypeError om den är fixerad.

setdefault(key: Any, default: Any = None) → Any#: Om key finns i ordboken returneras dess värde. Annars infogas key med värdet default (som standard None) och det värdet returneras. Ger upphov till TypeError om ordboken är fixerad.

update(*args: Any, **kwargs: Any) → None#: Uppdaterar ordboken på plats. Som mest ett positionsargument accepteras: antingen en annan ordbok eller en iterabel av tvåelements (key, value)-par (vart och ett måste ge exakt två element, annars ges upphov till ValueError). Nyckelordsargument läggs sedan till som poster med strängnycklar. Befintliga nycklar skrivs över. Ger upphov till TypeError om ordboken är fixerad.

values() → Any#: Returnerar ett dynamiskt vyobjekt över värdena som återspeglar efterföljande ändringar i ordboken och stöder iteration och len().

__getitem__(key: Any) → Any#: Returnerar self[key]. Implementerar indexeringsoperatorn d[key]; ger upphov till KeyError om key inte finns.

__setitem__(key: Any, value: Any) → None#: Sätter self[key] till value. Implementerar d[key] = value.

__delitem__(key: Any) → None#: Tar bort self[key]. Implementerar del d[key]; ger upphov till KeyError om key inte finns.

dir(obj: Any = None) → list#: Utan argument returneras listan över namn i det aktuella lokala omfånget. Med ett argument returneras en lista över giltiga attribut för det objektet.

divmod(a: Any, b: Any) → tuple#: Returnerar paret (a // b, a % b) som en tupel, för två (icke-komplexa) tal.

enumerate(iterable: Iterable[Any], start: int = 0) → Iterator[tuple]#: Returnerar ett enumerate-objekt som ger (index, value)-par från iterable, där indexet börjar vid start.

eval(expression: str | bytes, globals: dict | None = None, locals: dict | None = None) → Any#: Utvärderar ett Python-uttryck angivet som en sträng (eller ett kompilerat kodobjekt) och returnerar resultatet.

exec(object: str | bytes, globals: dict | None = None, locals: dict | None = None) → None#: Exekverar dynamiskt Python-kod som tillhandahålls som en sträng eller ett kompilerat kodobjekt.

filter(function: Callable[[Any], Any] | None, iterable: Iterable[Any]) → Iterator[Any]#: Konstruerar en iterator från de element i iterable för vilka function returnerar sant. Om function är None antas identitetsfunktionen.

class float(x: str | bytes | int | float = 0.0)#: Returnerar ett flyttal konstruerat från ett tal eller en sträng x.

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

Returnerar ett nytt frozenset-objekt, eventuellt med element tagna från iterable. frozenset är en oföränderlig, hashbar variant av set.

copy() → frozenset#: Returnerar en ytlig kopia av frozenset:et.

difference(*others: Iterable[Any]) → frozenset#: Returnerar ett nytt frozenset med element från frozenset:et som inte finns i något av others. Varje argument kan vara vilken iterabel som helst.

intersection(other: Iterable[Any]) → frozenset#: Returnerar ett nytt frozenset med element gemensamma för frozenset:et och other. I MicroPython accepteras endast ett enda other-argument (CPython accepterar flera).

isdisjoint(other: Iterable[Any]) → bool#: Returnerar True om frozenset:et inte har några element gemensamma med other.

issubset(other: Iterable[Any]) → bool#: Returnerar True om varje element i frozenset:et finns i other.

issuperset(other: Iterable[Any]) → bool#: Returnerar True om varje element i other finns i frozenset:et.

symmetric_difference(other: Iterable[Any]) → frozenset#: Returnerar ett nytt frozenset med element i antingen frozenset:et eller other men inte i båda. I MicroPython accepteras endast ett enda other-argument.

union(other: Iterable[Any]) → frozenset#: Returnerar ett nytt frozenset med element från frozenset:et och other. I MicroPython accepteras endast ett enda other-argument (CPython accepterar flera).

getattr(obj: Any, name: str, default: Any = None) → Any#: Returnerar värdet av det namngivna attributet hos obj. Om attributet inte finns returneras default om det anges, annars ges upphov till AttributeError.

globals() → dict#: Returnerar en ordbok som representerar den aktuella modulens globala symboltabell.

hasattr(obj: Any, name: str) → bool#: Returnerar True om obj har ett attribut med det angivna name, annars False.

hash(obj: Any) → int#: Returnerar hashvärdet för obj (om det har ett). Hashvärden är heltal som används för att snabbt jämföra ordboksnycklar vid en ordboksuppslagning.

hex(x: int) → str#: Konverterar ett heltal till en hexadecimal sträng med gemener och prefixet "0x".

id(obj: Any) → int#: Returnerar identiteten för ett objekt. Detta är ett heltal som garanterat är unikt och konstant för detta objekt under dess livstid.

input(prompt: str = '') → str#: Läser en rad från standardinmatningen och returnerar den som en sträng (utan avslutande radbrytning). Om prompt anges skrivs den först till standardutmatningen utan avslutande radbrytning.

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

classmethod from_bytes(bytes: bytes, byteorder: str) → int#: I MicroPython måste parametern byteorder vara ett positionsargument (detta är kompatibelt med CPython).

to_bytes(size: int, byteorder: str) → bytes#: I MicroPython måste parametern byteorder vara ett positionsargument (detta är kompatibelt med CPython).

Observera
Det valfria nyckelordsargumentet signed från CPython stöds inte. MicroPython konverterar för närvarande negativa heltal som teckenbärande och positiva som teckenlösa. (Detaljer.)

isinstance(obj: Any, classinfo: type | tuple) → bool#: Returnerar True om obj är en instans av classinfo eller någon av dess subklasser. classinfo kan vara en klass eller en tupel av klasser.

issubclass(cls: type, classinfo: type | tuple) → bool#: Returnerar True om cls är en subklass (direkt, indirekt eller virtuell) av classinfo.

iter(obj: Any, sentinel: Any = None) → Iterator[Any]#: Returnerar ett iteratorobjekt. Med ett argument måste obj stödja iterationsprotokollet. Med två argument måste obj vara anropbart och iterationen stoppar när det returnerar sentinel.

len(obj: Any) → int#: Returnerar antalet element i en behållare.

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

Bygger en ny lista, eventuellt fylld med element från iterable.

append(object: Any) → None#: Lägger till object i slutet av listan.

clear() → None#: Tar bort alla element från listan så att den blir tom.

copy() → list#: Returnerar en ytlig kopia av listan.

count(value: Any) → int#: Returnerar antalet element i listan som är lika med value.

extend(iterable: Iterable[Any]) → None#: Lägger till alla element från iterable i slutet av listan. Om iterable själv är en lista kopieras dess element direkt; annars itereras den över.

index(value: Any, start: int = 0, stop: int = -1) → int#: Returnerar indexet för det första elementet som är lika med value, genom att söka i utsnittet [start:stop]. Ger upphov till ValueError om value inte finns.

insert(index: int, object: Any) → None#: Infogar object före positionen index. Ett negativt index tolkas relativt slutet av listan, och indexet begränsas till det giltiga intervallet (så värden bortom någon av ändarna infogar i början eller slutet).

pop(index: int = -1) → Any#: Tar bort och returnerar elementet vid index (det sista elementet som standard). Ger upphov till IndexError om listan är tom eller index ligger utanför intervallet.

remove(value: Any) → None#: Tar bort det första elementet som är lika med value. Ger upphov till ValueError om value inte finns.

reverse() → None#: Vänder ordningen på listans element på plats.

sort(*, key: Callable[[Any], Any] | None = None, reverse: bool = False) → None#: Sorterar listans element på plats. key och reverse är endast nyckelordsargument. key, om angivet, är en funktion som tillämpas på varje element för att skapa jämförelsevärdet; reverse sorterar i fallande ordning.

Observera
Till skillnad från CPython är MicroPythons listsortering inte stabil.

locals() → dict#: Returnerar en ordbok som representerar den aktuella lokala symboltabellen.

map(function: Callable[..., Any], *iterables: Iterable[Any]) → Iterator[Any]#: Returnerar en iterator som tillämpar function på varje element i iterables och ger resultaten.

max(*args: Any, key: Callable[[Any], Any] | None = None, default: Any = None) → Any#: Med ett enda iterabelt argument returneras dess största element. Med två eller fler argument returneras det största argumentet.

class memoryview(obj: Any)#: Skapar en memoryview som refererar till obj, vilket måste stödja buffertprotokollet (t.ex. bytes, bytearray, array.array). Möjliggör åtkomst och utsnitt utan kopiering av det underliggande minnet; utsnitt av en memoryview returnerar en annan memoryview istället för en kopia.

min(*args: Any, key: Callable[[Any], Any] | None = None, default: Any = None) → Any#: Med ett enda iterabelt argument returneras dess minsta element. Med två eller fler argument returneras det minsta argumentet.

next(iterator: Iterator[Any], default: Any = None) → Any#: Hämtar nästa element från iterator. Om default anges och iteratorn är uttömd returneras default istället för att ge upphov till StopIteration.

class object#: Returnerar ett nytt egenskapslöst objekt. object är basklassen för alla klasser.

oct(x: int) → str#: Konverterar ett heltal till en oktal sträng med prefixet "0o".

open(file: str, mode: str = 'r', **kwargs) → Any#: Öppnar file och returnerar ett motsvarande filobjekt. mode är som standard "r" för textläsning.

ord(c: str) → int#: Returnerar Unicode-kodpunkten för en sträng c med ett tecken som ett heltal.

pow(base: Any, exp: Any, mod: Any | None = None) → Any#: Returnerar base upphöjt till exp. Om mod anges returneras base ** exp % mod (beräknat effektivare än den explicita formen).

print(*objects: Any, sep: str = ' ', end: str = '\n', file: Any = None) → None#: Skriver ut objects till textströmmen file, separerade med sep och följt av 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#: Returnerar ett egenskapsattribut. Används vanligtvis som en dekorator för att definiera hanterade attribut på en klass.

range(*args: int) → range#: Returnerar en oföränderlig sekvens av heltal. Anropas som range(stop), range(start, stop) eller range(start, stop, step).

repr(obj: Any) → str#: Returnerar en sträng som innehåller en utskrivbar representation av obj.

reversed(seq: Any) → Iterator[Any]#: Returnerar en omvänd iterator över värdena i den angivna sekvensen.

round(number: Any, ndigits: int | None = None) → Any#: Returnerar number avrundat till ndigits decimaler. Om ndigits utelämnas returneras närmaste heltal.

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

Returnerar ett nytt set-objekt, eventuellt med element tagna från iterable.

add(elem: Any) → None#: Lägger till elementet elem i mängden.

clear() → None#: Tar bort alla element från mängden.

copy() → set#: Returnerar en ytlig kopia av mängden.

difference(*others: Iterable[Any]) → set#: Returnerar en ny mängd med element från mängden som inte finns i något av others. Varje argument kan vara vilken iterabel som helst.

difference_update(*others: Iterable[Any]) → None#: Tar bort alla element som finns i något av others från mängden (på plats).

discard(elem: Any) → None#: Tar bort elementet elem från mängden om det finns. Till skillnad från remove() ger detta inte upphov till ett fel om elem saknas.

intersection(other: Iterable[Any]) → set#: Returnerar en ny mängd med element gemensamma för mängden och other. I MicroPython accepteras endast ett enda other-argument (CPython accepterar flera).

intersection_update(other: Iterable[Any]) → None#: Uppdaterar mängden och behåller endast element som även finns i other (på plats). I MicroPython accepteras endast ett enda other-argument.

isdisjoint(other: Iterable[Any]) → bool#: Returnerar True om mängden inte har några element gemensamma med other.

issubset(other: Iterable[Any]) → bool#: Returnerar True om varje element i mängden finns i other.

issuperset(other: Iterable[Any]) → bool#: Returnerar True om varje element i other finns i mängden.

pop() → Any#: Tar bort och returnerar ett godtyckligt element från mängden. Ger upphov till KeyError om mängden är tom.

remove(elem: Any) → None#: Tar bort elementet elem från mängden. Ger upphov till KeyError om elem inte finns i mängden.

symmetric_difference(other: Iterable[Any]) → set#: Returnerar en ny mängd med element i antingen mängden eller other men inte i båda. I MicroPython accepteras endast ett enda other-argument.

symmetric_difference_update(other: Iterable[Any]) → None#: Uppdaterar mängden och behåller endast element som finns i antingen mängden eller other men inte i båda (på plats). I MicroPython accepteras endast ett enda other-argument.

union(other: Iterable[Any]) → set#: Returnerar en ny mängd med element från mängden och other. I MicroPython accepteras endast ett enda other-argument (CPython accepterar flera).

update(*others: Iterable[Any]) → None#: Uppdaterar mängden genom att lägga till element från alla others (på plats).

setattr(obj: Any, name: str, value: Any) → None#: Sätter det namngivna attributet på obj till value. Motsvarigheten till getattr().

class slice#: Den inbyggda slice är den typ som slice-objekt har.

sorted(iterable: Iterable[Any], key: Callable[[Any], Any] | None = None, reverse: bool = False) → list#: Returnerar en ny sorterad lista från elementen i iterable.

staticmethod(func: Callable[..., Any]) → staticmethod#: Omvandlar en metod till en statisk metod. Används vanligtvis som en dekorator.

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

Returnerar en strängversion av object. Om object är ett bytes-liknande objekt styr argumenten encoding och errors avkodningen.

center(width: int) → str#: Returnerar en kopia av strängen centrerad i ett fält av längd width, utfyllt med blanksteg. I MicroPython används endast blanksteg som utfyllnadstecken (det finns inget utfyllnadsteckenargument), och den ursprungliga strängen returneras oförändrad när width inte är större än dess längd.

count(sub: str, start: int = 0, end: int = -1) → int#: Returnerar antalet icke-överlappande förekomster av sub i utsnittet [start:end]. En tom sub räknar varje mellanrum mellan tecken.

encode(encoding: str = 'utf-8', errors: str = 'strict') → bytes#: Returnerar ett bytes-objekt som kodar strängen. MicroPython ignorerar i praktiken argumenten och använder UTF-8; errors accepteras men beaktas inte. Motsvarar bytes(s, "utf-8").

endswith(suffix: str | tuple, start: int = 0, end: int = -1) → bool#: Returnerar True om strängen slutar med det angivna suffix, vilket kan vara en enstaka sträng eller en tupel av strängar att prova. Valfria start och end begränsar jämförelsen till utsnittet [start:end].

find(sub: str, start: int = 0, end: int = -1) → int#: Returnerar det lägsta indexet i strängen där delsträngen sub hittas inom utsnittet [start:end], eller -1 om den inte hittas.

format(*args: Any, **kwargs: Any) → str#: Utför en strängformateringsoperation och ersätter ersättningsfält avgränsade av klamrar {} med värden från args och kwargs. Stöder standardminispråket för formatspecifikation.

index(sub: str, start: int = 0, end: int = -1) → int#: Som find(), men ger upphov till ValueError när delsträngen sub inte hittas i utsnittet [start:end].

isalpha() → bool#: Returnerar True om alla tecken i strängen är alfabetiska och strängen är icke-tom, annars False.

isdigit() → bool#: Returnerar True om alla tecken i strängen är siffror och strängen är icke-tom, annars False.

islower() → bool#: Returnerar True om strängen innehåller minst ett alfabetiskt tecken och alla sådana tecken är gemener, annars False.

isspace() → bool#: Returnerar True om alla tecken i strängen är blanksteg och strängen är icke-tom, annars False.

isupper() → bool#: Returnerar True om strängen innehåller minst ett alfabetiskt tecken och alla sådana tecken är versaler, annars False.

join(iterable: Iterable[str]) → str#: Sammanfogar strängarna i iterable och infogar denna sträng som avgränsare mellan elementen. Elementen måste vara strängar, annars ges upphov till TypeError.

lower() → str#: Returnerar en kopia av strängen med alla tecken konverterade till gemener.

lstrip(chars: str | None = None) → str#: Returnerar en kopia av strängen med inledande tecken borttagna. Om chars utelämnas eller är None tas blanksteg bort; annars behandlas chars som en uppsättning tecken att ta bort.

partition(sep: str) → tuple#: Delar strängen vid den första förekomsten av sep och returnerar en 3-tupel (head, sep, tail). Om sep inte hittas returneras (self, "", ""). En tom sep ger upphov till ValueError.

replace(old: str, new: str, count: int = -1) → str#: Returnerar en kopia av strängen med alla förekomster av delsträngen old ersatta av new. Om count anges och är icke-negativt ersätts endast de första count förekomsterna.

rfind(sub: str, start: int = 0, end: int = -1) → int#: Returnerar det högsta indexet i strängen där delsträngen sub hittas inom utsnittet [start:end], eller -1 om den inte hittas.

rindex(sub: str, start: int = 0, end: int = -1) → int#: Som rfind(), men ger upphov till ValueError när delsträngen sub inte hittas i utsnittet [start:end].

rpartition(sep: str) → tuple#: Delar strängen vid den sista förekomsten av sep och returnerar en 3-tupel (head, sep, tail). Om sep inte hittas returneras ("", "", self). En tom sep ger upphov till ValueError.

rsplit(sep: str | None = None, maxsplit: int = -1) → list#: Delar strängen från höger till en lista av delsträngar med sep som avgränsare och utför som mest maxsplit delningar. Utan maxsplit (eller med ett negativt värde) beter den sig identiskt med split(); i MicroPython ger rsplit(None, n) med ett icke-negativt n upphov till NotImplementedError.

rstrip(chars: str | None = None) → str#: Returnerar en kopia av strängen med efterföljande tecken borttagna. Om chars utelämnas eller är None tas blanksteg bort; annars behandlas chars som en uppsättning tecken att ta bort.

split(sep: str | None = None, maxsplit: int = -1) → list#: Delar strängen till en lista av delsträngar med sep som avgränsare och utför som mest maxsplit delningar. Om sep utelämnas eller är None delas det vid serier av blanksteg med inledande blanksteg ignorerade; annars ger en tom sep upphov till ValueError.

splitlines(keepends: bool = False) → list#: Returnerar en lista över raderna i strängen, med radbrytning vid \n, \r och \r\n. Radbrytningar inkluderas inte om inte keepends är sant.

startswith(prefix: str | tuple, start: int = 0, end: int = -1) → bool#: Returnerar True om strängen börjar med det angivna prefix, vilket kan vara en enstaka sträng eller en tupel av strängar att prova. Valfria start och end begränsar jämförelsen till utsnittet [start:end].

strip(chars: str | None = None) → str#: Returnerar en kopia av strängen med inledande och efterföljande tecken borttagna. Om chars utelämnas eller är None tas blanksteg bort; annars behandlas chars som en uppsättning tecken att ta bort.

upper() → str#: Returnerar en kopia av strängen med alla tecken konverterade till versaler.

sum(iterable: Iterable[Any], start: Any = 0) → Any#: Summerar start och elementen i iterable från vänster till höger och returnerar totalsumman.

super(type: type | None = None, obj_or_type: Any | None = None) → Any#: Returnerar ett proxyobjekt som delegerar metodanrop till en förälder- eller systerklass till type. Användbart för att komma åt ärvda metoder som har åsidosatts i en klass.

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

Bygger en ny tupel, eventuellt fylld med element från iterable. Tupler är oföränderliga sekvenser.

count(value: Any) → int#: Returnerar antalet element i tupeln som är lika med value.

index(value: Any, start: int = 0, stop: int = -1) → int#: Returnerar indexet för det första elementet som är lika med value, genom att söka i utsnittet [start:stop]. Ger upphov till ValueError om value inte finns.

type(obj: Any) → type#: Med ett argument returneras typen av obj. Det returnerade värdet är ett typobjekt.

zip(*iterables: Iterable[Any]) → Iterator[tuple]#: Returnerar en iterator av tupler, där den i:te tupeln innehåller det i:te elementet från var och en av argumentiterablerna. Iterationen stoppar när den kortaste indatatabeln är uttömd.

Undantag#

exception AssertionError#: Ges upphov till när en assert-sats misslyckas.

exception AttributeError#: Ges upphov till när en attributreferens eller -tilldelning misslyckas.

exception Exception#: Gemensam basklass för alla undantag som inte avslutar systemet.

exception ImportError#: Ges upphov till när en import-sats misslyckas med att hitta moduldefinitionen.

exception IndexError#: Ges upphov till när ett sekvensindex ligger utanför intervallet.

exception KeyboardInterrupt#

Ges upphov till när användaren avbryter programkörningen, vanligtvis genom att trycka Ctrl+C i REPL:en.

Se även i sammanhanget Mjuk låsning (misslyckad uppstart).

exception KeyError#: Ges upphov till när en avbildnings- (ordboks-) nyckel inte hittas i uppsättningen av befintliga nycklar.

exception MemoryError#: Ges upphov till när en operation får slut på minne.

exception NameError#: Ges upphov till när ett lokalt eller globalt namn inte hittas.

exception NotImplementedError#: Ges upphov till när en abstrakt metod eller en icke-implementerad funktion anropas.

exception OSError#: Ges upphov till när en systemfunktion returnerar ett systemrelaterat fel.

exception RuntimeError#: Ges upphov till när ett fel upptäcks som inte faller inom någon av de andra kategorierna.

exception StopIteration#: Ges upphov till av next() och en iterators __next__()-metod för att signalera att det inte finns några fler element.

exception SyntaxError#: Ges upphov till när parsern stöter på ett syntaxfel.

exception SystemExit#

Ges upphov till av sys.exit() för att begära att tolken avslutas. Till skillnad från de flesta undantag ger det inte upphov till någon spårning (traceback) när det inte fångas.

På OpenMV Cam orsakar ett ohanterat SystemExit för närvarande en Mjuk återställning av MicroPython.

exception TypeError#: Ges upphov till när en operation eller funktion tillämpas på ett objekt av olämplig typ.

exception ValueError#: Ges upphov till när en inbyggd operation eller funktion tar emot ett argument av rätt typ men med ett olämpligt värde.

exception ZeroDivisionError#: Ges upphov till när det andra argumentet i en divisions- eller modulooperation är noll.

builtins — inbyggda funktioner och undantag#

Funktioner och typer#

Undantag#

`builtins` — inbyggda funktioner och undantag#