6. Uttryck

I detta kapitel förklaras betydelsen av elementen i uttryck i Python.

Syntaxanteckningar: I detta och de följande kapitlen används utökad BNF-notation för att beskriva syntax, inte lexikal analys. När (ett alternativ till) en syntaxregel har formen

name: othername

och ingen semantik anges, är semantiken för denna form av name densamma som för othername.

6.1. Aritmetiska omvandlingar

När en beskrivning av en aritmetisk operator nedan använder frasen ”de numeriska argumenten konverteras till en gemensam reell typ”, betyder det att operatorns implementering för inbyggda typer fungerar på följande sätt:

  • Om båda argumenten är komplexa tal utförs ingen konvertering;

  • om något av argumenten är ett komplext tal eller ett flyttal, konverteras det andra till ett flyttal;

  • i annat fall måste båda vara heltal och ingen konvertering behövs.

Vissa ytterligare regler gäller för vissa operatorer (t.ex. en sträng som vänster argument till operatorn ’%’). Tillägg måste definiera sitt eget konverteringsbeteende.

6.2. Atomer

Atomer är de mest grundläggande elementen i uttryck. De enklaste atomerna är identifierare eller literaler. Former inom parenteser, hakparenteser eller parenteser kategoriseras också syntaktiskt som atomer. Syntaxen för atomer är:

atom:      identifier | literal | enclosure
enclosure: parenth_form | list_display | dict_display | set_display
           | generator_expression | yield_atom

6.2.1. Identifierare (namn)

En identifierare som förekommer som en atom är ett namn. Se avsnitt Namn (identifierare och nyckelord) för lexikal definition och avsnitt Namngivning och bindning för dokumentation av namngivning och bindning.

När namnet är bundet till ett objekt, ger utvärderingen av atomen det objektet. När ett namn inte är bundet, ger ett försök att utvärdera det upphov till ett NameError undantag.

6.2.1.1. Mangling av privata namn

När en identifierare som förekommer textuellt i en klassdefinition börjar med två eller flera understreck och inte slutar med två eller flera understreck, anses den vara ett privat namn för den klassen.

Se även

Den klassspecifikationer.

Närmare bestämt omvandlas privata namn till en längre form innan kod genereras för dem. Om det transformerade namnet är längre än 255 tecken kan en implementationsdefinierad trunkering ske.

Omvandlingen är oberoende av det syntaktiska sammanhang i vilket identifieraren används, men endast följande privata identifierare manglas:

  • Varje namn som används som namn på en variabel som tilldelas eller läses eller varje namn på ett attribut som nås.

    Attributet __name__ för nästlade funktioner, klasser och typaliaser manglas dock inte.

  • Namnet på importerade moduler, t.ex. __spam i import __spam. Om modulen är en del av ett paket (dvs. dess namn innehåller en punkt), manglas namnet inte, t.ex. manglas inte __foo i import __foo.bar.

  • Namnet på en importerad medlem, t.ex. __f i from spam import __f.

Transformationsregeln definieras enligt följande:

  • Klassnamnet, med inledande understrykningar borttagna och en enda inledande understrykning införd, infogas framför identifieraren, t.ex. identifieraren __spam som förekommer i en klass med namnet Foo, _Foo eller __Foo omvandlas till _Foo__spam.

  • Om klassnamnet endast består av understreck är transformationen identiteten, t.ex. identifieraren __spam som förekommer i en klass med namnet _ eller __ lämnas oförändrad.

6.2.2. Bokstäver

Python stöder sträng- och byteslitteraler samt olika numeriska litteraler:

literal: strings | NUMBER

Utvärdering av en literal ger ett objekt av den angivna typen (sträng, bytes, heltal, flyttal, komplext tal) med det angivna värdet. Värdet kan approximeras när det gäller flyttal och imaginära (komplexa) literaler. Se avsnitt Bokstäver för detaljer. Se avsnitt Sammankoppling av strängbokstäver för detaljer om strängar.

Alla literaler motsvarar oföränderliga datatyper, och därför är objektets identitet mindre viktig än dess värde. Flera utvärderingar av litteraler med samma värde (antingen samma förekomst i programtexten eller en annan förekomst) kan ge samma objekt eller ett annat objekt med samma värde.

6.2.2.1. Sammankoppling av strängbokstäver

Flera intilliggande sträng- eller byte-litteraler (avgränsade av blanksteg), eventuellt med olika citatkonventioner, är tillåtna och deras betydelse är densamma som deras sammankoppling:

>>> "hello" 'world'
"helloworld"

Formellt sett:

strings: ( STRING | fstring)+ | tstring+

Den här funktionen definieras på syntaktisk nivå, så den fungerar bara med bokstavstecken. För att konkatenera stränguttryck i körtid kan operatorn ’+’ användas:

>>> greeting = "Hello"
>>> space = " "
>>> name = "Blaise"
>>> print(greeting + space + name)   # not: print(greeting space name)
Hello Blaise

Litteral konkatenering kan fritt blanda råa strängar, strängar med trippelcitat och formaterade stränglitteraler. Till exempel:

>>> "Hello" r', ' f"{name}!"
"Hello, Blaise!"

Denna funktion kan användas för att minska antalet backslash som behövs, för att dela upp långa strängar på ett bekvämt sätt över långa rader eller till och med för att lägga till kommentarer till delar av strängar. Till exempel:

re.compile("[A-Za-z_]"       # bokstav eller understreck
           "[A-Za-z0-9_]*"   # bokstav, siffra eller understreck
          )

Byte-litteraler får dock endast kombineras med andra byte-litteraler, inte med sträng-litteraler av något slag. Dessutom får mallsträngsliteraler endast kombineras med andra mallsträngsliteraler:

>>> t"Hello" t"{name}!"
Template(strings=('Hello', '!'), interpolations=(...))

6.2.3. Formulär inom parentes

En parentesform är en lista med valfria uttryck inom parentes:

parenth_form: "(" [starred_expression] ")"

En uttrycksförteckning med parenteser ger det som uttrycksförteckningen ger: om förteckningen innehåller minst ett kommatecken ger den en tupel, annars ger den det enskilda uttryck som utgör uttrycksförteckningen.

Ett tomt par parenteser ger ett tomt tupelobjekt. Eftersom tuplar är oföränderliga gäller samma regler som för literals (dvs. två förekomster av den tomma tupeln kan ge eller inte ge samma objekt).

Observera att tupler inte bildas av parenteserna, utan snarare genom att använda kommatecken. Undantaget är den tomma tupeln, för vilken parenteser krävs — att tillåta ”ingenting” utan parenteser i uttryck skulle orsaka tvetydigheter och tillåta vanliga typfel att passera utan att upptäckas.

6.2.4. Displayer för listor, uppsättningar och ordböcker

För att konstruera en lista, en uppsättning eller en ordbok tillhandahåller Python en speciell syntax som kallas ”displays”, var och en av dem i två varianter:

  • antingen anges innehållet i behållaren uttryckligen, eller

  • de beräknas via en uppsättning loopnings- och filtreringsinstruktioner, kallad en comprehension.

Vanliga syntaxelement för förståelser är:

comprehension: assignment_expression comp_for
comp_for:      ["async"] "for" target_list "in" or_test [comp_iter]
comp_iter:     comp_for | comp_if
comp_if:       "if" or_test [comp_iter]

Förståelsen består av ett enda uttryck följt av minst en for-klausul och noll eller fler for- eller if-klausuler. I detta fall är elementen i den nya behållaren de som skulle produceras genom att betrakta var och en av for- eller if-klausulerna som ett block, nestning från vänster till höger och utvärdering av uttrycket för att producera ett element varje gång det innersta blocket nås.

Bortsett från det iterabla uttrycket i for-satsen längst till vänster utförs dock förståelsen i ett separat implicit nästlat scope. Detta säkerställer att namn som tilldelats i mållistan inte ”läcker” in i det omslutande scopet.

Det iterabla uttrycket i for-satsen längst till vänster utvärderas direkt i det inneslutande scopet och skickas sedan som ett argument till det implicit nästlade scopet. Efterföljande for-satser och eventuella filtervillkor i for-satsen längst till vänster kan inte utvärderas i det inneslutande scopet eftersom de kan vara beroende av de värden som erhålls från iterabeln längst till vänster. Till exempel: [x*y for x in range(10) for y in range(x, x+10)].

