3. Datamodell¶

3.1. Objekt, värden och typer¶

Objekt är Pythons abstraktion för data. Alla data i ett Python-program representeras av objekt eller av relationer mellan objekt. (På sätt och vis, och i enlighet med Von Neumanns modell av en ”dator med lagrade program”, representeras kod också av objekt)

Varje objekt har en identitet, en typ och ett värde. Ett objekts identitet ändras aldrig när det väl har skapats; du kan tänka på det som objektets adress i minnet. Operatorn is jämför identiteten hos två objekt; funktionen id() returnerar ett heltal som representerar dess identitet.

För CPython är id(x) den minnesadress där x lagras.

Ett objekts typ avgör vilka operationer som objektet stöder (t.ex. ”har det en längd?”) och definierar också de möjliga värdena för objekt av den typen. Funktionen type() returnerar ett objekts typ (som i sin tur är ett objekt). Liksom dess identitet är ett objekts type också oföränderlig. [1]

Vissa objekts värde kan förändras. Objekt vars värde kan ändras sägs vara mutabla; objekt vars värde är oföränderligt när de skapas kallas immutable. (Värdet på ett oföränderligt containerobjekt som innehåller en referens till ett föränderligt objekt kan ändras när det senare objektets värde ändras; containern anses dock fortfarande vara oföränderlig, eftersom samlingen av objekt som den innehåller inte kan ändras. Så oföränderlighet är inte riktigt samma sak som att ha ett oföränderligt värde, det är mer subtilt) Ett objekts föränderlighet bestäms av dess typ; till exempel är tal, strängar och tupler oföränderliga, medan ordböcker och listor är föränderliga.

Objekt förstörs aldrig explicit, men när de blir oåtkomliga kan de bli föremål för garbage-collection. En implementering får skjuta upp skräpinsamlingen eller helt utelämna den — det är en fråga om implementeringskvalitet hur skräpinsamlingen implementeras, så länge inga objekt samlas in som fortfarande är nåbara.

CPython använder för närvarande ett referensräkningsschema med (valfri) fördröjd upptäckt av cykliskt länkat skräp, som samlar in de flesta objekt så snart de blir onåbara, men det är inte garanterat att skräp som innehåller cirkulära referenser samlas in. Se dokumentationen för modulen gc för information om hur du kontrollerar insamlingen av cykliskt skräp. Andra implementationer agerar annorlunda och CPython kan ändras. Förlita dig inte på omedelbar slutbehandling av objekt när de blir oåtkomliga (så du bör alltid stänga filer explicit).

Observera att användningen av implementationens spårnings- eller felsökningsfunktioner kan hålla objekt vid liv som normalt skulle vara insamlingsbara. Observera också att om du fångar ett undantag med en try…except-sats kan det hålla objekt vid liv.

Vissa objekt innehåller referenser till ”externa” resurser, t.ex. öppna filer eller fönster. Det är underförstått att dessa resurser frigörs när objektet garbage-collected, men eftersom garbage-collection inte garanterat kommer att ske, tillhandahåller sådana objekt också ett explicit sätt att frigöra den externa resursen, vanligtvis en close()-metod. Program rekommenderas starkt att explicit stänga sådana objekt. Satsen try…finally och with är praktiska sätt att göra detta.

Vissa objekt innehåller referenser till andra objekt, dessa kallas för containers. Exempel på containrar är tupler, listor och lexikon. Referenserna är en del av en containers värde. I de flesta fall, när vi talar om värdet på en container, menar vi värdena, inte identiteterna på de ingående objekten; men när vi talar om föränderligheten hos en container, är det bara identiteterna på de omedelbart ingående objekten som avses. Så om en oföränderlig behållare (som en tupel) innehåller en referens till ett föränderligt objekt, ändras dess värde om det föränderliga objektet ändras.

Typer påverkar nästan alla aspekter av objektets beteende. Till och med vikten av objektets identitet påverkas i någon mening: för oföränderliga typer kan operationer som beräknar nya värden faktiskt returnera en referens till ett befintligt objekt med samma typ och värde, medan detta inte är tillåtet för föränderliga objekt. Till exempel, efter a = 1; b = 1, kan a och b referera till samma objekt med värdet ett eller inte, beroende på implementeringen. Detta beror på att int är en oföränderlig typ, så referensen till 1 kan återanvändas. Detta beteende beror på vilken implementation som används och bör därför inte åberopas, men det är något att vara medveten om när man använder sig av objektidentitetstester. Efter c = []; d = [] är det dock garanterat att c och d refererar till två olika, unika, nyskapade tomma listor. (Observera att e = f = [] tilldelar samma objekt till både e och f)

3.2. Standardtypens hierarki¶

Nedan finns en lista över de typer som är inbyggda i Python. Tilläggsmoduler (skrivna i C, Java eller andra språk, beroende på implementeringen) kan definiera ytterligare typer. Framtida versioner av Python kan lägga till typer i typhierarkin (t.ex. rationella tal, effektivt lagrade matriser av heltal etc.), även om sådana tillägg ofta kommer att tillhandahållas via standardbiblioteket istället.

Vissa av typbeskrivningarna nedan innehåller ett stycke som listar ”specialattribut” Detta är attribut som ger tillgång till implementationen och som inte är avsedda för allmänt bruk. Deras definition kan komma att ändras i framtiden.

3.2.1. None¶

Denna typ har ett enda värde. Det finns ett enda objekt med detta värde. Detta objekt nås genom det inbyggda namnet None. Det används för att beteckna avsaknaden av ett värde i många situationer, t.ex. returneras det från funktioner som inte uttryckligen returnerar något. Dess sanningsvärde är false.

3.2.2. NotImplemented¶

Denna typ har ett enda värde. Det finns ett enda objekt med detta värde. Detta objekt är åtkomligt genom det inbyggda namnet NotImplemented. Numeriska metoder och rika jämförelsemetoder bör returnera detta värde om de inte implementerar operationen för de operander som tillhandahålls. (Tolken kommer då att prova den reflekterade operationen, eller någon annan fallback, beroende på operatorn) Det bör inte utvärderas i en boolesk kontext.

Se Implementering av aritmetiska operationer för mer information.

Ändrad i version 3.9: Utvärdering av NotImplemented i en boolesk kontext var föråldrad.

Ändrad i version 3.14: Utvärdering av NotImplemented i en booleansk kontext ger nu upphov till ett TypeError. Det utvärderades tidigare till True och gav upphov till en DeprecationWarning sedan Python 3.9.

3.2.3. Ellipsis¶

Denna typ har ett enda värde. Det finns ett enda objekt med detta värde. Detta objekt nås genom det bokstavliga ... eller det inbyggda namnet Ellipsis. Dess sanningsvärde är true.

3.2.4. `numbers.Number`¶

Dessa skapas av numeriska literaler och returneras som resultat av aritmetiska operatorer och inbyggda aritmetiska funktioner. Numeriska objekt är oföränderliga; när de väl har skapats ändras aldrig deras värde. Pythontal är naturligtvis starkt relaterade till matematiska tal, men är föremål för begränsningarna för numerisk representation i datorer.

Strängrepresentationerna av de numeriska klasserna, beräknade med __repr__() och __str__(), har följande egenskaper:

De är giltiga numeriska literaler som, när de skickas till sin klasskonstruktör, producerar ett objekt som har värdet av den ursprungliga numeriska.
Representationen är i bas 10, när så är möjligt.
Ledande nollor, möjligen med undantag för en enda nolla före ett decimaltecken, visas inte.
Efterföljande nollor, eventuellt med undantag för en enda nolla efter ett decimaltecken, visas inte.
Ett tecken visas endast när talet är negativt.

Python skiljer mellan heltal, flyttal och komplexa tal:

3.2.4.1. `numbers.Integral`¶

Dessa representerar element från den matematiska uppsättningen av heltal (positiva och negativa).

Anteckning

Reglerna för representation av heltal är avsedda att ge den mest meningsfulla tolkningen av skift- och maskoperationer som involverar negativa heltal.

Det finns två typer av heltal:

Heltal (int): Dessa representerar tal i ett obegränsat intervall, endast beroende på tillgängligt (virtuellt) minne. Vid skift- och maskoperationer förutsätts en binär representation och negativa tal representeras i en variant av 2:ans komplement som ger illusionen av en oändlig sträng av teckenbitar som sträcker sig åt vänster.
Booleaner (bool): Dessa representerar sanningsvärdena False och True. De två objekt som representerar värdena False och True är de enda booleska objekten. Den booleska typen är en subtyp av heltalstypen, och booleska värden beter sig som värdena 0 respektive 1 i nästan alla sammanhang, med undantaget att när de konverteras till en sträng returneras strängarna "False" respektive "True".

3.2.4.2. `numbers.Real` (`float`)¶

Dessa representerar flyttal med dubbel precision på maskinnivå. Du är utlämnad till den underliggande maskinarkitekturen (och C- eller Java-implementeringen) för det accepterade intervallet och hanteringen av överflöd. Python stöder inte flyttal med enkel precision; besparingarna i processor- och minnesanvändning som vanligtvis är skälet till att använda dessa dvärgas av omkostnaderna för att använda objekt i Python, så det finns ingen anledning att komplicera språket med två typer av flyttal.

3.2.4.3. `numbers.Complex` (`complex`)¶

Dessa representerar komplexa tal som ett par flyttal med dubbel precision på maskinnivå. Samma försiktighetsåtgärder gäller som för flyttal. De reella och imaginära delarna av ett komplext tal z kan hämtas genom de skrivskyddade attributen z.real och z.imag.

3.2.5. Sekvenser¶

Dessa representerar ändliga ordnade mängder indexerade med icke-negativa tal. Den inbyggda funktionen len() returnerar antalet objekt i en sekvens. När längden på en sekvens är n innehåller indexuppsättningen siffrorna 0, 1, …, n-1. Objekt i i sekvensen a väljs av a[i]. Vissa sekvenser, inklusive inbyggda sekvenser, tolkar negativa subskriptioner genom att lägga till sekvenslängden. Till exempel är a[-2] lika med a[n-2], det näst sista objektet i sekvensen a med längden n.

Sekvenser stöder också skivning: a[i:j] väljer alla objekt med index k så att i <= k < j. När en slice används som ett uttryck är den en sekvens av samma typ. Kommentaren ovan om negativa index gäller även för negativa slicepositioner.

Vissa sekvenser stöder också ”extended slicing” med en tredje parameter ”step”: a[i:j:k] väljer alla objekt i a med index x där x = i + n*k, n >= 0 och i <= x < j.

Sekvenserna skiljer sig åt beroende på hur föränderliga de är:

3.2.5.1. Oföränderliga sekvenser¶

Ett objekt av en oföränderlig sekvenstyp kan inte ändras när det väl har skapats. (Om objektet innehåller referenser till andra objekt kan dessa andra objekt vara föränderliga och kan ändras, men samlingen av objekt som ett oföränderligt objekt refererar direkt till kan inte ändras)

Följande typer är oföränderliga sekvenser:

Strängar: En sträng är en sekvens av värden som representerar Unicode-kodpunkter. Alla kodpunkter i intervallet U+0000 - U+10FFFF kan representeras i en sträng. Python har inte någon char-typ, utan varje kodpunkt i strängen representeras som ett strängobjekt med längden 1. Den inbyggda funktionen ord() konverterar en kodpunkt från dess strängform till ett heltal i intervallet 0 - 10FFFF; chr() konverterar ett heltal i intervallet 0 - 10FFFF till motsvarande strängobjekt med längden 1. str.encode() kan användas för att konvertera en str till bytes med den givna textkodningen, och bytes.decode() kan användas för att uppnå motsatsen.
Tupler: Objekten i en tupel är godtyckliga Python-objekt. Tuplar med två eller flera objekt bildas av kommaseparerade listor med uttryck. En tupel med ett objekt (en ”singleton”) kan bildas genom att ett uttryck förses med ett kommatecken (ett uttryck i sig skapar inte en tupel, eftersom parenteser måste kunna användas för gruppering av uttryck). En tom tupel kan bildas av ett tomt par parenteser.
Byte: Ett bytes-objekt är en oföränderlig array. Objekten är 8-bitars byte, representerade av heltal i intervallet 0 <= x < 256. Byteslitteraler (som b'abc') och den inbyggda bytes()-konstruktorn kan användas för att skapa bytes-objekt. Bytesobjekt kan också avkodas till strängar via metoden decode().

3.2.5.2. Mutabla sekvenser¶

Mutabla sekvenser kan ändras efter att de har skapats. Subscriptions- och slicing-notationerna kan användas som mål för assignment- och del (delete)-satser.

Anteckning

Modulerna collections och array ger ytterligare exempel på föränderliga sekvenstyper.

Det finns för närvarande två inneboende muterbara sekvenstyper:

Listor: Objekten i en lista är godtyckliga Python-objekt. Listor bildas genom att placera en kommaseparerad lista med uttryck inom hakparenteser. (Observera att det inte behövs några specialfall för att bilda listor med längden 0 eller 1)
Byte-arrayer: Ett bytearray-objekt är en föränderlig array. De skapas av den inbyggda bytearray()-konstruktören. Bortsett från att bytearray är föränderliga (och därmed ohashbara), har de i övrigt samma gränssnitt och funktionalitet som oföränderliga bytes-objekt.

3.2.6. Uppsättningstyper¶

Dessa representerar oordnade, ändliga uppsättningar av unika, oföränderliga objekt. Som sådana kan de inte indexeras med något subskript. De kan dock itereras över och den inbyggda funktionen len() returnerar antalet objekt i en uppsättning. Vanliga användningsområden för set är snabb testning av medlemskap, borttagning av dubbletter från en sekvens och beräkning av matematiska operationer som intersektion, union, differens och symmetrisk differens.

För set-element gäller samma regler för oföränderlighet som för nycklar i ordböcker. Observera att numeriska typer följer de normala reglerna för numerisk jämförelse: om två tal jämförs lika (t.ex. 1 och 1.0) kan endast ett av dem ingå i en uppsättning.

Det finns för närvarande två typer av intrinsic set:

Uppsättningar: Dessa representerar en föränderlig uppsättning. De skapas av den inbyggda set()-konstruktören och kan modifieras i efterhand med flera metoder, t.ex. add().
Frysta uppsättningar: Dessa representerar en oföränderlig uppsättning. De skapas av den inbyggda frozenset()-konstruktören. Eftersom en frozenset är oföränderlig och hashable kan den användas igen som ett element i en annan uppsättning eller som en nyckel i en ordbok.

3.2.7. Mappningar¶

Dessa representerar ändliga uppsättningar av objekt indexerade med godtyckliga indexuppsättningar. Subscript-notationen a[k] väljer objektet indexerat med k från mappningen a; detta kan användas i uttryck och som mål för tilldelningar eller del-satser. Den inbyggda funktionen len() returnerar antalet objekt i en mappning.

Det finns för närvarande en enda intrinsic mappningstyp:

3.2.7.1. Ordböcker¶

Dessa representerar ändliga uppsättningar av objekt indexerade med nästan godtyckliga värden. De enda typer av värden som inte kan accepteras som nycklar är värden som innehåller listor eller lexikon eller andra föränderliga typer som jämförs med värde i stället för med objektets identitet, eftersom en effektiv implementering av lexikon kräver att en nyckels hashvärde förblir konstant. Numeriska typer som används för nycklar följer de normala reglerna för numerisk jämförelse: om två tal jämförs lika (t.ex. 1 och 1.0) kan de användas omväxlande för att indexera samma ordbokspost.

Ordböcker bevarar inmatningsordningen, vilket innebär att nycklar kommer att produceras i samma ordning som de lades till sekventiellt över ordboken. Om du ersätter en befintlig nyckel ändras inte ordningen, men om du tar bort en nyckel och sätter in den igen läggs den till i slutet i stället för att behålla sin gamla plats.

