Inbyggda funktioner¶

Python-tolken har ett antal inbyggda funktioner och typer som alltid är tillgängliga. De listas här i alfabetisk ordning.

Inbyggda funktioner
A `abs()` `aiter()` `all()` `anext()` `any()` `ascii()` B `bin()` `bool()` `brytpunkt()` `bytearray()` `bytes()` C `kallbar()` `chr()` `klassmetod()` `kompilera()` `komplex()` D `delattr()` `dict()` `dir()` `divmod()`	E `uppräkna()` `eval()` `exec()` F `filter()` `flöde()` `format()` `frozenset()` G `getattr()` `globaler()` H `harattr()` `hash()` `help()` `hex()` I `id()` `inmatning()` `int()` `isinstance()` `issubclass()` `iter()`	L `len()` `list()` `lokal()` M `map()` `max()` `memoryview()` `min()` N `nästa()` O `objekt()` `oct()` `öppna()` `ord()` P `pow()` `print()` `egenskap()`	R `range()` `repr()` `vända()` `rund()` S `set()` `setattr()` `skiva()` `sorterad()` `statisk metod()` `str()` `summa()` `super()` T `tuple()` `typ()` V `vars()` Z `zip()` _ `__import__()`

abs(number, /)¶: Returnerar det absoluta värdet av ett tal. Argumentet kan vara ett heltal, ett flyttal eller ett objekt som implementerar __abs__(). Om argumentet är ett komplext tal returneras dess magnitud.

aiter(async_iterable, /)¶

Returnerar en asynkron iterator för en asynkron iterabel. Motsvarar anrop av x.__aiter__().

Notera: Till skillnad från iter() har aiter() ingen variant med 2 argument.

Tillagd i version 3.10.

all(iterable, /)¶

Returnerar True om alla element i iterabeln är sanna (eller om iterabeln är tom). Likvärdig med:

def all(iterabel):
    för element i iterabel:
        if inte element:
            returnera False
    returnera sant

awaitable anext(async_iterator, /)¶

awaitable anext(async_iterator, default, /)

När den är väntad returneras nästa objekt från den angivna asynchronous iterator, eller standard om den är angiven och iteratorn är uttömd.

Detta är den asynkrona varianten av next()-byggstenen och fungerar på samma sätt.

Detta anropar __anext__()-metoden för async_iterator och returnerar en awaitable. Awaiting detta returnerar nästa värde i iteratorn. Om default anges returneras det om iteratorn är uttömd, annars uppstår StopAsyncIteration.

Tillagd i version 3.10.

any(iterable, /)¶

Returnerar True om något element i iterabeln är sant. Om iterabeln är tom returneras False. Likvärdig med:

def any(iterable):
    för element i iterabel:
        if element:
            returnera True
    returnera Falskt

ascii(object, /)¶: Som repr(), returnera en sträng som innehåller en utskrivbar representation av ett objekt, men escape icke-ASCII-tecken i strängen som returneras av repr() med hjälp av \x, \u eller U\ escapes. Detta genererar en sträng som liknar den som returneras av repr() i Python 2.

bin(integer, /)¶

Konvertera ett heltal till en binär sträng med prefixet ”0b”. Resultatet är ett giltigt Python-uttryck. Om integer inte är ett Python int-objekt måste det definiera en __index__()-metod som returnerar ett heltal. Några exempel:

>>> bin(3)
'0b11'
>>> bin(-10)
'-0b1010'

Om prefixet ”0b” önskas eller inte, kan du använda något av följande sätt.

>>> format(14, '#b'), format(14, 'b')
('0b1110', '1110')
>>> f'{14:#b}', f'{14:b}'
('0b1110', '1110')

Se även format() för mer information.

class bool(object=False, /)¶: Returnerar ett booleskt värde, dvs. antingen True eller False. Argumentet konverteras med hjälp av standardproceduren sanningsprövning. Om argumentet är falskt eller utelämnat returneras False, annars returneras True. Klassen bool är en underklass till int (se Numeriska typer — int, float, complex). Den kan inte delas upp i ytterligare underklasser. Dess enda instanser är False och True (se Booleansk typ - bool).

Ändrad i version 3.7: Parametern är nu endast positionsbestämd.

breakpoint(*args, **kws)¶

Den här funktionen släpper in dig i felsökaren på anropsplatsen. Specifikt anropar den sys.breakpointhook() och skickar args och kws rakt igenom. Som standard anropar sys.breakpointhook() pdb.set_trace() och förväntar sig inga argument. I det här fallet är det en ren bekvämlighetsfunktion så att du inte uttryckligen behöver importera pdb eller skriva så mycket kod för att komma in i felsökaren. Men sys.breakpointhook() kan sättas till någon annan funktion och breakpoint() kommer automatiskt att anropa den, så att du kan hoppa in i den debugger du väljer. Om sys.breakpointhook() inte är tillgänglig kommer denna funktion att ge upphov till RuntimeError.

Som standard kan beteendet hos breakpoint() ändras med miljövariabeln PYTHONBREAKPOINT. Se sys.breakpointhook() för användningsdetaljer.

Observera att detta inte är garanterat om sys.breakpointhook() har ersatts.

Utlöser en auditing event builtins.breakpoint med argumentet breakpointhook.

Tillagd i version 3.7.

class bytearray(source=b'')

class bytearray(source, encoding, errors='strict')

Returnerar en ny array av bytes. Klassen bytearray är en föränderlig sekvens av heltal i intervallet 0 <= x < 256. Den har de flesta av de vanliga metoderna för muterbara sekvenser, beskrivna i Mutabla sekvenstyper, samt de flesta metoder som typen bytes har, se Bytes- och bytearrayoperationer.

Den valfria parametern source kan användas för att initiera matrisen på några olika sätt:

Om det är en sträng måste du också ange parametrarna encoding (och eventuellt errors); bytearray() konverterar sedan strängen till bytes med str.encode().
Om det är ett integer kommer arrayen att ha den storleken och initialiseras med null-bytes.
Om det är ett objekt som överensstämmer med buffer interface, kommer en skrivskyddad buffert av objektet att användas för att initiera bytesmatrisen.
Om det är en iterabel måste det vara en iterabel av heltal i intervallet 0 <= x < 256, som används som det ursprungliga innehållet i matrisen.

Utan argument skapas en array av storleken 0.

Se även Binära sekvenstyper — bytes, bytearray, memoryview och Bytearray-objekt.

class bytes(source=b'')

class bytes(source, encoding, errors='strict')

Returnerar ett nytt ”bytes”-objekt som är en oföränderlig sekvens av heltal i intervallet 0 <= x < 256. bytes är en oföränderlig version av bytearray – den har samma icke-muterande metoder och samma indexerings- och skivningsbeteende.

Följaktligen tolkas konstruktörsargument som för bytearray().

Bytesobjekt kan också skapas med literaler, se Sträng- och Bytes-litteraler.

Se även Binära sekvenstyper — bytes, bytearray, memoryview, Bytes-objekt och Bytes- och bytearrayoperationer.

callable(object, /)¶: Returnerar True om argumentet object verkar anropbart, False om inte. Om detta returnerar True är det fortfarande möjligt att ett anrop misslyckas, men om det är False kommer anropet av object aldrig att lyckas. Observera att klasser är anropsbara (anrop av en klass returnerar en ny instans); instanser är anropsbara om deras klass har en __call__()-metod.

Tillagd i version 3.2: Denna funktion togs först bort i Python 3.0 och återinfördes sedan i Python 3.2.

chr(codepoint, /)¶

Returnerar strängen som representerar ett tecken med den angivna Unicode-kodpunkten. Till exempel, vid chr(97), returneras strängen 'a', medan vid chr(8364) returneras strängen '€'. Detta är motsatsen till ord().

Det giltiga intervallet för argumentet är från 0 till 1 114 111 (0x10FFFF i bas 16). ValueError kommer att genereras om det ligger utanför detta intervall.

@classmethod¶

Omvandla en metod till en klassmetod.

En klassmetod tar emot klassen som ett implicit första argument, precis som en instansmetod tar emot instansen. För att deklarera en klassmetod använder du detta idiom:

klass C:
    @klassmetod
    def f(cls, arg1, arg2): ...

Formuläret @classmethod är en funktion decorator – se Definitioner av funktioner för detaljer.

En klassmetod kan anropas antingen på klassen (t.ex. C.f()) eller på en instans (t.ex. C().f()). Instansen ignoreras med undantag för dess klass. Om en klassmetod anropas för en härledd klass, skickas det härledda klassobjektet som det underförstådda första argumentet.

Klassmetoder är annorlunda än statiska metoder i C++ eller Java. Om du vill ha sådana, se staticmethod() i detta avsnitt. För mer information om klassmetoder, se Standardtypens hierarki.

Ändrad i version 3.9: Klassmetoder kan nu omsluta andra deskriptorer såsom property().

Ändrad i version 3.10: Klassmetoder ärver nu metodattributen (__module__, __name__, __qualname__, __doc__ och __annotations__) och har ett nytt attribut __wrapped__.

Deprecated since version 3.11, removed in version 3.13: Klassmetoder kan inte längre omsluta andra deskriptorer såsom property().

compile(source, filename, mode, flags=0, dont_inherit=False, optimize=-1)¶

Kompilera källan till ett kod- eller AST-objekt. Kodobjekt kan exekveras med exec() eller eval(). source kan antingen vara en normal sträng, en byte-sträng eller ett AST-objekt. Se dokumentationen för modulen ast för information om hur du arbetar med AST-objekt.

Argumentet filnamn ska ange den fil som koden lästes från; skicka något igenkännbart värde om den inte lästes från en fil ('<string>' används ofta).

Argumentet mode anger vilken typ av kod som ska kompileras; det kan vara 'exec' om källan består av en sekvens av satser, 'eval' om den består av ett enda uttryck, eller 'single' om den består av en enda interaktiv sats (i det senare fallet skrivs satser som utvärderas till något annat än None ut).