För att säkerställa att förståelsen alltid resulterar i en container av rätt typ, är uttrycken yield och yield from förbjudna i det implicit nästlade omfånget.

Sedan Python 3.6, i en async def-funktion, kan en async for-sats användas för att iterera över en asynkron iterator. En förståelse i en async def-funktion kan bestå av antingen en for- eller async for-klausul efter det ledande uttrycket, kan innehålla ytterligare for- eller async for-klausuler och kan även använda await-uttryck.

Om en comprehension innehåller async for-klausuler, eller om den innehåller await-uttryck eller andra asynkrona comprehensions överallt utom det iterabla uttrycket i for-klausulen längst till vänster, kallas den en asynchronous comprehension. En asynkron förståelse kan avbryta exekveringen av den coroutine-funktion där den förekommer. Se även PEP 530.

Tillagd i version 3.6: Asynkrona förståelser introducerades.

Ändrad i version 3.8: yield och yield from förbjudna i det implicit nästlade omfånget.

Ändrad i version 3.11: Asynkrona förståelser är nu tillåtna inuti förståelser i asynkrona funktioner. Yttre förståelser blir implicit asynkrona.

6.2.5. Lista visar

En listdisplay är en eventuellt tom serie av uttryck inom hakparenteser:

list_display: "[" [flexible_expression_list | comprehension] "]"

En listvisning resulterar i ett nytt listobjekt, vars innehåll specificeras av antingen en lista med uttryck eller en förståelse. När en kommaseparerad lista med uttryck anges, utvärderas dess element från vänster till höger och placeras i listobjektet i den ordningen. När en förståelse anges konstrueras listan av de element som blir resultatet av förståelsen.

6.2.6. Ställ in skärmar

En set-display betecknas med hakparenteser och skiljer sig från en dictionary-display genom att det inte finns några kolon som separerar nycklar och värden:

set_display: "{" (flexible_expression_list | comprehension) "}"

En set-visning ger ett nytt muterbart set-objekt, vars innehåll specificeras av antingen en sekvens av uttryck eller en förståelse. När en kommaseparerad lista med uttryck anges, utvärderas dess element från vänster till höger och läggs till i set-objektet. När en förståelse anges konstrueras setet av de element som blir resultatet av förståelsen.

En tom uppsättning kan inte konstrueras med {}; denna bokstav konstruerar en tom ordbok.

6.2.7. Ordbok visar

En dictionary-display är en eventuellt tom serie av dict-objekt (nyckel/värde-par) inneslutna inom hakparenteser:

dict_display:       "{" [dict_item_list | dict_comprehension] "}"
dict_item_list:     dict_item ("," dict_item)* [","]
dict_item:          expression ":" expression | "**" or_expr
dict_comprehension: expression ":" expression comp_for

En ordboksvisning resulterar i ett nytt ordboksobjekt.

Om en kommaseparerad sekvens av dict-objekt anges utvärderas de från vänster till höger för att definiera posterna i ordlistan: varje nyckelobjekt används som en nyckel i ordlistan för att lagra motsvarande värde. Det innebär att du kan ange samma nyckel flera gånger i listan med dict-objekt, och det slutliga värdet i ordboken för den nyckeln kommer att vara det senast angivna.

En dubbel asterisk ** betecknar dictionary unpacking. Dess operand måste vara en mapping. Varje mappningsobjekt läggs till i den nya ordboken. Senare värden ersätter värden som redan ställts in av tidigare dict-objekt och tidigare uppackningar av ordböcker.

Tillagd i version 3.5: Unpacking into dictionary displays, ursprungligen föreslagen av PEP 448.

En dict-förståelse, till skillnad från list- och set-förståelser, behöver två uttryck åtskilda med ett kolon följt av de vanliga ”for”- och ”if”-klausulerna. När förståelsen körs infogas de resulterande nyckel- och värdeelementen i den nya ordlistan i den ordning de producerades.

Restriktioner för typerna av nyckelvärden anges tidigare i avsnitt Standardtypens hierarki. (Sammanfattningsvis bör nyckeltypen vara hashable, vilket utesluter alla föränderliga objekt) Kollisioner mellan duplicerade nycklar upptäcks inte; det sista värdet (textuellt längst till höger i displayen) som lagras för ett visst nyckelvärde har företräde.

Ändrad i version 3.8: Före Python 3.8 var utvärderingsordningen för nyckel och värde inte väldefinierad i dict-comprehensions. I CPython utvärderades värdet före nyckeln. Från och med 3.8 utvärderas nyckeln före värdet, enligt förslaget i PEP 572.

6.2.8. Generatoruttryck

Ett generatoruttryck är en kompakt generatornotation inom parentes:

generator_expression: "(" expression comp_for ")"

Ett generatoruttryck ger upphov till ett nytt generatorobjekt. Syntaxen är densamma som för förståelser, förutom att det omges av parenteser istället för parenteser eller hakparenteser.

Variabler som används i generatoruttrycket utvärderas latent när metoden __next__() anropas för generatorobjektet (på samma sätt som för normala generatorer). Det iterabla uttrycket i for-satsen längst till vänster utvärderas dock omedelbart och iterator skapas omedelbart för den iterabla, så att ett fel som uppstår när iteratorn skapas kommer att avges vid den punkt där generatoruttrycket definieras, snarare än vid den punkt där det första värdet hämtas. Efterföljande for-satser och eventuella filtervillkor i for-satsen längst till vänster kan inte utvärderas i det omslutande området eftersom de kan vara beroende av de värden som erhålls från iteratorn längst till vänster. Till exempel: (x*y for x in range(10) for y in range(x, x+10)).

Parentesen kan utelämnas vid anrop med endast ett argument. Se avsnitt Calls för detaljer.

För att inte störa den förväntade funktionen hos själva generatoruttrycket är uttrycken yield och yield from förbjudna i den implicit definierade generatorn.

Om ett generatoruttryck innehåller antingen async for-klausuler eller await-uttryck kallas det ett asynkront generatoruttryck. Ett asynkront generatoruttryck returnerar ett nytt asynkront generatorobjekt, som är en asynkron iterator (se Asynkrona Iteratorer).

Tillagd i version 3.6: Asynkrona generatoruttryck infördes.

Ändrad i version 3.7: Före Python 3.7 kunde asynkrona generatoruttryck endast förekomma i async def coroutines. Från och med 3.7 kan alla funktioner använda asynkrona generatoruttryck.

Ändrad i version 3.8: yield och yield from förbjudna i det implicit nästlade omfånget.

6.2.9. Avkastningsuttryck

yield_atom:       "(" yield_expression ")"
yield_from:       "yield" "from" expression
yield_expression: "yield" yield_list | yield_from

Yield-uttrycket används när man definierar en generator-funktion eller en asynkron generator-funktion och kan därför bara användas i en funktionsdefinition. Om du använder ett yield-uttryck i en funktions kropp blir funktionen en generatorfunktion och om du använder det i en async def-funktions kropp blir coroutine-funktionen en asynkron generatorfunktion. Till exempel:

def gen():  # definierar en generatorfunktion
    avkastning 123

async def agen(): # definierar en asynkron generatorfunktion
    yield 123

På grund av sina bieffekter på det innehållande omfånget är yield-uttryck inte tillåtna som en del av de implicit definierade omfång som används för att implementera förståelser och generatoruttryck.

Ändrad i version 3.8: Yield-uttryck som är förbjudna i de implicit nästlade scopes som används för att implementera förståelser och generatoruttryck.

Generatorfunktioner beskrivs nedan, medan asynkrona generatorfunktioner beskrivs separat i avsnittet Asynkrongeneratorfunktioner.

När en generatorfunktion anropas returnerar den en iterator, en så kallad generator. Denna generator styr sedan exekveringen av generatorfunktionen. Exekveringen startar när någon av generatorns metoder anropas. Vid den tidpunkten fortsätter exekveringen till det första yield-uttrycket, där den avbryts igen och returnerar värdet av yield_list till generatorns anropare, eller None om yield_list utelämnas. Med suspenderad menar vi att allt lokalt tillstånd behålls, inklusive de aktuella bindningarna av lokala variabler, instruktionspekaren, den interna utvärderingsstacken och tillståndet för eventuell undantagshantering. När exekveringen återupptas genom att anropa en av generatorns metoder kan funktionen fortsätta precis som om yield-uttrycket bara var ett annat externt anrop. Värdet på yield-uttrycket efter återupptagandet beror på vilken metod som återupptog exekveringen. Om __next__() används (typiskt via antingen ett for eller next() inbyggd) så är resultatet None. Annars, om send() används, blir resultatet det värde som skickas in till den metoden.