Dictionaries är mutabla; de kan skapas med notationen {} (se avsnitt Ordbok visar).

Tilläggsmodulerna dbm.ndbm och dbm.gnu ger ytterligare exempel på mappningstyper, liksom modulen collections.

Ändrad i version 3.7: Ordböcker bevarade inte insättningsordning i versioner av Python före 3.6. I CPython 3.6 bevarades insättningsordningen, men det ansågs vara en implementeringsdetalj vid den tiden snarare än en språkgaranti.

3.2.8. Kallbara typer¶

Dessa är de typer på vilka funktionsanropsoperationen (se avsnitt Calls) kan tillämpas:

3.2.8.1. Användardefinierade funktioner¶

Ett användardefinierat funktionsobjekt skapas genom en funktionsdefinition (se avsnitt Definitioner av funktioner). Den bör anropas med en argumentlista som innehåller samma antal objekt som funktionens formella parameterlista.

3.2.8.1.1. Särskilda skrivskyddade attribut¶

Attribut

Betydelse

function.__globals__¶

En referens till dictionary som innehåller funktionens global variables – den globala namnrymden i den modul där funktionen definierades.

function.__closure__¶

None eller en tuple av celler som innehåller bindningar för de namn som anges i attributet co_freevars i funktionens code object.

Ett cellobjekt har attributet cell_contents. Detta kan användas för att hämta cellens värde och för att ställa in värdet.

3.2.8.1.2. Särskilda skrivbara attribut¶

De flesta av dessa attribut kontrollerar typen av det tilldelade värdet:

Attribut	Betydelse
function.__doc__¶	Funktionens dokumentationssträng, eller `None` om den inte finns tillgänglig.
function.__name__¶	Funktionens namn. Se även: `__name__ attribut`.
function.__qualname__¶	Funktionens qualified name. Se även: `__qualname__-attribut`. Tillagd i version 3.3.
function.__module__¶	Namnet på den modul som funktionen definierades i, eller `None` om den inte är tillgänglig.
function.__defaults__¶	En `tuple` som innehåller standardvärden för parameter för de parametrar som har standardvärden, eller `None` om inga parametrar har ett standardvärde.
function.__code__¶	Den code object som representerar den kompilerade funktionskroppen.
function.__dict__¶	Namnrymden som stöder godtyckliga funktionsattribut. Se även: `__dict__ attribut`.
function.__annotations__¶	En `dictionary` som innehåller annoteringar av parameters. Nycklarna i dictionariet är parameternamnen och `'return'` för returannoteringen, om en sådan har angetts. Se även: `object.__annotations__`. Ändrad i version 3.14: Annotationer är nu lazily evaluated. Se PEP 649.
function.__annotate__¶	annotate function för denna funktion, eller `None` om funktionen inte har några annotationer. Se `object.__annotate__`. Tillagd i version 3.14.
function.__kwdefaults__¶	En `dictionary` som innehåller standardvärden för nyckelordsspecifika parameters.
function.__type_params__¶	En `tuple` som innehåller typ-parametrarna för en generisk funktion. Tillagd i version 3.12.

Funktionsobjekt stöder också hämtning och inställning av godtyckliga attribut, som t.ex. kan användas för att koppla metadata till funktioner. Vanlig attributpunktnotation används för att hämta och ställa in sådana attribut.

CPythons nuvarande implementering stöder endast funktionsattribut på användardefinierade funktioner. Funktionsattribut på inbyggda funktioner kan komma att stödjas i framtiden.

Ytterligare information om en funktions definition kan hämtas från dess code object (tillgänglig via attributet __code__).

3.2.8.2. Instansmetoder¶

Ett instansmetodobjekt kombinerar en klass, en klassinstans och ett anropsbart objekt (normalt en användardefinierad funktion).

Särskilda skrivskyddade attribut:

method.__self__¶	Hänvisar till klassens instansobjekt som metoden är bunden till
method.__func__¶	Hänvisar till det ursprungliga funktionsobjektet
method.__doc__¶	Metodens dokumentation (samma som `method.__func__.__doc__`). En `sträng` om den ursprungliga funktionen hade en dokumentsträng, annars `None`.
method.__name__¶	Namnet på metoden (samma som `method.__func__.__name__`)
method.__module__¶	Namnet på den modul som metoden definierades i, eller `None` om den inte är tillgänglig.

Metoderna stöder också åtkomst till (men inte inställning av) godtyckliga funktionsattribut på det underliggande funktionsobjektet.

Användardefinierade metodobjekt kan skapas när man hämtar ett attribut för en klass (kanske via en instans av den klassen), om attributet är ett användardefinierat funktionsobjekt eller ett klassmetod-objekt.

När ett instansmetodobjekt skapas genom att hämta ett användardefinierat funktionsobjekt från en klass via en av dess instanser, är dess __self__-attribut instansen, och metodobjektet sägs vara bundet. Den nya metodens attribut __func__ är det ursprungliga funktionsobjektet.

När ett instansmetodobjekt skapas genom att ett classmethod-objekt hämtas från en klass eller instans, är dess attribut __self__ klassen själv och dess attribut __func__ är det funktionsobjekt som ligger till grund för klassmetoden.

När ett instansmetodobjekt anropas, anropas den underliggande funktionen (__func__), varvid klassinstansen (__self__) infogas framför argumentlistan. Till exempel, när C är en klass som innehåller en definition för en funktion f(), och x är en instans av C, är anrop av x.f(1) likvärdigt med anrop av C.f(x, 1).

När ett instansmetodobjekt härleds från ett classmethod-objekt kommer den ”klassinstans” som lagras i __self__ faktiskt att vara själva klassen, så att anrop av antingen x.f(1) eller C.f(1) motsvarar anrop av f(C,1) där f är den underliggande funktionen.

Det är viktigt att notera att användardefinierade funktioner som är attribut till en klassinstans inte konverteras till bundna metoder; detta sker endast när funktionen är ett attribut till klassen.

3.2.8.3. Generatorfunktioner¶

En funktion eller metod som använder yield-satsen (se avsnitt yield-satsen) kallas en generatorfunktion. När en sådan funktion anropas returnerar den alltid ett iterator-objekt som kan användas för att exekvera funktionens kropp: om iteratorns iterator.__next__()-metod anropas kommer funktionen att exekveras tills den ger ett värde med hjälp av yield-satsen. När funktionen exekverar en return-sats eller faller av i slutet, kommer ett StopIteration-undantag att uppstå och iteratorn kommer att ha nått slutet av uppsättningen värden som ska returneras.

3.2.8.4. Coroutine-funktioner¶

En funktion eller metod som definieras med hjälp av async def kallas en coroutine function. En sådan funktion returnerar ett coroutine-objekt när den anropas. Det kan innehålla await-uttryck, samt async with och async for-satser. Se även avsnittet Coroutine-objekt.

3.2.8.5. Asynkrongeneratorfunktioner¶

En funktion eller metod som definieras med async def och som använder yield kallas en asynchronous generator function. En sådan funktion returnerar, när den anropas, ett asynkron iterator-objekt som kan användas i en async for-sats för att exekvera funktionens kropp.

Anrop av den asynkrona iteratorns metod aiterator.__anext__ returnerar en awaitable som när den är väntad kommer att exekveras tills den ger ett värde med hjälp av uttrycket yield. När funktionen exekverar en tom return-sats eller faller av i slutet, kommer ett StopAsyncIteration-undantag att uppstå och den asynkrona iteratorn kommer att ha nått slutet av den uppsättning värden som ska ges.

3.2.8.6. Inbyggda funktioner¶

Ett inbyggt funktionsobjekt är ett omslag runt en C-funktion. Exempel på inbyggda funktioner är len() och math.sin() (math är en inbyggd standardmodul). Antalet och typen av argument bestäms av C-funktionen. Särskilda skrivskyddade attribut:

__doc__ är funktionens dokumentationssträng, eller None om den inte är tillgänglig. Se function.__doc__.
__name__ är funktionens namn. Se function.__name__.
__self__ är satt till None (men se nästa punkt).
__module__ är namnet på den modul som funktionen definierades i eller None om den inte är tillgänglig. Se function.__module__.

3.2.8.7. Inbyggda metoder¶

Detta är egentligen en annan förklädnad av en inbyggd funktion, som den här gången innehåller ett objekt som skickas till C-funktionen som ett implicit extra argument. Ett exempel på en inbyggd metod är alist.append(), förutsatt att alist är ett listobjekt. I detta fall sätts det speciella skrivskyddade attributet __self__ till det objekt som betecknas av alist. (Attributet har samma semantik som det har med andra instansmetoder.)

3.2.8.8. Klasser¶

Klasser är anropsbara. Dessa objekt fungerar normalt som fabriker för nya instanser av sig själva, men variationer är möjliga för klasstyper som åsidosätter __new__(). Argumenten för anropet skickas till __new__() och, i det typiska fallet, till __init__() för att initiera den nya instansen.

3.2.8.9. Klassinstanser¶

Instanser av godtyckliga klasser kan göras anropbara genom att definiera en __call__()-metod i sin klass.

3.2.9. Moduler¶

Moduler är en grundläggande organisatorisk enhet i Python-kod, och skapas av import system som anropas antingen av import-satsen, eller genom att anropa funktioner som importlib.import_module() och inbyggda __import__(). Ett modulobjekt har ett namnrymd som implementeras av ett dictionary-objekt (detta är den ordbok som refereras av attributet __globals__ för funktioner som definieras i modulen). Attributreferenser översätts till uppslagningar i denna ordbok, t.ex. är m.x likvärdigt med m.__dict__["x"]. Ett modulobjekt innehåller inte det kodobjekt som används för att initiera modulen (eftersom det inte behövs när initieringen är klar).

Attributtilldelning uppdaterar modulens namnrymdsordbok, t.ex. m.x = 1 är likvärdigt med m.__dict__["x"] = 1.

3.2.9.1. Importrelaterade attribut på modulobjekt¶

Modulobjekt har följande attribut som relaterar till importsystemet. När en modul skapas med hjälp av de maskiner som är associerade med importsystemet fylls dessa attribut i baserat på modulens spec, innan loader körs och laddar modulen.

Om du vill skapa en modul dynamiskt i stället för att använda importsystemet rekommenderas att du använder importlib.util.module_from_spec(), som sätter de olika importkontrollerade attributen till lämpliga värden. Det är också möjligt att använda types.ModuleType-konstruktören för att skapa moduler direkt, men den här tekniken är mer felbenägen, eftersom de flesta attribut måste ställas in manuellt på modulobjektet efter att det har skapats med den här metoden.

Försiktighet

Med undantag för __name__ rekommenderas starkt att du förlitar dig på __spec__ och dess attribut istället för något av de andra enskilda attributen som listas i detta underavsnitt. Observera att uppdatering av ett attribut på __spec__ inte kommer att uppdatera motsvarande attribut på själva modulen:

>>> import typing
>>> typing.__name__, typing.__spec__.name
('typing', 'typing')
>>> typing.__spec__.name = 'spelling'
>>> typing.__name__, typing.__spec__.name
('typing', 'spelling')
>>> typing.__name__ = 'keyboard_smashing'
>>> typing.__name__, typing.__spec__.name
('keyboard_smashing', 'spelling')

module.__name__¶

Det namn som används för att unikt identifiera modulen i importsystemet. För en direkt exekverad modul kommer detta att sättas till "__main__".

Detta attribut måste vara inställt på modulens fullständiga kvalificerade namn. Det förväntas matcha värdet av module.__spec__.name.

module.__spec__¶

En registrering av modulens importsystemrelaterade tillstånd.

Ställdes in till modulspecifikation som användes vid import av modulen. Se Specifikationer för modul för mer information.

Tillagd i version 3.4.

module.__package__¶

Den package som en modul tillhör.

Om modulen är på toppnivå (dvs. inte ingår i något specifikt paket) ska attributet anges till '' (den tomma strängen). Annars bör det sättas till namnet på modulens paket (som kan vara lika med module.__name__ om modulen själv är ett paket). Se PEP 366 för ytterligare detaljer.

Detta attribut används i stället för __name__ för att beräkna explicit relativ import för huvudmoduler. Standardvärdet är None för moduler som skapas dynamiskt med hjälp av types.ModuleType-konstruktören; använd importlib.util.module_from_spec() istället för att säkerställa att attributet är inställt på en str.

Det rekommenderas starkt att du använder module.__spec__.parent i stället för module.__package__. __package__ används nu endast som en reservväg om __spec__.parent inte har angetts, och denna reservväg är föråldrad.

Ändrad i version 3.4: Detta attribut är nu standard för None för moduler som skapas dynamiskt med hjälp av konstruktören types.ModuleType. Tidigare var attributet valfritt.

Ändrad i version 3.6: Värdet på __package__ förväntas vara detsamma som __spec__.parent. __package__ används nu endast som en reservlösning vid importupplösning om __spec__.parent inte är definierad.

Ändrad i version 3.10: ImportWarning tas upp om en importresolution faller tillbaka till __package__ istället för __spec__.parent.

Ändrad i version 3.12: Skicka DeprecationWarning istället för ImportWarning när man faller tillbaka till __package__ under importlösning.

Deprecated since version 3.13, will be removed in version 3.15: __package__ kommer inte längre att ställas in eller tas i beaktande av importsystemet eller standardbiblioteket.

module.__loader__¶

Det loader-objekt som importmaskinen använde för att ladda modulen.

Detta attribut är mest användbart för introspektion, men kan användas för ytterligare laddningsspecifika funktioner, t.ex. för att hämta data som är associerade med en laddare.

__loader__ är som standard None för moduler som skapas dynamiskt med hjälp av konstruktören types.ModuleType; använd istället importlib.util.module_from_spec() för att se till att attributet sätts till ett loader-objekt.

Det rekommenderas starkt att du använder module.__spec__.loader i stället för module.__loader__.

Ändrad i version 3.4: Detta attribut är nu standard för None för moduler som skapas dynamiskt med hjälp av konstruktören types.ModuleType. Tidigare var attributet valfritt.

Deprecated since version 3.12, will be removed in version 3.16: Att ange __loader__ för en modul utan att ange __spec__.loader är föråldrat. I Python 3.16 kommer __loader__ inte längre att anges eller tas i beaktande av importsystemet eller standardbiblioteket.

module.__path__¶

En (eventuellt tom) sequence av strängar som räknar upp de platser där paketets undermoduler kommer att hittas. Icke-paketmoduler bör inte ha ett __path__-attribut. Se __path__-attribut för moduler för mer information.

Det rekommenderas starkt att du använder module.__spec__.submodule_search_locations i stället för module.__path__.

module.__file__¶

module.__cached__¶

__file__ och __cached__ är båda valfria attribut som kan eller inte kan anges. Båda attributen bör vara en str när de är tillgängliga.

__file__ anger sökvägen till den fil från vilken modulen laddades (om den laddades från en fil), eller sökvägen till den delade biblioteksfilen för tilläggsmoduler som laddas dynamiskt från ett delat bibliotek. Det kan saknas för vissa typer av moduler, t.ex. C-moduler som länkas statiskt till tolken, och :import-systemet kan välja att lämna det oinställt om det inte har någon semantisk betydelse (t.ex. en modul som laddas från en databas).

Om __file__ anges kan även attributet __cached__ anges, vilket är sökvägen till en kompilerad version av koden (t.ex. en bytekompilerad fil). Filen behöver inte existera för att detta attribut ska kunna anges; sökvägen kan helt enkelt peka på var den kompilerade filen skulle finnas (se PEP 3147).

Observera att __cached__ kan anges även om __file__ inte anges. Det scenariot är dock ganska atypiskt. I slutändan är det loader som använder modulspecifikationen som tillhandahålls av finder (från vilken __file__ och __cached__ härleds). Så om en laddare kan ladda från en cachad modul men i övrigt inte laddar från en fil, kan det atypiska scenariot vara lämpligt.