De valfria argumenten flags och dont_inherit styr vilka compiler options som ska aktiveras och vilka future features som ska tillåtas. Om ingen av dessa är närvarande (eller om båda är noll) kompileras koden med samma flaggor som påverkar koden som anropar compile(). Om argumentet flags anges och dont_inherit inte anges (eller är noll) används de kompilatoralternativ och framtida uttalanden som anges i argumentet flags utöver de som ändå skulle ha använts. Om dont_inherit är ett heltal som inte är noll så är flags-argumentet det - flaggorna (framtida funktioner och kompilatoralternativ) i den omgivande koden ignoreras.

Kompilatoralternativ och framtidssatser specificeras av bitar som kan kombineras bitvis för att specificera flera alternativ. Bitfältet som krävs för att specificera en given framtida funktion kan hittas som attributet compiler_flag på _Feature instansen i __future__ modulen. Compiler flags kan hittas i ast modulen, med PyCF_ prefix.

Argumentet optimize anger kompilatorns optimeringsnivå; standardvärdet -1 väljer tolkens optimeringsnivå som anges i -O-alternativen. Explicita nivåer är 0 (ingen optimering; __debug__ är sant), 1 (asserts tas bort, __debug__ är falskt) eller 2 (docstrings tas också bort).

Denna funktion ger upphov till SyntaxError om den kompilerade källan är ogiltig, och ValueError om källan innehåller null bytes.

Om du vill analysera Python-kod till dess AST-representation, se ast.parse().

Utlöser en auditing-händelse compile med argumenten source och filename. Denna händelse kan också utlösas av implicit kompilering.

Anteckning

När en sträng med flerradig kod kompileras i läget 'single' eller 'eval' måste inmatningen avslutas med minst ett tecken för ny rad. Detta för att underlätta upptäckten av ofullständiga och fullständiga satser i modulen code.

Varning

Det är möjligt att krascha Python-tolken med en tillräckligt stor/komplex sträng när den kompileras till ett AST-objekt på grund av begränsningar i stackdjupet i Pythons AST-kompilator.

Ändrad i version 3.2: Tillåtet att använda Windows och Mac newlines. Dessutom behöver inmatning i 'exec'-läge inte längre avslutas med en ny rad. Parametern optimize har lagts till.

Ändrad i version 3.5: Tidigare skapades TypeError när null bytes påträffades i source.

Tillagd i version 3.8: ast.PyCF_ALLOW_TOP_LEVEL_AWAIT kan nu skickas i flaggor för att aktivera stöd för toppnivå await, async for och async with.

class complex(number=0, /)¶

class complex(string, /)

class complex(real=0, imag=0)

Konvertera en enskild sträng eller ett tal till ett komplext tal, eller skapa ett komplext tal från reella och imaginära delar.

Exempel:

>>> complex('+1.23')
(1.23+0j)
>>> complex('-4.5j')
-4.5j
>>> complex('-1.23+4.5j')
(-1.23+4.5j)
>>> complex('\t( -1.23+4.5J )\n')
(-1.23+4.5j)
>>> complex('-Infinity+NaNj')
(-inf+nanj)
>>> complex(1.23)
(1.23+0j)
>>> complex(imag=-4.5)
-4.5j
>>> complex(-1.23, 4.5)
(-1.23+4.5j)

Om argumentet är en sträng måste den innehålla antingen en reell del (i samma format som för float()) eller en imaginär del (i samma format men med suffixet 'j' eller 'J'), eller både en reell del och en imaginär del (tecknet för den imaginära delen är obligatoriskt i detta fall). Strängen kan eventuellt omges av blanksteg och de runda parenteserna '(' och ')', som ignoreras. Strängen får inte innehålla blanksteg mellan '+', '-', suffixet 'j' eller 'J' och decimaltalet. Till exempel, komplex('1+2j') är bra, men komplex('1 + 2j') ger upphov till ValueError. Mer exakt måste indata överensstämma med produktionsregeln complexvalue i följande grammatik, efter att parenteser och inledande och avslutande blankstegstecken har tagits bort:

complexvalue: floatvalue |
              floatvalue ("j" | "J") |
              floatvalue sign absfloatvalue ("j" | "J")

Om argumentet är ett tal fungerar konstruktorn som en numerisk konvertering som int och float. För ett allmänt Python-objekt x delegerar complex(x) till x.__complex__(). Om __complex__() inte är definierad faller den tillbaka till __float__(). Om __float__() inte är definierat faller det tillbaka till __index__().

Om två argument anges eller om nyckelordsargument används kan varje argument vara vilken numerisk typ som helst (inklusive komplex). Om båda argumenten är reella tal, returneras ett komplext tal med den reella komponenten real och den imaginära komponenten imag. Om båda argumenten är komplexa tal returneras ett komplext tal med den reella komponenten real.real-imag.imag och den imaginära komponenten real.imag+imag.real. Om ett av argumenten är ett reellt tal används endast dess reella komponent i ovanstående uttryck.

Se även complex.from_number() som bara accepterar ett enda numeriskt argument.

Om alla argument utelämnas returneras 0j.

Den komplexa typen beskrivs i Numeriska typer — int, float, complex.

Ändrad i version 3.6: Det är tillåtet att gruppera siffror med understrykningstecken som i kodbokstäver.

Ändrad i version 3.8: Faller tillbaka till __index__() om __complex__() och __float__() inte är definierade.

Föråldrad sedan version 3.14: Att skicka ett komplext tal som real- eller imag-argument är nu föråldrat; det ska bara skickas som ett enda positionellt argument.

delattr(object, name, /)¶: Detta är en relativ av setattr(). Argumenten är ett objekt och en sträng. Strängen måste vara namnet på ett av objektets attribut. Funktionen raderar det namngivna attributet, förutsatt att objektet tillåter det. Till exempel, delattr(x, 'foobar') är likvärdigt med del x.foobar. name behöver inte vara en Python-identifierare (se setattr()).

class dict(**kwargs)

class dict(mapping, /, **kwargs)

class dict(iterable, /, **kwargs)

Skapa en ny ordbok. Objektet dict är klassen för ordboken. Se dict och Mappningstyper — dict för dokumentation om denna klass.

För andra behållare se de inbyggda klasserna list, set och tuple samt modulen collections.

dir()¶

dir(object, /)

Utan argument returneras listan med namn i det aktuella lokala omfånget. Med ett argument, försök att returnera en lista över giltiga attribut för det objektet.

Om objektet har en metod som heter __dir__(), kommer denna metod att anropas och måste returnera listan med attribut. Detta gör att objekt som implementerar en egen __getattr__() eller __getattribute__() funktion kan anpassa hur dir() rapporterar deras attribut.

Om objektet inte tillhandahåller __dir__() försöker funktionen göra sitt bästa för att samla in information från objektets __dict__-attribut, om det är definierat, och från dess typobjekt. Den resulterande listan är inte nödvändigtvis fullständig och kan vara felaktig om objektet har en anpassad __getattr__().

Standardmekanismen dir() beter sig olika med olika typer av objekt, eftersom den försöker ta fram den mest relevanta informationen snarare än fullständig information:

Om objektet är ett modulobjekt innehåller listan namnen på modulens attribut.
Om objektet är ett typ- eller klassobjekt innehåller listan namnen på dess attribut och rekursivt på attributen för dess baser.
Annars innehåller listan namnen på objektets attribut, namnen på klassens attribut och rekursivt på attributen för klassens basklasser.

Den resulterande listan är sorterad i alfabetisk ordning. Till exempel

>>> import struct
>>> dir()   # show the names in the module namespace
['__builtins__', '__name__', 'struct']
>>> dir(struct)   # show the names in the struct module
['Struct', '__all__', '__builtins__', '__cached__', '__doc__', '__file__',
 '__initializing__', '__loader__', '__name__', '__package__',
 '_clearcache', 'calcsize', 'error', 'pack', 'pack_into',
 'unpack', 'unpack_from']
>>> class Shape:
...     def __dir__(self):
...         return ['area', 'perimeter', 'location']
...
>>> s = Shape()
>>> dir(s)
['area', 'location', 'perimeter']

Anteckning

Eftersom dir() främst tillhandahålls som en bekvämlighet för användning vid en interaktiv prompt, försöker den tillhandahålla en intressant uppsättning namn mer än den försöker tillhandahålla en rigoröst eller konsekvent definierad uppsättning namn, och dess detaljerade beteende kan ändras mellan olika versioner. Metaklassattribut finns t.ex. inte med i resultatlistan när argumentet är en klass.