Allt detta gör generatorfunktioner ganska lika coroutines; de ger flera gånger, de har mer än en ingångspunkt och deras exekvering kan avbrytas. Den enda skillnaden är att en generatorfunktion inte kan styra var exekveringen ska fortsätta efter att den har gett upp; kontrollen överförs alltid till generatorns anropare.

Yield-uttryck är tillåtna var som helst i en try-konstruktion. Om generatorn inte återupptas innan den är avslutad (genom att referensantalet blir noll eller genom att den samlas in), kommer generator-iteratorns close()-metod att anropas, vilket gör att alla väntande finally-klausuler kan utföras.

När yield from <expr> används måste det medföljande uttrycket vara en iterabel. De värden som produceras genom att iterera denna iterabel skickas direkt till den som anropar den aktuella generatorns metoder. Alla värden som skickas in med send() och alla undantag som skickas in med throw() skickas till den underliggande iteratorn om den har lämpliga metoder. Om så inte är fallet kommer send() att ge upphov till AttributeError eller TypeError, medan throw() bara kommer att ge upphov till det undantag som skickats in omedelbart.

När den underliggande iteratorn är klar blir attributet value i den upphöjda StopIteration-instansen värdet på yield-uttrycket. Det kan antingen sättas explicit när StopIteration väcks, eller automatiskt när subiteratorn är en generator (genom att returnera ett värde från subgeneratorn).

Ändrad i version 3.3: Lagt till yield from <expr> för att delegera kontrollflödet till en subiterator.

Parenteserna kan utelämnas när yield-uttrycket är det enda uttrycket på höger sida av en assignment-sats.

Se även

PEP 255 - Enkla generatorer

Förslaget att lägga till generatorer och yield-satsen i Python.

PEP 342 - Coroutines via förbättrade generatorer

Förslaget att förbättra API:et och syntaxen för generatorer, så att de kan användas som enkla coroutines.

PEP 380 - Syntax för att delegera till en undergenerator

Förslaget att införa syntaxen yield_from, vilket gör det enkelt att delegera till undergenererare.

PEP 525 - Asynkrona generatorer

Förslaget som utökade PEP 492 genom att lägga till generatormöjligheter till coroutine-funktioner.

6.2.9.1. Generator-iterator-metoder

I detta underavsnitt beskrivs metoderna för en generatoriterator. De kan användas för att styra utförandet av en generatorfunktion.

Observera att anrop av någon av generatormetoderna nedan när generatorn redan körs ger upphov till ett ValueError-undantag.

generator.__next__()

Startar exekveringen av en generatorfunktion eller återupptar den vid det senast exekverade yield-uttrycket. När en generatorfunktion återupptas med en __next__()-metod utvärderas det aktuella yield-uttrycket alltid till None. Exekveringen fortsätter sedan till nästa yield-uttryck, där generatorn avbryts igen och värdet i yield_list returneras till __next__():s anropare. Om generatorn avslutas utan att ge något annat värde, uppstår ett StopIteration-undantag.

Denna metod anropas normalt implicit, t.ex. av en for-loop, eller av den inbyggda next()-funktionen.

generator.send(value)

Återupptar exekveringen och ”skickar” ett värde till generatorfunktionen. Argumentet value blir resultatet av det aktuella yield-uttrycket. Metoden send() returnerar nästa värde som generatorn ger, eller ger upphov till StopIteration om generatorn avslutas utan att ge något annat värde. När send() anropas för att starta generatorn måste den anropas med None som argument, eftersom det inte finns något yield-uttryck som kan ta emot värdet.

generator.throw(value)
generator.throw(type[, value[, traceback]])

Utlöser ett undantag vid den punkt där generatorn pausades och returnerar nästa värde som generatorns funktion ger. Om generatorn avslutas utan att ge något annat värde, utlöses ett StopIteration-undantag. Om generatorfunktionen inte fångar upp det överlämnade undantaget, eller om ett annat undantag uppstår, sprids undantaget till den som anropar.

I normal användning anropas detta med en enda undantagsinstans på liknande sätt som nyckelordet raise används.

För bakåtkompatibilitet stöds dock den andra signaturen, enligt en konvention från äldre versioner av Python. Argumentet type ska vara en undantagsklass och value ska vara en undantagsinstans. Om value inte anges anropas konstruktören type för att hämta en instans. Om traceback anges, sätts det på undantaget, annars kan alla befintliga __traceback__-attribut som lagras i value rensas.

Ä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.

generator.close()

Utlöser ett GeneratorExit-undantag vid den punkt där generatorfunktionen pausades (motsvarar anropet throw(GeneratorExit)). Undantaget utlöses av det yield-uttryck där generatorn pausades. Om generatorfunktionen fångar upp undantaget och returnerar ett värde, returneras detta värde från close(). Om generatorfunktionen redan är stängd, eller ger upphov till GeneratorExit (genom att inte fånga upp undantaget), returnerar close() None. Om generatorn ger ett värde, uppstår ett RuntimeError. Om generatorn ger upphov till något annat undantag sprids det till den som anropar. Om generatorn redan har avslutats på grund av ett undantag eller en normal avslutning, returnerar close() None och har ingen annan effekt.

Ändrad i version 3.13: Om en generator returnerar ett värde när den stängs, returneras värdet av close().

6.2.9.2. Exempel

Här följer ett enkelt exempel som visar hur generatorer och generatorfunktioner fungerar:

>>> def echo(value=None):
...     print("Execution starts when 'next()' is called for the first time.")
...     try:
...         while True:
...             try:
...                 value = (yield value)
...             except Exception as e:
...                 value = e
...     finally:
...         print("Don't forget to clean up when 'close()' is called.")
...
>>> generator = echo(1)
>>> print(next(generator))
Execution starts when 'next()' is called for the first time.
1
>>> print(next(generator))
None
>>> print(generator.send(2))
2
>>> generator.throw(TypeError, "spam")
TypeError('spam',)
>>> generator.close()
Don't forget to clean up when 'close()' is called.

För exempel på användning av yield from, se PEP 380: Syntax för delegering till en undergenerator i ”What’s New in Python”

6.2.9.3. Asynkrongeneratorfunktioner

Närvaron av ett yield-uttryck i en funktion eller metod som definieras med async def definierar funktionen ytterligare som en asynkron generator-funktion.

När en asynkron generatorfunktion anropas returnerar den en asynkron iterator, ett så kallat asynkront generatorobjekt. Det objektet styr sedan exekveringen av generatorfunktionen. Ett asynkront generatorobjekt används vanligtvis i en async for-sats i en coroutine-funktion på samma sätt som ett generatorobjekt skulle användas i en for-sats.

Anrop av en av den asynkrona generatorns metoder returnerar ett awaitable-objekt, och exekveringen startar när detta objekt är väntat på. Vid den tidpunkten fortsätter exekveringen till det första yield-uttrycket, där den avbryts igen och returnerar värdet av yield_list till den väntande coroutinen. Precis som med en generator innebär avbrytandet att allt lokalt tillstånd bibehålls, inklusive de lokala variablernas aktuella bindningar, instruktionspekaren, den interna utvärderingsstapeln och tillståndet för eventuell undantagshantering. När exekveringen återupptas genom att vänta på nästa objekt som returneras av den asynkrona generatorns metoder, kan funktionen fortsätta precis som om yield-uttrycket bara var ett annat externt anrop. Värdet på yield-uttrycket efter återupptagandet beror på vilken metod som återupptog exekveringen. Om __anext__() används så är resultatet None. I annat fall, om asend() används, blir resultatet det värde som skickades in till den metoden.

Om en asynkron generator avslutas tidigt genom break, att den anropande uppgiften avbryts eller andra undantag, kommer generatorns asynkrona uppstädningskod att köras och eventuellt ge upphov till undantag eller åtkomst till kontextvariabler i ett oväntat sammanhang - kanske efter livstiden för de uppgifter den är beroende av, eller under nedstängningen av händelseslingan när async-generatorens garbage collection hook anropas. För att förhindra detta måste anroparen uttryckligen stänga async-generatorn genom att anropa aclose()-metoden för att slutföra generatorn och slutligen koppla bort den från händelseslingan.