Det rekommenderas starkt att du använder module.__spec__.cached i stället för module.__cached__.

Deprecated since version 3.13, will be removed in version 3.15: Att ställa in __cached__ på en modul samtidigt som man misslyckas med att ställa in __spec__.cached är föråldrat. I Python 3.15 kommer __cached__ inte längre att anges eller tas i beaktande av importsystemet eller standardbiblioteket.

3.2.9.2. Andra skrivbara attribut på modulobjekt¶

Förutom de importrelaterade attribut som anges ovan har modulobjekten även följande skrivbara attribut:

module.__doc__¶: Modulens dokumentationssträng, eller None om den inte är tillgänglig. Se även: __doc__-attribut.

module.__annotations__¶: En ordbok som innehåller variable annotations som samlats in under modulens exekvering. För bästa praxis för att arbeta med __annotations__, se annotationlib.

Ändrad i version 3.14: Annotationer är nu lazily evaluated. Se PEP 649.

module.__annotate__¶: annotate function för denna modul, eller None om modulen inte har några annotationer. Se även: __annotate__ attribut.

Tillagd i version 3.14.

3.2.9.3. Modul ordböcker¶

Modulobjekt har också följande speciella skrivskyddade attribut:

module.__dict__¶: Modulens namnrymd som ett ordboksobjekt. En unik egenskap bland de attribut som listas här är att __dict__ inte kan nås som en global variabel från en modul, utan endast som ett attribut på modulobjekt.

På grund av hur CPython rensar modulordböcker kommer modulordboken att rensas när modulen faller ur räckvidden även om ordboken fortfarande har levande referenser. För att undvika detta, kopiera ordlistan eller behåll modulen medan du använder dess ordlista direkt.

3.2.10. Anpassade klasser¶

Anpassade klasstyper skapas vanligen genom klassdefinitioner (se avsnitt Klassdefinitioner). En klass har ett namnrymd som implementeras av ett ordboksobjekt. Referenser till klassattribut översätts till uppslagningar i denna ordbok, t.ex. översätts C.x till C.__dict__["x"] (även om det finns ett antal hooks som tillåter andra sätt att lokalisera attribut). Om attributnamnet inte hittas där fortsätter sökningen i basklasserna. Vid denna sökning i basklasserna används C3-metodens upplösningsordning som fungerar korrekt även när det finns ”diamantformade” arvsstrukturer där det finns flera arvsvägar som leder tillbaka till en gemensam förfader. Ytterligare detaljer om C3 MRO som används av Python finns på Python 2.3-metodens upplösningsordning.

När en referens till ett klassattribut (t.ex. för klassen C) skulle ge ett klassmetodobjekt, omvandlas det till ett instansmetodobjekt vars attribut __self__ är C. När det skulle ge ett staticmethod-objekt, omvandlas det till det objekt som omsluts av det statiska metodobjektet. Se avsnitt Implementering av deskriptorer för ett annat sätt på vilket attribut som hämtas från en klass kan skilja sig från de som faktiskt finns i dess __dict__.

Tilldelningar av klassattribut uppdaterar klassens ordbok, aldrig en basklass ordbok.

Ett klassobjekt kan anropas (se ovan) för att ge en klassinstans (se nedan).

3.2.10.1. Särskilda egenskaper¶

Attribut	Betydelse
type.__name__¶	Klassens namn. Se även: `__name__ attribut`.
type.__qualname__¶	Klassens qualified name. Se även: `__qualname__-attribut`.
type.__module__¶	Namnet på den modul i vilken klassen definierades.
type.__dict__¶	En `mappningsproxy` som ger en skrivskyddad vy av klassens namnrymd. Se även: `__dict__-attribut`.
type.__bases__¶	En `tuple` som innehåller klassens baser. I de flesta fall, för en klass definierad som `class X(A, B, C)`, kommer `X.__bases__` att vara exakt lika med `(A, B, C)`.
type.__doc__¶	Klassens dokumentationssträng, eller `None` om den är odefinierad. Ärvs inte av underklasser.
type.__annotations__¶	En ordbok som innehåller variable annotations som samlats in under klassens exekvering. Se även: `__annotations__ attribut`. För bästa praxis för att arbeta med `__annotations__`, se `annotationlib`. Använd `annotationlib.get_annotations()` istället för att komma åt detta attribut direkt. Varning Om du använder attributet `__annotations__` direkt på ett klassobjekt kan du få tillbaka annoteringar för fel klass, särskilt i vissa fall där klassen, dess basklass eller en metaklass definieras under `from __future__ import annotations`. Se 749 för detaljer. Detta attribut finns inte i vissa inbyggda klasser. På användardefinierade klasser utan `__annotations__` är det en tom ordbok. Ändrad i version 3.14: Annotationer är nu lazily evaluated. Se PEP 649.
type.__annotate__()¶	annotate function för denna klass, eller `None` om klassen inte har några annoteringar. Se även: `__annotate__-attribut`. Tillagd i version 3.14.
type.__type_params__¶	En `tuple` som innehåller type parameters för en generic class. Tillagd i version 3.12.
type.__static_attributes__¶	En `tuple` som innehåller namn på attribut för denna klass som tilldelas via `self.X` från någon funktion i dess kropp. Tillagd i version 3.13.
type.__firstlineno__¶	Radnumret på den första raden i klassdefinitionen, inklusive dekoratorer. Genom att ange attributet `__module__` tas objektet `__firstlineno__` bort från typens dictionary. Tillagd i version 3.13.
type.__mro__¶	Den `tupel` av klasser som beaktas när man letar efter basklasser under metodresolution.

3.2.10.2. Särskilda metoder¶

Förutom de specialattribut som beskrivs ovan har alla Python-klasser också följande två metoder tillgängliga:

type.mro()¶: Den här metoden kan åsidosättas av en metaklass för att anpassa metodupplösningsordningen för dess instanser. Den anropas vid klassens instansiering och dess resultat lagras i __mro__.

type.__subclasses__()¶

Varje klass har en lista över svaga referenser till sina närmaste underklasser. Denna metod returnerar en lista över alla dessa referenser som fortfarande är vid liv. Listan är i definitionsordning. Ett exempel:

>>> class A: pass
>>> class B(A): pass
>>> A.__subclasses__()
[<class 'B'>]

3.2.11. Klassinstanser¶

En klassinstans skapas genom att anropa ett klassobjekt (se ovan). En klassinstans har ett namnrymd som är implementerat som en ordbok som är det första stället där attributreferenser söks. Om ett attribut inte hittas där och instansens klass har ett attribut med samma namn, fortsätter sökningen med klassattributen. Om ett klassattribut hittas som är ett användardefinierat funktionsobjekt omvandlas det till ett instansmetodobjekt vars attribut __self__ är instansen. Statiska metod- och klassmetodobjekt transformeras också; se ovan under ”Klasser”. Se avsnitt Implementering av deskriptorer för ett annat sätt på vilket attribut för en klass som hämtas via dess instanser kan skilja sig från de objekt som faktiskt lagras i klassens __dict__. Om inget klassattribut hittas, och objektets klass har en __getattr__()-metod, anropas den för att uppfylla sökningen.

Tilldelning och borttagning av attribut uppdaterar instansens dictionary, aldrig en klass’ dictionary. Om klassen har en metod __setattr__() eller __delattr__() anropas denna istället för att uppdatera instansens dictionary direkt.

Klassinstanser kan låtsas vara tal, sekvenser eller avbildningar om de har metoder med vissa speciella namn. Se avsnitt Särskilda metodnamn.

3.2.11.1. Särskilda egenskaper¶

object.__class__¶: Den klass som en klassinstans tillhör.

object.__dict__¶: En ordbok eller annat mappningsobjekt som används för att lagra ett objekts (skrivbara) attribut. Inte alla instanser har ett __dict__-attribut; se avsnittet om __slots__ för mer information.

3.2.12. I/O-objekt (även kända som filobjekt)¶

Ett filobjekt representerar en öppen fil. Olika genvägar finns tillgängliga för att skapa filobjekt: den inbyggda funktionen open(), och även os.popen(), os.fdopen() och metoden makefile() för socketobjekt (och kanske andra funktioner eller metoder som tillhandahålls av tilläggsmoduler).

Objekten sys.stdin, sys.stdout och sys.stderr initialiseras till filobjekt som motsvarar tolkens standardflöden för inmatning, utmatning och fel; de är alla öppna i textläge och följer därför det gränssnitt som definieras av den abstrakta klassen io.TextIOBase.

3.2.13. Interna typer¶

Några typer som används internt av tolken är exponerade för användaren. Deras definitioner kan komma att ändras i framtida versioner av tolken, men de nämns här för fullständighetens skull.

3.2.13.1. Kodobjekt¶

Kodobjekt representerar byte-kompilerad exekverbar Python-kod, eller bytecode. Skillnaden mellan ett kodobjekt och ett funktionsobjekt är att funktionsobjektet innehåller en explicit referens till funktionens globaler (den modul där den definierades), medan ett kodobjekt inte innehåller någon kontext; även standardargumentvärdena lagras i funktionsobjektet, inte i kodobjektet (eftersom de representerar värden som beräknas vid körning). Till skillnad från funktionsobjekt är kodobjekt oföränderliga och innehåller inga referenser (vare sig direkt eller indirekt) till föränderliga objekt.

3.2.13.1.1. Särskilda skrivskyddade attribut¶

codeobject.co_name¶	Funktionens namn
codeobject.co_qualname¶	Det fullständigt kvalificerade funktionsnamnet Tillagd i version 3.11.
codeobject.co_argcount¶	Det totala antalet positionella parametrar (inklusive enbart positionella parametrar och parametrar med standardvärden) som funktionen har
codeobject.co_posonlyargcount¶	Antalet positionsbestämda parametrar (inklusive argument med standardvärden) som funktionen har
codeobject.co_kwonlyargcount¶	Antalet nyckelordsspecifika parametrar (inklusive argument med standardvärden) som funktionen har
codeobject.co_nlocals¶	Antalet lokala variabler som används av funktionen (inklusive parametrar)
codeobject.co_varnames¶	En `tuple` som innehåller namnen på de lokala variablerna i funktionen (börjar med parameternamnen)
codeobject.co_cellvars¶	En `tuple` som innehåller namnen på lokala variabler som refereras från minst en nested scope inuti funktionen
codeobject.co_freevars¶	En `tupel` som innehåller namnen på free (closure) variables som en nested scope refererar till i ett yttre scope. Se även `function.__closure__`. Obs: referenser till globala och inbyggda namn är inte inkluderade.
codeobject.co_code¶	En sträng som representerar sekvensen av bytecode-instruktioner i funktionen
codeobject.co_consts¶	En `tuple` som innehåller de literaler som används av bytecode i funktionen
codeobject.co_names¶	En `tuple` som innehåller de namn som används av bytecode i funktionen
codeobject.co_filename¶	Namnet på den fil som koden kompilerades från
codeobject.co_firstlineno¶	Radnumret för den första raden i funktionen
codeobject.co_lnotab¶	En sträng som kodar mappningen från bytecode-offsets till radnummer. För detaljer, se källkoden för tolken. Föråldrad sedan version 3.12: Detta attribut för kodobjekt är föråldrat och kan komma att tas bort i Python 3.15.
codeobject.co_stacksize¶	Den nödvändiga stackstorleken för kodobjektet
codeobject.co_flags¶	En `integer` som kodar ett antal flaggor för tolken.

Följande flaggbitar är definierade för co_flags: bit 0x04 sätts om funktionen använder syntaxen *arguments för att acceptera ett godtyckligt antal positionella argument; bit 0x08 sätts om funktionen använder syntaxen **keywords för att acceptera godtyckliga nyckelordsargument; bit 0x20 sätts om funktionen är en generator. Se Kodobjekt Bit Flaggor för detaljer om semantiken för varje flagga som kan förekomma.

Deklarationer av framtida funktioner (t.ex. from __future__ import division) använder också bitar i co_flags för att ange om ett kodobjekt kompilerades med en viss funktion aktiverad. Se compiler_flag.

Övriga bitar i co_flags är reserverade för internt bruk.

Om ett kodobjekt representerar en funktion och har en docstring, sätts bit CO_HAS_DOCSTRING i co_flags och det första objektet i co_consts är funktionens docstring.

3.2.13.1.2. Metoder på kodobjekt¶

codeobject.co_positions()¶

Returnerar en iterabel över källkodspositionerna för varje bytecode-instruktion i kodobjektet.