divmod(a, b, /)¶: Tar två (icke-komplexa) tal som argument och returnerar ett talpar som består av deras kvot och rest vid användning av heltalsdivision. Med blandade operandtyper gäller reglerna för binära aritmetiska operatorer. För heltal är resultatet detsamma som (a // b, a % b). För flyttal är resultatet (q, a % b), där q vanligtvis är math.floor(a / b) men kan vara 1 mindre än så. I vilket fall som helst är q * b + a % b mycket nära a, om a % b inte är noll har det samma tecken som b, och 0 <= abs(a % b) < abs(b).

enumerate(iterable, start=0)¶

Returnerar ett uppräkningsobjekt. iterable måste vara en sekvens, en iterator, eller något annat objekt som stöder iteration. Metoden __next__() för den iterator som returneras av enumerate() returnerar en tupel som innehåller ett antal (från start som standard är 0) och de värden som erhålls genom att iterera över iterable.

>>> seasons = ['Spring', 'Summer', 'Fall', 'Winter']
>>> list(enumerate(seasons))
[(0, 'Spring'), (1, 'Summer'), (2, 'Fall'), (3, 'Winter')]
>>> list(enumerate(seasons, start=1))
[(1, 'Spring'), (2, 'Summer'), (3, 'Fall'), (4, 'Winter')]

Motsvarar:

def enumerate(iterabel, start=0):
    n = start
    för elem i iterabel:
        avkastning n, elem
        n += 1

eval(source, /, globals=None, locals=None)¶

Parametrar:

source (str | code object) – Ett Python-uttryck.
globals (dict | None) – Den globala namnrymden (standard: None).
locals (mapping | None) – Den lokala namnrymden (standard: None).

Returer:

Resultatet av det utvärderade uttrycket.

höjer:

Syntaxfel rapporteras som undantag.

Varning

Denna funktion exekverar godtycklig kod. Om den anropas med indata från användaren kan det leda till säkerhetsproblem.

Argumentet expression analyseras och utvärderas som ett Python-uttryck (tekniskt sett en villkorslista) med hjälp av mappningarna globals och locals som globala och lokala namnrymder. Om ordlistan globals finns och inte innehåller ett värde för nyckeln __builtins__, infogas en referens till ordlistan för den inbyggda modulen builtins under den nyckeln innan expression analyseras. På så sätt kan du kontrollera vilka inbyggda moduler som är tillgängliga för den exekverade koden genom att infoga din egen __builtins__-ordbok i globals innan du skickar den till eval(). Om locals-mappningen utelämnas används globals-ordlistan som standard. Om båda mappningarna utelämnas, exekveras uttrycket med globals och locals i den miljö där eval() anropas. Observera att eval() endast kommer att ha tillgång till nested scopes (non-locals) i den omgivande miljön om de redan är refererade i det scope som anropar eval() (t.ex. via en nonlocal-sats).

Exempel:

>>> x = 1
>>> eval('x+1')
2

Denna funktion kan också användas för att exekvera godtyckliga kodobjekt (t.ex. de som skapats av compile()). I detta fall ska du skicka ett kodobjekt i stället för en sträng. Om kodobjektet har kompilerats med 'exec som mode-argument, kommer eval`():s returvärde att vara None.

Tips: dynamisk exekvering av satser stöds av funktionen exec(). Funktionerna globals() och locals() returnerar den aktuella globala respektive lokala ordlistan, som kan vara användbar att skicka runt för användning av eval() eller exec().

Om den angivna källan är en sträng tas inledande och avslutande mellanslag och tabbar bort.

Se ast.literal_eval() för en funktion som på ett säkert sätt kan utvärdera strängar med uttryck som bara innehåller bokstavstecken.

Utlöser en auditing event exec med kodobjektet som argument. Händelser för kodkompilering kan också uppstå.

Ändrad i version 3.13: Argumenten globals och locals kan nu skickas som nyckelord.

Ändrad i version 3.13: Semantiken för standardnamnrymden locals har justerats enligt beskrivningen för locals()-byggstenen.

exec(source, /, globals=None, locals=None, *, closure=None)¶

Varning

Denna funktion exekverar godtycklig kod. Om den anropas med indata från användaren kan det leda till säkerhetsproblem.

Denna funktion stöder dynamisk exekvering av Python-kod. source måste vara antingen en sträng eller ett kodobjekt. Om det är en sträng analyseras strängen som en serie Python-satser som sedan exekveras (om inte ett syntaxfel uppstår). [1] Om det är ett kodobjekt exekveras det helt enkelt. I samtliga fall förväntas koden som exekveras vara giltig som filinmatning (se avsnittet Filinmatning i referenshandboken). Tänk på att nonlocal, yield och return inte får användas utanför funktionsdefinitioner, inte ens i samband med kod som skickas till funktionen exec(). Returvärdet är None.

I samtliga fall, om de valfria delarna utelämnas, exekveras koden i det aktuella omfånget. Om endast globals anges måste det vara en dictionary (och inte en subklass av dictionary), som används för både de globala och de lokala variablerna. Om globals och locals anges används de för de globala respektive lokala variablerna. Om locals anges kan det vara vilket mappningsobjekt som helst. Kom ihåg att på modulnivå är globals och locals samma ordbok.

Anteckning

När exec får två separata objekt som globals och locals kommer koden att exekveras som om den var inbäddad i en klassdefinition. Detta innebär att funktioner och klasser som definieras i den exekverade koden inte kommer att kunna komma åt variabler som tilldelats på den översta nivån (eftersom variablerna på ”översta nivån” behandlas som klassvariabler i en klassdefinition).

Om ordlistan globals inte innehåller något värde för nyckeln __builtins__, läggs en referens till ordlistan för den inbyggda modulen builtins in under den nyckeln. På så sätt kan du kontrollera vilka inbyggda moduler som är tillgängliga för den exekverade koden genom att infoga din egen __builtins__-ordbok i globals innan du skickar den till exec().

Argumentet closure anger en closure - en tupel av cellvarianter. Det är endast giltigt när object är ett kodobjekt som innehåller free (closure) variables. Längden på tupeln måste exakt matcha längden på kodobjektets co_freevars-attribut.

Utlöser en auditing event exec med kodobjektet som argument. Händelser för kodkompilering kan också uppstå.

Anteckning

De inbyggda funktionerna globals() och locals() returnerar den aktuella globala respektive lokala namnrymden, som kan vara användbar att skicka runt för att användas som det andra och tredje argumentet till exec().

Anteckning

Standard locals fungerar enligt beskrivningen för funktionen locals() nedan. Skicka en explicit locals-ordbok om du vill se effekterna av koden på locals efter att funktionen exec() har returnerats.

Ändrad i version 3.11: Parametern closure har lagts till.

Ändrad i version 3.13: Argumenten globals och locals kan nu skickas som nyckelord.

Ändrad i version 3.13: Semantiken för standardnamnrymden locals har justerats enligt beskrivningen för locals()-byggstenen.

filter(function, iterable, /)¶

Konstruera en iterator från de element i iterable för vilka function är sann. iterable kan vara antingen en sekvens, en behållare som stöder iteration eller en iterator. Om function är None antas identitetsfunktionen, det vill säga alla element i iterable som är falska tas bort.

Observera att filter(function, iterable) är ekvivalent med generatoruttrycket (item for item in iterable if function(item)) om funktionen inte är None och (item for item in iterable if item) om funktionen är None.

Se itertools.filterfalse() för den kompletterande funktionen som returnerar element i iterable för vilka function är false.

class float(number=0.0, /)¶

class float(string, /)

Returnerar ett flyttal konstruerat från ett tal eller en sträng.

Exempel:

>>> float('+1.23')
1.23
>>> float('   -12345\n')
-12345.0
>>> float('1e-003')
0.001
>>> float('+1E6')
1000000.0
>>> float('-Infinity')
-inf

Om argumentet är en sträng ska den innehålla ett decimaltal, eventuellt föregånget av ett tecken och eventuellt inbäddat i blanksteg. Det valfria tecknet kan vara '+' eller '-'; ett '+'-tecken har ingen effekt på det värde som produceras. Argumentet kan också vara en sträng som representerar ett NaN (not-a-number), eller positiv eller negativ oändlighet. Mer exakt måste indata överensstämma med produktionsregeln floatvalue i följande grammatik, efter att inledande och avslutande blankstegstecken har tagits bort:

sign:          "+" | "-"
infinity:      "Infinity" | "inf"
nan:           "nan"
digit:         <a Unicode decimal digit, i.e. characters in Unicode general category Nd>
digitpart:     digit (["_"] digit)*
number:        [digitpart] "." digitpart | digitpart ["."]
exponent:      ("e" | "E") [sign] digitpart
floatnumber:   number [exponent]
absfloatvalue: floatnumber | infinity | nan
floatvalue:    [sign] absfloatvalue

Bokstavering har ingen betydelse, så till exempel ”inf”, ”Inf”, ”INFINITY” och ”iNfINity” är alla acceptabla stavningar för positiv oändlighet.

Annars, om argumentet är ett heltal eller ett flyttal, returneras ett flyttal med samma värde (inom Pythons flyttalsprecision). Om argumentet ligger utanför intervallet för en Python float, kommer ett OverflowError att uppstå.

För ett allmänt Python-objekt x delegerar float(x) till x.__float__(). Om __float__() inte är definierad faller den tillbaka till __index__().

Se även float.from_number() som endast accepterar ett numeriskt argument.

Om inget argument anges returneras 0.0.

Typen float beskrivs i Numeriska typer — int, float, complex.

Ändrad i version 3.6: Det är tillåtet att gruppera siffror med understrykningstecken som i kodbokstäver.

Ändrad i version 3.7: Parametern är nu endast positionsbestämd.

Ändrad i version 3.8: Faller tillbaka till __index__() om __float__() inte är definierad.

format(value, format_spec='', /)¶

Konverterar ett värde till en ”formaterad” representation, som styrs av format_spec. Tolkningen av format_spec beror på typen av value-argumentet; det finns dock en standardformateringssyntax som används av de flesta inbyggda typer: Formatspecifikation Mini-språk.

Standard format_spec är en tom sträng, vilket vanligtvis ger samma effekt som att anropa str(value).

Ett anrop till format(värde, format_spec) översätts till type(värde).__format__(värde, format_spec) vilket förbigår instansordboken vid sökning efter värdets __format__()-metod. Ett TypeError-undantag uppstår om metodsökningen når object och format_spec inte är tom, eller om antingen format_spec eller returvärdet inte är strängar.

Ändrad i version 3.4: object().__format__(format_spec) ger upphov till TypeError om format_spec inte är en tom sträng.

class frozenset(iterable=(), /)

Returnerar ett nytt frozenset-objekt, eventuellt med element hämtade från iterable. frozenset är en inbyggd klass. Se frozenset och Set-typer — set, frozenset för dokumentation om denna klass.

För andra behållare se de inbyggda klasserna set, list, tuple och dict, samt modulen collections.

getattr(object, name, /)¶
getattr(object, name, default, /): Returnerar värdet för det namngivna attributet för objekt. name måste vara en sträng. Om strängen är namnet på ett av objektets attribut, blir resultatet värdet på det attributet. Till exempel motsvarar getattr(x, 'foobar') x.foobar. Om det namngivna attributet inte finns, returneras default om det anges, annars AttributeError. name behöver inte vara en Python-identifierare (se setattr()).

Anteckning

Eftersom private name mangling sker vid kompilering måste man manuellt mangla ett privat attributs (attribut med två inledande understreck) namn för att kunna hämta det med getattr().

globals()¶: Returnerar den ordbok som implementerar den aktuella modulens namnrymd. För kod inom funktioner ställs detta in när funktionen definieras och förblir detsamma oavsett var funktionen anropas.

hasattr(object, name, /)¶: Argumenten är ett objekt och en sträng. Resultatet är True om strängen är namnet på ett av objektets attribut, False om inte. (Detta implementeras genom att anropa getattr(object, name) och se om det ger upphov till ett AttributeError eller inte)

hash(object, /)¶: Returnerar objektets hashvärde (om det har ett sådant). Hashvärden är heltal. De används för att snabbt jämföra nycklar i en ordbok under en ordboksuppslagning. Numeriska värden som jämförs lika har samma hashvärde (även om de är av olika typer, vilket är fallet för 1 och 1.0).

Anteckning

För objekt med anpassade __hash__()-metoder, observera att hash() trunkerar returvärdet baserat på bitbredden i värdmaskinen.

help()¶

help(request)

Anropar det inbyggda hjälpsystemet. (Denna funktion är avsedd för interaktiv användning.) Om inget argument anges, startas det interaktiva hjälpsystemet på tolkens konsol. Om argumentet är en sträng, söks strängen upp som namnet på en modul, funktion, klass, metod, nyckelord eller dokumentationsämne, och en hjälpsida skrivs ut på konsolen. Om argumentet är någon annan typ av objekt genereras en hjälpsida om objektet.

Observera att om ett snedstreck (/) visas i parameterlistan för en funktion vid anrop av help(), betyder det att parametrarna före snedstrecket är enbart positionella. För mer information, se FAQ-posten om endast positionella parametrar.

Denna funktion läggs till i den inbyggda namnrymden av modulen site.

Ändrad i version 3.4: Ändringar i pydoc och inspect innebär att de rapporterade signaturerna för anropbara filer nu är mer omfattande och konsekventa.

hex(integer, /)¶

Konvertera ett heltal till en hexadecimal sträng med små bokstäver och prefixet ”0x”. Om heltal inte är ett Python int-objekt måste det definiera en __index__`()-metod som returnerar ett heltal. Några exempel:

>>> hex(255)
'0xff'
>>> hex(-42)
'-0x2a'

Om du vill konvertera ett heltal till en hexadecimalsträng med versaler eller gemener, med eller utan prefix, kan du använda något av följande sätt:

>>> '%#x' % 255, '%x' % 255, '%X' % 255
('0xff', 'ff', 'FF')
>>> format(255, '#x'), format(255, 'x'), format(255, 'X')
('0xff', 'ff', 'FF')
>>> f'{255:#x}', f'{255:x}', f'{255:X}'
('0xff', 'ff', 'FF')

Se även format() för mer information.

Se även int() för konvertering av en hexadecimal sträng till ett heltal med bas 16.

Anteckning

För att få en hexadecimal strängrepresentation för en float, använd metoden float.hex().

id(object, /)¶

Returnerar ”identiteten” för ett objekt. Detta är ett heltal som garanterat är unikt och konstant för detta objekt under dess livstid. Två objekt med icke-överlappande livstider kan ha samma id()-värde.

Detta är adressen till objektet i minnet.

Utlöser en auditing event builtins.id med argumentet id.

input()¶

input(prompt, /)

Om argumentet prompt finns med skrivs det till standardutdata utan efterföljande ny rad. Funktionen läser sedan en rad från indata, konverterar den till en sträng (utan efterföljande ny rad) och returnerar den. När EOF läses ut, EOFError. Exempel:

>>> s = input('--> ')
--> Monty Python's Flying Circus
>>> s
"Monty Python's Flying Circus"

Om modulen readline laddades, kommer input() att använda den för att tillhandahålla detaljerade funktioner för radredigering och historik.

Utlöser en auditing event builtins.input med argumentet prompt innan inmatningen läses

Utlöser en auditing event builtins.input/result med resultatet efter att ha lyckats läsa inmatning.

class int(number=0, /)¶

class int(string, /, base=10)

Returnerar ett heltalsobjekt konstruerat från ett tal eller en sträng, eller returnerar 0 om inga argument anges.

Exempel:

>>> int(123.45)
123
>>> int('123')
123
>>> int('   -12_345\n')
-12345
>>> int('FACE', 16)
64206
>>> int('0xface', 0)
64206
>>> int('01110011', base=2)
115

Om argumentet definierar __int__(), returnerar int(x) x.__int__(). Om argumentet definierar __index__(), returnerar det x.__index__(). För flyttal trunkeras detta mot noll.

Om argumentet inte är ett tal eller om base anges, måste det vara en sträng, bytes eller bytearray-instans som representerar ett heltal i radix base. Eventuellt kan strängen föregås av + eller - (utan mellanslag), ha inledande nollor, omges av blanksteg och ha enkla understrykningar mellan siffrorna.

En bas-n heltalssträng innehåller siffror som var och en representerar ett värde från 0 till n-1. Värdena 0–9 kan representeras av vilken Unicode-decimalsiffra som helst. Värdena 10–35 kan representeras av a till z (eller A till Z). Standardvärdet för bas är 10. De tillåtna baserna är 0 och 2–36. Strängar i bas 2, 8 och 16 kan eventuellt prefixeras med 0b/0B, 0o/0O eller 0x/0X, precis som med heltalslitteraler i kod. För bas 0 tolkas strängen på ett liknande sätt som en integer literal i kod, i det att den faktiska basen är 2, 8, 10 eller 16 som bestäms av prefixet. Bas 0 tillåter inte heller ledande nollor: int('010', 0) är inte lagligt, medan int('010') och int('010', 8) är det.

Typen integer beskrivs i Numeriska typer — int, float, complex.

Ändrad i version 3.4: Om base inte är en instans av int och base-objektet har en metod base.__index__, anropas den metoden för att erhålla ett heltal för basen. Tidigare versioner använde base.__int__ istället för base.__index__.

Ändrad i version 3.6: Det är tillåtet att gruppera siffror med understrykningstecken som i kodbokstäver.

Ändrad i version 3.7: Den första parametern är nu endast positionsbestämd.

Ändrad i version 3.8: Faller tillbaka till __index__() om __int__() inte är definierad.

Ändrad i version 3.11: int-stränginmatningar och strängrepresentationer kan begränsas för att undvika överbelastningsattacker. Ett ValueError uppstår när gränsen överskrids vid konvertering av en sträng till en int eller när konvertering av en int till en sträng skulle överskrida gränsen. Se dokumentationen Längdsbegränsning för konvertering av heltalssträngar.

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

isinstance(object, classinfo, /)¶: Returnera True om argumentet object är en instans av argumentet classinfo eller av en (direct, indirect eller virtual) underklass därav. Om object inte är ett objekt av den angivna typen returnerar funktionen alltid False. Om classinfo är en tupel av typobjekt (eller rekursivt, andra sådana tupel) eller en Typ av fackförening av flera typer, returnera True om object är en instans av någon av typerna. Om classinfo inte är en typ eller tupel av typer och sådana tupler, genereras ett TypeError-undantag. TypeError får inte genereras för en ogiltig typ om en tidigare kontroll lyckas.

Ändrad i version 3.10: classinfo kan vara en Typ av fackförening.

issubclass(class, classinfo, /)¶: Returnera True om class är en underklass (direkt, indirekt eller virtual) av classinfo. En klass betraktas som en underklass av sig själv. classinfo kan vara en tupel av klassobjekt (eller rekursivt, andra sådana tupler) eller en Typ av fackförening, i vilket fall returnera True om class är en underklass till någon post i classinfo. I alla andra fall genereras ett TypeError-undantag.

Ändrad i version 3.10: classinfo kan vara en Typ av fackförening.

iter(iterable, /)¶

iter(callable, sentinel, /)

Returnera ett iterator-objekt. Det första argumentet tolkas mycket olika beroende på förekomsten av det andra argumentet. Utan ett andra argument måste det enda argumentet vara ett samlingsobjekt som stöder protokollet iterable (metoden __iter__()), eller så måste det stödja sekvensprotokollet (metoden __getitem__() med heltalargument som börjar på 0). Om det inte stöder något av dessa protokoll, genereras TypeError. Om det andra argumentet, sentinel, anges, måste det första argumentet vara ett anropbart objekt. Iteratorn som skapas i detta fall kommer att anropa callable utan argument för varje anrop till dess __next__()-metod; om det returnerade värdet är lika med sentinel kommer StopIteration att genereras, annars kommer värdet att returneras.

Se även Iterator-typer.

En användbar tillämpning av den andra formen av iter() är att bygga en blockläsare. Till exempel, läsa block med fast bredd från en binär databasfil tills slutet av filen nås:

from functools import partial
med open('mydata.db', 'rb') som f:
    for block in iter(partial(f.read, 64), b''):
        process_block(block)

len(object, /)¶: Returnerar längden (antalet poster) för ett objekt. Argumentet kan vara en sekvens (t.ex. en sträng, bytes, tuple, list eller range) eller en samling (t.ex. en dictionary, set eller frozen set).

len ger upphov till OverflowError på längder som är större än sys.maxsize, till exempel range(2 ** 100).

class list(iterable=(), /): I stället för att vara en funktion är list faktiskt en muterbar sekvenstyp, vilket dokumenteras i Listor och Sekvenstyper — list, tuple, range.

locals()¶

Returnerar ett mappningsobjekt som representerar den aktuella lokala symboltabellen, med variabelnamn som nycklar och deras aktuella bundna referenser som värden.

I modulomfång, samt vid användning av exec() eller eval() med en enda namnrymd, returnerar denna funktion samma namnrymd som globals().

I klassomfånget returnerar den namnrymden som kommer att skickas till metaklasskonstruktören.

När exec() eller eval() används med separata lokala och globala argument, returneras den lokala namnrymden som skickas till funktionsanropet.

I alla ovanstående fall kommer varje anrop till locals() i en viss exekveringsram att returnera samma mappningsobjekt. Ändringar som görs genom det mappningsobjekt som returneras från locals() kommer att synas som tilldelade, omtilldelade eller borttagna lokala variabler, och tilldelning, omtilldelning eller borttagning av lokala variabler kommer omedelbart att påverka innehållet i det returnerade mappningsobjektet.

I ett optimized scope (inklusive funktioner, generatorer och coroutines) returnerar varje anrop till locals() i stället en ny ordbok som innehåller de aktuella bindningarna för funktionens lokala variabler och eventuella icke-lokala cellreferenser. I det här fallet skrivs namnbindningsändringar som görs via den returnerade dict inte tillbaka till motsvarande lokala variabler eller icke-lokala cellreferenser, och tilldelning, omtilldelning eller borttagning av lokala variabler och icke-lokala cellreferenser påverkar inte innehållet i tidigare returnerade lexikon.

Att anropa locals() som en del av en förståelse i en funktion, generator eller coroutine är likvärdigt med att anropa den i det innehållande scopet, förutom att förståelsens initialiserade iterationsvariabler kommer att inkluderas. I andra scopes beter det sig som om förståelsen kördes som en nästlad funktion.

Att anropa locals() som en del av ett generatoruttryck är likvärdigt med att anropa det i en nästlad generatorfunktion.

Ändrad i version 3.12: Beteendet för locals() i en comprehension har uppdaterats enligt beskrivningen i PEP 709.

Ändrad i version 3.13: Som en del av PEP 667 definieras nu semantiken för att mutera de mappningsobjekt som returneras från denna funktion. Beteendet i optimized scopes är nu som beskrivet ovan. Bortsett från definitionen är beteendet i andra scopes oförändrat jämfört med tidigare versioner.

map(function, iterable, /, *iterables, strict=False)¶: Returnerar en iterator som tillämpar function på varje objekt i iterable, vilket ger resultatet. Om ytterligare iterables-argument skickas, måste function ta lika många argument och tillämpas på objekten från alla iterables parallellt. Med flera iterabler stannar iteratorn när den kortaste iterabeln är uttömd. Om strict är True och en av iteratorerna är uttömd före de andra, uppstår ett ValueError. För fall där funktionsingångarna redan är ordnade i argumenttuplar, se itertools.starmap().

Ändrad i version 3.14: Parametern strict har lagts till.

max(iterable, *, key=None)¶

max(iterable, *, default, key=None)

max(arg1, arg2, *args, key=None)

Returnerar det största objektet i en iterabel eller det största av två eller flera argument.

Om ett positionellt argument anges bör det vara en iterable. Det största objektet i iterabeln returneras. Om två eller flera positionsargument anges, returneras det största av positionsargumenten.

Det finns två valfria argument som endast innehåller nyckelord. Argumentet key anger en ordningsfunktion med ett argument, som den som används för list.sort(). Argumentet default anger ett objekt som ska returneras om den angivna iterabeln är tom. Om iterabeln är tom och default inte anges, uppstår ett ValueError.

Om flera objekt är maximala returnerar funktionen det första som påträffas. Detta är förenligt med andra verktyg som bevarar sorteringsstabiliteten, t.ex. sorted(iterable, key=keyfunc, reverse=True)[0] och heapq.nlargest(1, iterable, key=keyfunc).

Ändrad i version 3.4: Lagt till parametern default keyword-only.

Ändrad i version 3.8: Nyckeln kan vara Ingen.

class memoryview(object): Returnerar ett ”minnesvy”-objekt som skapats från det angivna argumentet. Se Minnesvy för mer information.

min(iterable, *, key=None)¶

min(iterable, *, default, key=None)

min(arg1, arg2, *args, key=None)

Returnerar det minsta objektet i en iterabel eller det minsta av två eller flera argument.

Om ett positionellt argument anges bör det vara en iterable. Det minsta objektet i iterabeln returneras. Om två eller flera positionsargument anges, returneras det minsta av positionsargumenten.

Det finns två valfria argument som endast innehåller nyckelord. Argumentet key anger en ordningsfunktion med ett argument, som den som används för list.sort(). Argumentet default anger ett objekt som ska returneras om den angivna iterabeln är tom. Om iterabeln är tom och default inte anges, uppstår ett ValueError.

Om flera objekt är minimala returnerar funktionen det första som påträffas. Detta är förenligt med andra verktyg som bevarar sorteringsstabiliteten, t.ex. sorted(iterable, key=keyfunc)[0] och heapq.nsmallest(1, iterable, key=keyfunc).

Ändrad i version 3.4: Lagt till parametern default keyword-only.

Ändrad i version 3.8: Nyckeln kan vara Ingen.

next(iterator, /)¶
next(iterator, default, /): Hämtar nästa objekt från iterator genom att anropa dess __next__()-metod. Om default anges returneras den om iteratorn är uttömd, annars aktiveras StopIteration.

class object¶: Detta är den ultimata basklassen för alla andra klasser. Den har metoder som är gemensamma för alla instanser av Python-klasser. När konstruktören anropas returnerar den ett nytt funktionslöst objekt. Konstruktören accepterar inga argument.

Anteckning

object-instanser har inte __dict__-attribut, så du kan inte tilldela godtyckliga attribut till en instans av object.

oct(integer, /)¶

Konvertera ett heltal till en oktal sträng med prefixet ”0o”. Resultatet är ett giltigt Python-uttryck. Om integer inte är ett Python int-objekt måste det definiera en __index__()-metod som returnerar ett heltal. Till exempel:

>>> oct(8)
'0o10'
>>> oct(-56)
'-0o70'

Om du vill konvertera ett heltal till en oktalsträng, antingen med prefixet ”0o” eller inte, kan du använda något av följande sätt.

>>> '%#o' % 10, '%o' % 10
('0o12', '12')
>>> format(10, '#o'), format(10, 'o')
('0o12', '12')
>>> f'{10:#o}', f'{10:o}'
('0o12', '12')

Se även format() för mer information.

open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)¶

Öppnar fil och returnerar ett motsvarande filobjekt. Om filen inte kan öppnas genereras ett OSError. Se Läsa och skriva filer för fler exempel på hur denna funktion kan användas.

file är ett path-like object som anger sökvägen (absolut eller relativt till den aktuella arbetskatalogen) för den fil som ska öppnas eller en heltalsfilbeskrivning för den fil som ska omslutas. (Om en filbeskrivare anges stängs den när det returnerade I/O-objektet stängs, såvida inte closefd är satt till False)

mode är en valfri sträng som anger i vilket läge filen ska öppnas. Standardvärdet är 'r', vilket innebär att filen öppnas för läsning i textläge. Andra vanliga värden är 'w' för att skriva (avkorta filen om den redan finns), 'x' för exklusivt skapande och 'a' för att lägga till (vilket på vissa Unix-system innebär att alla skrivningar läggs till i slutet av filen oavsett aktuell sökposition). I textläge, om encoding inte anges, är den kodning som används plattformsberoende: locale.getencoding() anropas för att hämta den aktuella locale-kodningen. (För läsning och skrivning av råbytes används binärt läge och encoding anges inte) De tillgängliga lägena är:

Tecken	Betydelse
`'r'`	öppen för läsning (standard)
`'w'`	öppna för skrivning, avkorta filen först
`'x'`	öppen för exklusiv skapelse, misslyckas om filen redan finns
`'a'`	öppen för skrivning, läggs till i slutet av filen om den finns
`'b'`	binärt läge
`'t'`	textläge (standard)
`'+'`	öppen för uppdatering (läsning och skrivning)

Standardläget är 'r' (öppen för läsning av text, en synonym till 'rt'). Lägena 'w+' och 'w+b' öppnar och trunkerar filen. Lägena 'r+' och 'r+b' öppnar filen utan trunkering.

Som nämndes i Översikt skiljer Python mellan binär och text I/O. Filer som öppnas i binärt läge (inklusive 'b' i mode-argumentet) returnerar innehållet som bytes-objekt utan någon avkodning. I textläge (standard, eller när 't' ingår i mode-argumentet) returneras filens innehåll som str, där bytena först har avkodats med en plattformsberoende kodning eller med den angivna kodningen om den anges.

Anteckning

Python är inte beroende av det underliggande operativsystemets uppfattning om textfiler; all bearbetning görs av Python självt och är därför plattformsoberoende.

buffering är ett valfritt heltal som används för att ställa in buffringspolicyn. Ange 0 för att stänga av buffring (endast tillåtet i binärt läge), 1 för att välja linjebuffring (endast användbart när du skriver i textläge) och ett heltal > 1 för att ange storleken i byte på en buffert med fast storlek. Observera att om du anger en buffertstorlek på det här sättet gäller det för binärt buffrad I/O, men TextIOWrapper (dvs. filer som öppnas med mode='r+') skulle ha en annan buffring. För att inaktivera buffring i TextIOWrapper, överväg att använda write_through flaggan för io.TextIOWrapper.reconfigure(). När inget buffering-argument anges fungerar standardpolicyn för buffring på följande sätt:

Binära filer buffras i bitar av fast storlek; storleken på bufferten är max(min(blocksize, 8 MiB), DEFAULT_BUFFER_SIZE) när enhetens blockstorlek är tillgänglig. På de flesta system är bufferten vanligtvis 128 kilobyte lång.
”Interaktiva” textfiler (filer för vilka isatty() returnerar True) använder radbuffring. Andra textfiler använder den policy som beskrivs ovan för binära filer.

encoding är namnet på den kodning som används för att avkoda eller koda filen. Detta bör endast användas i textläge. Standardkodningen är plattformsberoende (oavsett vad locale.getencoding() returnerar), men alla text encoding som stöds av Python kan användas. Se modulen codecs för en lista över kodningar som stöds.

errors är en valfri sträng som anger hur kodnings- och avkodningsfel ska hanteras - detta kan inte användas i binärt läge. En mängd olika standardfelhanterare finns tillgängliga (listade under Felhanterare), men alla felhanteringsnamn som har registrerats med codecs.register_error() är också giltiga. Standardnamnen inkluderar:

'strict' för att skapa ett ValueError undantag om det finns ett kodningsfel. Standardvärdet None har samma effekt.
'ignore' ignorerar fel. Observera att om du ignorerar kodningsfel kan det leda till dataförlust.
'replace' gör att en ersättningsmarkör (t.ex. '?') infogas där det finns felaktiga data.
'surrogateescape' kommer att representera alla felaktiga byte som låga surrogatkodsenheter från U+DC80 till U+DCFF. Dessa surrogatkodsenheter kommer sedan att omvandlas tillbaka till samma byte när felhanteraren surrogateescape används vid skrivning av data. Detta är användbart för att bearbeta filer i en okänd kodning.
'xmlcharrefreplace' stöds endast när du skriver till en fil. Tecken som inte stöds av kodningen ersätts med lämplig XML-teckenreferens &#nnn;.
'backslashreplace' ersätter missbildade data med Pythons bakåtstreckade escape-sekvenser.
'namereplace' (stöds också endast vid skrivning) ersätter tecken som inte stöds med N{...} escape-sekvenser.

newline bestämmer hur man analyserar nya radtecken från flödet. Det kan vara None, '', '\n', '\r' och '\r\n'. Det fungerar på följande sätt:

Om newline är None aktiveras universal newlines-läget när indata läses från strömmen. Rader i inmatningen kan sluta på '\n', '\r' eller '\r\n', och dessa översätts till '\n' innan de returneras till den som anropar. Om det är '' aktiveras universal newlines mode, men radavslut returneras till uppringaren oöversatta. Om det har något av de andra lagliga värdena avslutas inmatningsraderna endast med den angivna strängen, och radavslutningen returneras till den som ringer upp oöversatt.
Om newline är None när utdata skrivs till strömmen, översätts alla '\n'-tecken som skrivs till systemets standardradavgränsare, os.linesep. Om newline är '' eller '\n' sker ingen översättning. Om newline är något av de andra lagliga värdena översätts alla '\n'-tecken som skrivs till den angivna strängen.

Om closefd är False och en filbeskrivare istället för ett filnamn har angetts, kommer den underliggande filbeskrivaren att hållas öppen när filen stängs. Om ett filnamn anges måste closefd vara True (standard), annars kommer ett fel att uppstå.

En anpassad öppnare kan användas genom att skicka en anropsbar som opener. Den underliggande filbeskrivaren för filobjektet erhålls sedan genom att anropa opener med (file, flags). opener måste returnera en öppen filbeskrivare (att skicka os.open som opener resulterar i funktionalitet som liknar att skicka None).

Den nyskapade filen är icke-ärftlig.

I följande exempel används parametern dir_fd i funktionen os.open() för att öppna en fil i förhållande till en viss katalog:

>>> import os
>>> dir_fd = os.open('somedir', os.O_RDONLY)
>>> def opener(path, flags):
...     return os.open(path, flags, dir_fd=dir_fd)
...
>>> with open('spamspam.txt', 'w', opener=opener) as f:
...     print('This will be written to somedir/spamspam.txt', file=f)
...
>>> os.close(dir_fd)  # don't leak a file descriptor

Typen av file object som returneras av funktionen open() beror på läget. När open() används för att öppna en fil i textläge ('w', 'r', 'wt', 'rt', etc.) returneras en underklass av io.TextIOBase (specifikt io.TextIOWrapper). När den används för att öppna en fil i binärt läge med buffring är den returnerade klassen en underklass till io.BufferedIOBase. Den exakta klassen varierar: i binärt läsläge returneras en io.BufferedReader, i binärt skrivläge och binärt append-läge returneras en io.BufferedWriter och i läs-/skrivläge returneras en io.BufferedRandom. När buffringen är inaktiverad returneras råströmmen, en underklass till io.RawIOBase, io.FileIO.

Se även filhanteringsmodulerna, till exempel fileinput, io (där open() deklareras), os, os.path, tempfile och shutil.

Skapar en auditing event open med argumenten path, mode, flags.

Argumenten mode och flags kan ha ändrats eller härletts från det ursprungliga anropet.

Ändrad i version 3.3:

Parametern opener har lagts till.
Läget 'x' lades till.
IOError användes tidigare, nu är det ett alias för OSError.
FileExistsError visas nu om filen som öppnades i exklusivt skapande-läge ('x') redan existerar.

Ändrad i version 3.4:

Filen är nu inte ärftlig.

Ändrad i version 3.5:

Om systemanropet avbryts och signalhanteraren inte ger upphov till ett undantag, försöker funktionen nu göra om systemanropet istället för att ge upphov till ett InterruptedError-undantag (se PEP 475 för förklaringen).
Felhanteraren 'namereplace' har lagts till.

Ändrad i version 3.6:

Stöd har lagts till för att acceptera objekt som implementerar os.PathLike.
I Windows kan öppnandet av en konsolbuffert returnera en annan underklass av io.RawIOBase än io.FileIO.

Ändrad i version 3.11: Läget 'U har tagits bort.

ord(c)¶: Givet en sträng som representerar ett Unicode-tecken, returnerar ett heltal som representerar Unicode-kodpunkten för det tecknet. Till exempel, ord('a') returnerar heltalet 97 och ord('€') (Euro-tecken) returnerar 8364. Detta är inversen av chr().

pow(base, exp, mod=None)¶

Returnerar bas till potensen exp; om mod finns, returneras bas till potensen exp, modulo mod (beräknas effektivare än pow(bas, exp) % mod). Formen pow(base, exp) med två argument är likvärdig med att använda potensoperatorn: base**exp.

Argumenten måste vara av numerisk typ. Med blandade operandtyper gäller koercitionsreglerna för binära aritmetiska operatorer. För int-operander har resultatet samma typ som operanderna (efter coercion) om inte det andra argumentet är negativt; i så fall konverteras alla argument till float och ett float-resultat levereras. Till exempel ger pow(10, 2) 100, men pow(10, -2) ger 0,01. För en negativ bas av typen int eller float och en icke-integral exponent, levereras ett komplext resultat. Till exempel ger pow(-9, 0,5) ett värde nära 3j. För en negativ bas av typen int eller float med en integrerad exponent levereras däremot ett float-resultat. Till exempel, pow(-9, 2.0) returnerar 81.0.

För int-operanderna base och exp gäller att om mod förekommer måste mod också vara av heltalstyp och mod måste vara icke-noll. Om mod finns och exp är negativ, måste base vara relativt primtal till mod. I så fall returneras pow(inv_base, -exp, mod), där inv_base är en invers till base modulo mod.

Här är ett exempel på att beräkna en invers för 38 modulo 97:

>>> pow(38, -1, mod=97)
23
>>> 23 * 38 % 97 == 1
True

Ändrad i version 3.8: För int-operander tillåter nu treargumentformen av pow att det andra argumentet är negativt, vilket möjliggör beräkning av modulära inverser.

Ändrad i version 3.8: Tillåt nyckelordsargument. Tidigare stöddes endast positionella argument.

print(*objects, sep=' ', end='\n', file=None, flush=False)¶

Skriver ut objekt till textflödet file, separerade med sep och följda av end. sep, end, file och flush, om de finns, måste anges som nyckelordsargument.

Alla argument som inte är nyckelord konverteras till strängar som str() gör och skrivs till strömmen, separerade med sep och följda av end. Både sep och end måste vara strängar; de kan också vara None, vilket innebär att standardvärdena används. Om inga objekt anges kommer print() bara att skriva end.

Argumentet file måste vara ett objekt med en write(string)-metod; om det inte finns eller om det är None, kommer sys.stdout att användas. Eftersom utskrivna argument konverteras till textsträngar kan print() inte användas med filobjekt i binärt läge. För dessa används istället file.write(...).

Buffring av utdata bestäms vanligtvis av file. Men om flush är true, spolas strömmen med våld.

Ändrad i version 3.3: Lagt till nyckelordsargumentet flush.

class property(fget=None, fset=None, fdel=None, doc=None)¶

Returnerar ett egenskapsattribut.

fget är en funktion för att hämta ett attributvärde. fset är en funktion för att ställa in ett attributvärde. fdel är en funktion för att ta bort ett attributvärde. Och doc skapar en docstring för attributet.

En typisk användning är att definiera ett hanterat attribut x:

klass C:
    def __init__(self):
        self._x = Ingen

    def getx(self):
        returnera self._x

    def setx(self, värde):
        self._x = värde

    def delx(self):
        del self._x

    x = property(getx, setx, delx, "Jag är egenskapen 'x'.")

Om c är en instans av C, kommer c.x att anropa getter, c.x = value kommer att anropa setter och del c.x deleter.

Om den anges kommer doc att vara docstring för egenskapens attribut. Annars kommer egenskapen att kopiera fgets docstring (om den finns). Detta gör det möjligt att skapa skrivskyddade egenskaper enkelt genom att använda property() som en decorator:

klass Papegoja:
    def __init__(self):
        self._voltage = 100000

    @egenskap
    def voltage(self):
        """Hämta den aktuella spänningen."""
        returnera self._voltage

Dekoratorn @property förvandlar metoden voltage() till en ”getter” för ett skrivskyddat attribut med samma namn och sätter docstring för voltage till ”Get the current voltage”

@getter¶

@setter¶

@deleter¶

Ett egenskapsobjekt har metoderna getter, etter och deleter som kan användas som dekoratorer som skapar en kopia av egenskapen med motsvarande accessorfunktion inställd på den dekorerade funktionen. Detta förklaras bäst med ett exempel:

klass C:
    def __init__(self):
        self._x = Ingen

    @egenskap
    def x(self):
        """Jag är egenskapen 'x'."""
        returnera self._x

    @x.inställare
    def x(self, värde):
        self._x = värde

    @x.borttagare
    def x(self):
        del self._x

Denna kod är exakt likvärdig med det första exemplet. Var noga med att ge de ytterligare funktionerna samma namn som den ursprungliga egenskapen (x i det här fallet.)

Det returnerade egenskapsobjektet har också attributen fget, fset och fdel som motsvarar konstruktörens argument.

Ändrad i version 3.5: Dokumentationen av property-objekt är nu skrivbar.

__name__¶: Attribut som innehåller namnet på egenskapen. Namnet på egenskapen kan ändras vid körning.

Tillagd i version 3.13.

class range(stop)
class range(start, stop, step=1): I stället för att vara en funktion är range faktiskt en oföränderlig sekvenstyp, vilket dokumenteras i Intervaller och Sekvenstyper — list, tuple, range.

repr(object, /)¶

Returnerar en sträng som innehåller en utskriftsvänlig representation av ett objekt. För många typer försöker denna funktion returnera en sträng som skulle ge ett objekt med samma värde när den skickas till eval(); annars är representationen en sträng inom hakparenteser som innehåller namnet på objektets typ tillsammans med ytterligare information, ofta inklusive objektets namn och adress. En klass kan styra vad denna funktion returnerar för sina instanser genom att definiera en __repr__()-metod. Om sys.displayhook() inte är tillgänglig kommer denna funktion att ge upphov till RuntimeError.

Denna klass har en anpassad representation som kan utvärderas:

klass Person:
   def __init__(self, namn, ålder):
      self.name = namn
      self.age = ålder

   def __repr__(self):
      return f"Person('{self.name}', {self.age})"

reversed(object, /)¶: Returnera en omvänd iterator. Argumentet måste vara ett objekt som har en __reversed__()-metod eller stöder sekvensprotokollet (metoden __len__() och metoden __getitem__() med heltal som argument som börjar på 0).

round(number, ndigits=None)¶

Returnerar tal avrundat till siffrors precision efter decimaltecknet. Om ndigits utelämnas eller är None, returneras det närmaste heltalet till indata.

För de inbyggda typer som stöder round() avrundas värden till närmaste multipel av 10 i potens minus ndigits; om två multiplar är lika nära avrundas till det jämna valet (så till exempel är både round(0.5) och round(-0.5) 0, och round(1.5) är 2). Alla heltalsvärden är giltiga för siffror (positiva, noll eller negativa). Returvärdet är ett heltal om ndigits utelämnas eller None. I annat fall har returvärdet samma typ som number.

För ett allmänt Python-objekt number delegerar round till number.__round__.

Anteckning

Beteendet hos round() för flyttal kan vara överraskande: till exempel ger round(2,675, 2) 2,67 istället för det förväntade 2,68. Detta är inte en bugg: det är ett resultat av det faktum att de flesta decimalfraktioner inte kan representeras exakt som ett flyttal. Se Aritmetik med flyttal: problem och begränsningar för mer information.

class set(iterable=(), /)

Returnerar ett nytt set-objekt, eventuellt med element hämtade från iterable. set är en inbyggd klass. Se set och Set-typer — set, frozenset för dokumentation om denna klass.

För andra behållare se de inbyggda klasserna frozenset, list, tuple och dict, samt modulen collections.

setattr(object, name, value, /)¶

Detta är motsvarigheten till getattr(). Argumenten är ett objekt, en sträng och ett godtyckligt värde. Strängen kan namnge ett befintligt attribut eller ett nytt attribut. Funktionen tilldelar värdet till attributet, förutsatt att objektet tillåter det. Exempelvis är setattr(x, 'foobar', 123) likvärdigt med x.foobar = 123.

name behöver inte vara en Python-identifierare enligt definitionen i Namn (identifierare och nyckelord) om inte objektet väljer att tillämpa detta, t.ex. i en anpassad __getattribute__() eller via __slots__. Ett attribut vars namn inte är en identifierare kommer inte att vara tillgängligt med hjälp av punktnotationen, men är tillgängligt via getattr() etc.

Anteckning

Eftersom private name mangling sker vid kompilering måste man manuellt mangla ett privat attributs (attribut med två inledande understreck) namn för att kunna ställa in det med setattr().

class slice(stop, /)¶

class slice(start, stop, step=None, /)

Returnerar ett slice-objekt som representerar den uppsättning index som anges av range(start, stop, step). Argumenten start och step är som standard None.

Slice-objekt har skrivskyddade dataattribut start, stop och step som bara returnerar argumentvärdena (eller deras standardvärden). De har ingen annan explicit funktionalitet, men de används av NumPy och andra tredjepartspaket.

start¶

stop¶

step¶

Slice-objekt genereras också när syntaxen för utökad indexering används. Till exempel: a[start:stop:step] eller a[start:stop, i]. Se itertools.islice() för en alternativ version som returnerar en iterator.

Ändrad i version 3.12: Slice-objekt är nu hashable (förutsatt att start, stop och step är hashable).

sorted(iterable, /, *, key=None, reverse=False)¶

Returnerar en ny sorterad lista från objekten i iterable.

Har två valfria argument som måste anges som nyckelordsargument.

key anger en funktion med ett argument som används för att extrahera en jämförelsenyckel från varje element i iterable (t.ex. key=str.lower). Standardvärdet är None (jämför elementen direkt).

reverse är ett booleanskt värde. Om värdet är satt till True sorteras listelementen som om varje jämförelse vore omvänd.

Använd functools.cmp_to_key() för att konvertera en gammaldags cmp-funktion till en key-funktion.

Den inbyggda funktionen sorted() är garanterat stabil. En sortering är stabil om den garanterar att den inte ändrar den relativa ordningen för element som jämförs lika — detta är användbart för sortering i flera omgångar (t.ex. sortera efter avdelning, sedan efter lönegrad).

Sorteringsalgoritmen använder endast < jämförelser mellan objekt. Även om det räcker att definiera en __lt__()-metod för sortering, rekommenderar PEP 8 att alla sex rich comparisons implementeras. Detta hjälper till att undvika buggar när samma data används med andra sorteringsverktyg som max() som förlitar sig på en annan underliggande metod. Implementering av alla sex jämförelser hjälper också till att undvika förvirring för jämförelser av blandade typer som kan anropa reflekterade __gt__()-metoden.

För sorteringsexempel och en kort sorteringshandledning, se Sorteringstekniker.

@staticmethod¶

Omvandla en metod till en statisk metod.

En statisk metod får inte något implicit första argument. För att deklarera en statisk metod, använd detta idiom:

klass C:
    @statiskmetod
    def f(arg1, arg2, argN): ...

Formen @staticmethod är en funktion decorator – se Definitioner av funktioner för detaljer.

En statisk metod kan anropas antingen på klassen (t.ex. C.f()) eller på en instans (t.ex. C().f()). Dessutom är den statiska metoden descriptor också anropsbar, så den kan användas i klassdefinitionen (t.ex. f()).

Statiska metoder i Python liknar dem som finns i Java eller C++. Se även classmethod() för en variant som är användbar för att skapa alternativa klasskonstruktörer.

Som alla dekoratorer är det också möjligt att anropa staticmethod som en vanlig funktion och göra något med dess resultat. Detta behövs i vissa fall där du behöver en referens till en funktion från en klass och du vill undvika den automatiska omvandlingen till instansmetod. För dessa fall, använd detta idiom:

def vanlig_funktion():
    ...

klass C:
    method = staticmethod(regular_function)

För mer information om statiska metoder, se Standardtypens hierarki.

Ändrad i version 3.10: Statiska metoder ärver nu metodattributen (__module__, __name__, __qualname__, __doc__ och __annotations__), har ett nytt attribut __wrapped__ och kan nu anropas som vanliga funktioner.

class str(*, encoding='utf-8', errors='strict')

class str(object)

class str(object, encoding, errors='strict')

class str(object, *, errors)

Returnerar en str-version av object. Se str() för detaljer.

str är den inbyggda strängen class. För allmän information om strängar, se Textsekvenstyp — str.

sum(iterable, /, start=0)¶

Summerar start och posterna i en iterabel från vänster till höger och returnerar totalsumman. Posterna i iterabeln är normalt tal och startvärdet får inte vara en sträng.

För vissa användningsfall finns det bra alternativ till sum(). Det föredragna, snabba sättet att sammanfoga en sekvens av strängar är genom att anropa ''.join(sequence). För att lägga till flyttalsvärden med utökad precision, se math.fsum(). För att konkatenera en serie iterabler, överväg att använda itertools.chain().

Ändrad i version 3.8: Parametern start kan anges som ett nyckelordsargument.

Ändrad i version 3.12: Summering av flyttal har bytts till en algoritm som ger högre noggrannhet och bättre kommutativitet på de flesta byggen.

Ändrad i version 3.14: Lagt till specialisering för summering av komplex, med samma algoritm som för summering av flyttal.

class super¶

class super(type, object_or_type=None, /)

Returnerar ett proxyobjekt som delegerar metodanrop till en överordnad eller syskonklass av typ. Detta är användbart för att komma åt ärvda metoder som har åsidosatts i en klass.

Object_or_type bestämmer vilken method resolution order som ska sökas. Sökningen börjar från klassen direkt efter typ.

Till exempel, om __mro__ av object_or_type är D -> B -> C -> A -> object och värdet av type är B, då söker super() C -> A -> object.

Attributet __mro__ i den klass som motsvarar object_or_type listar den sökordning för metodupplösning som används av både getattr() och super(). Attributet är dynamiskt och kan ändras när arvshierarkin uppdateras.

Om det andra argumentet utelämnas är det superobjekt som returneras obundet. Om det andra argumentet är ett objekt måste isinstance(obj, type) vara true. Om det andra argumentet är en typ måste issubclass(type2, type) vara true (detta är användbart för classmethods).

Vid anrop direkt inom en vanlig metod i en klass kan båda argumenten utelämnas (”zero-argument super()”). I detta fall kommer type att vara den inneslutande klassen och obj kommer att vara det första argumentet i den omedelbart inneslutande funktionen (vanligtvis self). (Detta innebär att nollargumentet super() inte fungerar som förväntat inom nästlade funktioner, inklusive generatoruttryck, som implicit skapar nästlade funktioner)

Det finns två typiska användningsområden för super. I en klasshierarki med enkel nedärvning kan super användas för att hänvisa till överordnade klasser utan att namnge dem explicit, vilket gör koden mer lätthanterlig. Denna användning är nära parallell med användningen av super i andra programmeringsspråk.

Det andra användningsfallet är att stödja kooperativ multipel nedärvning i en dynamisk exekveringsmiljö. Detta användningsfall är unikt för Python och finns inte i statiskt kompilerade språk eller språk som bara stöder enkel arvbarhet. Detta gör det möjligt att implementera ”diamantdiagram” där flera basklasser implementerar samma metod. God design kräver att sådana implementationer har samma anropssignatur i samtliga fall (eftersom anropsordningen bestäms vid körning, eftersom denna ordning anpassas till förändringar i klasshierarkin och eftersom denna ordning kan omfatta syskonklasser som är okända före körning).

För båda användningsfallen ser ett typiskt superklassanrop ut så här:

klass C(B):
    def method(self, arg):
        super().method(arg) # Detta gör samma sak som:
                               # super(C, self).method(arg)

Förutom metoduppslagningar fungerar super() också för attributuppslagningar. Ett möjligt användningsfall för detta är att anropa descriptors i en överordnad eller syskonklass.

Observera att super() implementeras som en del av bindningsprocessen för uttryckliga prickade attributuppslagningar som super().__getitem__(name). Den gör detta genom att implementera sin egen __getattribute__()-metod för att söka klasser i en förutsägbar ordning som stöder kooperativ multipel nedärvning. Följaktligen är super() odefinierad för implicita uppslagningar med satser eller operatorer som super()[name].

Observera också att super(), bortsett från formen med noll argument, inte är begränsad till att användas inuti metoder. Formen med två argument specificerar argumenten exakt och gör lämpliga referenser. Formen med nollargument fungerar bara inuti en klassdefinition, eftersom kompilatorn fyller i de nödvändiga detaljerna för att korrekt hämta den klass som definieras, samt för att komma åt den aktuella instansen för vanliga metoder.

För praktiska förslag på hur man utformar kooperativa klasser med hjälp av super(), se guide to using super().

Ändrad i version 3.14: super-objekt är nu pickleable och copyable.

class tuple(iterable=(), /): I stället för att vara en funktion är tuple faktiskt en oföränderlig sekvenstyp, vilket dokumenteras i Tupler och Sekvenstyper — list, tuple, range.

class type(object, /)¶

class type(name, bases, dict, /, **kwargs)

Returnerar typen av ett objekt med ett argument. Returvärdet är ett typobjekt och i allmänhet samma objekt som returneras av object.__class__.

Den inbyggda funktionen isinstance() rekommenderas för att testa typen av ett objekt, eftersom den tar hänsyn till underklasser.

Med tre argument, returnerar ett nytt typobjekt. Detta är i huvudsak en dynamisk form av class-satsen. Strängen name är klassnamnet och blir attributet __name__. Tupeln bases innehåller basklasserna och blir attributet __bases__; om den är tom läggs object, den yttersta basen för alla klasser, till. Dictionariet dict innehåller attribut- och metoddefinitioner för klassens kropp; det kan kopieras eller omslutas innan det blir attributet __dict__. Följande två satser skapar identiska type-objekt:

>>> class X:
...     a = 1
...
>>> X = type('X', (), dict(a=1))

Se även nedan:

Nyckelordsargument som anges i formuläret med tre argument skickas till lämplig metaklassmekanism (vanligtvis __init_subclass__()) på samma sätt som nyckelord i en klassdefinition (förutom metaklass).

Se även Anpassa skapandet av klasser.

Ändrad i version 3.6: Underklasser till type som inte åsidosätter type.__new__ får inte längre använda ett-argument-formuläret för att få fram typen av ett objekt.

vars()¶

vars(object, /)

Returnerar attributet __dict__ för en modul, klass, instans eller något annat objekt med attributet __dict__.

Objekt som moduler och instanser har ett uppdaterbart attribut __dict__, men andra objekt kan ha skrivbegränsningar på sina attribut __dict__ (klasser använder t.ex. en types.MappingProxyType för att förhindra direkta uppdateringar av ordlistan).

Utan ett argument fungerar vars() som locals().

Ett undantag av typen TypeError uppstår om ett objekt anges men det inte har något attribut __dict__ (t.ex. om dess klass definierar attributet __slots__).

Ändrad i version 3.13: Resultatet av att anropa denna funktion utan ett argument har uppdaterats enligt beskrivningen för locals() builtin.

zip(*iterables, strict=False)¶

Iterera över flera iterabler parallellt och producera tuples med ett objekt från var och en.

Exempel:

>>> for item in zip([1, 2, 3], ['sugar', 'spice', 'everything nice']):
...     print(item)
...
(1, 'sugar')
(2, 'spice')
(3, 'everything nice')

Mer formellt: zip() returnerar en iterator av tupler, där den i:e tupeln innehåller det i:e elementet från var och en av argumentets iterabler.

Ett annat sätt att tänka på zip() är att den förvandlar rader till kolumner och kolumner till rader. Detta liknar transponering av en matris.

zip() är lat: Elementen kommer inte att bearbetas förrän iterabeln itereras, t.ex. genom en for-loop eller genom att packas in i en list.

En sak att tänka på är att de iterabler som skickas till zip() kan ha olika längd; ibland på grund av design, och ibland på grund av en bugg i koden som förberedde dessa iterabler. Python erbjuder tre olika sätt att hantera detta problem:

Som standard stoppar zip() när den kortaste iterabeln är uttömd. Den ignorerar de återstående objekten i de längre iterationerna och skär av resultatet till längden på den kortaste iterationen:
```
>>> list(zip(range(3), ['fee', 'fi', 'fo', 'fum']))
[(0, 'fee'), (1, 'fi'), (2, 'fo')]
```
zip() används ofta i fall där iterablerna antas vara lika långa. I sådana fall rekommenderas det att använda alternativet strict=True. Dess utdata är samma som vanliga zip():
```
>>> list(zip(('a', 'b', 'c'), (1, 2, 3), strict=True))
[('a', 1), ('b', 2), ('c', 3)]
```
Till skillnad från standardbeteendet ger det upphov till ett ValueError om en iterabel är uttömd före de andra:
```
>>> for item in zip(range(3), ['fee', 'fi', 'fo', 'fum'], strict=True):
...     print(item)
...
(0, 'fee')
(1, 'fi')
(2, 'fo')
Traceback (most recent call last):
  ...
ValueError: zip() argument 2 is longer than argument 1
```
Utan argumentet strict=True kommer alla buggar som resulterar i iterabler av olika längd att tystas ner och eventuellt manifesteras som en svårfunnen bugg i en annan del av programmet.
Kortare iterabler kan fyllas på med ett konstant värde så att alla iterabler blir lika långa. Detta görs med itertools.zip_longest().

Gränsfall: Med ett enda iterabelt argument returnerar zip() en iterator av 1-tupler. Utan argument returnerar den en tom iterator.

Tips och tricks:

Utvärderingsordningen från vänster till höger för iterablerna är garanterad. Detta möjliggör ett idiom för att klustra en dataserie i grupper med n längder med hjälp av zip(*[iter(s)]*n, strict=True). Detta upprepar samma iterator n gånger så att varje utmatad tupel har resultatet av n anrop till iteratorn. Detta har effekten att inmatningen delas upp i n-långa bitar.

zip() i kombination med operatorn * kan användas för att packa upp en lista:

>>> x = [1, 2, 3]
>>> y = [4, 5, 6]
>>> list(zip(x, y))
[(1, 4), (2, 5), (3, 6)]
>>> x2, y2 = zip(*zip(x, y))
>>> x == list(x2) and y == list(y2)
True

Ändrad i version 3.10: Lagt till argumentet strict.

__import__(name, globals=None, locals=None, fromlist=(), level=0)¶

Anteckning

Detta är en avancerad funktion som inte behövs i vardaglig Python-programmering, till skillnad från importlib.import_module().

Denna funktion anropas av import-satsen. Den kan ersättas (genom att importera builtins-modulen och tilldela den builtins.__import__) för att ändra semantiken i import-satsen, men att göra det är starkt avrått eftersom det vanligtvis är enklare att använda import-hooks (se PEP 302) för att uppnå samma mål och inte orsakar problem med kod som antar att standardimplementeringen av import används. Direkt användning av __import__() avråds också till förmån för importlib.import_module().

Funktionen importerar modulen name, eventuellt med hjälp av de angivna globals och locals för att avgöra hur namnet ska tolkas i en paketkontext. fromlist anger namnen på de objekt eller undermoduler som ska importeras från den modul som anges med name. Standardimplementeringen använder inte locals-argumentet alls och använder globals endast för att bestämma paketkontexten för import-satsen.

level anger om absolut eller relativ import ska användas. 0 (standard) innebär att endast absolut import utförs. Positiva värden för level anger antalet överordnade kataloger som ska sökas i förhållande till katalogen för den modul som anropar __import__() (se PEP 328 för detaljer).

När variabeln name är av formen package.module returneras normalt paketet på högsta nivån (namnet fram till första punkten), inte den modul som namnges av name. Men när ett icke-tomt fromlist-argument anges, returneras den modul som namnges av name.

Till exempel resulterar uttalandet import spam i bytekod som liknar följande kod:

spam = __import__('spam', globals(), locals(), [], 0)

Satsen import spam.ham resulterar i detta anrop:

spam = __import__('spam.ham', globals(), locals(), [], 0)

Observera att __import__() returnerar toplevel-modulen här, eftersom det är det objekt som är bundet till ett namn av import-satsen.

Å andra sidan resulterar uttalandet from spam.ham import eggs, sausage as saus i

_temp = __import__('spam.ham', globals(), locals(), ['eggs', 'sausage'], 0)
ägg = _temp.ägg
korv = _temp.korv

Här returneras modulen spam.ham från __import__(). Från detta objekt hämtas de namn som ska importeras och tilldelas sina respektive namn.

Om du bara vill importera en modul (eventuellt inom ett paket) med namn, använd importlib.import_module().

Ändrad i version 3.3: Negativa värden för level stöds inte längre (vilket också innebär att standardvärdet ändras till 0).

Ändrad i version 3.9: När kommandoradsalternativen -E eller -I används, ignoreras nu miljövariabeln PYTHONCASEOK.

Fotnoter

Inbyggda funktioner¶

Föregående ämne

Nästa ämne

Denna sidan