I en asynkron generatorfunktion är yield-uttryck tillåtna var som helst i en try-konstruktion. Men om en asynkron generator inte återupptas innan den avslutas (genom att referensantalet blir noll eller genom att den samlas in i en s.k. garbage collection), kan ett yield-uttryck i en try-konstruktion leda till att väntande finally-klausuler inte kan exekveras. I detta fall är det ansvaret för den händelseslinga eller schemaläggare som kör den asynkrona generatorn att anropa den asynkrona generator-iteratorns aclose()-metod och köra det resulterande coroutine-objektet, så att eventuella väntande finally-klausuler kan exekveras.

För att ta hand om avslutning vid avslutning av en händelseslinga bör en händelseslinga definiera en finalizer-funktion som tar en asynkron generator-iterator och förmodligen anropar aclose() och kör coroutinen. Denna finalizer kan registreras genom att anropa sys.set_asyncgen_hooks(). Vid första iterationen över en asynkron generator-iterator lagras den registrerade finalizer som anropas vid slutförande. För ett referensexempel på en finalizer-metod se implementeringen av asyncio.Loop.shutdown_asyncgens i Lib/asyncio/base_events.py.

Uttrycket yield from <expr> är ett syntaxfel när det används i en asynkron generatorfunktion.

6.2.9.4. Asynkrona generator-iterator-metoder

I detta underavsnitt beskrivs metoderna för en asynkron generatoriterator, som används för att styra exekveringen av en generatorfunktion.

async agen.__anext__()

Returnerar en awaitable som när den körs börjar exekvera den asynkrona generatorn eller återupptar den vid det senast exekverade yield-uttrycket. När en asynkron generatorfunktion återupptas med en __anext__()-metod utvärderas det aktuella yield-uttrycket alltid till None i den returnerade awaitable, som när den körs fortsätter till nästa yield-uttryck. Värdet på yield_list i yield-uttrycket är värdet på StopIteration-undantaget som den avslutande coroutinen ger upphov till. Om den asynkrona generatorn avslutas utan att ge ett annat värde, ger awaitable istället upphov till ett StopAsyncIteration-undantag, vilket signalerar att den asynkrona iterationen har slutförts.

Denna metod anropas normalt implicit av en async for-slinga.

async agen.asend(value)

Returnerar en awaitable som när den körs återupptar exekveringen av den asynkrona generatorn. Precis som med metoden send() för en generator, ”skickar” denna ett värde till den asynkrona generatorfunktionen, och argumentet value blir resultatet av det aktuella yield-uttrycket. Den awaitable som returneras av metoden asend() kommer att returnera nästa värde som generatorn ger som värdet av den upphöjda StopIteration, eller upphöjer StopAsyncIteration om den asynkrona generatorn avslutas utan att ge ett annat värde. När asend() anropas för att starta den asynkrona generatorn måste den anropas med None som argument, eftersom det inte finns något yield-uttryck som kan ta emot värdet.

async agen.athrow(value)
async agen.athrow(type[, value[, traceback]])

Returnerar en awaitable som utlöser ett undantag av typen type vid den punkt där den asynkrona generatorn pausades, och returnerar nästa värde som genereras av generatorfunktionen som värdet på det utlösta StopIteration-undantaget. Om den asynkrona generatorn avslutas utan att ge något annat värde, väcks ett StopAsyncIteration-undantag av awaitable. Om generatorfunktionen inte fångar upp det överlämnade undantaget, eller väcker ett annat undantag, när awaitable körs, sprids undantaget till den som anropar awaitable.

Ä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.

async agen.aclose()

Returnerar en awaitable som när den körs kommer att kasta en GeneratorExit till den asynkrona generatorfunktionen vid den punkt där den pausades. Om den asynkrona generatorfunktionen sedan avslutas på ett elegant sätt, redan är stängd, eller ger upphov till GeneratorExit (genom att inte fånga upp undantaget), så kommer den returnerade awaitable att ge upphov till ett StopIteration undantag. Alla ytterligare awaitables som returneras av efterföljande anrop till den asynkrona generatorn kommer att ge upphov till ett StopAsyncIteration-undantag. Om den asynkrona generatorn ger ett värde, kommer ett RuntimeError att uppstå i awaitable. Om den asynkrona generatorn ger upphov till något annat undantag, sprids det till den som anropar awaitable. Om den asynkrona generatorn redan har avslutats på grund av ett undantag eller en normal avslutning, kommer ytterligare anrop till aclose() att returnera en awaitable som inte gör någonting.

6.3. Primärval

Primaries representerar de mest bundna operationerna i språket. Deras syntax är:

primary: atom | attributeref | subscription | slicing | call

6.3.1. Attributreferenser

En attributreferens är en primär följt av en punkt och ett namn:

attributeref: primary "." identifier

Primären måste utvärderas till ett objekt av en typ som stöder attributreferenser, vilket de flesta objekt gör. Detta objekt ombeds sedan att producera det attribut vars namn är identifieraren. Den typ och det värde som produceras bestäms av objektet. Flera utvärderingar av samma attributreferens kan ge olika objekt.

Denna produktion kan anpassas genom att åsidosätta metoden __getattribute__() eller metoden __getattr__(). Metoden __getattribute__() anropas först och returnerar antingen ett värde eller ger upphov till AttributeError om attributet inte är tillgängligt.

Om ett AttributeError uppstår och objektet har en __getattr__()-metod, anropas den metoden som en fallback.

6.3.2. Prenumerationer

Prenumerationen av en instans av en container class kommer i allmänhet att välja ett element från containern. Prenumerationen av en generic class kommer i allmänhet att returnera ett GenericAlias objekt.

subscription: primary "[" flexible_expression_list "]"

När ett objekt prenumereras kommer tolken att utvärdera primären och uttrycksförteckningen.

Primären måste utvärderas till ett objekt som stöder prenumeration. Ett objekt kan stödja prenumeration genom att definiera en eller båda av __getitem__() och __class_getitem__(). När primären är abonnerad kommer det utvärderade resultatet av uttryckslistan att skickas till en av dessa metoder. För mer information om när __class_getitem__ anropas i stället för __getitem__, se __class_getitem__ kontra __getitem__.

Om uttrycksförteckningen innehåller minst ett kommatecken eller om något av uttrycken är stjärnmärkt, utvärderas uttrycksförteckningen till en tuple som innehåller posterna i uttrycksförteckningen. I annat fall utvärderas uttrycksförteckningen till värdet av förteckningens enda medlem.

Ändrad i version 3.11: Uttryck i en uttrycksförteckning kan vara stjärnmärkta. Se PEP 646.

För inbyggda objekt finns det två typer av objekt som stöder prenumeration via __getitem__():

  1. Mappningar. Om primären är en mapping måste uttryckslistan utvärderas till ett objekt vars värde är en av nycklarna i mappningen, och prenumerationen väljer det värde i mappningen som motsvarar den nyckeln. Ett exempel på en inbyggd mappningsklass är klassen dict.

  2. Sekvenser. Om primären är en sequence måste uttryckslistan utvärderas till en int eller en slice (som beskrivs i följande avsnitt). Exempel på inbyggda sekvensklasser är klasserna str, list och tuple.

Den formella syntaxen innehåller inga särskilda bestämmelser för negativa index i sekvenser. Alla inbyggda sekvenser har dock en __getitem__()-metod som tolkar negativa index genom att lägga till sekvensens längd till indexet så att till exempel x[-1] väljer det sista objektet i x. Det resulterande värdet måste vara ett icke-negativt heltal som är mindre än antalet objekt i sekvensen, och prenumerationen väljer det objekt vars index är det värdet (räknat från noll). Eftersom stödet för negativa index och slicing finns i objektets __getitem__()-metod, måste subklasser som åsidosätter denna metod uttryckligen lägga till detta stöd.

En sträng är en speciell typ av sekvens vars element är tecken. Ett tecken är inte en separat datatyp utan en sträng med exakt ett tecken.

6.3.3. Skivor

En slicing väljer ut ett intervall av objekt i ett sekvensobjekt (t.ex. en sträng, tupel eller lista). Slicings kan användas som uttryck eller som mål i assignment- eller del-satser. Syntaxen för en slicing:

slicing:      primary "[" slice_list "]"
slice_list:   slice_item ("," slice_item)* [","]
slice_item:   expression | proper_slice
proper_slice: [lower_bound] ":" [upper_bound] [ ":" [stride] ]
lower_bound:  expression
upper_bound:  expression
stride:       expression

Det finns en tvetydighet i den formella syntaxen här: allt som ser ut som en uttryckslista ser också ut som en skivlista, så alla prenumerationer kan tolkas som en skivning. I stället för att ytterligare komplicera syntaxen, kan detta klargöras genom att definiera att i detta fall har tolkningen som en prenumeration prioritet över tolkningen som en skivning (detta är fallet om skivlistan inte innehåller någon riktig skiva).

Semantiken för en slicing är som följer. Primären indexeras (med samma __getitem__()-metod som vid normal prenumeration) med en nyckel som konstrueras från slice-listan, enligt följande. Om slice-listan innehåller minst ett kommatecken är nyckeln en tupel som innehåller konverteringen av slice-objekten; i annat fall är konverteringen av det enda slice-objektet nyckeln. Konverteringen av ett slice-objekt som är ett uttryck är detta uttryck. Konverteringen av en riktig slice är ett slice-objekt (se avsnitt Standardtypens hierarki) vars attribut start, stop och step är värdena för de uttryck som anges som lower bound, upper bound respektive stride, med None som ersättning för uttryck som saknas.

6.3.4. Calls

Ett anrop anropar ett anropbart objekt (t.ex. en funktion) med en eventuellt tom serie av argument:

call:                 primary "(" [argument_list [","] | comprehension] ")"
argument_list:        positional_arguments ["," starred_and_keywords]
                        ["," keywords_arguments]
                      | starred_and_keywords ["," keywords_arguments]
                      | keywords_arguments
positional_arguments: positional_item ("," positional_item)*
positional_item:      assignment_expression | "*" expression
starred_and_keywords: ("*" expression | keyword_item)
                      ("," "*" expression | "," keyword_item)*
keywords_arguments:   (keyword_item | "**" expression)
                      ("," keyword_item | "," "**" expression)*
keyword_item:         identifier "=" expression

Ett valfritt efterföljande kommatecken kan finnas efter positions- och nyckelordsargumenten, men påverkar inte semantiken.

Det primära måste utvärderas till ett anropbart objekt (användardefinierade funktioner, inbyggda funktioner, metoder för inbyggda objekt, klassobjekt, metoder för klassinstanser och alla objekt som har en __call__()-metod är anropbara). Alla argumentuttryck utvärderas innan anropet görs. Se avsnitt Definitioner av funktioner för syntaxen för formella parameter-listor.

Om nyckelordsargument förekommer konverteras de först till positionsargument på följande sätt. Först skapas en lista med ofyllda slots för de formella parametrarna. Om det finns N positionella argument placeras de i de första N platserna. Därefter används identifieraren för varje nyckelordsargument för att bestämma motsvarande plats (om identifieraren är densamma som det första formella parameternamnet används den första platsen, och så vidare). Om platsen redan är fylld utlöses ett TypeError-undantag. I annat fall placeras argumentet i slotten och fyller den (även om uttrycket är None fyller det slotten). När alla argument har behandlats fylls de platser som fortfarande är ofyllda med motsvarande standardvärde från funktionsdefinitionen. (Standardvärden beräknas en gång när funktionen definieras; ett föränderligt objekt som en lista eller en ordbok som används som standardvärde kommer därför att delas av alla anrop som inte anger ett argumentvärde för motsvarande slot; detta bör vanligtvis undvikas) Om det finns några ofyllda slots för vilka inget standardvärde har angetts, uppstår ett TypeError undantag. I annat fall används listan med fyllda slots som argumentlista för anropet.

En implementation kan tillhandahålla inbyggda funktioner vars positionella parametrar inte har namn, även om de ”namnges” i dokumentationssyfte, och som därför inte kan anges med nyckelord. I CPython är detta fallet för funktioner som implementerats i C och som använder PyArg_ParseTuple() för att analysera sina argument.

Om det finns fler positionella argument än det finns formella parameterplatser, uppstår ett TypeError-undantag, såvida inte en formell parameter med syntaxen *identifier finns; i så fall får den formella parametern en tupel som innehåller de överflödiga positionella argumenten (eller en tom tupel om det inte fanns några överflödiga positionella argument).

Om något nyckelordsargument inte motsvarar ett formellt parameternamn, uppstår ett TypeError-undantag, såvida inte en formell parameter med syntaxen **identifier finns; i så fall får den formella parametern en ordbok som innehåller de överflödiga nyckelordsargumenten (med nyckelorden som nycklar och argumentvärdena som motsvarande värden), eller en (ny) tom ordbok om det inte fanns några överflödiga nyckelordsargument.

Om syntaxen *expression förekommer i funktionsanropet måste expression utvärderas till en iterable. Element från dessa iterabler behandlas som om de vore ytterligare positionella argument. För anropet f(x1, x2, *y, x3, x4), om y utvärderas till en sekvens y1, …, yM, är detta likvärdigt med ett anrop med M+4 positionella argument x1, x2, y1, …, yM, x3, x4.

En konsekvens av detta är att även om syntaxen *expression kan visas efter explicita nyckelordsargument, bearbetas den före nyckelordsargumenten (och eventuella **expression -argument - se nedan). Så:

>>> def f(a, b):
...     print(a, b)
...
>>> f(b=1, *(2,))
2 1
>>> f(a=1, *(2,))
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: f() got multiple values for keyword argument 'a'
>>> f(1, *(2,))
1 2

Det är ovanligt att både nyckelordsargument och syntaxen *expression används i samma anrop, så i praktiken uppstår inte denna förvirring särskilt ofta.

Om syntaxen **expression förekommer i funktionsanropet, måste expression utvärderas till en mapping, vars innehåll behandlas som ytterligare nyckelordsargument. Om en parameter som matchar en nyckel redan har fått ett värde (genom ett explicit nyckelordsargument, eller från en annan uppackning), uppstår ett TypeError undantag.

När **expression används måste varje nyckel i denna mappning vara en sträng. Varje värde från mappningen tilldelas den första formella parametern som är kvalificerad för nyckelordstilldelning vars namn är lika med nyckeln. En nyckel behöver inte vara en Python-identifierare (t.ex. "max-temp °F" är acceptabelt, även om det inte kommer att matcha någon formell parameter som kan deklareras). Om det inte finns någon matchning till en formell parameter samlas nyckel-värdeparet in av parametern **, om det finns en, eller om det inte finns en, ett TypeError undantag tas upp.

Formella parametrar som använder syntaxen *identifier eller **identifier kan inte användas som positionella argumentplatser eller som nyckelordsargumentnamn.

Ändrad i version 3.5: Funktionsanrop accepterar valfritt antal * och ** uppackningar, positionella argument kan följa iterabla uppackningar (*) och nyckelordsargument kan följa uppackningar av ordböcker (**). Ursprungligen föreslagen av PEP 448.

Ett anrop returnerar alltid ett värde, eventuellt None, såvida det inte leder till ett undantag. Hur detta värde beräknas beror på typen av det anropbara objektet.

Om det är det..

en användardefinierad funktion:

Kodblocket för funktionen exekveras genom att argumentlistan skickas till det. Det första kodblocket gör är att binda de formella parametrarna till argumenten; detta beskrivs i avsnitt Definitioner av funktioner. När kodblocket exekverar en return-sats, anger detta returvärdet för funktionsanropet. Om exekveringen når slutet av kodblocket utan att en return-sats exekveras, är returvärdet None.

en inbyggd funktion eller metod:

Resultatet är upp till tolken; se Inbyggda funktioner för beskrivningar av inbyggda funktioner och metoder.

ett klassobjekt:

En ny instans av den klassen returneras.

en metod för klassinstans:

Motsvarande användardefinierade funktion anropas, med en argumentlista som är en längre än anropets argumentlista: instansen blir det första argumentet.

en klassinstans:

Klassen måste definiera en __call__()-metod; effekten blir då densamma som om den metoden anropades.

6.4. Avvakta uttryck

Avbryter exekveringen av coroutine på ett awaitable-objekt. Kan endast användas inuti en coroutine function.

await_expr: "await" primary