Iteratorn returnerar tuple` som innehåller (start_line, end_line, start_column, end_column). Tupeln i-th motsvarar positionen för den källkod som kompilerades till kodenheten i-th. Kolumninformationen är 0-indexerade utf-8-byteoffset på den angivna källkodsraden.

Denna positionsinformation kan saknas. En icke uttömmande lista över fall där detta kan inträffa:

Kör tolken med -X no_debug_ranges.
Läser in en pyc-fil som kompilerats med -X no_debug_ranges.
Positionstuplar som motsvarar artificiella instruktioner.
Rad- och kolumnnummer som inte kan representeras på grund av implementationsspecifika begränsningar.

När detta inträffar kan vissa eller alla element i tupeln vara None.

Tillagd i version 3.11.

Anteckning

Den här funktionen kräver att kolumnpositioner lagras i kodobjekt, vilket kan leda till en liten ökning av diskanvändningen för kompilerade Python-filer eller tolkens minnesanvändning. För att undvika att lagra den extra informationen och/eller avaktivera utskrift av extra spårningsinformation kan kommandoradsflaggan -X no_debug_ranges eller miljövariabeln PYTHONNODEBUGRANGES användas.

codeobject.co_lines()¶

Returnerar en iterator som ger information om successiva intervall av bytecode-element. Varje objekt som returneras är en (start, end, lineno) tuple:

start (en int) representerar förskjutningen (inklusive) av början på bytecode-intervallet
end (en int) representerar förskjutningen (exklusiv) av slutet på bytecode-intervallet
lineno är en int som representerar radnumret i bytecode-intervallet, eller None om bytekoderna i det angivna intervallet inte har något radnummer

De produkter som erhålls kommer att ha följande egenskaper:

Det första intervallet som genereras har start 0.
Områdena (start, end) kommer att vara icke avtagande och konsekutiva. Det vill säga, för varje par av tuple kommer start för det andra att vara lika med end för det första.
Inget intervall kommer att vara bakåtriktat: end >= start för alla tripplar.
Den sista tuple som erhålls kommer att ha end lika med storleken på bytecode.

Nollbreddsområden, där start == end, är tillåtna. Områden med nollbredd används för rader som finns i källkoden, men som har eliminerats av kompilatorn bytecode.

Tillagd i version 3.10.

Se även

PEP 626 - Exakta radnummer för felsökning och andra verktyg.: Den PEP som introducerade metoden co_lines().

codeobject.replace(**kwargs)¶

Returnerar en kopia av kodobjektet med nya värden för de angivna fälten.

Kodobjekt stöds också av den generiska funktionen copy.replace().

Tillagd i version 3.8.

3.2.13.2. Ramobjekt¶

Frame-objekt representerar exekveringsramar. De kan förekomma i traceback-objekt, och skickas också till registrerade spårningsfunktioner.

3.2.13.2.1. Särskilda skrivskyddade attribut¶

frame.f_back¶	Pekar på föregående stapelram (mot den som anropar), eller `None` om detta är den nedersta stapelramen
frame.f_code¶	Det code object som exekveras i denna frame. Åtkomst till detta attribut ger upphov till en auditing event `object.__getattr__` med argumenten `obj` och `"f_code"`.
frame.f_locals¶	Den mappning som används av ramen för att leta upp lokala variabler. Om ramen refererar till en optimized scope, kan detta returnera ett write-through proxy-objekt. Ändrad i version 3.13: Returnera en proxy för optimerade scopes.
frame.f_globals¶	Den ordbok som används av ramen för att slå upp globala variabler
frame.f_builtins¶	Den ordbok som används av ramen för att slå upp inbyggda (intrinsic) namn
frame.f_lasti¶	Den ”exakta instruktionen” för ramobjektet (detta är ett index i bytecode-strängen i code object)

3.2.13.2.2. Särskilda skrivbara attribut¶

frame.f_trace¶	Om inte `None`, är detta en funktion som anropas för olika händelser under kodkörning (detta används av debuggar). Normalt utlöses en händelse för varje ny källkodsrad (se `f_trace_lines`).
frame.f_trace_lines¶	Ställ in detta attribut på `False` för att inaktivera utlösningen av en spårningshändelse för varje källrad.
frame.f_trace_opcodes¶	Sätt detta attribut till `True` för att tillåta att händelser per operationskod begärs. Observera att detta kan leda till ett odefinierat tolkbeteende om undantag som skapas av spårningsfunktionen flyr till den funktion som spåras.
frame.f_lineno¶	Det aktuella radnumret för ramen - om du skriver till detta från en spårningsfunktion hoppar du till den angivna raden (endast för den nedersta ramen). En debugger kan implementera ett Jump-kommando (även kallat Set Next Statement) genom att skriva till detta attribut.

3.2.13.2.3. Metoder för ramobjekt¶

Ramobjekt stöder en metod:

frame.clear()¶

Denna metod rensar alla referenser till lokala variabler som finns i ramen. Dessutom, om ramen tillhörde en generator, slutförs generatorn. Detta hjälper till att bryta referenscykler som involverar ramobjekt (till exempel när man fångar ett exception och lagrar dess traceback för senare användning).

RuntimeError uppstår om ramen för närvarande körs eller avbryts.

Tillagd i version 3.4.

Ändrad i version 3.13: Försök att rensa en suspenderad ram ger upphov till RuntimeError (vilket alltid har varit fallet för exekverande ramar).

3.2.13.3. Spårningsobjekt¶

Traceback-objekt representerar stackspårningen av ett exception. Ett traceback-objekt skapas implicit när ett undantag inträffar, och kan också skapas explicit genom att anropa types.TracebackType.

Ändrad i version 3.7: Traceback-objekt kan nu uttryckligen instansieras från Python-kod.

För implicit skapade spårningar, när sökningen efter en undantagshanterare rullar upp exekveringsstacken, infogas ett spårningsobjekt framför den aktuella spårningen på varje upprullningsnivå. När en undantagshanterare anges görs stackspårningen tillgänglig för programmet. (Se avsnitt try-satsen.) Det är tillgängligt som det tredje objektet i den tupel som returneras av sys.exc_info(), och som attributet __traceback__ för det fångade undantaget.

När programmet inte innehåller någon lämplig hanterare skrivs stackspåret (snyggt formaterat) till standardfelsflödet; om tolken är interaktiv görs det också tillgängligt för användaren som sys.last_traceback.

För explicit skapade spårningar är det upp till skaparen av spårningen att avgöra hur tb_next-attributen ska länkas för att bilda en fullständig stackspårning.

Särskilda skrivskyddade attribut:

traceback.tb_frame¶

Pekar på exekveringen frame av den aktuella nivån.

Åtkomst till detta attribut ger upphov till en auditing event object.__getattr__ med argumenten obj och "tb_frame".

traceback.tb_lineno¶

Ger radnumret där undantaget inträffade

traceback.tb_lasti¶

Anger ”exakt instruktion”.

Radnumret och den sista instruktionen i spårningen kan skilja sig från radnumret i dess frame object om undantaget inträffade i en try-sats utan någon matchande except-sats eller med en finally-sats.

traceback.tb_next¶: Det speciella skrivbara attributet tb_next är nästa nivå i stackspårningen (mot den ram där undantaget inträffade), eller None om det inte finns någon nästa nivå.

Ändrad i version 3.7: Detta attribut är nu skrivbart

3.2.13.4. Skiva objekt¶

Slice-objekt används för att representera slices för __getitem__()-metoder. De skapas också av den inbyggda funktionen slice().

Särskilda skrivskyddade attribut: start är den nedre gränsen; stop är den övre gränsen; step är stegvärdet; varje attribut är None om det utelämnas. Dessa attribut kan ha vilken typ som helst.

Slice-objekt stöder en metod:

slice.indices(self, length)¶: Denna metod tar ett enda heltalsargument length och beräknar information om den del som slice-objektet skulle beskriva om det tillämpades på en sekvens av length-objekt. Den returnerar en tupel av tre heltal; dessa är indexen start och stop respektive step eller stride-längden för skivan. Saknade index eller index utanför gränserna hanteras på ett sätt som överensstämmer med vanliga slices.

3.2.13.5. Statiska metodobjekt¶

Statiska metodobjekt är ett sätt att motverka den omvandling av funktionsobjekt till metodobjekt som beskrivs ovan. Ett statiskt metodobjekt är ett omslag runt ett annat objekt, vanligtvis ett användardefinierat metodobjekt. När ett statiskt metodobjekt hämtas från en klass eller en klassinstans är det objekt som faktiskt returneras det omslutna objektet, som inte är föremål för någon ytterligare omvandling. Statiska metodobjekt är också anropsbara. Statiska metodobjekt skapas av den inbyggda staticmethod()-konstruktören.

3.2.13.6. Klassmetodobjekt¶

Ett klassmetodobjekt, liksom ett statiskt metodobjekt, är ett omslag runt ett annat objekt som ändrar det sätt på vilket det objektet hämtas från klasser och klassinstanser. Klassmetodobjektens beteende vid sådan hämtning beskrivs ovan, under ”instansmetoder”. Klassmetodobjekt skapas av den inbyggda classmethod()-konstruktören.

3.3. Särskilda metodnamn¶

En klass kan implementera vissa operationer som anropas med speciell syntax (t.ex. aritmetiska operationer eller subscripting och slicing) genom att definiera metoder med speciella namn. Detta är Pythons sätt att använda operator overloading, vilket gör det möjligt för klasser att definiera sitt eget beteende med avseende på språkoperatorer. Om en klass till exempel definierar en metod med namnet __getitem__(), och x är en instans av denna klass, så är x[i] ungefär likvärdig med type(x).__getitem__(x, i). Om inget annat anges leder försök att utföra en operation till ett undantag om ingen lämplig metod är definierad (typiskt AttributeError eller TypeError).

Om en specialmetod sätts till None innebär det att motsvarande operation inte är tillgänglig. Om en klass till exempel sätter __iter__() till None är klassen inte iterabel, så anrop av iter() på dess instanser kommer att ge upphov till ett TypeError (utan att falla tillbaka på __getitem__()). [2]

När man implementerar en klass som emulerar en inbyggd typ är det viktigt att emuleringen endast implementeras i den utsträckning som det är meningsfullt för det objekt som modelleras. Till exempel kan vissa sekvenser fungera bra för hämtning av enskilda element, men det kanske inte är meningsfullt att extrahera en del. (Ett exempel på detta är NodeList-gränssnittet i W3C:s Document Object Model)

3.3.1. Grundläggande anpassning¶

object.__new__(cls[, ...])¶

Anropas för att skapa en ny instans av klassen cls. __new__() är en statisk metod (specialklassad så att du inte behöver deklarera den som sådan) som tar den klass som en instans begärdes av som sitt första argument. De återstående argumenten är de som skickas till objektkonstruktörens uttryck (anropet till klassen). Returvärdet för __new__() bör vara den nya objektinstansen (vanligtvis en instans av cls).

Typiska implementeringar skapar en ny instans av klassen genom att anropa superklassens __new__()-metod genom att använda super().__new__(cls[, ...]) med lämpliga argument och sedan modifiera den nyskapade instansen efter behov innan den returneras.

Om __new__() anropas under objektkonstruktionen och den returnerar en instans av cls, kommer den nya instansens __init__()-metod att anropas som __init__(self[, ...]), där self är den nya instansen och de återstående argumenten är desamma som skickades till objektkonstruktören.

Om __new__() inte returnerar en instans av cls, kommer den nya instansens __init__()-metod inte att anropas.

__new__() är främst avsedd för att tillåta underklasser av oföränderliga typer (som int, str eller tuple) att anpassa skapandet av instanser. Den åsidosätts också ofta i anpassade metaklasser för att anpassa skapandet av klasser.

object.__init__(self[, ...])¶

Anropas efter att instansen har skapats (av __new__()), men innan den returneras till den som anropar. Argumenten är de som skickas till klassens konstruktörsuttryck. Om en basklass har en __init__()-metod, måste den härledda klassens __init__()-metod, om någon, uttryckligen anropa den för att säkerställa korrekt initialisering av basklassens del av instansen; till exempel: super().__init__([args...]).

Eftersom __new__() och __init__() arbetar tillsammans för att konstruera objekt (__new__() för att skapa det och __init__() för att anpassa det), får inget värde som inte är None returneras av __init__(); om så sker kommer ett TypeError att uppstå vid körning.

object.__del__(self)¶

Anropas när instansen är på väg att förstöras. Detta kallas också en finalizer eller (felaktigt) en destructor. Om en basklass har en __del__()-metod, måste den härledda klassens __del__()-metod, om någon, uttryckligen anropa den för att säkerställa korrekt radering av basklassens del av instansen.

Det är möjligt (men inte rekommenderat!) för metoden __del__() att skjuta upp destruktionen av instansen genom att skapa en ny referens till den. Detta kallas objektets återuppståndelse. Det är implementationsberoende om __del__() anropas en andra gång när ett återuppstått objekt är på väg att förstöras; den nuvarande CPython-implementationen anropar den bara en gång.

Det är inte garanterat att __del__()-metoder anropas för objekt som fortfarande existerar när tolken avslutas. weakref.finalize ger ett enkelt sätt att registrera en rensningsfunktion som ska anropas när ett objekt samlas in.

Anteckning

del x anropar inte direkt x.__del__() — den förra minskar referensantalet för x med ett, och den senare anropas endast när x referensantal når noll.

Det är möjligt för en referenscykel att förhindra att referensantalet för ett objekt går ner till noll. I så fall kommer cykeln senare att upptäckas och raderas av cyklisk skräpsamlare. En vanlig orsak till referenscykler är när ett undantag har fångats upp i en lokal variabel. Ramens lokala variabler refererar då till undantaget, som refererar till sin egen traceback, som refererar till de lokala variablerna i alla ramar som fångas i tracebacken.

Se även

Dokumentation för modulen gc.

Varning

På grund av de prekära omständigheter under vilka __del__()-metoderna anropas, ignoreras undantag som inträffar under deras exekvering och en varning skrivs ut till sys.stderr istället. I synnerhet:

__del__() kan anropas när godtycklig kod körs, inklusive från en godtycklig tråd. Om __del__() behöver ta ett lås eller anropa någon annan blockerande resurs kan det leda till dödläge eftersom resursen redan kan vara tagen av den kod som avbryts för att exekvera __del__().
__del__() kan köras när tolken stängs av. Som en följd av detta kan de globala variabler som den behöver komma åt (inklusive andra moduler) redan ha raderats eller satts till None. Python garanterar att globaler vars namn börjar med ett enda understreck raderas från sin modul innan andra globaler raderas; om det inte finns några andra referenser till sådana globaler kan detta hjälpa till att säkerställa att importerade moduler fortfarande är tillgängliga vid den tidpunkt då metoden __del__() anropas.

object.__repr__(self)¶

Anropas av den inbyggda funktionen repr() för att beräkna den ”officiella” strängrepresentationen av ett objekt. Om det är möjligt bör detta se ut som ett giltigt Python-uttryck som kan användas för att återskapa ett objekt med samma värde (i en lämplig miljö). Om detta inte är möjligt bör en sträng av formen <...some useful description...> returneras. Returvärdet måste vara ett strängobjekt. Om en klass definierar __repr__() men inte __str__(), så används __repr__() också när en ”informell” strängrepresentation av instanser av klassen krävs.

Detta används vanligtvis för felsökning, så det är viktigt att representationen är informationsrik och otvetydig. En standardimplementation tillhandahålls av object-klassen själv.

object.__str__(self)¶

Anropas av str(object), standardimplementeringen __format__() och den inbyggda funktionen print(), för att beräkna den ”informella” eller snyggt utskrivbara strängrepresentationen av ett objekt. Returvärdet måste vara ett str-objekt.

Den här metoden skiljer sig från object.__repr__() genom att det inte finns någon förväntan på att __str__() ska returnera ett giltigt Python-uttryck: en mer bekväm eller kortfattad representation kan användas.

Standardimplementeringen som definieras av den inbyggda typen object anropar object.__repr__().

object.__bytes__(self)¶: Anropas av bytes för att beräkna en byte-strängrepresentation av ett objekt. Detta bör returnera ett bytes-objekt. Klassen object tillhandahåller inte själv denna metod.

object.__format__(self, format_spec)¶

Anropas av den inbyggda funktionen format(), och i förlängningen utvärdering av formatted string literals och metoden str.format(), för att producera en ”formaterad” strängrepresentation av ett objekt. Argumentet format_spec är en sträng som innehåller en beskrivning av de formateringsalternativ som önskas. Tolkningen av argumentet format_spec är upp till den typ som implementerar __format__(), men de flesta klasser kommer antingen att delegera formateringen till en av de inbyggda typerna eller använda en liknande syntax för formateringsalternativ.

Se Formatspecifikation Mini-språk för en beskrivning av standardformateringssyntaxen.

Returvärdet måste vara ett strängobjekt.

Standardimplementeringen av object-klassen bör ges en tom format_spec-sträng. Den delegerar till __str__().

Ändrad i version 3.4: Metoden __format__ i object själv ger upphov till ett TypeError om den skickar en icke-tom sträng.

Ändrad i version 3.7: object.__format__(x, '') är nu likvärdigt med str(x) i stället för format(str(x), '').

object.__lt__(self, other)¶

object.__le__(self, other)¶

object.__eq__(self, other)¶

object.__ne__(self, other)¶

object.__gt__(self, other)¶

object.__ge__(self, other)¶

Dessa är de så kallade ”rich comparison”-metoderna. Korrespondensen mellan operatorsymboler och metodnamn är följande: x<y kallar x.__lt__(y), x<=y kallar x.__le__(y), x==y kallar x.__eq__(y), x!=y kallar x.__ne__(y), x>y kallar x.__gt__(y) och x>=y kallar x.__ge__(y).

En rik jämförelsemetod kan returnera singleton NotImplemented om den inte implementerar operationen för ett givet par argument. Av konvention returneras False och True för en lyckad jämförelse. Dessa metoder kan dock returnera vilket värde som helst, så om jämförelseoperatorn används i ett booleskt sammanhang (t.ex. i villkoret för en if-sats), kommer Python att anropa bool() på värdet för att avgöra om resultatet är sant eller falskt.

Som standard implementerar object __eq__() genom att använda is och returnerar NotImplemented` vid en falsk jämförelse: True if x is y else NotImplemented. För __ne__() delegerar den som standard till __eq__() och inverterar resultatet om det inte är NotImplemented. Det finns inga andra underförstådda relationer mellan jämförelseoperatorerna eller standardimplementeringarna; till exempel innebär sanningen i (x<y eller x==y) inte x<=y. För att automatiskt generera ordningsoperationer från en enda rotoperation, se functools.total_ordering().

Som standard tillhandahåller klassen object implementeringar som överensstämmer med Värdejämförelser: jämlikhet jämförs enligt objektets identitet, och ordningsjämförelser ger upphov till TypeError. Varje standardmetod kan generera dessa resultat direkt, men kan också returnera NotImplemented.

Se stycket om __hash__() för några viktiga anvisningar om hur du skapar hashable-objekt som stöder anpassade jämförelseoperationer och kan användas som nycklar i ordböcker.

Det finns inga versioner med utbytta argument av dessa metoder (som ska användas när det vänstra argumentet inte stöder operationen men det högra argumentet gör det); istället är __lt__() och __gt__() varandras reflektion, __le__() och __ge__() är varandras reflektion, och __eq__() och __ne__() är deras egen reflektion. Om operanderna är av olika typer och den högra operandens typ är en direkt eller indirekt subklass av den vänstra operandens typ, har den reflekterade metoden för den högra operanden prioritet, annars har den vänstra operandens metod prioritet. Virtuell subklassning beaktas inte.

När ingen lämplig metod returnerar något annat värde än NotImplemented, kommer operatorerna == och != att falla tillbaka till is respektive is not.

object.__hash__(self)¶

Anropas av den inbyggda funktionen hash() och för operationer på medlemmar i hashade samlingar inklusive set, frozenset och dict. Metoden __hash__() bör returnera ett heltal. Den enda egenskap som krävs är att objekt som jämförs lika har samma hashvärde; det är lämpligt att blanda ihop hashvärdena för de komponenter i objektet som också spelar en roll vid jämförelse av objekt genom att packa dem i en tupel och hasha tupeln. Exempel:

def __hash__(self):
    return hash((self.name, self.nick, self.color))

Anteckning

hash() trunkerar värdet som returneras från ett objekts anpassade __hash__()-metod till storleken på en Py_ssize_t. Detta är vanligtvis 8 byte på 64-bitarsversioner och 4 byte på 32-bitarsversioner. Om ett objekts __hash__() måste fungera på byggsystem med olika bitstorlekar, se till att kontrollera bredden på alla byggsystem som stöds. Ett enkelt sätt att göra detta är med python -c "import sys; print(sys.hash_info.width)".

Om en klass inte definierar en __eq__()-metod bör den inte heller definiera en __hash__()-operation; om den definierar __eq__() men inte __hash__() kommer dess instanser inte att kunna användas som objekt i hashbara samlingar. Om en klass definierar föränderliga objekt och implementerar en __eq__()-metod, bör den inte implementera __hash__(), eftersom implementeringen av hashable-samlingar kräver att en nyckels hashvärde är oföränderligt (om objektets hashvärde ändras kommer det att finnas i fel hashhink).

Användardefinierade klasser har metoderna __eq__() och __hash__() som standard (ärvda från klassen object); med dem jämförs alla objekt olika (utom med sig själva) och x.__hash__() returnerar ett lämpligt värde så att x == y innebär både att x är y och hash(x) == hash(y).

En klass som åsidosätter __eq__() och inte definierar __hash__() kommer att ha sin __hash__() implicit satt till None. När metoden __hash__() för en klass är None, kommer instanser av klassen att ge upphov till ett lämpligt TypeError` när ett program försöker hämta deras hashvärde, och kommer också att identifieras korrekt som unhashable när man kontrollerar isinstance(obj, collections.abc.Hashable).

Om en klass som åsidosätter __eq__() behöver behålla implementeringen av __hash__() från en överordnad klass, måste tolken uttryckligen få veta detta genom att ange __hash__ = <ParentClass>.__hash__.

Om en klass som inte åsidosätter __eq__() vill undertrycka hash-stöd, bör den inkludera __hash__ = None i klassdefinitionen. En klass som definierar sin egen __hash__() som uttryckligen ger upphov till ett TypeError skulle felaktigt identifieras som hashable av ett isinstance(obj, collections.abc.Hashable)-anrop.

Anteckning

Som standard är __hash__()-värdena för str- och bytes-objekt ”saltade” med ett oförutsägbart slumpmässigt värde. Även om de förblir konstanta inom en enskild Python-process, är de inte förutsägbara mellan upprepade anrop av Python.

Detta är avsett att ge skydd mot en överbelastningsattack som orsakas av noggrant utvalda inmatningar som utnyttjar den sämsta prestandan för en diktinmatning, O(n²) komplexitet. Se http://ocert.org/advisories/ocert-2011-003.html för mer information.

Om du ändrar hashvärden påverkas iterationsordningen för uppsättningar. Python har aldrig gett några garantier för denna ordning (och den varierar vanligtvis mellan 32-bitars och 64-bitars versioner).

Se även PYTHONHASHSEED.

Ändrad i version 3.3: Hash-randomisering är aktiverad som standard.

object.__bool__(self)¶: Anropas för att implementera sanningsvärdestestning och den inbyggda operationen bool(); bör returnera False eller True. När denna metod inte är definierad anropas __len__(), om den är definierad, och objektet anses vara sant om resultatet är ett annat än noll. Om en klass varken definierar __len__() eller __bool__() (vilket gäller för själva klassen object), anses alla dess instanser vara sanna.

3.3.2. Anpassning av attributåtkomst¶

Följande metoder kan definieras för att anpassa betydelsen av attributåtkomst (användning av, tilldelning till eller borttagning av x.name) för klassinstanser.

object.__getattr__(self, name)¶

Anropas när standardattributåtkomsten misslyckas med ett AttributeError (antingen __getattribute__() ger upphov till ett AttributeError eftersom namn inte är ett instansattribut eller ett attribut i klassträdet för self; eller __get__() av en namn-egenskap ger upphov till AttributeError). Denna metod bör antingen returnera det (beräknade) attributvärdet eller ge upphov till ett AttributeError undantag. Klassen object tillhandahåller inte själv denna metod.

Observera att om attributet hittas genom den normala mekanismen anropas inte __getattr__(). (Detta är en avsiktlig asymmetri mellan __getattr__() och __setattr__()) Detta görs både av effektivitetsskäl och för att __getattr__() annars inte skulle ha något sätt att komma åt andra attribut hos instansen. Observera att åtminstone för instansvariabler kan du ta total kontroll genom att inte infoga några värden i instansens attributordbok (utan istället infoga dem i ett annat objekt). Se metoden __getattribute__() nedan för ett sätt att faktiskt få total kontroll över attributåtkomst.

object.__getattribute__(self, name)¶

Anropas ovillkorligen för att implementera attributåtkomst för instanser av klassen. Om klassen också definierar __getattr__(), kommer den senare inte att anropas om inte __getattribute__() antingen anropar den explicit eller ger upphov till ett AttributeError. Denna metod bör returnera det (beräknade) attributvärdet eller ge upphov till ett AttributeError undantag. För att undvika oändlig rekursion i denna metod bör dess implementering alltid anropa basklassens metod med samma namn för att komma åt de attribut den behöver, till exempel object.__getattribute__(self, name).

Anteckning

Denna metod kan fortfarande förbigås när man letar upp specialmetoder som ett resultat av implicit anrop via språksyntax eller inbyggda funktioner. Se :ref:Särskild metoduppslagning.

För vissa känsliga attributåtkomster, väcker en auditing event object.__getattr__ med argumenten obj och name.

object.__setattr__(self, name, value)¶

Anropas när ett försök till attributtilldelning görs. Detta anropas i stället för den normala mekanismen (dvs. lagra värdet i instansordboken). name är attributets namn, value är det värde som ska tilldelas attributet.

Om __setattr__() vill tilldela ett instansattribut ska den anropa basklassens metod med samma namn, t.ex. object.__setattr__(self, name, value).

För vissa känsliga attributtilldelningar, väcker en auditing event object.__setattr__ med argumenten obj, name, value.

object.__delattr__(self, name)¶

Som __setattr__() men för borttagning av attribut istället för tilldelning. Detta bör endast implementeras om del obj.name är meningsfullt för objektet.

För vissa känsliga attribut raderingar, väcker en auditing event object.__delattr__ med argument obj och name.

object.__dir__(self)¶: Anropas när dir() anropas på objektet. En iterabel måste returneras. dir() konverterar den returnerade iterabeln till en lista och sorterar den.

3.3.2.1. Anpassa åtkomst till modulattribut¶

Specialnamnen __getattr__ och __dir__ kan också användas för att anpassa åtkomsten till modulattribut. Funktionen __getattr__ på modulnivå bör acceptera ett argument som är namnet på ett attribut och returnera det beräknade värdet eller ge upphov till ett AttributeError. Om ett attribut inte hittas på ett modulobjekt genom den normala sökningen, dvs object.__getattribute__(), söks __getattr__ i modulen __dict__ innan ett AttributeError` avges. Om det hittas anropas det med attributnamnet och resultatet returneras.

Funktionen __dir__ ska inte acceptera några argument och returnera en iterabel av strängar som representerar de namn som är tillgängliga i modulen. Om den finns, åsidosätter den här funktionen standard dir()-sökningen på en modul.

För en mer finkornig anpassning av modulens beteende (inställning av attribut, egenskaper etc.) kan man ställa in attributet __class__ för ett modulobjekt till en underklass av types.ModuleType. Till exempel:

import sys
from types import ModuleType

class VerboseModule(ModuleType):
    def __repr__(self):
        return f'Verbose {self.__name__}'

    def __setattr__(self, attr, value):
        print(f'Setting {attr}...')
        super().__setattr__(attr, value)

sys.modules[__name__].__class__ = VerboseModule

Anteckning

Att definiera modulen __getattr__ och ställa in modulen __class__ påverkar endast uppslagningar som görs med hjälp av syntaxen för attributåtkomst - direkt åtkomst till modulens globaler (oavsett om det sker med kod i modulen eller via en referens till modulens globals-ordbok) påverkas inte.

Ändrad i version 3.5: modulattributet __class__ är nu skrivbart.

Tillagd i version 3.7: modulattributen __getattr__ och __dir__.

Se även

PEP 562 - Modulerna __getattr__ och __dir__: Beskriver funktionerna __getattr__ och __dir__ för moduler.

3.3.2.2. Implementering av deskriptorer¶

Följande metoder gäller endast när en instans av den klass som innehåller metoden (en så kallad descriptor-klass) förekommer i en owner-klass (descriptorn måste finnas i antingen ägarens klassordbok eller i klassordboken för en av dess föräldrar). I exemplen nedan syftar ”attributet” på det attribut vars namn är nyckeln till egenskapen i ägarklassens __dict__. Klassen object i sig implementerar inte något av dessa protokoll.

object.__get__(self, instance, owner=None)¶

Anropas för att hämta attributet för ägarklassen (tillgång till klassattribut) eller för en instans av den klassen (tillgång till instansattribut). Det valfria argumentet owner är ägarklassen, medan instance är den instans som attributet åtkom genom, eller None när attributet åtkom genom owner.

Denna metod bör returnera det beräknade attributvärdet eller ge upphov till ett AttributeError undantag.

PEP 252 specificerar att __get__() är anropsbar med ett eller två argument. Pythons egna inbyggda deskriptorer stöder denna specifikation, men det är troligt att vissa tredjepartsverktyg har deskriptorer som kräver båda argumenten. Pythons egen implementation av __getattribute__() skickar alltid in båda argumenten oavsett om de krävs eller inte.

object.__set__(self, instance, value)¶

Anropas för att sätta attributet på en instans instans av ägarklassen till ett nytt värde, värde.

Observera att om du lägger till __set__() eller __delete__() ändras typen av deskriptor till en ”data descriptor”. Se Anropa beskrivare för mer information.

object.__delete__(self, instance)¶: Anropas för att ta bort attributet på en instans instans av ägarklassen.

Instanser av deskriptorer kan också ha attributet __objclass__ närvarande:

object.__objclass__¶: Attributet __objclass__ tolkas av modulen inspect som att det anger den klass där objektet definierades (om detta anges på rätt sätt kan det underlätta introspektion av dynamiska klassattribut under körning). För anropsbara objekt kan det indikera att en instans av den angivna typen (eller en underklass) förväntas eller krävs som det första positionella argumentet (CPython anger till exempel detta attribut för obundna metoder som implementeras i C).

3.3.2.3. Anropa beskrivare¶

I allmänhet är en descriptor ett objektattribut med ”bindningsbeteende”, ett attribut vars attributåtkomst har åsidosatts av metoder i descriptorprotokollet: __get__(), __set__() och __delete__(). Om någon av dessa metoder är definierade för ett objekt, sägs det vara en deskriptor.

Standardbeteendet för attributåtkomst är att hämta, ställa in eller ta bort attributet från ett objekts ordbok. Till exempel har a.x en uppslagskedja som börjar med a.__dict__['x'], sedan type(a).__dict__['x'] och fortsätter genom basklasserna för type(a) exklusive metaklasser.

Men om det sökta värdet är ett objekt som definierar en av deskriptormetoderna, kan Python åsidosätta standardbeteendet och anropa deskriptormetoden istället. Var detta inträffar i prioriteringskedjan beror på vilka descriptormetoder som definierades och hur de anropades.

Utgångspunkten för anrop av beskrivare är en bindning, a.x. Hur argumenten sammanställs beror på a:

Direktsamtal: Det enklaste och minst vanliga anropet är när användarkoden direkt anropar en deskriptormetod: x.__get__(a).
Bindning av instans: Om bindning sker till en objektinstans omvandlas a.x till anropet: type(a).__dict__['x'].__get__(a, type(a)).
Klassbindning: Om bindning sker till en klass omvandlas A.x till anropet: A.__dict__['x'].__get__(None, A).
Super bindning: En prickad uppslagning som super(A, a).x söker i a.__class__.__mro__ efter en basklass B efter A och returnerar sedan B.__dict__['x'].__get__(a, A). Om det inte är en deskriptor returneras x oförändrad.

För instansbindningar beror företrädet för anrop av deskriptorer på vilka deskriptormetoder som är definierade. En descriptor kan definiera valfri kombination av __get__(), __set__() och __delete__(). Om den inte definierar __get__(), kommer åtkomst till attributet att returnera deskriptorobjektet självt om det inte finns ett värde i objektets instansordbok. Om deskriptorn definierar __set__() och/eller __delete__() är den en datadeskriptor; om den inte definierar någotdera är den en icke-datadeskriptor. Normalt definierar datadescriptorer både __get__() och __set__(), medan icke-datadescriptorer bara har metoden __get__(). Databeskrivare med __get__() och __set__() (och/eller __delete__()) definierade åsidosätter alltid en omdefiniering i en instansordbok. Däremot kan deskriptorer som inte är data åsidosättas av instanser.

Python-metoder (inklusive de som dekoreras med @staticmethod och @classmethod) implementeras som icke-databeskrivare. Följaktligen kan instanser omdefiniera och åsidosätta metoder. Detta gör att enskilda instanser kan få beteenden som skiljer sig från andra instanser av samma klass.

Funktionen property() är implementerad som en databeskrivare. Följaktligen kan instanser inte åsidosätta beteendet hos en egenskap.

3.3.2.4. slots¶

__slots__ tillåter oss att uttryckligen deklarera datamedlemmar (som egenskaper) och neka skapandet av __dict__ och __weakref__ (om inte uttryckligen deklarerat i __slots__ eller tillgängligt i en förälder.)

Det utrymme som sparas jämfört med att använda __dict__ kan vara betydande. Hastigheten för attributuppslagning kan också förbättras avsevärt.

object.__slots__¶: Denna klassvariabel kan tilldelas en sträng, en iterabel eller en sekvens av strängar med variabelnamn som används av instanser. __slots__ reserverar utrymme för de deklarerade variablerna och förhindrar automatiskt skapande av __dict__ och __weakref__ för varje instans.

Anvisningar för användning av __slots__:

När du ärver från en klass utan __slots__ kommer attributen __dict__ och __weakref__ för instanserna alltid att vara tillgängliga.
Utan variabeln __dict__ kan instanser inte tilldelas nya variabler som inte listas i __slots__-definitionen. Försök att tilldela ett olistat variabelnamn ger upphov till AttributeError. Om dynamisk tilldelning av nya variabler önskas, lägg då till '__dict__' till sekvensen av strängar i __slots__-deklarationen.
Utan en __weakref__-variabel för varje instans stöder klasser som definierar __slots__ inte svaga referenser till sina instanser. Om stöd för svaga referenser behövs, lägg till '__weakref__' till sekvensen av strängar i __slots__-deklarationen.
__slots__ implementeras på klassnivå genom att skapa deskriptorer för varje variabelnamn. Därför kan klassattribut inte användas för att ange standardvärden för instansvariabler som definieras av __slots__; i annat fall skulle klassattributet skriva över deskriptortilldelningen.
Verkan av en __slots__-deklaration är inte begränsad till den klass där den är definierad. __slots__ som deklareras i föräldraklasser är tillgängliga i underordnade klasser. Instanser av en underordnad underklass kommer dock att få en __dict__ och __weakref__ om inte underklassen också definierar __slots__ (som bara bör innehålla namn på eventuella ytterligare slots).
Om en klass definierar en slot som också definieras i en basklass, är den instansvariabel som definieras av basklassens slot otillgänglig (utom genom att hämta dess deskriptor direkt från basklassen). Detta gör programmets innebörd odefinierad. I framtiden kan en kontroll läggas till för att förhindra detta.
TypeError kommer att uppstå om icke-tomma __slots__ definieras för en klass som härrör från en "variabel-längd" inbyggd typ såsom int, bytes och tuple.
Alla icke-strängformade iterable kan tilldelas __slots__.
Om en dictionary används för att tilldela __slots__, kommer nycklarna i ordlistan att användas som slotnamn. Värdena i ordlistan kan användas för att tillhandahålla dokumentsträngar per attribut som kommer att identifieras av inspect.getdoc() och visas i utdata från help().
__class__ fungerar endast om båda klasserna har samma __slots__.
Multiple inheritance med flera slotted föräldraklasser kan användas, men endast en förälder får ha attribut som skapats av slots (de andra baserna måste ha tomma slot layouter) - överträdelser ger upphov till TypeError.
Om en iterator används för __slots__ skapas en descriptor för vart och ett av iteratorns värden. Attributet __slots__ kommer dock att vara en tom iterator.

3.3.3. Anpassa skapandet av klasser¶

När en klass ärver från en annan klass anropas __init_subclass__() på moderklassen. På så sätt är det möjligt att skriva klasser som ändrar beteendet hos underklasser. Detta är nära besläktat med klassdekoratorer, men där klassdekoratorer endast påverkar den specifika klass som de tillämpas på, gäller __init_subclass__ endast framtida subklasser av den klass som definierar metoden.

classmethod object.__init_subclass__(cls)¶

Denna metod anropas när den innehållande klassen underklassas. cls är då den nya subklassen. Om den definieras som en normal instansmetod konverteras denna metod implicit till en klassmetod.

Nyckelordsargument som ges till en ny klass skickas till moderklassens __init_subclass__. För kompatibilitet med andra klasser som använder __init_subclass__, bör man ta ut de nyckelordsargument som behövs och skicka de andra till basklassen, som i:

klass Filosof:
    def __init_subclass__(cls, /, default_name, **kwargs):
        super().__init_subclass__(**kwargs)
        cls.default_name = default_name

class AustralianPhilosopher(Filosof, default_name="Bruce"):
    pass

Standardimplementeringen object.__init_subclass__ gör ingenting, men ger upphov till ett fel om den anropas med några argument.

Anteckning

Metaklasstipset metaclass används av resten av typmaskineriet och skickas aldrig till implementationer av __init_subclass__. Den faktiska metaklassen (snarare än den explicita ledtråden) kan nås som type(cls).

Tillagd i version 3.6.

När en klass skapas söker type.__new__() igenom klassvariablerna och gör återkallelser till dem med en __set_name__()-hook.

object.__set_name__(self, owner, name)¶

Anropas automatiskt när den ägande klassen owner skapas. Objektet har tilldelats namn i den klassen:

klass A:
    x = C() # Anropar automatiskt: x.__set_name__(A, 'x')

Om klassvariabeln tilldelas efter att klassen har skapats, kommer __set_name__() inte att anropas automatiskt. Om det behövs kan __set_name__() anropas direkt:

klass A:
   pass

c = C()
A.x = c # Hooken anropas inte
c.__set_name__(A, 'x') # Anropa hooken manuellt

Se Skapa klassobjektet för mer information.

Tillagd i version 3.6.

3.3.3.1. Metaklasser¶

Som standard konstrueras klasser med hjälp av type(). Klassens kropp exekveras i ett nytt namnrymd och klassnamnet binds lokalt till resultatet av type(name, bases, namespace).

Processen för att skapa klasser kan anpassas genom att skicka nyckelordsargumentet metaclass i klassdefinitionsraden, eller genom att ärva från en befintlig klass som innehåller ett sådant argument. I följande exempel är både MyClass och MySubclass instanser av Meta:

klass Meta(typ):
    pass

klass MyClass(metaklass=Meta):
    pass

klass MySubclass(MyClass):
    pass

Alla andra nyckelordsargument som anges i klassdefinitionen skickas vidare till alla metaklassoperationer som beskrivs nedan.

När en klassdefinition exekveras sker följande steg:

MRO-posterna är åtgärdade;
bestäms vilken metaklass som är lämplig;
klassnamnrymden är förberedd;
klassens kropp exekveras;
skapas klassobjektet.

3.3.3.2. Lösning av MRO-poster¶

object.__mro_entries__(self, bases)¶: Om en bas som förekommer i en klassdefinition inte är en instans av type, söks en __mro_entries__()-metod på basen. Om en __mro_entries__()-metod hittas ersätts basen med resultatet av ett anrop till __mro_entries__() när klassen skapades. Metoden anropas med den ursprungliga tupeln av baser som skickas till parametern bases och måste returnera en tupel av klasser som ska användas i stället för basen. Den returnerade tupeln kan vara tom: i dessa fall ignoreras den ursprungliga basen.

Se även

types.resolve_bases(): Dynamisk upplösning av baser som inte är instanser av type.
types.get_original_bases(): Hämta en klass ”ursprungliga baser” före modifieringar med __mro_entries__().
PEP 560: Kärnstöd för typningsmodul och generiska typer.

3.3.3.3. Fastställande av lämplig metaklass¶

Vilken metaklass som är lämplig för en klassdefinition bestäms på följande sätt:

om inga baser och ingen explicit metaklass anges, används type();
om en explicit metaklass anges och den inte är en instans av type(), så används den direkt som metaklass;
om en instans av type() anges som explicit metaklass, eller om baser har definierats, används den mest härledda metaklassen.

Den mest härledda metaklassen väljs från den explicit angivna metaklassen (om någon) och metaklasserna (dvs. type(cls)) för alla angivna basklasser. Den mest härledda metaklassen är en metaklass som är en subtyp av alla dessa kandidatmetaklasser. Om ingen av kandidatmetaklasserna uppfyller detta kriterium kommer klassdefinitionen att misslyckas med TypeError.

3.3.3.4. Förbereda klassens namnrymd¶

När rätt metaklass har identifierats förbereds klassens namnrymd. Om metaklassen har ett attribut __prepare__, anropas det som namespace = metaclass.__prepare__(name, bases, **kwds) (där eventuella ytterligare nyckelordsargument kommer från klassdefinitionen). Metoden __prepare__ bör implementeras som en classmethod. Namnrymden som returneras av __prepare__ skickas till __new__, men när det slutliga klassobjektet skapas kopieras namnrymden till en ny dict.

Om metaklassen inte har något __prepare__-attribut initieras klassnamnrymden som en tom ordnad mappning.

Se även

PEP 3115 - Metaklasser i Python 3000: Införde namnrymdshaken __prepare__

3.3.3.5. Exekvering av klassens kropp¶

Klassens kropp exekveras (ungefär) som exec(body, globals(), namespace). Den viktigaste skillnaden mot ett normalt anrop till exec() är att lexical scoping gör att klassens kropp (inklusive alla metoder) kan referera till namn från det aktuella och det yttre scopet när klassdefinitionen finns inuti en funktion.

Men även om klassdefinitionen finns i funktionen kan metoder som definieras i klassen fortfarande inte se namn som definieras i klassens scope. Klassvariabler måste nås via den första parametern i instans- eller klassmetoder, eller via den implicita lexikaliskt scopade __class__-referensen som beskrivs i nästa avsnitt.

3.3.3.6. Skapa klassobjektet¶

När klassens namnrymd har fyllts genom att exekvera klassens kropp, skapas klassobjektet genom att anropa metaclass(name, bases, namespace, **kwds) (de ytterligare nyckelord som skickas här är desamma som de som skickas till __prepare__).

Detta klassobjekt är det som kommer att refereras till av nollargumentformen av super(). __class__ är en implicit stängningsreferens som skapas av kompilatorn om några metoder i en klass kropp refererar till antingen __class__ eller super. Detta gör att nollargumentformen av super() korrekt identifierar den klass som definieras baserat på lexikal scoping, medan den klass eller instans som användes för att göra det aktuella anropet identifieras baserat på det första argumentet som skickas till metoden.

I CPython 3.6 och senare skickas cellen __class__ till metaklassen som en __classcell__-post i klassnamnrymden. Om den finns måste den spridas upp till type.__new__-anropet för att klassen ska initialiseras korrekt. Om detta inte görs resulterar det i ett RuntimeError i Python 3.8.

När du använder standardmetaklassen type, eller en metaklass som i slutändan anropar type.__new__, anropas följande ytterligare anpassningssteg efter att klassobjektet har skapats:

Metoden type.__new__ samlar in alla attribut i klassens namnrymd som definierar en __set_name__()-metod;
Dessa __set_name__-metoder anropas med den klass som definieras och det tilldelade namnet på det specifika attributet;
Hooken __init_subclass__() anropas på den nya klassens omedelbara förälder i dess metodresolutionsordning.

När klassobjektet har skapats skickas det till de klassdekoratorer som ingår i klassdefinitionen (om sådana finns) och det resulterande objektet binds i det lokala namnrymden som den definierade klassen.

När en ny klass skapas med type.__new__ kopieras det objekt som anges som namnrymdsparameter till en ny ordnad mappning och originalobjektet kasseras. Den nya kopian förpackas i en skrivskyddad proxy, som blir attributet __dict__ för klassobjektet.

Se även

PEP 3135 - Ny super: Beskriver den implicita __class__ stängningsreferensen

3.3.3.7. Användningsområden för metaklasser¶

De potentiella användningsområdena för metaklasser är gränslösa. Några idéer som har utforskats är enum, loggning, gränssnittskontroll, automatisk delegering, automatiskt skapande av egenskaper, proxies, ramverk och automatisk resurslåsning/synkronisering.

3.3.4. Anpassa kontroller av instanser och underklasser¶

Följande metoder används för att åsidosätta standardbeteendet för de inbyggda funktionerna isinstance() och issubclass().

I synnerhet metaklassen abc.ABCMeta implementerar dessa metoder för att göra det möjligt att lägga till abstrakta basklasser (ABC) som ”virtuella basklasser” till vilken klass eller typ som helst (inklusive inbyggda typer), inklusive andra ABC.

type.__instancecheck__(self, instance)¶: Returnerar true om instance ska betraktas som en (direkt eller indirekt) instans av class. Om definierad, anropas för att implementera isinstance(instance, class).

type.__subclasscheck__(self, subclass)¶: Returnerar true om subclass ska betraktas som en (direkt eller indirekt) underklass till class. Om definierad, anropas för att implementera issubclass(subclass, class).

Observera att dessa metoder söks upp i typen (metaklassen) för en klass. De kan inte definieras som klassmetoder i den faktiska klassen. Detta överensstämmer med uppslagningen av specialmetoder som anropas på instanser, men i det här fallet är instansen själv en klass.

Se även

PEP 3119 - Introduktion av abstrakta basklasser: Innehåller specifikationen för anpassning av isinstance() och issubclass() beteende genom __instancecheck__() och __subclasscheck__(), med motivering för denna funktionalitet i samband med tillägg av abstrakta basklasser (se modulen abc) till språket.

3.3.5. Emulering av generiska typer¶

När man använder type annotations, är det ofta användbart att parametrisera en generic type med Pythons hakparentesnotation. Till exempel kan annoteringen list[int] användas för att beteckna en list där alla element är av typen int.

Se även

PEP 484 - Tips om typ: Introduktion till Pythons ramverk för typannoteringar
Generiska alias-typer: Dokumentation för objekt som representerar parametriserade generiska klasser
Generiska läkemedel, användardefinierad generik och typing.Generic: Dokumentation om hur man implementerar generiska klasser som kan parametriseras vid körning och förstås av statiska typkontrollanter.

En klass kan generellt endast parametriseras om den definierar den speciella klassmetoden __class_getitem__().

classmethod object.__class_getitem__(cls, key)¶

Returnerar ett objekt som representerar specialiseringen av en generisk klass med typargument som finns i key.

När den definieras för en klass är __class_getitem__() automatiskt en klassmetod. Som sådan behöver den inte dekoreras med @classmethod när den definieras.

3.3.5.1. Syftet med __class_getitem__¶

Syftet med __class_getitem__() är att tillåta runtime-parametrisering av generiska klasser i standardbibliotek för att lättare kunna tillämpa type hints på dessa klasser.

För att implementera anpassade generiska klasser som kan parametriseras vid körning och förstås av statiska typkontrollanter, bör användare antingen ärva från en standardbiblioteksklass som redan implementerar __class_getitem__(), eller ärva från typing.Generic, som har sin egen implementering av __class_getitem__().

Anpassade implementeringar av __class_getitem__() på klasser som definieras utanför standardbiblioteket kanske inte förstås av typkontrollprogram från tredje part, t.ex. mypy. Att använda __class_getitem__() på någon klass för andra syften än typhinting är avrådande.

3.3.5.2. __class_getitem kontra getitem__¶

Vanligtvis anropar subscription för ett objekt med hakparenteser __getitem__()-instansmetoden som definieras i objektets klass. Men om objektet som prenumereras i sig är en klass, kan klassmetoden __class_getitem__() anropas istället. __class_getitem__() bör returnera ett GenericAlias objekt om det är korrekt definierat.

När expression obj[x] presenteras, följer Python-tolken ungefär följande process för att avgöra om __getitem__() eller __class_getitem__() ska anropas:

från inspect import isclass

def subscribe(obj, x):
    """Returnera resultatet av uttrycket 'obj[x]'"""

    class_of_obj = typ(obj)

    # Om klassen för obj definierar __getitem__,
    # anropa class_of_obj.__getitem__(obj, x)
    if hasattr(class_of_obj, '__getitem__'):
        return class_of_obj.__getitem__(obj, x)

    # Annars, om obj är en klass och definierar __class_getitem__,
    # anropa obj.__class_getitem__(x)
    elif isclass(obj) and hasattr(obj, '__class_getitem__'):
        return obj.__class_getitem__(x)

    # Annars, skapa ett undantag
    else:
        raise TypeError(
            f"'{class_of_obj.__name__}' objektet är inte subskriberbart"
        )

I Python är alla klasser själva instanser av andra klasser. Klassen för en klass är känd som klassens metaklass, och de flesta klasser har klassen type som sin metaklass. type definierar inte __getitem__(), vilket innebär att uttryck som list[int], dict[str, float] och tuple[str, bytes] alla resulterar i att __class_getitem__() anropas:

>>> # list has class "type" as its metaclass, like most classes:
>>> type(list)
<class 'type'>
>>> type(dict) == type(list) == type(tuple) == type(str) == type(bytes)
True
>>> # "list[int]" calls "list.__class_getitem__(int)"
>>> list[int]
list[int]
>>> # list.__class_getitem__ returns a GenericAlias object:
>>> type(list[int])
<class 'types.GenericAlias'>