Tillagd i version 3.5.

6.5. Den kraftfulla operatoren

Power-operatorn binder hårdare än unära operatorer till vänster om den; den binder mindre hårt än unära operatorer till höger om den. Syntaxen är:

power: (await_expr | primary) ["**" u_expr]

I en sekvens av potens- och unära operatorer som inte är parentetisk utvärderas operatorerna från höger till vänster (detta begränsar inte utvärderingsordningen för operanderna): -1**2 resulterar i -1.

Potensoperatorn har samma semantik som den inbyggda funktionen pow(), när den anropas med två argument: den ger sitt vänstra argument upphöjt till potensen av sitt högra argument. De numeriska argumenten konverteras först till en gemensam typ, och resultatet är av den typen.

För int-operander har resultatet samma typ som operanderna om inte det andra argumentet är negativt; i så fall konverteras alla argument till float och ett float-resultat levereras. Till exempel ger 10**2 resultatet 100, men 10**-2 ger 0,01.

Att höja 0.0 till en negativ potens resulterar i ett ZeroDivisionError. Att höja ett negativt tal till en bråkpotens resulterar i ett komplex tal. (I tidigare versioner gav det upphov till ett ValueError.)

Denna operation kan anpassas med hjälp av specialmetoderna __pow__() och __rpow__().

6.6. Unär aritmetik och bitvisa operationer

Alla unära aritmetiska och bitvisa operationer har samma prioritet:

u_expr: power | "-" u_expr | "+" u_expr | "~" u_expr

Den unära operatorn - (minus) ger negationen av sitt numeriska argument; operationen kan åsidosättas med specialmetoden __neg__().

Den unära operatorn + (plus) ger sitt numeriska argument oförändrat; operationen kan åsidosättas med specialmetoden __pos__().

Den unära operatorn ~ (invert) ger den bitvisa inverteringen av dess heltalsargument. Den bitvisa inverteringen av x definieras som -(x+1). Den gäller endast för heltal eller för anpassade objekt som åsidosätter specialmetoden __invert__().

I alla tre fallen, om argumentet inte har rätt typ, uppstår ett TypeError undantag.

6.7. Binära aritmetiska operationer

De binära aritmetiska operationerna har de konventionella prioritetsnivåerna. Observera att vissa av dessa operationer även gäller för vissa icke-numeriska typer. Bortsett från potensoperatorn finns det bara två nivåer, en för multiplikativa operatorer och en för additiva operatorer:

m_expr: u_expr | m_expr "*" u_expr | m_expr "@" m_expr |
        m_expr "//" u_expr | m_expr "/" u_expr |
        m_expr "%" u_expr
a_expr: m_expr | a_expr "+" m_expr | a_expr "-" m_expr

Operatorn * (multiplikation) ger produkten av sina argument. Argumenten måste antingen båda vara tal eller så måste det ena argumentet vara ett heltal och det andra en sekvens. I det förstnämnda fallet konverteras talen till en gemensam reell typ och multipliceras sedan med varandra. I det senare fallet utförs sekvensrepetition; en negativ repetitionsfaktor ger en tom sekvens.

Denna operation kan anpassas med hjälp av specialmetoderna __mul__() och __rmul__().

Ändrad i version 3.14: Om endast ett operand är ett komplext tal, omvandlas det andra operand till ett flyttal.

Operatorn @ (at) är avsedd att användas för matrismultiplikation. Inga inbyggda Python-typer implementerar denna operator.

Denna operation kan anpassas med hjälp av specialmetoderna __matmul__() och __rmatmul__().

Tillagd i version 3.5.

Operatorerna / (division) och // (golvdivision) ger kvoten av sina argument. De numeriska argumenten konverteras först till en gemensam typ. Division av heltal ger en float, medan golvdivision av heltal ger ett heltal; resultatet är detsamma som matematisk division med ”golv”-funktionen tillämpad på resultatet. Division med noll ger upphov till undantaget ZeroDivisionError.

Delningsoperationen kan anpassas med hjälp av specialmetoderna __truediv__() och __rtruediv__(). Golvdelningsoperationen kan anpassas med hjälp av specialmetoderna __floordiv__() och __rfloordiv__().

Operatorn % (modulo) ger återstoden av divisionen av det första argumentet med det andra. De numeriska argumenten konverteras först till en gemensam typ. Ett argument med noll till höger ger upphov till undantaget ZeroDivisionError. Argumenten kan vara flyttal, t.ex. 3,14%0,7 är lika med 0,34 (eftersom 3,14 är lika med 4*0,7 + 0,34.) Operatorn modulo ger alltid ett resultat med samma tecken som den andra operanden (eller noll); resultatets absoluta värde är strikt mindre än den andra operandens absoluta värde [1].