Men om en klass har en egen metaklass som definierar __getitem__(), kan en prenumeration av klassen resultera i ett annat beteende. Ett exempel på detta finns i modulen enum:

>>> from enum import Enum
>>> class Menu(Enum):
...     """A breakfast menu"""
...     SPAM = 'spam'
...     BACON = 'bacon'
...
>>> # Enum classes have a custom metaclass:
>>> type(Menu)
<class 'enum.EnumMeta'>
>>> # EnumMeta defines __getitem__,
>>> # so __class_getitem__ is not called,
>>> # and the result is not a GenericAlias object:
>>> Menu['SPAM']
<Menu.SPAM: 'spam'>
>>> type(Menu['SPAM'])
<enum 'Menu'>

Se även

PEP 560 - Kärnstöd för typning av moduler och generiska typer: Introducerar __class_getitem__(), och beskriver när en subscription resulterar i att __class_getitem__() anropas istället för __getitem__()

3.3.6. Emulering av anropsbara objekt¶

object.__call__(self[, args...])¶: Anropas när instansen ”anropas” som en funktion; om denna metod är definierad översätts x(arg1, arg2, ...) ungefär till type(x).__call__(x, arg1, ...). Klassen object tillhandahåller inte själv denna metod.

3.3.7. Emulering av containertyper¶

Följande metoder kan definieras för att implementera containerobjekt. Ingen av dem tillhandahålls av object-klassen själv. Containers är vanligtvis sequences (som lists eller tuples) eller mappings (som dictionaries), men kan även representera andra containers. Den första uppsättningen metoder används antingen för att emulera en sekvens eller för att emulera en mappning; skillnaden är att för en sekvens bör de tillåtna nycklarna vara heltalen k för vilka 0 <= k < N där N är sekvensens längd, eller slice-objekt, som definierar ett intervall av objekt. Det rekommenderas också att mappningar tillhandahåller metoderna keys(), values(), items(), get(), clear(), setdefault(), pop(), popitem(), copy() och update() som beter sig på liknande sätt som Pythons standardobjekt dictionary. Modulen collections.abc tillhandahåller en MutableMapping abstrakt basklass som hjälper till att skapa dessa metoder från en basuppsättning av __getitem__(), __setitem__(), __delitem__() och keys(). Mutabla sekvenser bör tillhandahålla metoderna append(), count(), index(), extend(), insert(), pop(), remove(), reverse() och sort(), precis som Pythons standardobjekt list. Slutligen bör sekvenstyper implementera addition (vilket betyder sammankoppling) och multiplikation (vilket betyder upprepning) genom att definiera metoderna __add__(), __radd__(), __iadd__(), __mul__(), __rmul__() och __imul__() som beskrivs nedan; de bör inte definiera andra numeriska operatorer. Det rekommenderas att både mappningar och sekvenser implementerar metoden __contains__() för att möjliggöra effektiv användning av operatorn in; för mappningar bör in söka igenom mappningens nycklar; för sekvenser bör den söka igenom värdena. Det rekommenderas vidare att både mappningar och sekvenser implementerar metoden __iter__() för att möjliggöra effektiv iteration genom containern; för mappningar bör __iter__() iterera genom objektets nycklar; för sekvenser bör den iterera genom värdena.

object.__len__(self)¶: Anropas för att implementera den inbyggda funktionen len(). Bör returnera objektets längd, ett heltal >= 0. Dessutom anses ett objekt som inte definierar en __bool__()-metod och vars __len__()-metod returnerar noll vara falskt i en boolesk kontext.

I CPython krävs det att längden är högst sys.maxsize. Om längden är större än sys.maxsize kan vissa funktioner (t.ex. len()) ge upphov till OverflowError. För att förhindra att OverflowError uppstår genom sanningsvärdestestning måste ett objekt definiera en __bool__()-metod.

object.__length_hint__(self)¶: Anropas för att implementera operator.length_hint(). Bör returnera en uppskattad längd för objektet (som kan vara större eller mindre än den faktiska längden). Längden måste vara ett heltal >= 0. Returvärdet kan också vara NotImplemented, vilket behandlas på samma sätt som om metoden __length_hint__ inte existerade alls. Denna metod är enbart en optimering och krävs aldrig för korrekthet.

Tillagd i version 3.4.

Anteckning

Slicing görs uteslutande med följande tre metoder. Ett anrop som

a[1:2] = b

är översatt till

a[slice(1, 2, None)] = b

och så vidare. Saknade slice-objekt fylls alltid i med None.

object.__getitem__(self, key)¶: Anropas för att implementera utvärdering av self[key]. För sequence-typer bör de accepterade nycklarna vara heltal. Eventuellt kan de även stödja slice-objekt. Stöd för negativa index är också valfritt. Om key är av en olämplig typ kan TypeError visas; om key är ett värde som ligger utanför uppsättningen index för sekvensen (efter eventuell speciell tolkning av negativa värden) bör IndexError visas. För mapping-typer, om key saknas (inte i behållaren), bör KeyError anges.

Anteckning

for loopar förväntar sig att ett IndexError kommer att uppstå för olagliga index för att möjliggöra korrekt upptäckt av slutet av sekvensen.

Anteckning

När subscripting en klass, kan den speciella klassmetoden __class_getitem__() anropas istället för __getitem__(). Se __class_getitem__ kontra __getitem__ för mer information.

object.__setitem__(self, key, value)¶: Anropas för att implementera tilldelning till self[key]. Samma anmärkning som för __getitem__(). Detta bör endast implementeras för mappningar om objekten stöder ändringar av värden för nycklar, eller om nya nycklar kan läggas till, eller för sekvenser om element kan ersättas. Samma undantag bör göras för felaktiga nyckel-värden som för metoden __getitem__().

object.__delitem__(self, key)¶: Anropas för att implementera borttagning av self[key]. Samma anmärkning som för __getitem__(). Detta bör endast implementeras för mappningar om objekten stöder borttagning av nycklar, eller för sekvenser om element kan tas bort från sekvensen. Samma undantag bör göras för felaktiga key-värden som för metoden __getitem__().

object.__missing__(self, key)¶: Anropas av dict .__getitem__() för att implementera self[key] för dict-subklasser när key inte finns i ordlistan.

object.__iter__(self)¶: Denna metod anropas när en iterator krävs för en container. Denna metod bör returnera ett nytt iteratorobjekt som kan iterera över alla objekt i containern. För mappningar bör den iterera över nycklarna i behållaren.

object.__reversed__(self)¶

Anropas (om det finns) av den inbyggda reversed() för att implementera omvänd iteration. Det bör returnera ett nytt iteratorobjekt som itererar över alla objekt i behållaren i omvänd ordning.

Om metoden __reversed__() inte tillhandahålls kommer den inbyggda reversed() att falla tillbaka till att använda sekvensprotokollet (__len__() och __getitem__()). Objekt som stöder sekvensprotokollet bör endast tillhandahålla __reversed__() om de kan tillhandahålla en implementering som är mer effektiv än den som tillhandahålls av reversed().

Operatorerna för medlemskapstest (in och not in) implementeras normalt som en iteration genom en behållare. Containerobjekt kan dock förse följande specialmetod med en mer effektiv implementering, som inte heller kräver att objektet är itererbart.

object.__contains__(self, item)¶

Anropas för att implementera operatorer för medlemskapstest. Bör returnera true om item finns i self, false annars. För mappningsobjekt bör detta beakta nycklarna i mappningen snarare än värdena eller paren nyckel-objekt.

För objekt som inte definierar __contains__() försöker medlemskapstestet först iteration via __iter__(), sedan det gamla sekvensiterationsprotokollet via __getitem__(), se det här avsnittet i språkreferensen.

3.3.8. Emulering av numeriska typer¶

Följande metoder kan definieras för att emulera numeriska objekt. Metoder som motsvarar operationer som inte stöds av den särskilda typ av tal som implementeras (t.ex. bitvisa operationer för icke-integrala tal) bör lämnas odefinierade.

object.__add__(self, other)¶

object.__sub__(self, other)¶

object.__mul__(self, other)¶

object.__matmul__(self, other)¶

object.__truediv__(self, other)¶

object.__floordiv__(self, other)¶

object.__mod__(self, other)¶

object.__divmod__(self, other)¶

object.__pow__(self, other[, modulo])¶

object.__lshift__(self, other)¶

object.__rshift__(self, other)¶

object.__and__(self, other)¶

object.__xor__(self, other)¶

object.__or__(self, other)¶