Operatorerna vågdivision och modulo är förbundna med varandra genom följande identitet: x == (x//y)*y + (x%y). Våningsdivision och modulo är också kopplade till den inbyggda funktionen divmod(): divmod(x, y) == (x//y, x%y). [2].

Förutom att utföra modulo-operationen på tal, är operatorn % också överbelastad av strängobjekt för att utföra gammaldags strängformatering (även känd som interpolering). Syntaxen för strängformatering beskrivs i Python Library Reference, avsnitt strängformatering i stil med printf.

Operationen modulo kan anpassas med hjälp av specialmetoderna __mod__() och __rmod__().

Operatorn för vågdivision, operatorn modulo och funktionen divmod() är inte definierade för komplexa tal. Konvertera istället till ett flyttal med hjälp av funktionen abs() om det är lämpligt.

Operatorn + (addition) ger summan av sina argument. Argumenten måste antingen båda vara tal eller båda vara sekvenser av samma typ. I det förstnämnda fallet konverteras talen till en gemensam reell typ och adderas sedan. I det senare fallet konkateneras sekvenserna.

Denna operation kan anpassas med hjälp av specialmetoderna __add__() och __radd__().

Ändrad i version 3.14: Om endast ett operand är ett komplext tal, omvandlas det andra operand till ett flyttal.

Operatorn - (subtraktion) ger skillnaden mellan sina argument. De numeriska argumenten konverteras först till en gemensam real typ.

Denna operation kan anpassas med hjälp av specialmetoderna __sub__() och __rsub__().

Ändrad i version 3.14: Om endast ett operand är ett komplext tal, omvandlas det andra operand till ett flyttal.

6.8. Skiftande verksamhet

Skiftoperationerna har lägre prioritet än de aritmetiska operationerna:

shift_expr: a_expr | shift_expr ("<<" | ">>") a_expr

Dessa operatorer accepterar heltal som argument. De förskjuter det första argumentet åt vänster eller höger med det antal bitar som anges i det andra argumentet.

Vänsterförskjutningen kan anpassas med hjälp av specialmetoderna __lshift__() och __rlshift__(). Högerförskjutningen kan anpassas med hjälp av specialmetoderna __rshift__() och __rrshift__().

En högerförskjutning med n bitar definieras som golvdivision med pow(2,n). En vänsterförskjutning med n bitar definieras som multiplikation med pow(2,n).

6.9. Binära bitvisa operationer

Var och en av de tre bitvisa operationerna har olika prioritetsnivå:

and_expr: shift_expr | and_expr "&" shift_expr
xor_expr: and_expr | xor_expr "^" and_expr
or_expr:  xor_expr | or_expr "|" xor_expr

Operatorn & ger det bitvisa AND av sina argument, som måste vara heltal eller ett av dem måste vara ett anpassat objekt som åsidosätter specialmetoderna __and__() eller __rand__().

Operatorn ^ ger bitvis XOR (exclusive OR) av sina argument, som måste vara heltal eller ett av dem måste vara ett anpassat objekt som åsidosätter specialmetoderna __xor__() eller __rxor__().

Operatorn | ger det bitvisa (inkluderande) OR av dess argument, som måste vara heltal eller så måste ett av dem vara ett anpassat objekt som åsidosätter specialmetoderna __or__() eller __ror__().

6.10. Jämförelser

Till skillnad från C har alla jämförelseoperationer i Python samma prioritet, som är lägre än den för aritmetiska, skiftande eller bitvisa operationer. Till skillnad från C har också uttryck som a < b < c den tolkning som är konventionell inom matematiken:

comparison:    or_expr (comp_operator or_expr)*
comp_operator: "<" | ">" | "==" | ">=" | "<=" | "!="
               | "is" ["not"] | ["not"] "in"

Jämförelser ger booleska värden: True eller False. Anpassade rich comparison methods kan returnera icke-booleska värden. I detta fall kommer Python att anropa bool() på sådana värden i booleska kontexter.

Jämförelser kan kedjas godtyckligt, t.ex. är x < y <= z ekvivalent med x < y and y <= z, förutom att y bara utvärderas en gång (men i båda fallen utvärderas inte z alls när x < y visar sig vara falskt).

Formellt sett, om a, b, c, …, y, z är uttryck och op1, op2, …, opN är jämförelseoperatorer, då är a op1 b op2 c ... y opN z ekvivalent med a op1 b and b op2 c and ... y opN z, med undantag för att varje uttryck utvärderas högst en gång.

Observera att a op1 b op2 c inte innebär någon form av jämförelse mellan a och c, så att t.ex. x < y > z är helt lagligt (men kanske inte vackert).

6.10.1. Värdejämförelser

Operatorerna <, >, ==, >=, <= och != jämför värdena hos två objekt. Objekten behöver inte ha samma typ.

Kapitel Objekt, värden och typer anger att objekt har ett värde (utöver typ och identitet). Värdet på ett objekt är ett ganska abstrakt begrepp i Python: Det finns t.ex. ingen kanonisk åtkomstmetod för ett objekts värde. Det finns inte heller något krav på att ett objekts värde ska vara konstruerat på ett visst sätt, t.ex. bestå av alla dess dataattribut. Jämförelseoperatorer implementerar en särskild uppfattning om vad ett objekts värde är. Man kan se det som att de definierar ett objekts värde indirekt, med hjälp av sin jämförelseimplementering.

Eftersom alla typer är (direkta eller indirekta) subtyper av object, ärver de standardjämförelsebeteendet från object. Typer kan anpassa sitt jämförelsebeteende genom att implementera rika jämförelsemetoder som __lt__(), som beskrivs i Grundläggande anpassning.

Standardbeteendet för jämlikhetsjämförelser (== och !=) baseras på objektens identitet. Därför resulterar jämlikhetsjämförelse av instanser med samma identitet i jämlikhet, och jämlikhetsjämförelse av instanser med olika identiteter resulterar i ojämlikhet. Ett motiv för detta standardbeteende är önskemålet att alla objekt ska vara reflexiva (dvs. x is y innebär x == y).

En standardjämförelseordning (<, >, <= och >=) tillhandahålls inte; ett försök ger upphov till TypeError. Ett motiv för detta standardbeteende är avsaknaden av en liknande invariant som för likhet.

Standardjämförelsen för jämlikhet, att instanser med olika identiteter alltid är ojämlika, kan stå i kontrast till vad typer behöver som har en vettig definition av objektvärde och värdebaserad jämlikhet. Sådana typer kommer att behöva anpassa sitt jämförelsebeteende, och det har faktiskt ett antal inbyggda typer gjort.

I följande lista beskrivs jämförelsebeteendet för de viktigaste inbyggda typerna.

  • Tal av inbyggda numeriska typer (Numeriska typer — int, float, complex) och av standardbibliotekets typer fractions.Fraction och decimal.Decimal kan jämföras inom och mellan sina typer, med begränsningen att komplexa tal inte stöder orderjämförelse. Inom gränserna för de berörda typerna jämförs de matematiskt (algoritmiskt) korrekt utan förlust av precision.

    Värdena ”not-a-number” float('NaN') och decimal.Decimal('NaN') är speciella. Varje ordnad jämförelse av ett tal med ett värde som inte är ett tal är falsk. En kontraintuitiv implikation är att värden som inte är ett tal inte är lika med sig själva. Till exempel, om x = float('NaN'), 3 < x, x < 3 och x == x är alla falska, medan x != x är sant. Detta beteende är förenligt med IEEE 754.

  • None och NotImplemented är singletons. PEP 8 rekommenderar att jämförelser för singletons alltid skall göras med is eller is not, aldrig med jämställdhetsoperatorerna.

  • Binära sekvenser (instanser av bytes eller bytearray) kan jämföras inom och mellan sina typer. De jämförs lexikografiskt med hjälp av de numeriska värdena för sina element.

  • Strängar (instanser av str) jämförs lexikografiskt med hjälp av de numeriska Unicode-kodpunkterna (resultatet av den inbyggda funktionen ord()) för sina tecken. [3]

    Strängar och binära sekvenser kan inte jämföras direkt.

  • Sekvenser (instanser av tuple, list eller range) kan endast jämföras inom var och en av sina typer, med begränsningen att intervall inte stöder orderjämförelse. Jämlikhetsjämförelse mellan dessa typer resulterar i ojämlikhet, och ordningsjämförelse mellan dessa typer ger upphov till TypeError.

    Sekvenser jämförs lexikografiskt med hjälp av jämförelse av motsvarande element. De inbyggda behållarna antar vanligtvis att identiska objekt är lika med sig själva. Det gör att de kan kringgå likhetstester för identiska objekt för att förbättra prestanda och för att upprätthålla sina interna invarianter.

    Lexikografisk jämförelse mellan inbyggda samlingar fungerar på följande sätt:

    • För att två samlingar ska kunna jämföras lika måste de vara av samma typ, ha samma längd och varje par av motsvarande element måste jämföras lika (till exempel är [1,2] == (1,2) falskt eftersom typen inte är densamma).

    • Samlingar som stöder orderjämförelse ordnas på samma sätt som deras första ojämna element (till exempel har [1,2,x] <= [1,2,y] samma värde som x <= y). Om det inte finns något motsvarande element ordnas den kortare samlingen först (t.ex. [1,2] < [1,2,3] är sant).

  • Avbildningar (instanser av dict) jämför lika om och endast om de har lika (key, value) -par. Jämförelse av nycklar och värden som är lika verkställer reflexivitet.

    Orderjämförelser (<, >, <= och >=) ger upphov till TypeError.

  • Uppsättningar (instanser av set eller frozenset) kan jämföras inom och mellan sina typer.

    De definierar operatorer för jämförelse av ordningar som innebär test av delmängder och övermängder. Dessa relationer definierar inte totalordning (till exempel är de två mängderna {1,2} och {2,3} inte lika, och inte heller delmängder av varandra eller övermängder av varandra). Följaktligen är mängder inte lämpliga argument för funktioner som är beroende av total ordning (till exempel min(), max() och sorted() ger odefinierade resultat om de får en lista med mängder som indata).

    Jämförelse av uppsättningar tvingar fram reflexivitet hos dess element.

  • De flesta andra inbyggda typer har inga jämförelsemetoder implementerade, så de ärver standardjämförelsebeteendet.

Användardefinierade klasser som anpassar sitt jämförelsebeteende bör om möjligt följa vissa konsistensregler:

  • Jämförelse av jämlikhet bör vara reflexiv. Med andra ord bör identiska objekt jämföras lika:

    x is y innebär x == y

  • Jämförelsen ska vara symmetrisk. Med andra ord ska följande uttryck ge samma resultat:

    x == y och y == x

    x != y och y != x

    x < y och y > x

    x <= y och y >= x

  • Jämförelsen ska vara transitiv. Följande (icke uttömmande) exempel illustrerar detta:

    x > y and y > z innebär x > z

    x < y and y <= z innebär x < z

  • Omvänd jämförelse bör resultera i den booleska negationen. Med andra ord bör följande uttryck ge samma resultat:

    x == y och not x != y

    x < y och not x >= y (för total ordning)

    x > y och not x <= y (för total ordning)

    De två sista uttrycken gäller för totalt ordnade samlingar (t.ex. sekvenser, men inte för mängder eller avbildningar). Se även dekoratorn total_ordering().

  • Resultatet av hash() bör vara förenligt med likhet. Objekt som är lika bör antingen ha samma hashvärde eller markeras som icke-hashbara.

Python upprätthåller inte dessa konsistensregler. Faktum är att värdena för not-a-number är ett exempel på att dessa regler inte följs.

6.10.2. Testverksamhet för medlemskap

Operatorerna in och not in testar medlemskap. x in s utvärderas till True om x är medlem i s, och False i annat fall. x not in s returnerar negationen av x in s. Alla inbyggda sekvenser och uppsättningstyper stöder detta, liksom ordböcker, för vilka in testar om ordboken har en given nyckel. För behållartyp som list, tuple, set, frozenset, dict eller collections.deque är uttrycket x in y ekvivalent med any(x is e or x == e for e in y).

För sträng- och bytestyperna är x in y True om och endast om x är en delsträng av y. Ett motsvarande test är y.find(x) != -1. Tomma strängar anses alltid vara en delsträng av någon annan sträng, så "" i "abc" kommer att returnera True.

För användardefinierade klasser som definierar metoden __contains__() returnerar x in y True om y.__contains__(x) returnerar ett sant värde och False annars.

För användardefinierade klasser som inte definierar __contains__() men som definierar __iter__(), är x in y True om något värde z, för vilket uttrycket x är z eller x == z är sant, produceras under iteration över y. Om ett undantag görs under iterationen, är det som om in gjorde detta undantag.

Slutligen prövas det gamla iterationsprotokollet: om en klass definierar __getitem__(), är x in y True om och endast om det finns ett icke-negativt heltalsindex i så att x är y[i] eller x == y[i], och inget lägre heltalsindex ger upphov till IndexError-undantaget. (Om något annat undantag görs, är det som om in gjorde det undantaget).

Operatorn not in är definierad att ha det omvända sanningsvärdet av in.

6.10.3. Identitetsjämförelser

Operatorerna is och is not testar ett objekts identitet: x is y är sant om och endast om x och y är samma objekt. Ett objekts identitet bestäms med hjälp av funktionen id(). x is not y ger det omvända sanningsvärdet. [4]

6.11. Booleska operationer

or_test:  and_test | or_test "or" and_test
and_test: not_test | and_test "and" not_test
not_test: comparison | "not" not_test

I samband med booleska operationer, och även när uttryck används av kontrollflödessatser, tolkas följande värden som falska: False, None, numeriska nollor av alla typer, och tomma strängar och behållare (inklusive strängar, tupler, listor, ordböcker, mängder och frozensets). Alla andra värden tolkas som sanna. Användardefinierade objekt kan anpassa sitt sanningsvärde genom att tillhandahålla en __bool__()-metod.

Operatorn not ger True om dess argument är falskt, False annars.

Uttrycket x och y utvärderar först x; om x är falskt returneras dess värde; i annat fall utvärderas y och det resulterande värdet returneras.

Uttrycket x eller y utvärderar först x; om x är sant returneras dess värde; annars utvärderas y och det resulterande värdet returneras.

Observera att varken and eller or begränsar värdet och typen som returneras till False och True, utan returnerar det senast utvärderade argumentet. Detta är ibland användbart, t.ex. om s är en sträng som ska ersättas med ett standardvärde om den är tom, ger uttrycket s or 'foo' det önskade värdet. Eftersom not måste skapa ett nytt värde, returnerar det ett booleskt värde oavsett typen av argument (till exempel, not 'foo' producerar False snarare än '')

6.12. Uppdragsuttryck

assignment_expression: [identifier ":="] expression

Ett tilldelningsuttryck (ibland även kallat ”namngivet uttryck” eller ”valross”) tilldelar en expression till en identifier, samtidigt som det returnerar värdet av expression.

Ett vanligt användningsfall är när man hanterar matchade reguljära uttryck:

if matching := pattern.search(data):
    gör_något(matchning)

Eller när du bearbetar en filström i bitar:

while chunk := file.read(9000):
    process(chunk)

Tilldelningsuttryck måste omges av parenteser när de används som uttryckssatser och när de används som underuttryck i slicing-, villkor-, lambda-, nyckelordsargument- och comprehension-if-uttryck samt i assert, with och assignment -satser. På alla andra ställen där de kan användas krävs inte parenteser, inklusive i if och while -satser.

Tillagd i version 3.8: Se PEP 572 för mer information om assignment-uttryck.

6.13. Villkorliga uttryck

conditional_expression: or_test ["if" or_test "else" expression]
expression:             conditional_expression | lambda_expr

Villkorliga uttryck (kallas ibland ”ternär operator”) har den lägsta prioriteten av alla Python-operationer.

Uttrycket x if C else y utvärderar först villkoret C i stället för x. Om C är sant, utvärderas x och dess värde returneras; annars utvärderas y och dess värde returneras.

Se PEP 308 för mer information om villkorliga uttryck.

6.14. Lambdas

lambda_expr: "lambda" [parameter_list] ":" expression

Lambda-uttryck (ibland kallade lambda-formulär) används för att skapa anonyma funktioner. Uttrycket lambda parameters: expression ger ett funktionsobjekt. Det namnlösa objektet beter sig som ett funktionsobjekt definierat med:

def <lambda>(parameters):
    return expression

Se avsnitt Definitioner av funktioner för syntaxen för parameterlistor. Observera att funktioner som skapas med lambda-uttryck inte kan innehålla satser eller annoteringar.

6.15. Uttryckslistor

starred_expression:       "*" or_expr | expression
flexible_expression:      assignment_expression | starred_expression
flexible_expression_list: flexible_expression ("," flexible_expression)* [","]
starred_expression_list:  starred_expression ("," starred_expression)* [","]
expression_list:          expression ("," expression)* [","]
yield_list:               expression_list | starred_expression "," [starred_expression_list]

En uttrycksförteckning som innehåller minst ett kommatecken ger en tupel, utom när den ingår i en list- eller set-visning. Längden på tupeln är lika med antalet uttryck i listan. Uttrycken utvärderas från vänster till höger.

En asterisk * betecknar iterable unpacking. Dess operand måste vara en iterable. Den iterabla expanderas till en sekvens av objekt som ingår i den nya tupeln, listan eller mängden på platsen för uppackningen.

Tillagd i version 3.5: Iterabel uppackning i uttrycksförteckningar, ursprungligen föreslagen av PEP 448.

Tillagd i version 3.11: Alla objekt i en uttrycksförteckning kan stjärnmarkeras. Se PEP 646.

Ett efterföljande kommatecken krävs endast för att skapa en tupel med en post, t.ex. 1,; det är valfritt i alla andra fall. Ett enstaka uttryck utan efterföljande kommatecken skapar inte en tupel, utan ger värdet av uttrycket. (Om du vill skapa en tom tupel använder du ett tomt par parenteser: ().)

6.16. Utvärderingsorder

Python utvärderar uttryck från vänster till höger. Lägg märke till att när du utvärderar en tilldelning utvärderas högersidan före vänstersidan.

I följande rader kommer uttrycken att utvärderas i aritmetisk ordning efter sina suffix:

expr1, expr2, expr3, expr4
(expr1, expr2, expr3, expr4)
{expr1: expr2, expr3: expr4}
expr1 + expr2 * (expr3 - expr4)
expr1(expr2, expr3, *expr4, **expr5)
expr3, expr4 = expr1, expr2

6.17. Operatorens företräde

Följande tabell sammanfattar operatorprioriteringen i Python, från högsta prioritet (mest bindande) till lägsta prioritet (minst bindande). Operatorer i samma ruta har samma företräde. Om inte syntaxen uttryckligen anges är operatorer binära. Operatorer i samma ruta grupperas från vänster till höger (med undantag för exponentiering och villkorliga uttryck, som grupperas från höger till vänster).

Observera att jämförelser, medlemskapstest och identitetstest alla har samma företräde och har en vänster-till-höger kedjefunktion som beskrivs i avsnittet Jämförelser.

Operator

Beskrivning

(expressions...),

[expressions...], {key: value...}, {expressions...}

Bindande eller parentetiskt uttryck, listvisning, ordboksvisning, set-visning

x[index], x[index:index], x(arguments...), x.attribute

Prenumeration, slicing, samtal, attributreferens

await x

Avvakta uttryck

**

Exponentiering [5]

+x, -x, ~x

Positiv, negativ, bitvis NOT

*, @, /, //, %

Multiplikation, matrismultiplikation, division, våningsdivision, rest [6]

+, -

Addition och subtraktion

<<, >>

Skift

&

Bitvis AND

^

Bitvis XOR

|

Bitvis OR

in, not in, is, is not, <, <=, >, >=, !=, ==

Jämförelser, inklusive medlemstester och identitetstester

not x

Boolean NOT

and

Booleansk AND

or

Booleansk OR

if – else

Villkorligt uttryck

lambda

Lambda-uttryck

:=

Uppdragets uttryck

Fotnoter