Dessa metoder anropas för att implementera binära aritmetiska operationer (+, -, *, @, /, //, %, divmod(), pow(), **, <<, >>, &, ^, |). För att t.ex. utvärdera uttrycket x + y, där x är en instans av en klass som har en __add__()-metod, anropas type(x).__add__(x, y). Metoden __divmod__() bör vara likvärdig med att använda __floordiv__() och __mod__(); den bör inte vara relaterad till __truediv__(). Observera att __pow__() bör definieras så att den accepterar ett valfritt tredje argument om treargumentversionen av den inbyggda funktionen pow() skall stödjas.

Om en av dessa metoder inte stöder operationen med de angivna argumenten, bör den returnera NotImplemented.

object.__radd__(self, other)¶

object.__rsub__(self, other)¶

object.__rmul__(self, other)¶

object.__rmatmul__(self, other)¶

object.__rtruediv__(self, other)¶

object.__rfloordiv__(self, other)¶

object.__rmod__(self, other)¶

object.__rdivmod__(self, other)¶

object.__rpow__(self, other[, modulo])¶

object.__rlshift__(self, other)¶

object.__rrshift__(self, other)¶

object.__rand__(self, other)¶

object.__rxor__(self, other)¶

object.__ror__(self, other)¶

Dessa metoder anropas för att implementera binära aritmetiska operationer (+, -, *, @, /, //, %, divmod(), pow(), **, <<, >>, &, ^, |) med reflekterade (swappade) operander. Dessa funktioner anropas endast om operanderna är av olika typer, om den vänstra operanden inte stöder motsvarande operation [3] eller om den högra operandens klass är härledd från den vänstra operandens klass. [4] Till exempel, för att utvärdera uttrycket x - y, där y är en instans av en klass som har en __rsub__() metod, anropas type(y).__rsub__(y, x) om type(x).__sub__(x, y) returnerar NotImplemented eller type(y) är en subklass av type(x). [5]

Observera att __rpow__() bör definieras så att den accepterar ett valfritt tredje argument om treargumentversionen av den inbyggda pow()-funktionen skall stödjas.

Ändrad i version 3.14: Tre-argument pow() försöker nu anropa __rpow__() om det behövs. Tidigare anropades det bara i två-argument pow() och den binära potensoperatorn.

Anteckning

Om den högra operandens typ är en subklass av den vänstra operandens typ och denna subklass tillhandahåller en annan implementering av den reflekterade metoden för operationen, kommer denna metod att anropas före den vänstra operandens icke-reflekterade metod. Detta beteende gör det möjligt för subklasser att åsidosätta sina förfäders operationer.

object.__iadd__(self, other)¶
object.__isub__(self, other)¶
object.__imul__(self, other)¶
object.__imatmul__(self, other)¶
object.__itruediv__(self, other)¶
object.__ifloordiv__(self, other)¶
object.__imod__(self, other)¶
object.__ipow__(self, other[, modulo])¶
object.__ilshift__(self, other)¶
object.__irshift__(self, other)¶
object.__iand__(self, other)¶
object.__ixor__(self, other)¶
object.__ior__(self, other)¶: Dessa metoder anropas för att implementera de utökade aritmetiska tilldelningarna (+=, -=, *=, @=, /=, //=, %=, **=, <<=, >>=, &=, ^=, |=). Dessa metoder bör försöka utföra operationen på plats (modifiera self) och returnera resultatet (som kan vara, men inte behöver vara, self). Om en specifik metod inte är definierad, eller om metoden returnerar NotImplemented, faller det utökade uppdraget tillbaka på de normala metoderna. Om till exempel x är en instans av en klass med en __iadd__-metod, är ``x += y`() ekvivalent med x = x.__iadd__(y) . Om __iadd__() inte finns, eller om x.__iadd__(y) returnerar NotImplemented, beaktas x.__add__(y) och y.__radd__(x), precis som vid utvärderingen av x + y. I vissa situationer kan augmented assignment resultera i oväntade fel (se Varför ger a_tuple[i] += [’item’] upphov till ett undantag när tillägget fungerar?), men detta beteende är i själva verket en del av datamodellen.

object.__neg__(self)¶
object.__pos__(self)¶
object.__abs__(self)¶
object.__invert__(self)¶: Anropas för att implementera de unära aritmetiska operationerna (-, +, abs() och ~).

object.__complex__(self)¶
object.__int__(self)¶
object.__float__(self)¶: Anropas för att implementera de inbyggda funktionerna complex(), int() och float(). Bör returnera ett värde av lämplig typ.

object.__index__(self)¶

Anropas för att implementera operator.index(), och när Python behöver konvertera det numeriska objektet till ett heltalsobjekt (t.ex. vid slicing, eller i de inbyggda funktionerna bin(), hex() och oct()). Närvaron av denna metod indikerar att det numeriska objektet är en heltalstyp. Måste returnera ett heltal.

Om __int__(), __float__() och __complex__() inte är definierade faller motsvarande inbyggda funktioner int(), float() och complex() tillbaka på __index__().

object.__round__(self[, ndigits])¶
object.__trunc__(self)¶
object.__floor__(self)¶
object.__ceil__(self)¶: Anropas för att implementera den inbyggda funktionen round() och math funktionerna trunc(), floor() och ceil(). Om inte ndigits skickas till __round__() bör alla dessa metoder returnera värdet av objektet trunkerat till en Integral (typiskt en int).

Ändrad i version 3.14: int() delegerar inte längre till metoden __trunc__().

3.3.9. Med uttalande från kontextansvariga¶

En context manager är ett objekt som definierar det körtidssammanhang som skall upprättas när en with-sats exekveras. Kontexthanteraren hanterar inträdet i och utträdet ur den önskade körtidskontexten för exekveringen av kodblocket. Kontexthanterare anropas normalt med hjälp av with-satsen (beskrivs i avsnitt with-satsen), men kan också användas genom att direkt anropa deras metoder.

Typiska användningsområden för kontexthanterare är att spara och återställa olika typer av globala tillstånd, låsa och låsa upp resurser, stänga öppnade filer etc.

För mer information om kontexthanterare, se Typer av kontexthanterare. Klassen object i sig tillhandahåller inte kontexthanteringsmetoderna.

object.__enter__(self)¶: Ange den runtime-kontext som är relaterad till detta objekt. Satsen with kommer att binda denna metods returvärde till det eller de mål som anges i satsens as-klausul, om det finns något.

object.__exit__(self, exc_type, exc_value, traceback)¶

Avslutar runtime-kontexten som är relaterad till detta objekt. Parametrarna beskriver det undantag som orsakade att kontexten avslutades. Om kontexten avslutades utan ett undantag, kommer alla tre argumenten att vara None.

Om ett undantag anges och metoden vill undertrycka undantaget (dvs. förhindra att det sprids), ska den returnera ett sant värde. Annars kommer undantaget att behandlas normalt när metoden avslutas.

Observera att __exit__() -metoder inte bör återskapa det överlämnade undantaget; detta är anroparens ansvar.

Se även

PEP 343 - Uttalandet ”med”: Specifikation, bakgrund och exempel för Pythons with-sats.

3.3.10. Anpassning av positionella argument vid matchning av klassmönster¶

När ett klassnamn används i ett mönster tillåts inte positionella argument i mönstret som standard, dvs. case MyClass(x, y) är typiskt ogiltigt utan särskilt stöd i MyClass. För att kunna använda den typen av mönster måste klassen definiera ett __match_args__-attribut.

object.__match_args__¶: Denna klassvariabel kan tilldelas en tupel av strängar. När den här klassen används i ett klassmönster med positionella argument konverteras varje positionellt argument till ett nyckelordsargument, med motsvarande värde i __match_args__* som nyckelord. Avsaknaden av detta attribut är likvärdigt med att sätta det till ().

Om till exempel MyClass.__match_args__ är ("left", "center", "right") betyder det att case MyClass(x, y) är likvärdigt med case MyClass(left=x, center=y). Observera att antalet argument i mönstret måste vara mindre än eller lika med antalet element i __match_args__; om det är större kommer försöket att matcha mönstret att ge upphov till ett TypeError.

Tillagd i version 3.10.

Se även

PEP 634 - Matchning av strukturella mönster: Specifikationen för Pythons match-sats.

3.3.11. Emulering av bufferttyper¶

buffer protocol ger Python-objekt ett sätt att exponera effektiv åtkomst till en minnesmatris på låg nivå. Detta protokoll implementeras av inbyggda typer som bytes och memoryview, och tredjepartsbibliotek kan definiera ytterligare bufferttyper.

Bufferttyper implementeras vanligtvis i C, men det är också möjligt att implementera protokollet i Python.

object.__buffer__(self, flags)¶: Anropas när en buffert begärs från self (t.ex. av memoryview-konstruktören). Argumentet flags är ett heltal som representerar den typ av buffert som begärs, vilket t.ex. påverkar om den returnerade bufferten är skrivskyddad eller skrivbar. inspect.BufferFlags ger ett bekvämt sätt att tolka flaggorna. Metoden måste returnera ett memoryview-objekt.

object.__release_buffer__(self, buffer)¶: Anropas när en buffert inte längre behövs. Argumentet buffer är ett objekt av memoryview som tidigare returnerats av __buffer__(). Metoden måste frigöra alla resurser som är associerade med bufferten. Denna metod bör returnera None. Buffertobjekt som inte behöver utföra någon rensning behöver inte implementera den här metoden.

Tillagd i version 3.12.

Se även

PEP 688 - Att göra buffertprotokollet tillgängligt i Python: Presenterar Python-metoderna __buffer__ och __release_buffer__.
samlingar.abc.buffert: ABC för bufferttyper.

3.3.12. Anteckningar¶

Funktioner, klasser och moduler kan innehålla annotations, som är ett sätt att associera information (vanligtvis type hints) med en symbol.

object.__annotations__¶: Detta attribut innehåller annoteringarna för ett objekt. Det utvärderas slentrianmässigt, så åtkomst till attributet kan exekvera godtycklig kod och ge upphov till undantag. Om utvärderingen lyckas sätts attributet till en dictionary-mappning från variabelnamn till annotationer.

Ändrad i version 3.14: Annotationer utvärderas nu på ett lättsamt sätt.

object.__annotate__(format)¶

En annotate function. Returnerar ett nytt ordboksobjekt som mappar attribut-/parameternamn till deras annoteringsvärden.

Tar emot en formatparameter som anger i vilket format värden för anteckningar ska anges. Den måste vara en medlem i enum annotationlib.Format, eller ett heltal med ett värde som motsvarar en medlem i enum.

Om en annoteringsfunktion inte stöder det begärda formatet måste den ge upphov till NotImplementedError. Annoteringsfunktioner måste alltid stödja formatet VALUE; de får inte ge upphov till NotImplementedError() när de anropas med detta format.

När en annotate-funktion anropas med VALUE-format kan den ge upphov till NameError; den får inte ge upphov till NameError när den anropas med något annat format.

Om ett objekt inte har några annoteringar bör __annotate__ helst sättas till None (det kan inte tas bort), snarare än att sättas till en funktion som returnerar en tom dict.

Tillagd i version 3.14.

Se även

PEP 649 — Uppskjuten utvärdering av annotering med hjälp av deskriptorer: Introducerar latent utvärdering av annoteringar och funktionen __annotate__.

3.3.13. Särskild metoduppslagning¶

För anpassade klasser garanteras implicita anrop av specialmetoder att fungera korrekt endast om de definieras på ett objekts typ, inte i objektets instansordbok. Detta beteende är anledningen till att följande kod ger upphov till ett undantag:

>>> class C:
...     pass
...
>>> c = C()
>>> c.__len__ = lambda: 5
>>> len(c)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: object of type 'C' has no len()

Anledningen till detta beteende är ett antal specialmetoder som __hash__() och __repr__() som implementeras av alla objekt, inklusive typobjekt. Om den implicita uppslagningen av dessa metoder använde den konventionella uppslagningsprocessen skulle de misslyckas när de anropas på typobjektet självt:

>>> 1 .__hash__() == hash(1)
True
>>> int.__hash__() == hash(int)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: descriptor '__hash__' of 'int' object needs an argument

Att felaktigt försöka anropa en obunden metod i en klass på detta sätt kallas ibland ”metaklassförvirring” och undviks genom att förbigå instansen när man söker efter speciella metoder:

>>> type(1).__hash__(1) == hash(1)
True
>>> type(int).__hash__(int) == hash(int)
True

Förutom att implicit specialmetoduppslagning förbigår alla instansattribut för korrekthetens skull, förbigår den i allmänhet också __getattribute__()-metoden, även för objektets metaklass:

>>> class Meta(type):
...     def __getattribute__(*args):
...         print("Metaclass getattribute invoked")
...         return type.__getattribute__(*args)
...
>>> class C(object, metaclass=Meta):
...     def __len__(self):
...         return 10
...     def __getattribute__(*args):
...         print("Class getattribute invoked")
...         return object.__getattribute__(*args)
...
>>> c = C()
>>> c.__len__()                 # Explicit lookup via instance
Class getattribute invoked
10
>>> type(c).__len__(c)          # Explicit lookup via type
Metaclass getattribute invoked
10
>>> len(c)                      # Implicit lookup
10

Att kringgå __getattribute__()-maskineriet på detta sätt ger betydande utrymme för hastighetsoptimeringar i tolken, på bekostnad av viss flexibilitet i hanteringen av specialmetoder (specialmetoden måste ställas in på själva klassobjektet för att konsekvent kunna anropas av tolken).

3.4. Coroutines¶

3.4.1. Väntande objekt¶

Ett awaitable-objekt implementerar i allmänhet en __await__()-metod. Coroutine objects som returneras från async def-funktioner är awaitable.

Anteckning

De generator iterator-objekt som returneras från generatorer dekorerade med types.coroutine() är också awaitable, men de implementerar inte __await__().

object.__await__(self)¶: Måste returnera en iterator. Bör användas för att implementera awaitable-objekt. Till exempel implementerar asyncio.Future den här metoden för att vara kompatibel med await-uttrycket. Klassen object i sig är inte awaitable och tillhandahåller inte denna metod.

Anteckning

Språket lägger inga restriktioner på typen eller värdet av de objekt som iteratorn som returneras av __await__ ger, eftersom detta är specifikt för implementeringen av ramverket för asynkron exekvering (t.ex. asyncio`) som kommer att hantera objektet awaitable.

Tillagd i version 3.5.

Se även

PEP 492 för ytterligare information om awaitable-objekt.

3.4.2. Coroutine-objekt¶

Coroutine-objekt är awaitable-objekt. En coroutines exekvering kan kontrolleras genom att anropa __await__() och iterera över resultatet. När coroutinen har exekverats färdigt och returnerar, ger iteratorn upphov till StopIteration, och undantagets attribut value innehåller returvärdet. Om coroutinen ger upphov till ett undantag sprids det vidare av iteratorn. Coroutines bör inte direkt ge upphov till ohanterade StopIteration-undantag.

Coroutines har också de metoder som anges nedan, vilka är analoga med dem för generatorer (se Generator-iterator-metoder). Till skillnad från generatorer har coroutines dock inte direkt stöd för iteration.

Ändrad i version 3.5.2: Det är ett RuntimeError att awaita på en coroutine mer än en gång.

coroutine.send(value)¶: Startar eller återupptar körningen av coroutinen. Om värde är None, motsvarar detta att flytta fram iteratorn som returneras av __await__(). Om value inte är None delegerar denna metod till metoden send() för den iterator som orsakade att coroutinen avbröts. Resultatet (returvärde, StopIteration eller annat undantag) är detsamma som när man itererar över returvärdet för __await__(), som beskrivs ovan.

coroutine.throw(value)¶
coroutine.throw(type[, value[, traceback]]): Utlöser det angivna undantaget i coroutinen. Denna metod delegerar till throw()-metoden för den iterator som orsakade att coroutinen avbröts, om den har en sådan metod. Annars tas undantaget upp vid avbrottspunkten. Resultatet (returvärde, StopIteration eller annat undantag) är detsamma som när man itererar över returvärdet för __await__(), som beskrivs ovan. Om undantaget inte fångas upp i coroutinen sprids det tillbaka till den som anropar.

Ändrad i version 3.12: Den andra signaturen (type[, value[, traceback]]) är föråldrad och kan tas bort i en framtida version av Python.

coroutine.close()¶

Gör att coroutinen rensar upp sig själv och avslutas. Om coroutinen är avbruten delegerar den här metoden först till close()-metoden för den iterator som fick coroutinen att avbrytas, om den har en sådan metod. Sedan utlöser den GeneratorExit vid avbrottspunkten, vilket gör att coroutinen omedelbart rensar upp sig själv. Slutligen markeras coroutinen som färdig exekverad, även om den aldrig startades.

Coroutine-objekt stängs automatiskt med hjälp av ovanstående process när de är på väg att förstöras.

3.4.3. Asynkrona Iteratorer¶

En asynkron iterator kan anropa asynkron kod i sin metod __anext__.

Asynkrona iteratorer kan användas i en async for-sats.

Klassen object i sig tillhandahåller inte dessa metoder.

object.__aiter__(self)¶: Måste returnera ett asynkront iterator-objekt.

object.__anext__(self)¶: Måste returnera en awaitable som resulterar i ett nästa värde för iteratorn. Bör ge upphov till ett StopAsyncIteration-fel när iterationen är över.

Ett exempel på ett asynkront iterabelt objekt:

klass Läsare:
    async def readline(self):
        ...

    def __aiter__(self):
        return self

    async def __anext__(self):
        val = await self.readline()
        om val == b'':
            höja StopAsyncIteration
        returnera val

Tillagd i version 3.5.

Ändrad i version 3.7: Före Python 3.7 kunde __aiter__() returnera en awaitable som skulle lösas till en asynkron iterator.

Från och med Python 3.7 måste __aiter__() returnera ett asynkront iteratorobjekt. Om något annat returneras kommer det att resultera i ett TypeError-fel.

3.4.4. Asynkrona kontexthanterare¶

En asynkron kontexthanterare är en kontexthanterare som kan avbryta exekveringen i sina metoder __aenter__ och __aexit__.

Asynkrona kontexthanterare kan användas i en async with-sats.

Klassen object i sig tillhandahåller inte dessa metoder.

object.__aenter__(self)¶: Semantiskt lik __enter__(), den enda skillnaden är att den måste returnera en awaitable.

object.__aexit__(self, exc_type, exc_value, traceback)¶: Semantiskt lik __exit__(), den enda skillnaden är att den måste returnera en awaitable.

Ett exempel på en asynkron kontexthanteringsklass:

klass AsyncContextManager:
    async def __aenter__(self):
        await log('går in i kontext')

    async def __aexit__(self, exc_type, exc, tb):
        await log('lämnar kontext')

Tillagd i version 3.5.

Fotnoter

3. Datamodell¶

3.1. Objekt, värden och typer¶

3.2. Standardtypens hierarki¶

3.2.1. None¶

3.2.2. NotImplemented¶

3.2.3. Ellipsis¶

3.2.4. numbers.Number¶

3.2.4.1. numbers.Integral¶

3.2.4.2. numbers.Real (float)¶

3.2.4.3. numbers.Complex (complex)¶

3.2.5. Sekvenser¶

3.2.5.1. Oföränderliga sekvenser¶

3.2.5.2. Mutabla sekvenser¶

3.2.6. Uppsättningstyper¶

3.2.7. Mappningar¶

3.2.7.1. Ordböcker¶

3.2.8. Kallbara typer¶

3.2.8.1. Användardefinierade funktioner¶

3.2.8.1.1. Särskilda skrivskyddade attribut¶

3.2.8.1.2. Särskilda skrivbara attribut¶

3.2.8.2. Instansmetoder¶

3.2.8.3. Generatorfunktioner¶

3.2.8.4. Coroutine-funktioner¶

3.2.8.5. Asynkrongeneratorfunktioner¶

3.2.8.6. Inbyggda funktioner¶

3.2.8.7. Inbyggda metoder¶

3.2.8.8. Klasser¶

3.2.8.9. Klassinstanser¶

3.2.9. Moduler¶

3.2.9.1. Importrelaterade attribut på modulobjekt¶

3.2.9.2. Andra skrivbara attribut på modulobjekt¶

3.2.9.3. Modul ordböcker¶

3.2.10. Anpassade klasser¶

3.2.10.1. Särskilda egenskaper¶

3.2.10.2. Särskilda metoder¶

3.2.11. Klassinstanser¶

3.2.11.1. Särskilda egenskaper¶

3.2.12. I/O-objekt (även kända som filobjekt)¶

3.2.13. Interna typer¶

3.2.13.1. Kodobjekt¶

3.2.13.1.1. Särskilda skrivskyddade attribut¶

3.2.13.1.2. Metoder på kodobjekt¶

3.2.13.2. Ramobjekt¶

3.2.13.2.1. Särskilda skrivskyddade attribut¶

3.2.13.2.2. Särskilda skrivbara attribut¶

3.2.13.2.3. Metoder för ramobjekt¶

3.2.13.3. Spårningsobjekt¶

3.2.13.4. Skiva objekt¶

3.2.13.5. Statiska metodobjekt¶

3.2.13.6. Klassmetodobjekt¶

3.3. Särskilda metodnamn¶

3.3.1. Grundläggande anpassning¶

3.3.2. Anpassning av attributåtkomst¶

3.3.2.1. Anpassa åtkomst till modulattribut¶

3.3.2.2. Implementering av deskriptorer¶

3.3.2.3. Anropa beskrivare¶

3.3.2.4. __slots__¶

3.3.3. Anpassa skapandet av klasser¶

3.3.3.1. Metaklasser¶

3.3.3.2. Lösning av MRO-poster¶

3.3.3.3. Fastställande av lämplig metaklass¶

3.3.3.4. Förbereda klassens namnrymd¶

3.3.3.5. Exekvering av klassens kropp¶

3.3.3.6. Skapa klassobjektet¶

3.3.3.7. Användningsområden för metaklasser¶

3.3.4. Anpassa kontroller av instanser och underklasser¶

3.3.5. Emulering av generiska typer¶

3.3.5.1. Syftet med __class_getitem__¶

3.3.5.2. __class_getitem__ kontra __getitem__¶

3.3.6. Emulering av anropsbara objekt¶

3.3.7. Emulering av containertyper¶

3.3.8. Emulering av numeriska typer¶

3.3.9. Med uttalande från kontextansvariga¶

3.3.10. Anpassning av positionella argument vid matchning av klassmönster¶

3.3.11. Emulering av bufferttyper¶

3.3.12. Anteckningar¶

3.3.13. Särskild metoduppslagning¶

3.4. Coroutines¶

3.4.1. Väntande objekt¶

3.4.2. Coroutine-objekt¶

3.2.4. `numbers.Number`¶

3.2.4.1. `numbers.Integral`¶

3.2.4.2. `numbers.Real` (`float`)¶

3.2.4.3. `numbers.Complex` (`complex`)¶

3.3.2.4. slots¶

3.3.5.2. __class_getitem kontra getitem__¶