Inbyggda typer¶

I följande avsnitt beskrivs de standardtyper som finns inbyggda i tolken.

De viktigaste inbyggda typerna är numeriska, sekvenser, mappningar, klasser, instanser och undantag.

Vissa samlingsklasser är mutabla. De metoder som lägger till, subtraherar eller omorganiserar sina medlemmar på plats, och inte returnerar ett specifikt objekt, returnerar aldrig själva samlingsinstansen utan None.

Vissa operationer stöds av flera objekttyper; i synnerhet kan praktiskt taget alla objekt jämföras med avseende på likhet, testas för sanningsvärde och konverteras till en sträng (med funktionen repr() eller den något annorlunda funktionen str()). Den senare funktionen används implicit när ett objekt skrivs ut med funktionen print().

Test av sanning och värde¶

Alla objekt kan testas för sanningsvärde, för användning i ett if eller while villkor eller som operand i de booleska operationerna nedan.

Som standard anses ett objekt vara sant om inte dess klass definierar antingen en __bool__()-metod som returnerar False eller en __len__()-metod som returnerar noll, när den anropas med objektet. [1] Här är de flesta av de inbyggda objekt som anses vara falska:

konstanter som definieras som falska: None och False
noll av valfri numerisk typ: 0, 0.0, 0j, Decimal(0), Fraktion(0, 1)
tomma sekvenser och samlingar: '', (), [], {}, set(), range(0)

Operationer och inbyggda funktioner som har ett booleskt resultat returnerar alltid 0 eller False för false och 1 eller True för true, om inget annat anges. (Viktigt undantag: de booleska operationerna eller och och returnerar alltid en av sina operander)

Booleska operationer — `and`, `or`, `not`¶

Dessa är de booleska operationerna, ordnade efter stigande prioritet:

Operation	Resultat	Anteckningar
`x eller y`	om x är sant, då x, annars y	(1)
`x och y`	om x är falskt, då x, annars y	(2)
`inte x`	om x är falskt, då `True`, annars `False`	(3)

Anteckningar:

Detta är en kortslutningsoperator, vilket innebär att den bara utvärderar det andra argumentet om det första är falskt.
Detta är en kortslutningsoperator, vilket innebär att den bara utvärderar det andra argumentet om det första är sant.
not har lägre prioritet än icke booleska operatorer, så not a == b tolkas som not (a == b), och a == not b är ett syntaxfel.

Jämförelser¶

Det finns åtta jämförelseoperationer i Python. De har alla samma prioritet (som är högre än den för de booleska operationerna). Jämförelser kan kedjas godtyckligt; till exempel är x < y <= z ekvivalent med x < y och y <= z, förutom att y bara utvärderas en gång (men i båda fallen utvärderas z inte alls när x < y visar sig vara falskt).

I denna tabell sammanfattas jämförelseoperationerna:

Operation	Betydelse
`<`	strikt mindre än
`<=`	mindre än eller lika med
`>`	strikt större än
`>=`	större än eller lika med
`==`	lika
`!=`	är inte lika med
`är`	objektets identitet
`är inte`	förnekad objektsidentitet

Objekt av olika typer, utom olika numeriska typer, jämför aldrig lika. Operatorn == är alltid definierad men för vissa objekttyper (t.ex. klassobjekt) är den ekvivalent med is. Operatorerna <, <=, > och >= definieras endast där de är meningsfulla; till exempel ger de upphov till ett TypeError-undantag när ett av argumenten är ett komplext tal.

Icke-identiska instanser av en klass jämförs normalt som icke-jämlika om inte klassen definierar metoden __eq__().

Instanser av en klass kan inte ordnas med avseende på andra instanser av samma klass eller andra typer av objekt, såvida inte klassen definierar tillräckligt många av metoderna __lt__(), __le__(), __gt__(), och __ge__() (i allmänhet räcker det med __lt__() och __eq__(), om man vill ha de konventionella betydelserna av jämförelseoperatorerna).

Beteendet hos operatorerna is och is not kan inte anpassas; de kan också tillämpas på två valfria objekt och aldrig ge upphov till ett undantag.

Ytterligare två operationer med samma syntaktiska prioritet, in och not in, stöds av typer som är iterable eller implementerar metoden __contains__().

Numeriska typer — `int`, `float`, `complex`¶

Det finns tre olika numeriska typer: integrer, flytande tal och komplexa tal. Dessutom är booleaner en subtyp av heltal. Heltal har obegränsad precision. Flyttal implementeras vanligtvis med double i C; information om precisionen och den interna representationen av flyttal för den maskin som ditt program körs på finns i sys.float_info. Komplexa tal har en reell del och en imaginär del, som var och en är ett flyttal. För att extrahera dessa delar från ett komplext tal z, använd z.real och z.imag. (Standardbiblioteket innehåller de ytterligare numeriska typerna fractions.Fraction, för rationella tal, och decimal.Decimal, för flyttal med precision som kan definieras av användaren)

Tal skapas av numeriska literaler eller som resultat av inbyggda funktioner och operatorer. Heltalslitteraler utan utsmyckning (inklusive hex-, oktal- och binära tal) ger heltal. Numeriska literaler som innehåller en decimalpunkt eller ett exponenttecken ger flyttal. Om du lägger till 'j' eller 'J' till en numerisk literal får du ett imaginärt tal (ett komplext tal med en reell del på noll) som du kan lägga till ett heltal eller en float för att få ett komplext tal med en reell och en imaginär del.

Konstruktörerna int(), float() och complex() kan användas för att producera tal av en viss typ.

Python har fullt stöd för blandad aritmetik: när en binär aritmetisk operator har operander av olika numeriska typer, breddas operanden med den ”smalare” typen till den andra, där heltal är smalare än flyttal. Aritmetik med komplexa och reella operander definieras av den vanliga matematiska formeln, till exempel:

x + komplex(u, v) = komplex(x + u, v)
x * komplex(u, v) = komplex(x * u, x * v)

En jämförelse mellan tal av olika typer beter sig som om det var de exakta värdena för dessa tal som jämfördes. [2]

Alla numeriska typer (utom komplexa) stöder följande operationer (för prioriteringar av operationerna, se Operatorens företräde):

Operation	Resultat	Anteckningar	Fullständig dokumentation
`x + y`	summan av x och y
`x - y`	skillnaden mellan x och y
`x * y`	produkten av x och y
`x / y`	kvot av x och y
`x // y`	golvad kvot av x och y	(1)(2)
`x % y`	återstoden av `x / y`	(2)
`-x`	x negerad
`+x`	x oförändrad
`abs(x)`	absolut värde eller magnitud av x		`abs()`
`int(x)`	x omvandlad till heltal	(3)(6)	`int()`
`flata(x)`	x omvandlad till flyttal	(4)(6)	`flöde()`
`komplex(re, im)`	ett komplext tal med realdel re, imaginärdel im. im är som standard noll.	(6)	`komplex()`
`c.conjugate()`	konjugat av det komplexa talet c
`divmod(x, y)`	paret `(x // y, x % y)`	(2)	`divmod()`
`pow(x, y)`	x till potensen y	(5)	`pow()`
`x ** y`	x till potensen y	(5)

Anteckningar:

Kallas även heltalsdivision. För operander av typen int har resultatet typen int. För operander av typen float har resultatet typen float. I allmänhet är resultatet ett helt heltal, även om resultatets typ inte nödvändigtvis är int. Resultatet är alltid avrundat mot minus oändligheten: 1//2 är 0, (-1)//2 är -1, 1//(-2) är -1 och (-1)//(-2) är 0.
Inte för komplexa tal. Konvertera istället till flyttal med abs() om det är lämpligt.
Konvertering från float till int trunkerar och kastar bort bråkdelen. Se funktionerna math.floor() och math.ceil() för alternativa omvandlingar.
float accepterar också strängarna ”nan” och ”inf” med ett valfritt prefix ”+” eller ”-” för Not a Number (NaN) och positiv eller negativ oändlighet.
Python definierar pow(0, 0) och 0 ** 0 som 1, vilket är vanligt för programmeringsspråk.
De numeriska literaler som accepteras inkluderar siffrorna 0 till 9 eller någon Unicode-ekvivalent (kodpunkter med egenskapen Nd).

Se the Unicode Standard för en fullständig lista över kodpunkter med egenskapen Nd.

Alla numbers.Real-typer (int och float) innehåller också följande operationer:

Operation	Resultat
`math.trunc(x)`	x trunkerad till `Integral`
`round(x[, n])`	x avrundat till n siffror, avrundning hälften till jämnt. Om n utelämnas är standardvärdet 0.
`math.floor(x)`	den största `Integral` <= x
`math.ceil(x)`	den minsta `Integral` >= x

För ytterligare numeriska operationer, se modulerna math och cmath.

Bitvisa operationer på heltalstyper¶

Bitvisa operationer är bara meningsfulla för heltal. Resultatet av bitvisa operationer beräknas som om de utförts i tvåkomplement med ett oändligt antal teckenbitar.

Prioriteringarna för de binära bitvisa operationerna är alla lägre än de numeriska operationerna och högre än jämförelserna; den unära operationen ~ har samma prioritet som de andra unära numeriska operationerna (+ och -).

I denna tabell listas de bitvisa operationerna sorterade i stigande prioritetsordning:

Operation	Resultat	Anteckningar
`x \| y`	bitvis or av x och y	(4)
`x ^ y`	bitvis exklusivt eller av x och y	(4)
`x & y`	bitvis och av x och y	(4)
`x << n`	x vänsterförskjutet med n bitar	(1)(2)
`x >> n`	x högerförskjutet med n bitar	(1)(3)
`~x`	bitarna i x inverterade

Anteckningar:

Negativa skifträkningar är olagliga och orsakar ett ValueError.
En vänsterförskjutning med n bitar är likvärdig med multiplikation med pow(2, n).
En högerförskjutning med n bitar motsvarar en vågdivision med pow(2, n).
Att utföra dessa beräkningar med minst en extra teckenförlängningsbit i en ändlig tvåkomplementrepresentation (en fungerande bitbredd på 1 + max(x.bit_length(), y.bit_length()) eller mer) är tillräckligt för att få samma resultat som om det fanns ett oändligt antal teckenbitar.

Ytterligare metoder för heltalstyper¶

Typen int implementerar numbers.Integral abstrakt basklass. Dessutom tillhandahåller den några fler metoder:

int.bit_length()¶

Returnerar det antal bitar som krävs för att representera ett heltal i binär form, exklusive tecken och inledande nollor:

>>> n = -37
>>> bin(n)
'-0b100101'
>>> n.bit_length()
6

Närmare bestämt, om x inte är noll, så är x.bit_length() det unika positiva heltalet k så att 2**(k-1) <= abs(x) < 2**k. På motsvarande sätt gäller att när abs(x) är tillräckligt litet för att ha en korrekt avrundad logaritm, så är k = 1 + int(log(abs(x), 2)). Om x är noll, så returnerar x.bit_length() 0.

Motsvarar:

def bit_längd(self):
    s = bin(self) # binär representation: bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # ta bort ledande nollor och minustecken
    return len(s) # len('100101') --> 6

Tillagd i version 3.1.

int.bit_count()¶

Returnerar antalet ettor i den binära representationen av heltalets absoluta värde. Detta är också känt som populationsantalet. Exempel:

>>> n = 19
>>> bin(n)
'0b10011'
>>> n.bit_count()
3
>>> (-n).bit_count()
3

Motsvarar:

def bit_count(self):
    return bin(self).count("1")

Tillagd i version 3.10.

int.to_bytes(length=1, byteorder='big', *, signed=False)¶

Returnerar en array av bytes som representerar ett heltal.

>>> (1024).to_bytes(2, byteorder='big')
b'\x04\x00'
>>> (1024).to_bytes(10, byteorder='big')
b'\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00'
>>> (-1024).to_bytes(10, byteorder='big', signed=True)
b'\xff\xff\xff\xff\xff\xff\xff\xff\xfc\x00'
>>> x = 1000
>>> x.to_bytes((x.bit_length() + 7) // 8, byteorder='little')
b'\xe8\x03'

Heltalet representeras med längd byte och standardvärdet är 1. Ett OverflowError uppstår om heltalet inte kan representeras med det givna antalet byte.

Argumentet byteorder bestämmer den byteordning som används för att representera heltalet, och standardvärdet är "big". Om byteorder är "big" ligger den mest signifikanta byten i början av bytearrayen. Om byteorder är "little" ligger den mest signifikanta byten i slutet av bytearrayen.

Argumentet signed avgör om tvåkomplement används för att representera heltalet. Om signed är False och ett negativt heltal anges, uppstår ett OverflowError. Standardvärdet för signed är False.

Standardvärdena kan användas för att enkelt omvandla ett heltal till ett objekt med en byte:

>>> (65).to_bytes()
b'A'

När du använder standardargumenten ska du dock inte försöka konvertera ett värde som är större än 255, för då får du ett OverflowError.

Motsvarar:

def to_bytes(n, length=1, byteorder='big', signed=False):
    om byteorder == 'liten':
        order = intervall(längd)
    elif byteorder == 'stor':
        ordning = omvänd(intervall(längd))
    else:
        raise ValueError("byteorder måste vara antingen 'liten' eller 'stor'")

    return bytes((n >> i*8) & 0xff for i in order)

Tillagd i version 3.2.

Ändrad i version 3.11: Lagt till standardargumentvärden för length och byteorder.

classmethod int.from_bytes(bytes, byteorder='big', *, signed=False)¶

Returnerar det heltal som representeras av den givna arrayen av bytes.

>>> int.from_bytes(b'\x00\x10', byteorder='big')
16
>>> int.from_bytes(b'\x00\x10', byteorder='little')
4096
>>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=True)
-1024
>>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=False)
64512
>>> int.from_bytes([255, 0, 0], byteorder='big')
16711680

Argumentet bytes måste antingen vara ett bytesliknande objekt eller en iterabel som producerar bytes.

Argumentet byteorder bestämmer den byteordning som används för att representera heltalet, och standardvärdet är "big". Om byteorder är "big" ligger den mest signifikanta byten i början av bytearrayen. Om byteorder är "little" ligger den mest betydelsefulla byten i slutet av bytearrayen. Om du vill begära värdsystemets inbyggda byteordning använder du sys.byteorder som värde för byteordningen.

Argumentet signed anger om tvåkomplement ska användas för att representera heltalet.

Motsvarar:

def from_bytes(bytes, byteorder='big', signed=False):
    if byteorder == 'little':
        little_ordered = list(byte)
    elif byteorder == 'big':
        little_ordered = list(reversed(bytes))
    else:
        raise ValueError("byteorder måste vara antingen 'liten' eller 'stor'")

    n = sum(b << i*8 for i, b in enumerate(little_ordered))
    om signerad och little_ordered och (little_ordered[-1] & 0x80):
        n -= 1 << 8*len(little_ordered)

    returnera n

Tillagd i version 3.2.

Ändrad i version 3.11: Lagt till standardargumentvärde för byteorder.

int.as_integer_ratio()¶: Returnerar ett par heltal vars kvot är lika med det ursprungliga heltalet och har en positiv nämnare. Heltalsförhållandet mellan heltal (hela tal) är alltid heltalet i täljaren och 1 i nämnaren.

Tillagd i version 3.8.

int.is_integer()¶: Returnerar True. Existerar för kompatibilitet med float.is_integer().

Tillagd i version 3.12.

Ytterligare metoder på Float¶

Typen float implementerar numbers.Real abstrakt basklass. float har också följande ytterligare metoder.

classmethod float.from_number(x)¶

Klassmetod för att returnera ett flyttal konstruerat från ett tal x.

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-flottör, kommer ett OverflowError att uppstå.

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

Tillagd i version 3.14.

float.as_integer_ratio()¶: Returnerar ett par heltal vars kvot är exakt lika med den ursprungliga floaten. Kvoten är i lägsta termer och har en positiv nämnare. Utlöser OverflowError på oändligheter och ett ValueError på NaNs.

float.is_integer()¶

Returnerar True om float-instansen är finit med integrerat värde, och False annars:

>>> (-2.0).is_integer()
True
>>> (3.2).is_integer()
False

Två metoder stöder konvertering till och från hexadecimala strängar. Eftersom Pythons flyttal lagras internt som binära tal innebär konvertering av ett flyttal till eller från en decimal sträng vanligtvis ett litet avrundningsfel. Däremot tillåter hexadecimala strängar exakt representation och specifikation av flyttal. Detta kan vara användbart vid felsökning och i numeriskt arbete.

float.hex()¶: Returnerar en representation av ett flyttal som en hexadecimal sträng. För finita flyttal kommer denna representation alltid att innehålla en inledande 0x och en efterföljande p och exponent.

classmethod float.fromhex(s)¶: Klassmetod för att returnera den flottör som representeras av en hexadecimal sträng s. Strängen s kan ha inledande och avslutande blanksteg.

Observera att float.hex() är en instansmetod, medan float.fromhex() är en klassmetod.

En hexadecimal sträng har formen:

[tecken] ['0x'] heltal ['.' bråk] ['p' exponent]

där det valfria tecknet kan vara antingen + eller -, integer och fraction är strängar av hexadecimala siffror, och exponent är ett decimalt heltal med ett valfritt inledande tecken. Versaler är oviktiga och det måste finnas minst en hexadecimal siffra i antingen heltalet eller bråket. Denna syntax liknar den syntax som anges i avsnitt 6.4.4.2 i C99-standarden, och även den syntax som används i Java 1.5 och framåt. I synnerhet kan resultatet från float.hex() användas som en hexadecimal flyttalslitteral i C- eller Java-kod, och hexadecimala strängar som produceras av C:s %a formattecken eller Javas Double.toHexString accepteras av float.fromhex().

Observera att exponenten skrivs i decimalform i stället för hexadecimalform och att den anger med vilken potens 2 koefficienten ska multipliceras. Till exempel representerar den hexadecimala strängen 0x3.a7p10 flyttalstalet (3 + 10./16 + 7./16**2) * 2,0**10, eller 3740,0:

>>> float.fromhex('0x3.a7p10')
3740.0

Genom att tillämpa den omvända konverteringen på 3740.0 får man en annan hexadecimal sträng som representerar samma nummer:

>>> float.hex(3740.0)
'0x1.d380000000000p+11'

Ytterligare metoder för komplexa¶

Typen complex implementerar numbers.Complex abstrakt basklass. complex har även följande ytterligare metoder.

classmethod complex.from_number(x)¶

Klassmetod för att konvertera ett tal till ett komplext tal.

För ett allmänt Python-objekt x delegerar complex.from_number(x) till x.__complex__(). Om __complex__() inte är definierad så faller den tillbaka till __float__(). Om __float__() inte är definierat faller det tillbaka till __index__().

Tillagd i version 3.14.

Hashning av numeriska typer¶

För talen x och y, eventuellt av olika typer, är det ett krav att hash(x) == hash(y) när x == y (se __hash__() metoddokumentation för mer information). För att underlätta implementering och effektivitet över en mängd olika numeriska typer (inklusive int, float, decimal.Decimal och fractions.Fraction) Pythons hash för numeriska typer baseras på en enda matematisk funktion som är definierad för alla rationella tal, och gäller därför för alla instanser av int och fractions.Fraction, och alla ändliga instanser av float och decimal.Decimal. I huvudsak ges denna funktion genom reduktion modulo P för ett fast primtal P. Värdet av P görs tillgängligt för Python som attributet modulus av sys.hash_info.

För närvarande används primtalet P = 2**31 - 1 på maskiner med 32-bitars C-längder och P = 2**61 - 1 på maskiner med 64-bitars C-längder.

Här är reglerna i detalj:

Om x = m / n är ett nonnegativt rationellt tal och n inte är delbart med P, definiera hash(x) som m * invmod(n, P) % P, där invmod(n, P) anger inversen av n modulo P.
Om x = m / n är ett nonnegativt rationellt tal och n är delbart med P (men m inte är det) så har n ingen invers modulo P och regeln ovan gäller inte; i detta fall definieras hash(x) som det konstanta värdet sys.hash_info.inf.
Om x = m / n är ett negativt rationellt tal, definiera hash(x) som -hash(-x). Om den resulterande hashen är -1, ersätt den med -2.
De särskilda värdena sys.hash_info.inf och -sys.hash_info.inf används som hashvärden för positiv oändlighet respektive negativ oändlighet.
För ett complex-tal z kombineras hashvärdena för de reella och imaginära delarna genom att beräkna hash(z.real) + sys.hash_info.imag * hash(z.imag), reducerat modulo 2**sys.hash_info.width så att det ligger i range(-2**(sys.hash_info.width - 1), 2**(sys.hash_info.width - 1)). Återigen, om resultatet är -1 ersätts det med -2.

För att klargöra ovanstående regler följer här ett exempel på Python-kod, motsvarande den inbyggda hashen, för att beräkna hashen för ett rationellt tal, float, eller complex:

import sys, matematik

def hash_fraktion(m, n):
    """Beräkna hashvärdet av ett rationellt tal m / n.

    Antar att m och n är heltal, med n positivt.
    Likvärdig med hash(fractions.Fraction(m, n)).

    """
    P = sys.hash_info.modulus
    # Ta bort gemensamma faktorer i P. (Onödigt om m och n redan är coprime.)
    while m % P == n % P == 0:
        m, n = m // P, n // P

    om n % P == 0:
        hash_värde = sys.hash_info.inf
    else:
        # Fermats lilla sats: pow(n, P-1, P) är 1, så
        # pow(n, P-2, P) ger inversen av n modulo P.
        hash_value = (abs(m) % P) * pow(n, P - 2, P) % P
    om m < 0:
        hash_värde = -hash_värde
    om hash_value == -1:
        hash_värde = -2
    returnera hash_värde

def hash_float(x):
    """Beräkna hashvärdet för en float x."""

    om math.isnan(x):
        returnera objekt.__hash__(x)
    elif math.isinf(x):
        return sys.hash_info.inf if x > 0 else -sys.hash_info.inf
    annat:
        return hash_fraction(*x.as_integer_ratio())

def hash_komplex(z):
    """Beräkna hashvärdet för ett komplext tal z."""

    hash_value = hash_float(z.real) + sys.hash_info.imag * hash_float(z.imag)
    # gör en signerad reduktion modulo 2**sys.hash_info.width
    M = 2**(sys.hash_info.width - 1)
    hash_värde = (hash_värde & (M - 1)) - (hash_värde & M)
    om hash_value == -1:
        hash_värde = -2
    returnera hash_värde

Booleansk typ - `bool`¶

Booleaner representerar sanningsvärden. Typen bool har exakt två konstanta instanser: True och False.

Den inbyggda funktionen bool() konverterar ett värde till en boolean, om värdet kan tolkas som ett sanningsvärde (se avsnitt Test av sanning och värde ovan).

För logiska operationer, använd booleska operatorer and, or och not. När man använder de bitvisa operatorerna &, |, ^ på två booleaner returnerar de en bool som motsvarar de logiska operationerna ”and”, ”or”, ”xor”. De logiska operatorerna och, eller och != bör dock föredras framför &, | och ^.

Föråldrad sedan version 3.12: Användningen av den bitvisa inversionsoperatorn ~ är föråldrad och kommer att ge upphov till ett fel i Python 3.16.

bool är en underklass till int (se Numeriska typer — int, float, complex). I många numeriska sammanhang beter sig False och True som heltalen 0 respektive 1. Det är dock inte rekommenderat att förlita sig på detta; konvertera explicit med int() istället.

Iterator-typer¶

Python stöder ett koncept för iteration över behållare. Detta implementeras med hjälp av två olika metoder; dessa används för att låta användardefinierade klasser stödja iteration. Sekvenser, som beskrivs mer i detalj nedan, stöder alltid iterationsmetoderna.

En metod måste definieras för containerobjekt för att ge stöd för iterable:

container.__iter__()¶: Returnerar ett iterator-objekt. Objektet måste ha stöd för iteratorprotokollet som beskrivs nedan. Om en container stöder olika typer av iteration kan ytterligare metoder tillhandahållas för att specifikt begära iteratorer för dessa iterationstyper. (Ett exempel på ett objekt som stöder flera former av iteration är en trädstruktur som stöder både bredd-först- och djup-först-traversering) Denna metod motsvarar tp_iter slot i typstrukturen för Python-objekt i Python/C API.

Själva iteratorobjekten måste stödja följande två metoder, som tillsammans utgör iteratorprotokollet:

iterator.__iter__()¶: Returnerar själva iterator-objektet. Detta krävs för att både containers och iteratorer ska kunna användas med for och in satserna. Denna metod motsvarar tp_iter-platsen i typstrukturen för Python-objekt i Python/C API.

iterator.__next__()¶: Returnerar nästa objekt från iterator. Om det inte finns några fler objekt, utlöses undantaget StopIteration. Denna metod motsvarar tp_iternext-platsen i typstrukturen för Python-objekt i Python/C API.

Python definierar flera iteratorobjekt för att stödja iteration över allmänna och specifika sekvenstyper, ordböcker och andra mer specialiserade former. De specifika typerna är inte viktiga utöver deras implementering av iteratorprotokollet.

När en iterators __next__()-metod ger upphov till StopIteration, måste den fortsätta att göra det vid efterföljande anrop. Implementationer som inte följer denna egenskap anses vara trasiga.

Typer av generatorer¶

Pythons generator ger ett bekvämt sätt att implementera iteratorprotokollet. Om ett containerobjekts metod __iter__() implementeras som en generator, kommer den automatiskt att returnera ett iteratorobjekt (tekniskt sett ett generatorobjekt) som tillhandahåller metoderna __iter__() och __next__(). Mer information om generatorer finns i dokumentationen för yield-uttrycket.

Sekvenstyper — `list`, `tuple`, `range`¶

Det finns tre grundläggande sekvenstyper: listor, tupler och intervallobjekt. Ytterligare sekvenstyper som är anpassade för bearbetning av binär data och textsträngar beskrivs i särskilda avsnitt.

Vanliga sekvensoperationer¶

Operationerna i följande tabell stöds av de flesta sekvenstyper, både föränderliga och oföränderliga. ABC collections.abc.Sequence tillhandahålls för att göra det enklare att korrekt implementera dessa operationer på anpassade sekvenstyper.

I denna tabell listas sekvensoperationerna sorterade i stigande prioritet. I tabellen är s och t sekvenser av samma typ, n, i, j och k är heltal och x är ett godtyckligt objekt som uppfyller alla typ- och värdebegränsningar som s ställer upp.

Operationerna in och not in har samma prioritet som jämförelseoperationerna. Operationerna + (konkatenering) och * (repetition) har samma prioritet som motsvarande numeriska operationer. [3]

Operation	Resultat	Anteckningar
`x in s`	`True` om ett objekt i s är lika med x, annars `False`	(1)
`x not in s`	`False` om ett objekt i s är lika med x, annars `True`	(1)
`s + t`	sammankopplingen av s och t	(6)(7)
`s * n` eller `n * s`	motsvarar att addera s till sig själv n gånger	(2)(7)
`s[i]`	idet tredje objektet i s, ursprung 0	(3)(9)
`s[i:j]`	skiva av s från i till j	(3)(4)
`[i:j:k]`	skiva av s från i till j med steg k	(3)(5)
`len(s)`	längd på s
`min(s)`	minsta delen av s
`max(s)`	största posten av s
`s.index(x[, i[, j]])`	index för den första förekomsten av x i s (vid eller efter index i och före index j)	(8)
`s.count(x)`	totalt antal förekomster av x i s

Sekvenser av samma typ stöder också jämförelser. Framför allt jämförs tupler och listor lexikografiskt genom att jämföra motsvarande element. Detta innebär att för att jämföra lika måste varje element jämföra lika och de två sekvenserna måste vara av samma typ och ha samma längd. (För fullständig information se Jämförelser i språkreferensen)

Framåtriktade och bakåtriktade iteratorer över muterbara sekvenser får tillgång till värden med hjälp av ett index. Detta index kommer att fortsätta att marschera framåt (eller bakåt) även om den underliggande sekvensen muteras. Iteratorn avslutas först när ett IndexError eller ett StopIteration inträffar (eller när indexet sjunker under noll).

Anteckningar:

Medan operationerna in och not in endast används för enkel testning av inneslutning i det allmänna fallet, använder vissa specialiserade sekvenser (t.ex. str, bytes och bytearray) dem också för testning av undersekvenser:
```
>>> "gg" in "eggs"
True
```
Värden av n mindre än 0 behandlas som 0 (vilket ger en tom sekvens av samma typ som s). Observera att objekt i sekvensen s inte kopieras; de refereras flera gånger. Detta spökar ofta för nya Python-programmerare; tänk på:
```
>>> lists = [[]] * 3
>>> lists
[[], [], []]
>>> lists[0].append(3)
>>> lists
[[3], [3], [3]]
```
Vad som har hänt är att []] är en lista med ett element som innehåller en tom lista, så alla tre elementen i []] * 3 är referenser till denna enda tomma lista. Om du ändrar något av elementen i lists ändras denna enda lista. Du kan skapa en lista med olika listor på följande sätt:
```
>>> lists = [[] for i in range(3)]
>>> lists[0].append(3)
>>> lists[1].append(5)
>>> lists[2].append(7)
>>> lists
[[3], [5], [7]]
```
Ytterligare förklaringar finns i FAQ-artikeln Hur skapar jag en flerdimensionell lista?.
Om i eller j är negativ, är indexet relativt slutet av sekvensen s: len(s) + i eller len(s) + j ersätts. Men observera att -0 fortfarande är 0.
Slice av s från i till j definieras som den sekvens av objekt med index k som är sådan att i <= k < j. Om i eller j är större än len(s), använd len(s). Om i är utelämnad eller None, använd 0. Om j utelämnas eller None, använd len(s). Om i är större än eller lika med j är skivan tom.
Slice av s från i till j med steg k definieras som sekvensen av objekt med index x = i + n*k så att 0 <= n < (j-i)/k. Med andra ord är indexen i, i+k, i+2*k, i+3*k och så vidare, med stopp när j nås (men aldrig inklusive j). När k är positiv reduceras i och j till len(s) om de är större. När k är negativ reduceras i och j till len(s) - 1 om de är större. Om i eller j utelämnas eller är None, blir de ”slut”-värden (vilket slut beror på tecknet för k). Observera att k inte kan vara noll. Om k är None behandlas det som 1.
Sammankoppling av oföränderliga sekvenser resulterar alltid i ett nytt objekt. Detta innebär att uppbyggnaden av en sekvens genom upprepad konkatenering får en kvadratisk körtidskostnad i den totala sekvenslängden. För att få en linjär körtidskostnad måste du byta till något av alternativen nedan:
- om du sammanfogar str-objekt kan du bygga en lista och använda str.join() i slutet eller skriva till en io.StringIO-instans och hämta dess värde när du är klar
- om du konkatenerar bytes-objekt kan du på samma sätt använda bytes.join() eller io.BytesIO, eller så kan du göra konkatenering på plats med ett bytearray -objekt. bytearray -objekt är muterbara och har en effektiv mekanism för overallokering
- om du konkatenerar tuple-objekt, förläng en list istället
- för andra typer, undersök den relevanta klassdokumentationen
Vissa sekvenstyper (t.ex. range) stöder endast sekvenser av objekt som följer specifika mönster och stöder därför inte sammankoppling eller upprepning av sekvenser.
index ger upphov till ValueError när x inte finns i s. Det är inte alla implementationer som stöder de ytterligare argumenten i och j. Dessa argument möjliggör effektiv sökning av underavsnitt av sekvensen. Att skicka de extra argumenten motsvarar i stort sett att använda s[i:j].index(x), men utan att kopiera några data och med det returnerade indexet i förhållande till början av sekvensen snarare än början av skivan.
Ett IndexError uppstår om i ligger utanför sekvensintervallet.

Oföränderliga sekvenstyper¶

Den enda operation som oföränderliga sekvenstyper i allmänhet implementerar och som inte också implementeras av föränderliga sekvenstyper är stöd för den inbyggda hash().

Detta stöd gör att oföränderliga sekvenser, t.ex. tuple-instanser, kan användas som dict-nycklar och lagras i set- och frozenset-instanser.

Försök att hasha en oföränderlig sekvens som innehåller värden som inte kan hashas kommer att resultera i TypeError.

Mutabla sekvenstyper¶

Operationerna i följande tabell är definierade för mutabla sekvenstyper. Klassen collections.abc.MutableSequence ABC tillhandahålls för att göra det enklare att korrekt implementera dessa operationer på anpassade sekvenstyper.

I tabellen är s en instans av en föränderlig sekvenstyp, t är ett itererbart objekt och x är ett godtyckligt objekt som uppfyller alla typ- och värdebegränsningar som s ställer (till exempel accepterar bytearray endast heltal som uppfyller värdebegränsningen 0 <= x <= 255).

Operation	Resultat	Anteckningar
`s[i] = x`	post i i s ska ersättas med x
`del s[i]`	tar bort objekt i av s
`s[i:j] = t`	slice av s från i till j ersätts av innehållet i iterabeln t
`del s[i:j]`	tar bort elementen i `s[i:j]` från listan (samma som `s[i:j] = []`)
`s[i:j:k] = t`	elementen i `s[i:j:k]` ersätts med elementen i t	(1)
`del s[i:j:k]`	tar bort elementen i `s[i:j:k]` från listan
`s.append(x)`	lägger till x i slutet av sekvensen (samma som `s[len(s):len(s)] = [x]`)
`s.clear()`	tar bort alla objekt från s (samma som `del s[:]`)	(5)
`s.copy()`	skapar en ytlig kopia av s (samma som `s[:]`)	(5)
`s.extend(t)` eller `s += t`	utökar s med innehållet i t (till största delen samma sak som `s[len(s):len(s)] = t`)
`s *= n`	uppdaterar s med dess innehåll upprepade n gånger	(6)
`s.insert(i, x)`	infogar x i s vid det index som anges av i (samma som `s[i:i] = [x]`)
`s.pop()` eller `s.pop(i)`	hämtar objektet på i och tar även bort det från s	(2)
`s.remove(x)`	tar bort det första objektet från s där `s[i]` är lika med x	(3)
`s.reverse()`	vänder posterna av s på plats	(4)

Anteckningar:

Om k inte är lika med 1, måste t ha samma längd som den skiva den ersätter.
Det valfria argumentet i är som standard -1, så att det sista objektet som standard tas bort och returneras.
remove() ger upphov till ValueError när x inte finns i s.
Metoden reverse() modifierar sekvensen på plats för att spara utrymme vid omkastning av en stor sekvens. För att påminna användarna om att den fungerar som en bieffekt returnerar den inte den omvända sekvensen.
clear() och copy() ingår för att vara konsekventa med gränssnitten för mutabla behållare som inte stöder skivningsoperationer (t.ex. dict och set). copy() är inte en del av collections.abc.MutableSequence ABC, men de flesta konkreta klasser för mutabla sekvenser har det.

Tillagd i version 3.3: metoderna clear() och copy().
Värdet n är ett heltal eller ett objekt som implementerar __index__(). Noll och negativa värden på n rensar sekvensen. Objekten i sekvensen kopieras inte; de refereras flera gånger, vilket förklaras för s * n under Vanliga sekvensoperationer.

Listor¶

Listor är föränderliga sekvenser som vanligtvis används för att lagra samlingar av homogena objekt (där den exakta graden av likhet varierar beroende på tillämpning).

class list(iterable=(), /)¶

Listor kan byggas upp på flera olika sätt:

Använd ett par hakparenteser för att beteckna den tomma listan: []
Använd hakparenteser och separera objekt med kommatecken: [a], [a, b, c]
Använda en listförståelse: [x for x in iterable]
Använda typkonstruktören: list() eller list(iterable)

Konstruktorn bygger en lista vars objekt är desamma och i samma ordning som iterable:s objekt. iterable kan vara antingen en sekvens, en behållare som stöder iteration eller ett iteratorobjekt. Om iterable redan är en lista görs en kopia och returneras, på samma sätt som iterable[:]. Till exempel returnerar list('abc') ['a', 'b', 'c'] och list( (1, 2, 3) ) returnerar [1, 2, 3]. Om inget argument anges skapar konstruktören en ny tom lista, [].

Många andra operationer producerar också listor, inklusive den inbyggda sorted().

Listor implementerar alla common och mutable sekvensoperationer. Listor tillhandahåller också följande ytterligare metod:

sort(*, key=None, reverse=False)¶

Den här metoden sorterar listan på plats och använder endast <-jämförelser mellan objekten. Undantag undertrycks inte - om någon jämförelseoperation misslyckas, kommer hela sorteringsoperationen att misslyckas (och listan kommer sannolikt att lämnas i ett delvis modifierat tillstånd).

sort() accepterar två argument som endast kan skickas med nyckelord (keyword-only arguments):

key anger en funktion med ett argument som används för att extrahera en jämförelsenyckel från varje listelement (t.ex. key=str.lower). Den nyckel som motsvarar varje objekt i listan beräknas en gång och används sedan för hela sorteringsprocessen. Standardvärdet None innebär att listobjekten sorteras direkt utan att ett separat nyckelvärde beräknas.

Verktyget functools.cmp_to_key() är tillgängligt för att konvertera en cmp-funktion i 2.x-stil till en key-funktion.

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

Denna metod modifierar sekvensen på plats för att spara utrymme vid sortering av en stor sekvens. För att påminna användarna om att den fungerar som en bieffekt returneras inte den sorterade sekvensen (använd sorted() för att uttryckligen begära en ny instans av en sorterad lista).

Metoden sort() är garanterat stabil. En sortering är stabil om den garanterar att den inte ändrar den relativa ordningen på 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).

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

När en lista sorteras är effekten av att försöka mutera, eller till och med inspektera, listan odefinierad. C-implementeringen av Python gör att listan ser tom ut under tiden och ger ValueError om den kan upptäcka att listan har muterats under en sortering.

Tupler¶

Tupler är oföränderliga sekvenser som vanligtvis används för att lagra samlingar av heterogena data (t.ex. de 2-tupler som produceras av den inbyggda enumerate()). Tuples används också i fall där en oföränderlig sekvens av homogena data behövs (t.ex. för att tillåta lagring i en set- eller dict-instans).

class tuple(iterable=(), /)¶

Tupler kan konstrueras på ett antal olika sätt:

Använda ett par parenteser för att beteckna den tomma tupeln: ()
Använda ett efterföljande kommatecken för en singleton-tupel: a, eller (a,)
Separera objekt med kommatecken: a, b, c eller (a, b, c)
Använda den inbyggda tuple(): tuple() eller tuple(iterable)

Konstruktorn bygger en tupel vars poster är desamma och i samma ordning som iterable*s poster. *iterable kan vara antingen en sekvens, en behållare som stöder iteration eller ett iteratorobjekt. Om iterable redan är en tupel returneras den oförändrad. Till exempel returnerar tuple('abc') ('a', 'b', 'c') och tuple( [1, 2, 3] ) returnerar (1, 2, 3). Om inget argument anges skapar konstruktören en ny tom tupel, ().

Observera att det faktiskt är kommatecknet som skapar en tupel, inte parentesen. Parenteserna är valfria, utom i fallet med en tom tupel, eller när de behövs för att undvika syntaktisk tvetydighet. Till exempel är f(a, b, c) ett funktionsanrop med tre argument, medan f((a, b, c)) är ett funktionsanrop med en 3-tupel som enda argument.

Tupler implementerar alla common sekvensoperationer.

För heterogena samlingar av data där åtkomst via namn är tydligare än åtkomst via index kan collections.namedtuple() vara ett lämpligare val än ett enkelt tuple-objekt.

Intervaller¶

Typen range representerar en oföränderlig sekvens av tal och används ofta för att loopa ett visst antal gånger i for-loopar.

class range(stop, /)¶

class range(start, stop, step=1, /)

Argumenten till intervallkonstruktören måste vara heltal (antingen inbyggd int eller något objekt som implementerar specialmetoden __index__()). Om argumentet step utelämnas är standardvärdet 1. Om argumentet start utelämnas är standardvärdet 0. Om step är noll genereras ValueError.

För ett positivt steg bestäms innehållet i ett intervall r av formeln r[i] = start + steg*i där i >= 0 och r[i] < stopp.

För ett negativt steg bestäms innehållet i intervallet fortfarande av formeln r[i] = start + steg*i, men begränsningarna är i >= 0 och r[i] > stopp.

Ett intervallobjekt är tomt om r[0] inte uppfyller värdebegränsningen. Ranges har stöd för negativa index, men dessa tolkas som indexering från slutet av den sekvens som bestäms av de positiva indexen.

Intervall som innehåller absoluta värden som är större än sys.maxsize är tillåtna men vissa funktioner (t.ex. len()) kan ge upphov till OverflowError.

Exempel på intervall:

>>> list(range(10))
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> list(range(1, 11))
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
>>> list(range(0, 30, 5))
[0, 5, 10, 15, 20, 25]
>>> list(range(0, 10, 3))
[0, 3, 6, 9]
>>> list(range(0, -10, -1))
[0, -1, -2, -3, -4, -5, -6, -7, -8, -9]
>>> list(range(0))
[]
>>> list(range(1, 0))
[]

Ranges implementerar alla common sekvensoperationer utom konkatenering och repetition (på grund av att range-objekt endast kan representera sekvenser som följer ett strikt mönster och repetition och konkatenering bryter vanligtvis mot detta mönster).

start¶: Värdet på parametern start (eller 0 om parametern inte har angetts)

stop¶: Värdet på parametern stop

step¶: Värdet på parametern step (eller 1 om parametern inte har angetts)

Fördelen med typen range jämfört med en vanlig list eller tuple är att ett range-objekt alltid tar samma (lilla) mängd minne i anspråk, oavsett storleken på det intervall det representerar (eftersom det bara lagrar värdena start, stop och step och beräknar enskilda objekt och delintervall efter behov).

Range-objekt implementerar collections.abc.Sequence ABC, och tillhandahåller funktioner som inneslutningstest, elementindexuppslagning, skivning och stöd för negativa index (se Sekvenstyper — list, tuple, range):

>>> r = range(0, 20, 2)
>>> r
range(0, 20, 2)
>>> 11 in r
False
>>> 10 in r
True
>>> r.index(10)
5
>>> r[5]
10
>>> r[:5]
range(0, 10, 2)
>>> r[-1]
18

När intervallobjekt testas för likhet med == och != jämförs de som sekvenser. Det innebär att två intervallobjekt anses vara lika om de representerar samma sekvens av värden. (Observera att två intervallobjekt som jämförs lika kan ha olika attribut start, stop och step, till exempel range(0) == range(2, 1, 3) eller range(0, 3, 2) == range(0, 4, 2).)

Ändrad i version 3.2: Implementera sekvensen ABC. Stödjer skivning och negativa index. Testa int-objekt för medlemskap i konstant tid istället för att iterera genom alla objekt.

Ändrad i version 3.3: Definiera ’==’ och ’!=’ för att jämföra intervallobjekt baserat på den sekvens av värden som de definierar (istället för att jämföra baserat på objektets identitet).

Lagt till attributen start, stop och step.

Se även

I linspace-receptet visas hur man implementerar en lat version av range som är lämplig för flyttalsapplikationer.

Metoder för text- och binära sekvenstyper Sammanfattning¶

I följande tabell sammanfattas metoderna för text- och binära sekvenstyper per kategori.

Kategori	`str` metoder				metoderna `bytes` och `bytearray`
Formaterar	`str.format()`
	`str.format_map()`
	f-strängar
	strängformatering i stil med printf				byteformatering i stil med printf
Sökning och byte	`str.find()`	`str.rfind()`			`bytes.find()`	`bytes.rfind()`
	`str.index()`	`str.rindex()`			`bytes.index()`	`bytes.rindex()`
	`str.startswith()`				`bytes.startswith()`
	`str.endswith()`				`bytes.endswith()`
	`str.count()`				`bytes.count()`
	`str.replace()`				`bytes.replace()`
Delning och sammanfogning	`str.split()`		`str.rsplit()`		`bytes.split()`		`bytes.rsplit()`
	`str.splitlines()`				`bytes.splitlines()`
	`str.partition()`				`bytes.partition()`
	`str.rpartition()`				`bytes.rpartition()`
	`str.join()`				`bytes.join()`
Klassificering av strängar	`str.isalpha()`				`bytes.isalpha()`
	`str.isdecimal()`
	`str.isdigit()`				`bytes.isdigit()`
	`str.isnumeric()`
	`str.isalnum()`				`bytes.isalnum()`
	`str.isidentifier()`
	`str.islower()`				`bytes.islower()`
	`str.isupper()`				`bytes.isupper()`
	`str.istitle()`				`bytes.istitle()`
	`str.isspace()`				`bytes.isspace()`
	`str.isprintable()`
Manipulation av ärenden	`str.lower()`				`bytes.lägre()`
	`str.övre()`				`bytes.övre()`
	`str.casefold()`
	`str.capitalize()`				`bytes.capitalize()`
	`str.title()`				`bytes.titel()`
	`str.swapcase()`				`bytes.swapcase()`
Stoppning och strippning	`str.ljust()`		`str.rjust()`		`bytes.ljust()`		`bytes.rjust()`
	`str.center()`				`bytes.center()`
	`str.expandtabs()`				`bytes.expandtabs()`
	`str.strip()`				`bytes.strip()`
	`str.lstrip()`			`str.rstrip()`	`bytes.lstrip()`			`bytes.rstrip()`
Översättning och kodning	`str.translate()`				`bytes.translate()`
	`str.maketrans()`				`bytes.maketrans()`
	`str.encode()`
					`bytes.avkodning()`

Textsekvenstyp — `str`¶

Textdata i Python hanteras med str-objekt, eller strings. Strängar är oföränderliga sekvenser av Unicode-kodpunkter. Stränglitteraler skrivs på en mängd olika sätt:

Enkla citattecken: 'allows embedded "double" quotes'
Dubbla citattecken: "tillåter inbäddade 'enkla' citationstecken"
Trippelcitat: """Tre enkla citattecken""", """Tre dubbla citattecken"""

Strängar med trippelcitat kan sträcka sig över flera rader - alla tillhörande blanksteg kommer att inkluderas i strängens bokstav.

Stränglitteraler som är en del av ett enda uttryck och som bara har blanksteg mellan sig konverteras implicit till en enda stränglitteral. Det vill säga ("spam " "ägg") == "spam ägg".

Se Sträng- och Bytes-litteraler för mer information om de olika formerna av strängbokstäver, inklusive stöd för escape-sekvenser, och prefixet r (”raw”) som inaktiverar den mesta bearbetningen av escape-sekvenser.

Strängar kan också skapas från andra objekt med hjälp av str-konstruktören.

Eftersom det inte finns någon separat ”tecken”-typ, ger indexering av en sträng strängar med längden 1. Det vill säga, för en icke-tom sträng s, s[0] == s[0:1].

Det finns inte heller någon mutabel strängtyp, men str.join() eller io.StringIO kan användas för att effektivt konstruera strängar från flera fragment.

Ändrad i version 3.3: För bakåtkompatibilitet med Python 2-serien är prefixet u återigen tillåtet för stränglitteraler. Det har ingen effekt på betydelsen av stränglitteraler och kan inte kombineras med prefixet r.

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

class str(object)

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

class str(object, *, errors)

Returnerar en sträng-version av objekt. Om object inte anges, returneras den tomma strängen. Annars beror beteendet hos str() på om encoding eller errors anges, enligt följande.

Om varken encoding eller errors anges returnerar str(object) type(object).__str__(object), vilket är den ”informella” eller snyggt utskrivbara strängrepresentationen av object. För strängobjekt är detta själva strängen. Om object inte har en __str__()-metod, faller str() tillbaka till att returnera repr(object).

Om minst en av encoding eller errors anges, bör object vara ett bytes-like object (t.ex. bytes eller bytearray). I det här fallet, om objekt är ett bytes (eller bytearray) objekt, så är str(bytes, encoding, errors) ekvivalent med bytes.decode(encoding, errors). I annat fall erhålls bytesobjektet som ligger under buffertobjektet innan bytes.decode() anropas. Se Binära sekvenstyper — bytes, bytearray, memoryview och Buffertprotokoll för information om buffertobjekt.

Att skicka ett bytes-objekt till str() utan argumenten encoding eller errors faller under det första fallet av att returnera den informella strängrepresentationen (se även kommandoradsalternativet -b till Python). Till exempel:

>>> str(b'Zoot!')
"b'Zoot!'"

Mer information om klassen str och dess metoder finns i avsnitten Textsekvenstyp — str och Strängmetoder nedan. För att skriva ut formaterade strängar, se avsnitten f-strängar och Format String Syntax. Dessutom, se avsnittet Textbehandlingstjänster.

Strängmetoder¶

Strängar implementerar alla common sekvensoperationer, tillsammans med de ytterligare metoder som beskrivs nedan.

Strängar har också stöd för två typer av strängformatering, en som ger stor flexibilitet och möjlighet till anpassning (se str.format(), Format String Syntax och Anpassad strängformatering) och en som baseras på C printf-stilformatering som hanterar ett smalare urval av typer och är något svårare att använda korrekt, men som ofta är snabbare i de fall den kan hantera (strängformatering i stil med printf).

Avsnittet Textbehandlingstjänster i standardbiblioteket omfattar ett antal andra moduler som tillhandahåller olika textrelaterade verktyg (inklusive stöd för reguljära uttryck i modulen re).

str.capitalize()¶: Returnerar en kopia av strängen med första tecknet i versaler och resten i gemener.

Ändrad i version 3.8: Det första tecknet sätts nu i titelbokstäver i stället för versaler. Detta innebär att tecken som digrafer endast får sin första bokstav versaliserad, istället för hela tecknet.

str.casefold()¶

Returnerar en casefoldad kopia av strängen. Casefoldade strängar kan användas för caseless matchning.

Casefolding liknar lowercasing men är mer aggressivt eftersom det är avsett att ta bort alla skillnader i versaler i en sträng. Till exempel är den tyska gemena bokstaven 'ß' likvärdig med "ss". Eftersom den redan är gemen skulle lower() inte göra något med 'ß'; casefold() konverterar den till "ss".

Algoritmen för casefolding beskrivs i avsnitt 3.13 ”Default Case Folding” i Unicode-standarden.

Tillagd i version 3.3.

str.center(width, fillchar=' ', /)¶

Returnerar centrerad i en sträng av längden bredd. Utfyllnad görs med hjälp av det angivna fillchar (standard är ett ASCII-rymd). Den ursprungliga strängen returneras om width är mindre än eller lika med len(s). Till exempel:

>>> 'Python'.center(10)
'  Python  '
>>> 'Python'.center(10, '-')
'--Python--'
>>> 'Python'.center(4)
'Python'

str.count(sub[, start[, end]])¶

Returnerar antalet icke-överlappande förekomster av substring sub i intervallet [start, slut]. De valfria argumenten start och slut tolkas som i slice-notation.

Om sub är tom, returneras antalet tomma strängar mellan tecknen, vilket är strängens längd plus ett. Till exempel:

>>> 'spam, spam, spam'.count('spam')
3
>>> 'spam, spam, spam'.count('spam', 5)
2
>>> 'spam, spam, spam'.count('spam', 5, 10)
1
>>> 'spam, spam, spam'.count('eggs')
0
>>> 'spam, spam, spam'.count('')
17

str.encode(encoding='utf-8', errors='strict')¶

Returnerar strängen kodad till bytes.

encoding är som standard 'utf-8'; se Standardkodningar för möjliga värden.

errors styr hur kodningsfel ska hanteras. Om 'strict' (standard), kommer ett UnicodeError undantag att uppstå. Andra möjliga värden är 'ignore', 'replace', 'xmlcharrefreplace', 'backslashreplace' och alla andra namn som registreras via codecs.register_error(). Se Felhanterare för detaljer.

Av prestandaskäl kontrolleras inte värdet på errors om inte ett kodningsfel faktiskt inträffar, Python-utvecklingsläge är aktiverat eller en debug build används. Till exempel:

>>> encoded_str_to_bytes = 'Python'.encode()
>>> type(encoded_str_to_bytes)
<class 'bytes'>
>>> encoded_str_to_bytes
b'Python'

Ändrad i version 3.1: Stöd för nyckelordsargument har lagts till.

Ändrad i version 3.9: Värdet på errors-argumentet kontrolleras nu i Python-utvecklingsläge och i debug mode.

str.endswith(suffix[, start[, end]])¶

Returnerar True om strängen slutar med det angivna suffixet, annars returneras False. suffix kan också vara en tupel av suffix att leta efter. Med valfri start börjar testet vid den positionen. Med valfri end, sluta jämföra vid den positionen. Att använda start och end är likvärdigt med str[start:end].endswith(suffix). Till exempel:

>>> 'Python'.endswith('on')
True
>>> 'a tuple of suffixes'.endswith(('at', 'in'))
False
>>> 'a tuple of suffixes'.endswith(('at', 'es'))
True
>>> 'Python is amazing'.endswith('is', 0, 9)
True

Se även startswith() och removesuffix().

str.expandtabs(tabsize=8)¶

Returnerar en kopia av strängen där alla tabbtecken ersatts av ett eller flera mellanslag, beroende på aktuell kolumn och angiven tabbstorlek. Tabbpositioner uppstår varje tabsize tecken (standard är 8, vilket ger tabbpositioner i kolumnerna 0, 8, 16 och så vidare). För att expandera strängen sätts den aktuella kolumnen till noll och strängen granskas tecken för tecken. Om tecknet är en tabb (t) infogas ett eller flera mellanslagstecken i resultatet tills den aktuella kolumnen är lika med nästa tabbposition. (Tabbtecknet i sig kopieras inte.) Om tecknet är en ny rad (\n) eller en retur (\r) kopieras det och den aktuella kolumnen nollställs. Alla andra tecken kopieras oförändrade och den aktuella kolumnen ökas med ett oavsett hur tecknet representeras när det skrivs ut. Till exempel:

>>> '01\t012\t0123\t01234'.expandtabs()
'01      012     0123    01234'
>>> '01\t012\t0123\t01234'.expandtabs(4)
'01  012 0123    01234'
>>> print('01\t012\n0123\t01234'.expandtabs(4))
01  012
0123    01234

str.find(sub[, start[, end]])¶

Returnera det lägsta indexet i strängen där delsträngen sub finns inom segmentet s[start:end]. Valfria argument start och end tolkas som i segmentnotation. Returnera -1 om sub inte hittas. Till exempel:

>>> 'spam, spam, spam'.find('sp')
0
>>> 'spam, spam, spam'.find('sp', 5)
6

Se även rfind() och index().

Anteckning

Metoden find() bör endast användas om du behöver veta positionen för sub. Om du vill kontrollera om sub är en delsträng eller inte använder du operatorn in:

>>> 'Py' in 'Python'
True

str.format(*args, **kwargs)¶

Utför en strängformateringsoperation. Strängen som den här metoden anropas på kan innehålla bokstavlig text eller ersättningsfält som avgränsas av hakparenteser {}. Varje ersättningsfält innehåller antingen det numeriska indexet för ett positionsargument eller namnet på ett nyckelordsargument. Returnerar en kopia av strängen där varje ersättningsfält ersätts med strängvärdet för motsvarande argument.

>>> "The sum of 1 + 2 is {0}".format(1+2)
'The sum of 1 + 2 is 3'

Se Format String Syntax för en beskrivning av de olika formateringsalternativ som kan anges i formatsträngar.

Anteckning

Vid formatering av ett tal (int, float, complex, decimal.Decimal och underklasser) med typen n (ex: '{:n}'.format(1234)), ställer funktionen temporärt in LC_CTYPE locale till LC_NUMERIC locale för att avkoda decimal_point och thousands_sep fälten i localeconv() om de är icke-ASCII eller längre än 1 byte, och LC_NUMERIC locale är annorlunda än LC_CTYPE locale. Denna tillfälliga ändring påverkar andra trådar.

Ändrad i version 3.7: Vid formatering av ett tal med typen n ställer funktionen i vissa fall tillfälligt in LC_CTYPE locale till LC_NUMERIC locale.

str.format_map(mapping, /)¶

Liknar str.format(**mapping), förutom att mapping används direkt och inte kopieras till en dict. Detta är användbart om till exempel mapping är en dict-underklass:

>>> class Default(dict):
...     def __missing__(self, key):
...         return key
...
>>> '{name} was born in {country}'.format_map(Default(name='Guido'))
'Guido was born in country'

Tillagd i version 3.2.

str.index(sub[, start[, end]])¶: Som find(), men ger upphov till ValueError när delsträngen inte hittas.

str.isalnum()¶: Returnerar True om alla tecken i strängen är alfanumeriska och det finns minst ett tecken, annars False. Ett tecken c är alfanumeriskt om något av följande returnerar True: c.isalpha(), c.isdecimal(), c.isdigit(), eller c.isnumeric().

str.isalpha()¶: Returnerar True om alla tecken i strängen är alfabetiska och det finns minst ett tecken, False annars. Alfabetiska tecken är de tecken som i Unicodes teckendatabas definieras som ”Letter”, dvs. de som har en allmän kategoriegenskap som är en av ”Lm”, ”Lt”, ”Lu”, ”Ll” eller ”Lo”. Observera att detta skiljer sig från egenskapen Alphabetic som definieras i avsnitt 4.10 ’Letters, Alphabetic, and Ideographic’ i Unicode-standarden.

str.isascii()¶: Returnerar True om strängen är tom eller om alla tecken i strängen är ASCII, annars False. ASCII-tecken har kodpunkter i intervallet U+0000-U+007F.

Tillagd i version 3.7.

str.isdecimal()¶: Returnerar True om alla tecken i strängen är decimala tecken och det finns minst ett tecken, annars False. Decimala tecken är sådana som kan användas för att bilda tal i bas 10, t.ex. U+0660, ARABIC-INDIC DIGIT ZERO. Formellt är ett decimaltal ett tecken i Unicodes allmänna kategori ”Nd”.

str.isdigit()¶: Returnerar True om alla tecken i strängen är siffror och det finns minst ett tecken, annars False. Siffror omfattar decimala tecken och siffror som kräver särskild hantering, t.ex. upphöjda siffror för kompatibilitet. Detta omfattar siffror som inte kan användas för att bilda tal i bas 10, t.ex. Kharosthi-talen. Formellt sett är en siffra ett tecken som har egenskapsvärdet Numeric_Type=Digit eller Numeric_Type=Decimal.

str.isidentifier()¶

Returnerar True om strängen är en giltig identifierare enligt språkdefinitionen, avsnitt Namn (identifierare och nyckelord).

keyword.iskeyword() kan användas för att testa om strängen s är en reserverad identifierare, t.ex. def och class.

Exempel:

>>> from keyword import iskeyword

>>> 'hello'.isidentifier(), iskeyword('hello')
(True, False)
>>> 'def'.isidentifier(), iskeyword('def')
(True, True)

str.islower()¶: Returnerar True om alla tecken med versaler [4] i strängen är gemener och det finns minst ett tecken med versaler, False annars.

str.isnumeric()¶: Returnerar True om alla tecken i strängen är numeriska tecken och det finns minst ett tecken, annars False. Numeriska tecken inkluderar siffertecken och alla tecken som har egenskapen Unicode numeriskt värde, t.ex. U+2155, VULGAR FRACTION ONE FIFTH. Formellt är numeriska tecken de som har egenskapsvärdet Numeric_Type=Digit, Numeric_Type=Decimal eller Numeric_Type=Numeric.

str.isprintable()¶

Returnerar True om alla tecken i strängen är utskrivbara, False om den innehåller minst ett icke-utskrivbart tecken.

Här betyder ”printable” att tecknet är lämpligt för repr() att använda i sin utdata; ”non-printable” betyder att repr() på inbyggda typer kommer att hex-escape tecknet. Det har ingen betydelse för hanteringen av strängar som skrivs till sys.stdout eller sys.stderr.

De tryckbara tecknen är de som i Unicodes teckendatabas (se unicodedata) har en allmän kategori i gruppen Letter, Mark, Number, Punctuation, or Symbol (L, M, N, P, or S); plus ASCII-rymden 0x20. Icke-tryckbara tecken är de som finns i gruppen Separator eller Annat (Z eller C), förutom ASCII-utrymmet.

str.isspace()¶

Returnerar True om det bara finns blankstegstecken i strängen och det finns minst ett tecken, False annars.

Ett tecken är whitespace om det i Unicodes teckendatabas (se unicodedata) antingen har den allmänna kategorin Zs (”Separator, mellanslag”), eller om dess dubbelriktade klass är en av WS, B eller S.

str.istitle()¶: Returnerar True om strängen är en titlecased-sträng och det finns minst ett tecken, till exempel kan versaler bara följa obokstaverade tecken och gemena tecken bara bokstaverade. Returnerar False annars.

str.isupper()¶

Returnerar True om alla tecken med versaler [4] i strängen är versaler och det finns minst ett tecken med versaler, False annars.

>>> 'BANANA'.isupper()
True
>>> 'banana'.isupper()
False
>>> 'baNana'.isupper()
False
>>> ' '.isupper()
False

str.join(iterable, /)¶: Returnerar en sträng som är en konkatenering av strängarna i iterable. Ett TypeError kommer att uppstå om det finns några värden som inte är strängar i iterable, inklusive bytes-objekt. Separatorn mellan elementen är den sträng som tillhandahåller denna metod.

str.ljust(width, fillchar=' ', /)¶: Returnerar strängen vänsterställd i en sträng med längden width. Utfyllnad görs med det angivna fillchar (standard är ett ASCII-rymd). Den ursprungliga strängen returneras om width är mindre än eller lika med len(s).

str.lower()¶

Returnerar en kopia av strängen med alla tecken med versaler [4] konverterade till gemener.

Den algoritm för gemener som används beskrivs i avsnitt 3.13 ”Default Case Folding” i Unicode-standarden.

str.lstrip(chars=None, /)¶

Returnerar en kopia av strängen med inledande tecken borttagna. Argumentet chars är en sträng som anger den uppsättning tecken som ska tas bort. Om chars utelämnas eller är None är standardinställningen att ta bort blanksteg. Argumentet chars är inte ett prefix, utan alla kombinationer av dess värden tas bort:

>>> '   spacious   '.lstrip()
'spacious   '
>>> 'www.example.com'.lstrip('cmowz.')
'example.com'

Se str.removeprefix() för en metod som tar bort en enda prefixsträng i stället för alla tecken i en uppsättning. Till exempel:

>>> 'Arthur: three!'.lstrip('Arthur: ')
'ee!'
>>> 'Arthur: three!'.removeprefix('Arthur: ')
'three!'

static str.maketrans(dict, /)¶

static str.maketrans(from, to, remove='', /)

Denna statiska metod returnerar en översättningstabell som kan användas för str.translate().

Om det bara finns ett argument måste det vara en ordbok som mappar Unicode-ordinaler (heltal) eller tecken (strängar av längd 1) till Unicode-ordinaler, strängar (av godtycklig längd) eller None. Teckennycklar kommer då att konverteras till ordinaler.

Om det finns två argument måste de vara strängar av samma längd, och i den resulterande ordlistan kommer varje tecken i from att mappas till tecknet på samma position i to. Om det finns ett tredje argument måste det vara en sträng, vars tecken kommer att mappas till None i resultatet.

str.partition(sep, /)¶: Dela strängen vid den första förekomsten av sep och returnera en 3-tupel som innehåller delen före separatorn, själva separatorn och delen efter separatorn. Om separatorn inte hittas returneras en 3-tupel som innehåller själva strängen, följt av två tomma strängar.

str.removeprefix(prefix, /)¶

Om strängen börjar med prefix-strängen returneras sträng[len(prefix):]. Annars returneras en kopia av den ursprungliga strängen:

>>> 'TestHook'.removeprefix('Test')
'Hook'
>>> 'BaseTestCase'.removeprefix('Test')
'BaseTestCase'

Tillagd i version 3.9.

str.removesuffix(suffix, /)¶

Om strängen slutar med strängen suffix och suffix inte är tomt, returneras sträng[:-len(suffix)]. Annars returneras en kopia av den ursprungliga strängen:

>>> 'MiscTests'.removesuffix('Tests')
'Misc'
>>> 'TmpDirMixin'.removesuffix('Tests')
'TmpDirMixin'

Tillagd i version 3.9.

str.replace(old, new, /, count=-1)¶: Returnerar en kopia av strängen med alla förekomster av delsträngen old ersatt av new. Om count anges ersätts endast de första count förekomsterna. Om count inte anges eller om -1, ersätts alla förekomster.

Ändrad i version 3.13: count stöds nu som ett nyckelordsargument.

str.rfind(sub[, start[, end]])¶: Returnerar det högsta indexet i strängen där delsträngen sub finns, så att sub ingår i s[start:end]. De valfria argumenten start och end tolkas som i slice-notation. Returnerar -1 om den misslyckas.

str.rindex(sub[, start[, end]])¶: Som rfind() men ger upphov till ValueError när delsträngen sub inte hittas.

str.rjust(width, fillchar=' ', /)¶: Returnerar strängen högerställd i en sträng med längden width. Utfyllnad görs med det angivna fillchar (standard är ett ASCII-rymd). Den ursprungliga strängen returneras om width är mindre än eller lika med len(s).

str.rpartition(sep, /)¶: Dela strängen vid den sista förekomsten av sep och returnera en 3-tupel som innehåller delen före separatorn, själva separatorn och delen efter separatorn. Om separatorn inte hittas, returneras en 3-tupel som innehåller två tomma strängar, följt av själva strängen.

str.rsplit(sep=None, maxsplit=-1)¶: Returnerar en lista med orden i strängen, med sep som avgränsningssträng. Om maxsplit anges görs högst maxsplit uppdelningar, de högst till höger. Om sep inte anges eller om None, är alla strängar med blanksteg en separator. Förutom att dela upp från höger, beter sig rsplit() som split() som beskrivs i detalj nedan.

str.rstrip(chars=None, /)¶

Returnerar en kopia av strängen med borttagna efterföljande tecken. Argumentet chars är en sträng som anger den uppsättning tecken som ska tas bort. Om det utelämnas eller None, är chars-argumentet standard för att ta bort blanksteg. Argumentet chars är inte ett suffix, utan alla kombinationer av dess värden tas bort:

>>> '   spacious   '.rstrip()
'   spacious'
>>> 'mississippi'.rstrip('ipz')
'mississ'

Se str.removesuffix() för en metod som tar bort en enda suffixsträng istället för alla tecken i en uppsättning. Till exempel:

>>> 'Monty Python'.rstrip(' Python')
'M'
>>> 'Monty Python'.removesuffix(' Python')
'Monty'

str.split(sep=None, maxsplit=-1)¶

Returnerar en lista med orden i strängen, med sep som avgränsningssträng. Om maxsplit anges görs högst maxsplit uppdelningar (listan kommer alltså att ha högst maxsplit+1 element). Om maxsplit inte anges eller -1, finns det ingen begränsning av antalet uppdelningar (alla möjliga uppdelningar görs).

Om sep anges, grupperas inte på varandra följande avgränsare tillsammans och anses avgränsa tomma strängar (till exempel returnerar '1,,2'.split(',') ['1', '', '2']). Argumentet sep kan bestå av flera tecken som en enda avgränsare (för att dela med flera avgränsare, använd re.split()). Om en tom sträng delas med en angiven avgränsare returneras [''].

Till exempel:

>>> '1,2,3'.split(',')
['1', '2', '3']
>>> '1,2,3'.split(',', maxsplit=1)
['1', '2,3']
>>> '1,2,,3,'.split(',')
['1', '2', '', '3', '']
>>> '1<>2<>3<4'.split('<>')
['1', '2', '3<4']

Om sep inte anges eller är None används en annan delningsalgoritm: flera på varandra följande blanksteg betraktas som en enda separator, och resultatet innehåller inga tomma strängar i början eller slutet om strängen har inledande eller avslutande blanksteg. Om en tom sträng eller en sträng som bara består av blanksteg delas upp med en None-separator blir följaktligen resultatet [].

Till exempel:

>>> '1 2 3'.split()
['1', '2', '3']
>>> '1 2 3'.split(maxsplit=1)
['1', '2 3']
>>> '   1   2   3   '.split()
['1', '2', '3']

Om sep inte anges eller är None och maxsplit är 0, beaktas endast ledande serier av på varandra följande blanksteg.

Till exempel:

>>> "".split(None, 0)
[]
>>> "   ".split(None, 0)
[]
>>> "   foo   ".split(maxsplit=0)
['foo   ']

str.splitlines(keepends=False)¶

Returnerar en lista över raderna i strängen, med radbrytning vid radgränser. Radbrytningar inkluderas inte i den resulterande listan om inte keepends anges och är true.

Denna metod delar på följande linjegränser. I synnerhet är gränserna en övermängd av universal newlines.

Representation	Beskrivning
`\n`	Linje matning
`\r`	Vagnretur
`R\n`	Vagnretur + radmatning
”v” eller ”x0b	Linjetabellering
”f” eller ”x0c	Formulärmatning
`x1c`	Filavskiljare
`x1d`	Gruppseparator
`x1e`	Skivseparator
`\x85`	Nästa rad (C1-kontrollkod)
`\u2028`	Separatorlinje
`\u2029`	Paragrafavskiljare

Ändrad i version 3.2: ”v” och ”f” läggs till i listan över linjegränser.

Till exempel:

>>> 'ab c\n\nde fg\rkl\r\n'.splitlines()
['ab c', '', 'de fg', 'kl']
>>> 'ab c\n\nde fg\rkl\r\n'.splitlines(keepends=True)
['ab c\n', '\n', 'de fg\r', 'kl\r\n']

Till skillnad från split() när en avgränsningssträng sep anges, returnerar den här metoden en tom lista för den tomma strängen, och en terminal radbrytning resulterar inte i en extra rad:

>>> "".splitlines()
[]
>>> "One line\n".splitlines()
['One line']

Som jämförelse ger split('\n'):

>>> ''.split('\n')
['']
>>> 'Two lines\n'.split('\n')
['Two lines', '']

str.startswith(prefix[, start[, end]])¶: Returnerar True om strängen börjar med prefixet, annars returneras False. prefix kan också vara en tupel av prefix att leta efter. Med valfri start, testa strängen som börjar vid den positionen. Med valfri end, sluta jämföra strängen vid den positionen.

str.strip(chars=None, /)¶

Returnerar en kopia av strängen med de inledande och avslutande tecknen borttagna. Argumentet chars är en sträng som anger den uppsättning tecken som ska tas bort. Om det utelämnas eller None, är chars-argumentet standard för att ta bort blanksteg. Argumentet chars är inte ett prefix eller suffix, utan alla kombinationer av dess värden tas bort:

>>> '   spacious   '.strip()
'spacious'
>>> 'www.example.com'.strip('cmowz.')
'example'

De yttersta inledande och avslutande chars-argumentvärdena tas bort från strängen. Tecken tas bort från den främre änden tills man når ett strängtecken som inte ingår i teckenuppsättningen i chars. En liknande åtgärd sker i den bakre änden. Till exempel:

>>> comment_string = '#....... Section 3.2.1 Issue #32 .......'
>>> comment_string.strip('.#! ')
'Section 3.2.1 Issue #32'

str.swapcase()¶: Returnerar en kopia av strängen med versaler omvandlade till gemener och vice versa. Observera att det inte nödvändigtvis är sant att s.swapcase().swapcase() == s.

str.title()¶

Returnerar en titelanpassad version av strängen där orden börjar med en versal och övriga tecken är gemener.

Till exempel:

>>> 'Hello world'.title()
'Hello World'

Algoritmen använder en enkel språkoberoende definition av ett ord som grupper av på varandra följande bokstäver. Definitionen fungerar i många sammanhang men innebär att apostrofer i sammandragningar och possessiver bildar ordgränser, vilket kanske inte är det önskade resultatet:

>>> "they're bill's friends from the UK".title()
"They'Re Bill'S Friends From The Uk"

Funktionen string.capwords() har inte detta problem, eftersom den endast delar upp ord efter mellanslag.

Alternativt kan en lösning för apostrofer konstrueras med hjälp av reguljära uttryck:

>>> import re
>>> def titlecase(s):
...     return re.sub(r"[A-Za-z]+('[A-Za-z]+)?",
...                   lambda mo: mo.group(0).capitalize(),
...                   s)
...
>>> titlecase("they're bill's friends.")
"They're Bill's Friends."

str.translate(table, /)¶

Returnerar en kopia av strängen där varje tecken har mappats genom den angivna översättningstabellen. Tabellen måste vara ett objekt som implementerar indexering via __getitem__(), vanligtvis en mapping eller sequence. När tabellen indexeras med en Unicode-ordinal (ett heltal) kan tabellobjektet göra något av följande: returnera en Unicode-ordinal eller en sträng, för att mappa tecknet till ett eller flera andra tecken; returnera None, för att ta bort tecknet från retursträngen; eller skapa ett LookupError-undantag, för att mappa tecknet till sig själv.

Du kan använda str.maketrans() för att skapa en översättningsmappning från tecken-till-tecken-mappningar i olika format.

Se även modulen codecs för en mer flexibel metod för anpassade teckenmappningar.

str.upper()¶

Returnerar en kopia av strängen med alla tecken med versaler [4] konverterade till versaler. Observera att s.upper().isupper() kan vara False om s innehåller obehandlade tecken eller om Unicode-kategorin för de resulterande tecknen inte är ”Lu” (Letter, uppercase), utan t.ex. ”Lt” (Letter, titlecase).

Den uppercasing-algoritm som används beskrivs i avsnitt 3.13 ”Default Case Folding” i Unicode-standarden.

str.zfill(width, /)¶

Returnerar en kopia av strängen som fyllts med ASCII '0' siffror för att skapa en sträng med längden bredd. Ett ledande teckenprefix ('+'/'-') hanteras genom att utfyllnaden infogas efter tecknet i stället för före. Den ursprungliga strängen returneras om width är mindre än eller lika med len(s).

Till exempel:

>>> "42".zfill(5)
'00042'
>>> "-42".zfill(5)
'-0042'

Formaterade strängbokstäver (f-strängar)¶

Tillagd i version 3.6.

Ändrad i version 3.7: await och async for kan användas i uttryck inom f-strängar.

Ändrad i version 3.8: Lagt till felsökningsoperatorn (=)

Ändrad i version 3.12: Många restriktioner för uttryck inom f-strängar har tagits bort. Bland annat är nästlade strängar, kommentarer och backslash nu tillåtna.

En f-string (formellt en formatted string literal) är en stränglitual som har prefixet f eller F. Den här typen av stränglital möjliggör inbäddning av godtyckliga Python-uttryck i ersättningsfält, som avgränsas av hakparenteser ({}). Dessa uttryck utvärderas vid körning, på liknande sätt som str.format(), och konverteras till vanliga str-objekt. Ett exempel:

>>> who = 'nobody'
>>> nationality = 'Spanish'
>>> f'{who.title()} expects the {nationality} Inquisition!'
'Nobody expects the Spanish Inquisition!'

Det är också möjligt att använda en f-sträng med flera linjer:

>>> f'''This is a string
... on two lines'''
'This is a string\non two lines'

En enda öppnande hakparentes, '{', markerar ett ersättningsfält som kan innehålla vilket Python-uttryck som helst:

>>> nationality = 'Spanish'
>>> f'The {nationality} Inquisition!'
'The Spanish Inquisition!'

För att inkludera en bokstavlig { eller }, använd en dubbelparentes:

>>> x = 42
>>> f'{{x}} is {x}'
'{x} is 42'

Funktioner kan också användas och formatangivelser:

>>> from math import sqrt
>>> f'√2 \N{ALMOST EQUAL TO} {sqrt(2):.5f}'
'√2 ≈ 1.41421'

Alla uttryck som inte är strängar konverteras som standard med str():

>>> from fractions import Fraction
>>> f'{Fraction(1, 3)}'
'1/3'

För att använda en explicit konvertering, använd operatorn ! (utropstecken), följt av något av de giltiga formaten, vilka är:

Konvertering	Betydelse
`!a`	`ascii()`
`!r`	`repr()`
`!s`	`str()`

Till exempel:

>>> from fractions import Fraction
>>> f'{Fraction(1, 3)!s}'
'1/3'
>>> f'{Fraction(1, 3)!r}'
'Fraction(1, 3)'
>>> question = '¿Dónde está el Presidente?'
>>> print(f'{question!a}')
'\xbfD\xf3nde est\xe1 el Presidente?'

Vid felsökning kan det vara till hjälp att se både uttrycket och dess värde genom att använda likhetstecknet (=) efter uttrycket. Detta bevarar mellanslag inom parenteserna och kan användas med en konverterare. Som standard använder debugging-operatorn konverteringen repr() (!r). Till exempel

>>> from fractions import Fraction
>>> calculation = Fraction(1, 3)
>>> f'{calculation=}'
'calculation=Fraction(1, 3)'
>>> f'{calculation = }'
'calculation = Fraction(1, 3)'
>>> f'{calculation = !s}'
'calculation = 1/3'

När utdata har utvärderats kan de formateras med hjälp av formatspecificerare efter ett kolon (':'). När uttrycket har utvärderats och eventuellt konverterats till en sträng anropas resultatets __format__()-metod med formatangivaren, eller den tomma strängen om ingen formatangivelse anges. Det formaterade resultatet används sedan som det slutliga värdet för ersättningsfältet. Till exempel

>>> from fractions import Fraction
>>> f'{Fraction(1, 7):.6f}'
'0.142857'
>>> f'{Fraction(1, 7):_^+10}'
'___+1/7___'

strängformatering i stil med `printf`¶

Anteckning

De formateringsåtgärder som beskrivs här uppvisar en rad egenheter som leder till ett antal vanliga fel (t.ex. att tupler och ordböcker inte visas korrekt).

Genom att använda formaterade strängkonstanter, gränssnittet str.format() eller string.Template kan du undvika dessa fel. Var och en av dessa alternativ har sina egna för- och nackdelar när det gäller enkelhet, flexibilitet och/eller utbyggbarhet.

Strängobjekt har en unik inbyggd operation: operatorn % (modulo). Den är också känd som strängens formatering eller interpolering-operator. Givet format % värden (där format är en sträng), ersätts % konverteringsspecifikationer i format med noll eller flera element i värden. Effekten liknar användningen av funktionen sprintf() i C-språket. Ett exempel:

>>> print('%s has %d quote types.' % ('Python', 2))
Python has 2 quote types.

Om format kräver ett enda argument kan values vara ett enda objekt som inte är en tupel. [5] Annars måste values vara en tupel med exakt det antal objekt som anges i formatsträngen, eller ett enda mappningsobjekt (t.ex. en ordbok).

En konverteringsspecifikator innehåller två eller flera tecken och har följande komponenter, som måste förekomma i denna ordning:

Tecknet '%', som markerar början på specifikationen.
Mappningsnyckel (valfri) som består av en sekvens av tecken inom parentes (t.ex. (somename)).
Konverteringsflaggor (valfritt), som påverkar resultatet av vissa konverteringstyper.
Minsta fältbredd (valfritt). Om den anges som en '*' (asterisk) läses den faktiska bredden från nästa element i tupeln i values, och objektet som ska konverteras kommer efter den minsta fältbredden och den valfria precisionen.
Precision (valfri), anges som en '.' (punkt) följt av precisionen. Om den anges som '*' (en asterisk) läses den faktiska precisionen från nästa element i tupeln i values, och värdet som ska konverteras kommer efter precisionen.
Längdmodifierare (valfritt).
Typ av konvertering.

När det högra argumentet är en ordbok (eller annan mappningstyp), måste formaten i strängen inkludera en parentetisk mappningsnyckel till ordboken som infogas omedelbart efter tecknet '%'. Mappningsnyckeln väljer det värde som ska formateras från mappningen. Till exempel

>>> print('%(language)s has %(number)03d quote types.' %
...       {'language': "Python", "number": 2})
Python has 002 quote types.

I detta fall får inga *-specifikatorer förekomma i ett format (eftersom de kräver en sekventiell parameterlista).

Konverteringens flaggtecken är:

Flagga	Betydelse
`'#'`	Värdeomvandlingen kommer att använda den ”alternativa formen” (enligt definitionen nedan).
`'0'`	Omvandlingen kommer att nollställas för numeriska värden.
`'-'`	Det konverterade värdet lämnas justerat (åsidosätter konverteringen `'0'` om båda anges).
`' '`	(ett mellanslag) Ett mellanslag ska lämnas före ett positivt tal (eller en tom sträng) som produceras genom en signerad konvertering.
`'+'`	Ett tecken (`'+'` eller `'-'`) kommer att föregå konverteringen (åsidosätter en ”mellanslagsflagga”).

En längdmodifierare (h, l eller L) kan förekomma, men ignoreras eftersom den inte är nödvändig för Python - så t.ex. %ld är identisk med %d.

Konverteringstyperna är:

Konvertering	Betydelse	Anteckningar
`'d'`	Decimalt heltal med tecken.
`'i'`	Decimalt heltal med tecken.
`'o'`	Sekvenserat oktalt värde.	(1)
`'u'`	Föråldrad typ - identisk med `'d'`.	(6)
`'x'`	Signerad hexadecimal (gemener).	(2)
`'X'`	Signerad hexadecimal (versaler).	(2)
`'e'`	Exponentiellt format för flyttal (små bokstäver).	(3)
`'E'`	Exponentiellt format för flyttal (versaler).	(3)
`'f'`	Decimalformat för flyttal.	(3)
`'F'`	Decimalformat för flyttal.	(3)
`'g'`	Flyttalsformat. Använder exponentiellt format med gemener om exponenten är mindre än -4 eller inte mindre än precision, annars decimalformat.	(4)
`'G'`	Flyttalsformat. Använder exponentiellt format med versaler om exponenten är mindre än -4 eller inte mindre än precision, annars decimalformat.	(4)
`'c'`	Enstaka tecken (accepterar heltal eller sträng med enstaka tecken).
`'r'`	String (konverterar valfritt Python-objekt med `repr()`).	(5)
`'s'`	String (konverterar valfritt Python-objekt med `str()`).	(5)
`'a'`	String (konverterar valfritt Python-objekt med `ascii()`).	(5)
`'%'`	Inget argument konverteras, vilket resulterar i ett `'%'`-tecken i resultatet.

Anteckningar:

Den alternativa formen innebär att en ledande oktalspecifikator ('0o') infogas före den första siffran.
Den alternativa formen gör att en inledande '0x' eller '0X' (beroende på om formatet 'x' eller 'X' användes) infogas före den första siffran.
Den alternativa formen gör att resultatet alltid innehåller en decimalpunkt, även om inga siffror följer efter den.

Precisionen bestämmer antalet siffror efter decimaltecknet och är som standard 6.
Den alternativa formen gör att resultatet alltid innehåller en decimalpunkt och att efterföljande nollor inte tas bort som de annars skulle ha gjort.

Precisionen bestämmer antalet signifikanta siffror före och efter decimaltecknet och är som standard 6.
Om precision är N trunkeras utdata till N tecken.
Se PEP 237.

Eftersom Python-strängar har en explicit längd, antar inte %s-konverteringar att '\0' är slutet på strängen.

Ändrad i version 3.1: %f-konverteringar för tal vars absoluta värde är över 1e50 ersätts inte längre av %g-konverteringar.

Binära sekvenstyper — `bytes`, `bytearray`, `memoryview`¶

De viktigaste inbyggda typerna för att manipulera binära data är bytes och bytearray. De stöds av memoryview som använder buffer protocol för att komma åt minnet hos andra binära objekt utan att behöva göra en kopia.

Modulen array stöder effektiv lagring av grundläggande datatyper som 32-bitars heltal och flytande värden med dubbel precision enligt IEEE754.

Bytes-objekt¶

Bytesobjekt är oföränderliga sekvenser av enstaka bytes. Eftersom många större binära protokoll baseras på ASCII-textkodningen erbjuder bytesobjekt flera metoder som endast är giltiga när man arbetar med ASCII-kompatibla data och är nära besläktade med strängobjekt på en mängd andra sätt.

class bytes(source=b'')¶

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

För det första är syntaxen för bytes-litteraler i stort sett densamma som för sträng-litteraler, förutom att prefixet b läggs till:

Enkla citattecken: b'still allows embedded "double" quotes'
Dubbla citattecken: b"still allows embedded 'single' quotes"
Tredubbla citat: b"''3 enkla citattecken''', b""'3 dubbla citattecken'""

Endast ASCII-tecken är tillåtna i byteslitteraler (oavsett den deklarerade källkodskodningen). Alla binära värden över 127 måste anges i byteslitteraler med hjälp av lämplig escape-sekvens.

Precis som med stränglitteraler kan byteslitteraler också använda prefixet r för att inaktivera bearbetning av escape-sekvenser. Se Sträng- och Bytes-litteraler för mer information om de olika formerna av bytes-litteraler, inklusive escape-sekvenser som stöds.

Medan bytes literaler och representationer är baserade på ASCII-text, beter sig bytes objekt faktiskt som oföränderliga sekvenser av heltal, med varje värde i sekvensen begränsat så att 0 <= x < 256 (försök att bryta mot denna begränsning kommer att utlösa ValueError). Detta görs avsiktligt för att betona att även om många binära format innehåller ASCII-baserade element och kan manipuleras med vissa textorienterade algoritmer, så är detta inte generellt fallet för godtyckliga binära data (att blint tillämpa textbehandlingsalgoritmer på binära dataformat som inte är ASCII-kompatibla leder vanligtvis till att data korrumperas).

Förutom de bokstavliga formerna kan bytesobjekt skapas på ett antal andra sätt:

Ett nollfyllt bytesobjekt med en angiven längd: bytes(10)
Från en iterabel av heltal: bytes(range(20))
Kopiering av befintliga binära data via buffertprotokollet: bytes(obj)

Se även den inbyggda bytes.

Eftersom 2 hexadecimala siffror exakt motsvarar en enda byte är hexadecimala tal ett vanligt format för att beskriva binära data. Bytes-typen har därför en extra klassmetod för att läsa data i det formatet:

classmethod fromhex(string, /)¶

Denna klassmetod bytes returnerar ett bytes-objekt som avkodar det givna strängobjektet. Strängen måste innehålla två hexadecimala siffror per byte, med ASCII-teckensnitt som ignoreras.

>>> bytes.fromhex('2Ef0 F1f2  ')
b'.\xf0\xf1\xf2'

Ändrad i version 3.7: bytes.fromhex() hoppar nu över alla ASCII-teckensnitt i strängen, inte bara mellanslag.

Ändrad i version 3.14: bytes.fromhex() accepterar nu ASCII bytes och bytesliknande objekt som indata.

En omvänd konverteringsfunktion finns för att omvandla ett bytesobjekt till dess hexadecimala representation.

hex(*, bytes_per_sep=1)¶

hex(sep, bytes_per_sep=1)

Returnerar ett strängobjekt som innehåller två hexadecimala siffror för varje byte i instansen.

>>> b'\xf0\xf1\xf2'.hex()
'f0f1f2'

Om du vill göra hexsträngen mer lättläst kan du ange en parameter för en teckenseparator sep som ska inkluderas i utdata. Som standard kommer denna separator att inkluderas mellan varje byte. En andra valfri parameter bytes_per_sep styr avståndet. Positiva värden beräknar separatorns position från höger, negativa värden från vänster.

>>> value = b'\xf0\xf1\xf2'
>>> value.hex('-')
'f0-f1-f2'
>>> value.hex('_', 2)
'f0_f1f2'
>>> b'UUDDLRLRAB'.hex(' ', -4)
'55554444 4c524c52 4142'

Tillagd i version 3.5.

Ändrad i version 3.8: bytes.hex() har nu stöd för de valfria parametrarna sep och bytes_per_sep för att infoga separatorer mellan byte i hex-utdata.

Eftersom bytesobjekt är sekvenser av heltal (liknande en tupel), för ett bytesobjekt b, kommer b[0] att vara ett heltal, medan b[0:1] kommer att vara ett bytesobjekt av längd 1. (Detta står i kontrast till textsträngar, där både indexering och skivning kommer att producera en sträng av längd 1)

Representationen av bytes-objekt använder det bokstavliga formatet (b'...') eftersom det ofta är mer användbart än t.ex. bytes([46, 46, 46]). Du kan alltid konvertera ett bytesobjekt till en lista med heltal med hjälp av list(b).

Bytearray-objekt¶

bytearray-objekt är en föränderlig motsvarighet till bytes-objekt.

class bytearray(source=b'')¶

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

Det finns ingen särskild litteral syntax för bytearray-objekt, utan de skapas alltid genom att anropa konstruktören:

Skapa en tom instans: bytearray()
Skapa en nollfylld instans med en given längd: bytearray(10)
Från en iterabel av heltal: bytearray(range(20))
Kopiering av befintliga binära data via buffertprotokollet: bytearray(b'Hej!')

Eftersom bytearray-objekt är mutabla stöder de mutable sekvensoperationer utöver de vanliga bytes- och bytearray-operationer som beskrivs i Bytes- och bytearrayoperationer.

Se även den inbyggda bytearray.

Eftersom 2 hexadecimala siffror exakt motsvarar en enda byte är hexadecimala tal ett vanligt format för att beskriva binära data. Följaktligen har bytearray-typen en extra klassmetod för att läsa data i det formatet:

classmethod fromhex(string, /)¶

Denna bytearray-klassmetod returnerar bytearray-objekt, som avkodar det givna strängobjektet. Strängen måste innehålla två hexadecimala siffror per byte, med ASCII-teckensnitt som ignoreras.

>>> bytearray.fromhex('2Ef0 F1f2  ')
bytearray(b'.\xf0\xf1\xf2')

Ändrad i version 3.7: bytearray.fromhex() hoppar nu över alla ASCII-teckensnitt i strängen, inte bara mellanslag.

Ändrad i version 3.14: bytearray.fromhex() accepterar nu ASCII bytes och bytesliknande objekt som indata.

En omvänd konverteringsfunktion finns för att omvandla ett bytearray-objekt till dess hexadecimala representation.

hex(*, bytes_per_sep=1)¶

hex(sep, bytes_per_sep=1)

Returnerar ett strängobjekt som innehåller två hexadecimala siffror för varje byte i instansen.

>>> bytearray(b'\xf0\xf1\xf2').hex()
'f0f1f2'

Tillagd i version 3.5.

Ändrad i version 3.8: I likhet med bytes.hex() har bytearray.hex() nu stöd för de valfria parametrarna sep och bytes_per_sep för att infoga separatorer mellan byte i hex-utdata.

resize(size, /)¶

Ändra storlek på bytearray så att den innehåller size bytes. size måste vara större än eller lika med 0.

Om bytearray behöver krympas, trunkeras byte som är större än size.

Om bytearray behöver växa kommer alla nya bytes, de som överstiger size, att sättas till null bytes.

Detta är likvärdigt med:

>>> def resize(ba, size):
...     if len(ba) > size:
...         del ba[size:]
...     else:
...         ba += b'\0' * (size - len(ba))

Exempel:

>>> shrink = bytearray(b'abc')
>>> shrink.resize(1)
>>> (shrink, len(shrink))
(bytearray(b'a'), 1)
>>> grow = bytearray(b'abc')
>>> grow.resize(5)
>>> (grow, len(grow))
(bytearray(b'abc\x00\x00'), 5)

Tillagd i version 3.14.

Eftersom bytearray-objekt är sekvenser av heltal (i likhet med en lista), kommer b[0] för ett bytearray-objekt b att vara ett heltal, medan b[0:1] kommer att vara ett bytearray-objekt med längden 1. (Detta står i kontrast till textsträngar, där både indexering och skivning kommer att producera en sträng med längden 1)

Representationen av bytearray-objekt använder bytes literal-formatet (bytearray(b'...')) eftersom det ofta är mer användbart än t.ex. bytearray([46, 46, 46]). Du kan alltid konvertera ett bytearray-objekt till en lista med heltal med hjälp av list(b).

Bytes- och bytearrayoperationer¶

Både bytes och bytearray-objekt stöder common sekvensoperationer. De fungerar inte bara med operander av samma typ, utan med alla bytesliknande objekt. På grund av denna flexibilitet kan de blandas fritt i operationer utan att orsaka fel. Returtypen för resultatet kan dock bero på ordningen på operanderna.

Anteckning

Metoderna för bytes och bytearray-objekt accepterar inte strängar som argument, precis som metoderna för strängar inte accepterar bytes som argument. Till exempel måste du skriva:

a = "abc"
b = a.replace("a", "f")

och:

a = b"abc"
b = a.replace(b"a", b"f")

Vissa bytes- och bytearrayoperationer förutsätter användning av ASCII-kompatibla binära format och bör därför undvikas när man arbetar med godtyckliga binära data. Dessa begränsningar beskrivs nedan.

Anteckning

Om dessa ASCII-baserade operationer används för att manipulera binära data som inte lagras i ett ASCII-baserat format kan det leda till att data korrumperas.

Följande metoder för bytes och bytearray-objekt kan användas med godtyckliga binära data.

bytes.count(sub[, start[, end]])¶

bytearray.count(sub[, start[, end]])¶

Returnerar antalet icke-överlappande förekomster av undersekvensen sub i intervallet [start, slut]. De valfria argumenten start och slut tolkas som i slice-notation.

Den undersekvens som ska sökas kan vara valfri bytesliknande objekt eller ett heltal i intervallet 0 till 255.

Om sub är tomt, returneras antalet tomma delar mellan tecken, vilket är bytesobjektets längd plus ett.

Ändrad i version 3.3: Acceptera också ett heltal i intervallet 0 till 255 som undersekvens.

bytes.removeprefix(prefix, /)¶

bytearray.removeprefix(prefix, /)¶

Om de binära data börjar med strängen prefix, returneras bytes[len(prefix):]. I annat fall returneras en kopia av den ursprungliga binära datan:

>>> b'TestHook'.removeprefix(b'Test')
b'Hook'
>>> b'BaseTestCase'.removeprefix(b'Test')
b'BaseTestCase'

prefixet kan vara valfri bytesliknande objekt.

Anteckning

Bytearray-versionen av den här metoden fungerar inte på plats - den producerar alltid ett nytt objekt, även om inga ändringar har gjorts.

Tillagd i version 3.9.

bytes.removesuffix(suffix, /)¶

bytearray.removesuffix(suffix, /)¶

Om de binära data slutar med strängen suffix och suffix inte är tomt, returneras bytes[:-len(suffix)]. I annat fall returneras en kopia av de ursprungliga binära data:

>>> b'MiscTests'.removesuffix(b'Tests')
b'Misc'
>>> b'TmpDirMixin'.removesuffix(b'Tests')
b'TmpDirMixin'

Suffix kan vara valfri bytesliknande objekt.

Anteckning

Bytearray-versionen av den här metoden fungerar inte på plats - den producerar alltid ett nytt objekt, även om inga ändringar har gjorts.

Tillagd i version 3.9.

bytes.decode(encoding='utf-8', errors='strict')¶

bytearray.decode(encoding='utf-8', errors='strict')¶

Returnera byte som avkodats till en str.

encoding är som standard 'utf-8'; se Standardkodningar för möjliga värden.

errors styr hur avkodningsfel ska hanteras. Om 'strict' (standard), kommer ett UnicodeError undantag att skapas. Andra möjliga värden är 'ignore', 'replace', och alla andra namn som registreras via codecs.register_error(). Se Felhanterare för detaljer.

Av prestandaskäl kontrolleras inte värdet på errors om inte ett avkodningsfel faktiskt inträffar, Python-utvecklingsläge är aktiverat eller en debug build används.

Anteckning

Genom att skicka argumentet encoding till str kan man avkoda alla bytes-like object direkt, utan att behöva skapa ett tillfälligt bytes- eller bytearray-objekt.

Ändrad i version 3.1: Stöd för nyckelordsargument har lagts till.

Ändrad i version 3.9: Värdet på errors-argumentet kontrolleras nu i Python-utvecklingsläge och i debug mode.

bytes.endswith(suffix[, start[, end]])¶

bytearray.endswith(suffix[, start[, end]])¶

Returnerar True om binärdata slutar med det angivna suffixet, annars returneras False. suffix kan också vara en tupel av suffix att leta efter. Med valfri start börjar testet vid den positionen. Med valfri end, sluta jämföra vid den positionen.

Suffixet (suffixen) som skall sökas efter kan vara valfri bytesliknande objekt.

bytes.find(sub[, start[, end]])¶

bytearray.find(sub[, start[, end]])¶

Returnerar det lägsta indexet i data där undersekvensen sub finns, så att sub finns i skivan s[start:end]. De valfria argumenten start och end tolkas som i slice-notation. Returnerar -1 om sub inte hittas.

Den undersekvens som ska sökas kan vara valfri bytesliknande objekt eller ett heltal i intervallet 0 till 255.

Anteckning

Metoden find() bör endast användas om du behöver veta positionen för sub. Om du vill kontrollera om sub är en delsträng eller inte använder du operatorn in:

>>> b'Py' in b'Python'
True

Ändrad i version 3.3: Acceptera också ett heltal i intervallet 0 till 255 som undersekvens.

bytes.index(sub[, start[, end]])¶

bytearray.index(sub[, start[, end]])¶

Som find(), men ger upphov till ValueError när undersekvensen inte hittas.

Den undersekvens som ska sökas kan vara valfri bytesliknande objekt eller ett heltal i intervallet 0 till 255.

Ändrad i version 3.3: Acceptera också ett heltal i intervallet 0 till 255 som undersekvens.

bytes.join(iterable, /)¶
bytearray.join(iterable, /)¶: Returnerar ett bytes- eller bytearray-objekt som är sammankopplingen av de binära datasekvenserna i iterable. Ett TypeError kommer att tas upp om det finns några värden i iterable som inte är bytesliknande objekt, inklusive str-objekt. Separatorn mellan elementen är innehållet i bytes- eller bytearray-objektet som tillhandahåller denna metod.

static bytes.maketrans(from, to, /)¶
static bytearray.maketrans(from, to, /)¶: Denna statiska metod returnerar en översättningstabell användbar för bytes.translate() som mappar varje tecken i from till tecknet på samma position i to; from och to måste båda vara bytes-like objects och ha samma längd.

Tillagd i version 3.1.

bytes.partition(sep, /)¶

bytearray.partition(sep, /)¶

Dela sekvensen vid den första förekomsten av sep och returnera en 3-tupel som innehåller delen före separatorn, själva separatorn eller dess bytearray-kopia och delen efter separatorn. Om separatorn inte hittas returneras en 3-tupel som innehåller en kopia av den ursprungliga sekvensen, följt av två tomma bytes eller bytearray-objekt.

Separatorn att söka efter kan vara valfri bytesliknande objekt.

bytes.replace(old, new, count=-1, /)¶

bytearray.replace(old, new, count=-1, /)¶

Returnerar en kopia av sekvensen med alla förekomster av undersekvensen old ersatta av new. Om det valfria argumentet count anges, ersätts endast de första count förekomsterna.

Den undersekvens som ska sökas och dess ersättning kan vara valfri bytesliknande objekt.

Anteckning

Bytearray-versionen av den här metoden fungerar inte på plats - den producerar alltid ett nytt objekt, även om inga ändringar har gjorts.

bytes.rfind(sub[, start[, end]])¶

bytearray.rfind(sub[, start[, end]])¶

Returnerar det högsta indexet i sekvensen där undersekvensen sub finns, så att sub ingår i s[start:end]. De valfria argumenten start och end tolkas som i slice-notation. Returnerar -1 om den misslyckas.

Den undersekvens som ska sökas kan vara valfri bytesliknande objekt eller ett heltal i intervallet 0 till 255.

Ändrad i version 3.3: Acceptera också ett heltal i intervallet 0 till 255 som undersekvens.

bytes.rindex(sub[, start[, end]])¶

bytearray.rindex(sub[, start[, end]])¶

Som rfind() men ger upphov till ValueError när undersekvensen sub inte hittas.

Den undersekvens som ska sökas kan vara valfri bytesliknande objekt eller ett heltal i intervallet 0 till 255.

Ändrad i version 3.3: Acceptera också ett heltal i intervallet 0 till 255 som undersekvens.

bytes.rpartition(sep, /)¶

bytearray.rpartition(sep, /)¶

Dela sekvensen vid den sista förekomsten av sep, och returnera en 3-tupel som innehåller delen före separatorn, själva separatorn eller dess bytearray-kopia, och delen efter separatorn. Om separatorn inte hittas returneras en 3-tupel som innehåller två tomma bytes eller bytearray-objekt, följt av en kopia av den ursprungliga sekvensen.

Separatorn att söka efter kan vara valfri bytesliknande objekt.

bytes.startswith(prefix[, start[, end]])¶

bytearray.startswith(prefix[, start[, end]])¶

Returnerar True om de binära data börjar med det angivna prefixet, annars returneras False. prefix kan också vara en tupel av prefix att leta efter. Med valfri start börjar testet vid den positionen. Med valfri end, sluta jämföra vid den positionen.

Prefixet/prefixen att söka efter kan vara valfri bytesliknande objekt.

bytes.translate(table, /, delete=b'')¶

bytearray.translate(table, /, delete=b'')¶

Returnerar en kopia av bytes- eller bytearray-objektet där alla bytes som förekommer i det valfria argumentet delete har tagits bort, och de återstående bytesen har mappats genom den angivna översättningstabellen, som måste vara ett bytes-objekt med längden 256.

Du kan använda metoden bytes.maketrans() för att skapa en översättningstabell.

Sätt argumentet table till None för översättningar som bara tar bort tecken:

>>> b'read this short text'.translate(None, b'aeiou')
b'rd ths shrt txt'

Ändrad i version 3.6: delete stöds nu som ett nyckelordsargument.

Följande metoder för bytes och bytearray-objekt har standardbeteenden som förutsätter användning av ASCII-kompatibla binära format, men kan ändå användas med godtyckliga binära data genom att lämpliga argument anges. Observera att alla bytearray-metoder i det här avsnittet inte fungerar på plats, utan istället producerar nya objekt.

bytes.center(width, fillbyte=b' ', /)¶
bytearray.center(width, fillbyte=b' ', /)¶: Returnerar en kopia av objektet centrerat i en sekvens med längden width. Utfyllnad görs med hjälp av den angivna fillbyte (standard är ett ASCII-utrymme). För bytes-objekt returneras originalsekvensen om width är mindre än eller lika med len(s).

Anteckning

Bytearray-versionen av den här metoden fungerar inte på plats - den producerar alltid ett nytt objekt, även om inga ändringar har gjorts.

bytes.ljust(width, fillbyte=b' ', /)¶
bytearray.ljust(width, fillbyte=b' ', /)¶: Returnerar en kopia av objektet vänsterjusterat i en sekvens med längden bredd. Utfyllnad görs med hjälp av den angivna fillbyte (standard är ett ASCII-utrymme). För bytes-objekt returneras originalsekvensen om width är mindre än eller lika med len(s).

Anteckning

Bytearray-versionen av den här metoden fungerar inte på plats - den producerar alltid ett nytt objekt, även om inga ändringar har gjorts.

bytes.lstrip(bytes=None, /)¶

bytearray.lstrip(bytes=None, /)¶

Returnera en kopia av sekvensen med angivna inledande byte borttagna. Argumentet bytes är en binär sekvens som anger uppsättningen bytevärden som ska tas bort. Om det utelämnas eller är None, tas ASCII-mellanslag bort som standard. Argumentet bytes är inte ett prefix; istället tas alla kombinationer av dess värden bort:

>>> b'   spacious   '.lstrip()
b'spacious   '
>>> b'www.example.com'.lstrip(b'cmowz.')
b'example.com'

Den binära sekvensen av bytevärden som ska tas bort kan vara valfri bytesliknande objekt. Se removeprefix() för en metod som tar bort en enda prefixsträng i stället för alla tecken i en uppsättning. Till exempel:

>>> b'Arthur: three!'.lstrip(b'Arthur: ')
b'ee!'
>>> b'Arthur: three!'.removeprefix(b'Arthur: ')
b'three!'

Anteckning

Bytearray-versionen av den här metoden fungerar inte på plats - den producerar alltid ett nytt objekt, även om inga ändringar har gjorts.

bytes.rjust(width, fillbyte=b' ', /)¶
bytearray.rjust(width, fillbyte=b' ', /)¶: Returnerar en kopia av objektet högerställd i en sekvens med längd bredd. Utfyllnad görs med hjälp av den angivna fillbyte (standard är ett ASCII-utrymme). För bytes-objekt returneras originalsekvensen om width är mindre än eller lika med len(s).

Anteckning

Bytearray-versionen av den här metoden fungerar inte på plats - den producerar alltid ett nytt objekt, även om inga ändringar har gjorts.

bytes.rsplit(sep=None, maxsplit=-1)¶
bytearray.rsplit(sep=None, maxsplit=-1)¶: Dela upp den binära sekvensen i undersekvenser av samma typ, med sep som avgränsningssträng. Om maxsplit anges görs högst maxsplit uppdelningar, de högst till höger. Om sep inte specificeras eller om None, är varje delsekvens som enbart består av ASCII-teckensnitt en separator. Förutom att dela upp från höger, beter sig rsplit() som split() som beskrivs i detalj nedan.

bytes.rstrip(bytes=None, /)¶

bytearray.rstrip(bytes=None, /)¶

Returnera en kopia av sekvensen med angivna efterföljande byte borttagna. Argumentet bytes är en binär sekvens som anger uppsättningen bytevärden som ska tas bort. Om det utelämnas eller är None, tas ASCII-mellanslag bort som standard. Argumentet bytes är inte ett suffix; istället tas alla kombinationer av dess värden bort:

>>> b'   spacious   '.rstrip()
b'   spacious'
>>> b'mississippi'.rstrip(b'ipz')
b'mississ'

Den binära sekvensen av bytevärden som ska tas bort kan vara valfritt bytesliknande objekt. Se removesuffix() för en metod som tar bort en enda suffixsträng i stället för alla tecken i en uppsättning. Till exempel:

>>> b'Monty Python'.rstrip(b' Python')
b'M'
>>> b'Monty Python'.removesuffix(b' Python')
b'Monty'

Anteckning

Bytearray-versionen av den här metoden fungerar inte på plats - den producerar alltid ett nytt objekt, även om inga ändringar har gjorts.

bytes.split(sep=None, maxsplit=-1)¶

bytearray.split(sep=None, maxsplit=-1)¶

Dela upp den binära sekvensen i undersekvenser av samma typ, med sep som avgränsningssträng. Om maxsplit anges och är icke-negativ görs högst maxsplit uppdelningar (listan kommer alltså att ha högst maxsplit+1 element). Om maxsplit inte anges eller är -1 finns det ingen begränsning av antalet uppdelningar (alla möjliga uppdelningar görs).

Om sep anges grupperas inte på varandra följande avgränsare och de anses avgränsa tomma undersekvenser (t.ex. b'1,,2'.split(b',') ger [b'1', b'', b'2']). Argumentet sep kan bestå av en multibyte-sekvens som en enda avgränsare. Om en tom sekvens delas med en angiven separator returneras [b''] eller [bytearray(b'')] beroende på vilken typ av objekt som delas. Argumentet sep kan vara valfri bytesliknande objekt.

Till exempel:

>>> b'1,2,3'.split(b',')
[b'1', b'2', b'3']
>>> b'1,2,3'.split(b',', maxsplit=1)
[b'1', b'2,3']
>>> b'1,2,,3,'.split(b',')
[b'1', b'2', b'', b'3', b'']
>>> b'1<>2<>3<4'.split(b'<>')
[b'1', b'2', b'3<4']

Om sep inte anges eller är None, används en annan delningsalgoritm: sekvenser av på varandra följande ASCII-teckensnitt betraktas som en enda separator, och resultatet innehåller inga tomma strängar i början eller slutet om sekvensen har inledande eller avslutande teckensnitt. Följaktligen returneras [] när en tom sekvens eller en sekvens som endast består av ASCII-teckensnitt utan en angiven separator delas.

Till exempel:

>>> b'1 2 3'.split()
[b'1', b'2', b'3']
>>> b'1 2 3'.split(maxsplit=1)
[b'1', b'2 3']
>>> b'   1   2   3   '.split()
[b'1', b'2', b'3']

bytes.strip(bytes=None, /)¶

bytearray.strip(bytes=None, /)¶

Returnera en kopia av sekvensen med angivna inledande och avslutande byte borttagna. Argumentet bytes är en binär sekvens som anger den uppsättning bytevärden som ska tas bort. Om det utelämnas eller är None, tas ASCII-mellanslag bort som standard. Argumentet bytes är inte ett prefix eller suffix; istället tas alla kombinationer av dess värden bort:

>>> b'   spacious   '.strip()
b'spacious'
>>> b'www.example.com'.strip(b'cmowz.')
b'example'

Den binära sekvensen av bytevärden som skall tas bort kan vara valfri bytesliknande objekt.

Anteckning

Bytearray-versionen av den här metoden fungerar inte på plats - den producerar alltid ett nytt objekt, även om inga ändringar har gjorts.

Följande metoder för bytes och bytearray-objekt förutsätter användning av ASCII-kompatibla binära format och bör inte tillämpas på godtyckliga binära data. Observera att alla bytearray-metoder i detta avsnitt inte arbetar på plats, utan istället producerar nya objekt.

bytes.capitalize()¶
bytearray.capitalize()¶: Returnerar en kopia av sekvensen där varje byte tolkas som ett ASCII-tecken och den första byten skrivs med stor bokstav och resten med liten bokstav. Bytevärden som inte är ASCII-värden skickas oförändrade.

Anteckning

Bytearray-versionen av den här metoden fungerar inte på plats - den producerar alltid ett nytt objekt, även om inga ändringar har gjorts.

bytes.expandtabs(tabsize=8)¶

bytearray.expandtabs(tabsize=8)¶

Returnerar en kopia av sekvensen där alla ASCII tabbtecken ersätts av ett eller flera ASCII-rymder, beroende på aktuell kolumn och angiven tabbstorlek. Tabbpositioner förekommer varje tabsize byte (standard är 8, vilket ger tabbpositioner i kolumnerna 0, 8, 16 och så vidare). För att expandera sekvensen sätts den aktuella kolumnen till noll och sekvensen undersöks byte för byte. Om byten är ett ASCII-tab-tecken (b'\t') infogas ett eller flera mellanslagstecken i resultatet tills den aktuella kolumnen är lika med nästa tab-position. (Tabbtecknet i sig kopieras inte.) Om den aktuella byten är en ASCII newline (b'\n') eller carriage return (b'\r') kopieras den och den aktuella kolumnen nollställs. Alla andra bytevärden kopieras oförändrade och den aktuella kolumnen ökas med ett oavsett hur bytevärdet representeras när det skrivs ut:

>>> b'01\t012\t0123\t01234'.expandtabs()
b'01      012     0123    01234'
>>> b'01\t012\t0123\t01234'.expandtabs(4)
b'01  012 0123    01234'

Anteckning

Bytearray-versionen av den här metoden fungerar inte på plats - den producerar alltid ett nytt objekt, även om inga ändringar har gjorts.

bytes.isalnum()¶

bytearray.isalnum()¶

Returnerar True om alla bytes i sekvensen är alfabetiska ASCII-tecken eller ASCIIdecimalsiffror och sekvensen inte är tom, annars False. Alfabetiska ASCII-tecken är de bytevärden som finns i sekvensen b'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'. ASCII decimalsiffror är de bytevärden i sekvensen b'0123456789'.

Till exempel:

>>> b'ABCabc1'.isalnum()
True
>>> b'ABC abc1'.isalnum()
False

bytes.isalpha()¶

bytearray.isalpha()¶

Returnerar True om alla bytes i sekvensen är alfabetiska ASCII-tecken och sekvensen inte är tom, annars False. Alfabetiska ASCII-tecken är de bytevärden som finns i sekvensen b'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'.

Till exempel:

>>> b'ABCabc'.isalpha()
True
>>> b'ABCabc1'.isalpha()
False

bytes.isascii()¶
bytearray.isascii()¶: Returnerar True om sekvensen är tom eller om alla byte i sekvensen är ASCII, annars False. ASCII-bytes ligger i intervallet 0-0x7F.

Tillagd i version 3.7.

bytes.isdigit()¶

bytearray.isdigit()¶

Returnerar True om alla bytes i sekvensen är ASCII decimala siffror och sekvensen inte är tom, annars False. ASCII decimalsiffror är de bytevärden som finns i sekvensen b'0123456789'.

Till exempel:

>>> b'1234'.isdigit()
True
>>> b'1.23'.isdigit()
False

bytes.islower()¶

bytearray.islower()¶

Returnerar True om det finns minst ett ASCII-tecken med små bokstäver i sekvensen och inga ASCII-tecken med stora bokstäver, annars False.

Till exempel:

>>> b'hello world'.islower()
True
>>> b'Hello world'.islower()
False

ASCII-tecken med gemener är de bytevärden som ingår i sekvensen b'abcdefghijklmnopqrstuvwxyz'. Versala ASCII-tecken är de bytevärden som ingår i sekvensen b'ABCDEFGHIJKLMNOPQRSTUVWXYZ'.

bytes.isspace()¶
bytearray.isspace()¶: Returnerar True om alla byte i sekvensen är ASCII blanksteg och sekvensen inte är tom, annars False. ASCII-tecknen för blanksteg är de bytevärden i sekvensen b' \t\n\r\x0b\f' (mellanslag, tabb, ny rad, vagnsretur, vertikal tabb, form feed).

bytes.istitle()¶

bytearray.istitle()¶

Returnerar True om sekvensen är ASCII titlecase och sekvensen inte är tom, False annars. Se bytes.title() för mer information om definitionen av ”titlecase”.

Till exempel:

>>> b'Hello World'.istitle()
True
>>> b'Hello world'.istitle()
False

bytes.isupper()¶

bytearray.isupper()¶

Returnerar True om det finns minst ett versalt alfabetiskt ASCII-tecken i sekvensen och inga gemena ASCII-tecken, annars False.

Till exempel:

>>> b'HELLO WORLD'.isupper()
True
>>> b'Hello world'.isupper()
False

ASCII-tecken med gemener är de bytevärden som ingår i sekvensen b'abcdefghijklmnopqrstuvwxyz'. Versala ASCII-tecken är de bytevärden som ingår i sekvensen b'ABCDEFGHIJKLMNOPQRSTUVWXYZ'.

bytes.lower()¶

bytearray.lower()¶

Returnerar en kopia av sekvensen med alla ASCII-tecken med versaler konverterade till motsvarande tecken med gemener.

Till exempel:

>>> b'Hello World'.lower()
b'hello world'

ASCII-tecken med gemener är de bytevärden som ingår i sekvensen b'abcdefghijklmnopqrstuvwxyz'. Versala ASCII-tecken är de bytevärden som ingår i sekvensen b'ABCDEFGHIJKLMNOPQRSTUVWXYZ'.

Anteckning

Bytearray-versionen av den här metoden fungerar inte på plats - den producerar alltid ett nytt objekt, även om inga ändringar har gjorts.

bytes.splitlines(keepends=False)¶

bytearray.splitlines(keepends=False)¶

Returnerar en lista med raderna i den binära sekvensen, med brytning vid ASCII-radgränser. Den här metoden använder universal newlines för att dela upp rader. Radbrytningar inkluderas inte i den resulterande listan om inte keepends anges och är true.

Till exempel:

>>> b'ab c\n\nde fg\rkl\r\n'.splitlines()
[b'ab c', b'', b'de fg', b'kl']
>>> b'ab c\n\nde fg\rkl\r\n'.splitlines(keepends=True)
[b'ab c\n', b'\n', b'de fg\r', b'kl\r\n']

Till skillnad från split() när en avgränsningssträng sep anges, returnerar den här metoden en tom lista för den tomma strängen, och en terminal radbrytning resulterar inte i en extra rad:

>>> b"".split(b'\n'), b"Two lines\n".split(b'\n')
([b''], [b'Two lines', b''])
>>> b"".splitlines(), b"One line\n".splitlines()
([], [b'One line'])

bytes.swapcase()¶

bytearray.swapcase()¶

Returnerar en kopia av sekvensen med alla ASCII-tecken med gemener konverterade till motsvarande tecken med versaler och vice versa.

Till exempel:

>>> b'Hello World'.swapcase()
b'hELLO wORLD'

ASCII-tecken med gemener är de bytevärden som ingår i sekvensen b'abcdefghijklmnopqrstuvwxyz'. Versala ASCII-tecken är de bytevärden som ingår i sekvensen b'ABCDEFGHIJKLMNOPQRSTUVWXYZ'.

Till skillnad från str.swapcase() är det alltid så att bin.swapcase().swapcase() == bin för de binära versionerna. Omvandling av versaler är symmetrisk i ASCII, även om det i allmänhet inte är sant för godtyckliga Unicode-kodpunkter.

Anteckning

Bytearray-versionen av den här metoden fungerar inte på plats - den producerar alltid ett nytt objekt, även om inga ändringar har gjorts.

bytes.title()¶

bytearray.title()¶

Returnerar en version med versaler av den binära sekvensen där orden börjar med ett ASCII-tecken med versaler och de återstående tecknen är gemener. Bytevärden som inte är versaler lämnas oförändrade.

Till exempel:

>>> b'Hello world'.title()
b'Hello World'

ASCII-tecken med gemener är de bytevärden som ingår i sekvensen b'abcdefghijklmnopqrstuvwxyz'. Versala ASCII-tecken är de bytevärden i sekvensen b'ABCDEFGHIJKLMNOPQRSTUVWXYZ'. Alla andra bytevärden är okommaterade.

Algoritmen använder en enkel språkoberoende definition av ett ord som grupper av på varandra följande bokstäver. Definitionen fungerar i många sammanhang men innebär att apostrofer i sammandragningar och possessiver bildar ordgränser, vilket kanske inte är det önskade resultatet:

>>> b"they're bill's friends from the UK".title()
b"They'Re Bill'S Friends From The Uk"

En lösning för apostrofer kan konstrueras med hjälp av reguljära uttryck:

>>> import re
>>> def titlecase(s):
...     return re.sub(rb"[A-Za-z]+('[A-Za-z]+)?",
...                   lambda mo: mo.group(0)[0:1].upper() +
...                              mo.group(0)[1:].lower(),
...                   s)
...
>>> titlecase(b"they're bill's friends.")
b"They're Bill's Friends."

Anteckning

Bytearray-versionen av den här metoden fungerar inte på plats - den producerar alltid ett nytt objekt, även om inga ändringar har gjorts.

bytes.upper()¶

bytearray.upper()¶

Returnerar en kopia av sekvensen med alla ASCII-tecken med gemener konverterade till motsvarande tecken med versaler.

Till exempel:

>>> b'Hello World'.upper()
b'HELLO WORLD'

ASCII-tecken med gemener är de bytevärden som ingår i sekvensen b'abcdefghijklmnopqrstuvwxyz'. Versala ASCII-tecken är de bytevärden som ingår i sekvensen b'ABCDEFGHIJKLMNOPQRSTUVWXYZ'.

Anteckning

Bytearray-versionen av den här metoden fungerar inte på plats - den producerar alltid ett nytt objekt, även om inga ändringar har gjorts.

bytes.zfill(width, /)¶

bytearray.zfill(width, /)¶

Returnerar en kopia av den sekvens som lämnats fylld med ASCII b'0' siffror för att skapa en sekvens med längden bredd. Ett ledande teckenprefix (b'+'/ b'-') hanteras genom att utfyllnaden infogas efter tecknet istället för före. För bytes-objekt returneras den ursprungliga sekvensen om width är mindre än eller lika med len(seq).

Till exempel:

>>> b"42".zfill(5)
b'00042'
>>> b"-42".zfill(5)
b'-0042'

Anteckning

Bytearray-versionen av den här metoden fungerar inte på plats - den producerar alltid ett nytt objekt, även om inga ändringar har gjorts.

byteformatering i stil med `printf`¶

Anteckning

De formateringsoperationer som beskrivs här uppvisar en rad olika egenheter som leder till ett antal vanliga fel (t.ex. att tuplar och ordböcker inte visas korrekt). Om det värde som skrivs ut kan vara en tupel eller en ordbok ska det paketeras i en tupel.

Bytes-objekt (bytes/bytearray) har en unik inbyggd operation: operatorn % (modulo). Denna kallas även bytes formaterings- eller interpolationsoperatorn. Givet format % values (där format är ett bytes-objekt) ersätts % konverteringsspecifikationerna i format med noll eller flera element av values. Effekten är liknande den som uppnås med sprintf() i språket C.

Om format kräver ett enda argument kan values vara ett enda objekt som inte är en tupel. [5] Annars måste values vara en tupel med exakt det antal objekt som anges av formatbytesobjektet, eller ett enda mappningsobjekt (t.ex. en ordbok).

En konverteringsspecifikator innehåller två eller flera tecken och har följande komponenter, som måste förekomma i denna ordning:

Tecknet '%', som markerar början på specifikationen.
Mappningsnyckel (valfri) som består av en sekvens av tecken inom parentes (t.ex. (somename)).
Konverteringsflaggor (valfritt), som påverkar resultatet av vissa konverteringstyper.
Minsta fältbredd (valfritt). Om den anges som en '*' (asterisk) läses den faktiska bredden från nästa element i tupeln i values, och objektet som ska konverteras kommer efter den minsta fältbredden och den valfria precisionen.
Precision (valfri), anges som en '.' (punkt) följt av precisionen. Om den anges som '*' (en asterisk) läses den faktiska precisionen från nästa element i tupeln i values, och värdet som ska konverteras kommer efter precisionen.
Längdmodifierare (valfritt).
Typ av konvertering.

När det högra argumentet är en ordbok (eller annan mappningstyp), måste formaten i bytesobjektet inkludera en parentetisk mappningsnyckel till ordboken som infogas omedelbart efter tecknet '%'. Mappningsnyckeln väljer det värde som ska formateras från mappningen. Exempelvis

>>> print(b'%(language)s has %(number)03d quote types.' %
...       {b'language': b"Python", b"number": 2})
b'Python has 002 quote types.'

I detta fall får inga *-specifikatorer förekomma i ett format (eftersom de kräver en sekventiell parameterlista).

Konverteringens flaggtecken är:

Flagga	Betydelse
`'#'`	Värdeomvandlingen kommer att använda den ”alternativa formen” (enligt definitionen nedan).
`'0'`	Omvandlingen kommer att nollställas för numeriska värden.
`'-'`	Det konverterade värdet lämnas justerat (åsidosätter konverteringen `'0'` om båda anges).
`' '`	(ett mellanslag) Ett mellanslag ska lämnas före ett positivt tal (eller en tom sträng) som produceras genom en signerad konvertering.
`'+'`	Ett tecken (`'+'` eller `'-'`) kommer att föregå konverteringen (åsidosätter en ”mellanslagsflagga”).

En längdmodifierare (h, l eller L) kan förekomma, men ignoreras eftersom den inte är nödvändig för Python - så t.ex. %ld är identisk med %d.

Konverteringstyperna är:

Konvertering	Betydelse	Anteckningar
`'d'`	Decimalt heltal med tecken.
`'i'`	Decimalt heltal med tecken.
`'o'`	Sekvenserat oktalt värde.	(1)
`'u'`	Föråldrad typ - identisk med `'d'`.	(8)
`'x'`	Signerad hexadecimal (gemener).	(2)
`'X'`	Signerad hexadecimal (versaler).	(2)
`'e'`	Exponentiellt format för flyttal (små bokstäver).	(3)
`'E'`	Exponentiellt format för flyttal (versaler).	(3)
`'f'`	Decimalformat för flyttal.	(3)
`'F'`	Decimalformat för flyttal.	(3)
`'g'`	Flyttalsformat. Använder exponentiellt format med gemener om exponenten är mindre än -4 eller inte mindre än precision, annars decimalformat.	(4)
`'G'`	Flyttalsformat. Använder exponentiellt format med versaler om exponenten är mindre än -4 eller inte mindre än precision, annars decimalformat.	(4)
`'c'`	Single byte (accepterar objekt med heltal eller single byte).
`'b'`	Bytes (alla objekt som följer buffer protocol eller har `__bytes__()`).	(5)
`'s'`	`'s'` är ett alias för `'b'` och bör endast användas för Python2/3-kodbaser.	(6)
`'a'`	Bytes (konverterar valfritt Python-objekt med `repr(obj).encode('ascii', 'backslashreplace')`).	(5)
`'r'`	`'r'` är ett alias för `'a'` och bör endast användas för Python2/3-kodbaser.	(7)
`'%'`	Inget argument konverteras, vilket resulterar i ett `'%'`-tecken i resultatet.

Anteckningar:

Den alternativa formen innebär att en ledande oktalspecifikator ('0o') infogas före den första siffran.
Den alternativa formen gör att en inledande '0x' eller '0X' (beroende på om formatet 'x' eller 'X' användes) infogas före den första siffran.
Den alternativa formen gör att resultatet alltid innehåller en decimalpunkt, även om inga siffror följer efter den.

Precisionen bestämmer antalet siffror efter decimaltecknet och är som standard 6.
Den alternativa formen gör att resultatet alltid innehåller en decimalpunkt och att efterföljande nollor inte tas bort som de annars skulle ha gjort.

Precisionen bestämmer antalet signifikanta siffror före och efter decimaltecknet och är som standard 6.
Om precision är N trunkeras utdata till N tecken.
b'%s' är föråldrad, men kommer inte att tas bort under 3.x-serien.
b'%r' är föråldrad, men kommer inte att tas bort under 3.x-serien.
Se PEP 237.

Anteckning

Bytearray-versionen av den här metoden fungerar inte på plats - den producerar alltid ett nytt objekt, även om inga ändringar har gjorts.

Se även

PEP 461 - Lägga till % formatering till bytes och bytearray

Tillagd i version 3.5.

Minnesvy¶

memoryview-objekt gör det möjligt för Python-kod att komma åt interna data i ett objekt som stöder buffer protocol utan kopiering.

class memoryview(object)¶

Skapa en memoryview som refererar till object. object måste stödja buffertprotokollet. Inbyggda objekt som stöder buffertprotokollet inkluderar bytes och bytearray.

En memoryview har begreppet element, som är den atomära minnesenhet som hanteras av det ursprungliga objektet. För många enkla typer som bytes och bytearray är ett element en enda byte, men andra typer som array.array kan ha större element.

len(view) är lika med längden på tolist, som är den nästlade listrepresentationen av vyn. Om view.ndim = 1 är detta lika med antalet element i vyn.

Ändrad i version 3.12: Om view.ndim == 0, len(view) ger nu TypeError istället för att returnera 1.

Attributet itemsize ger dig antalet byte i ett enda element.

En memoryview stöder skivning och indexering för att exponera sina data. Endimensionell skivning kommer att resultera i en undervy:
>>> v = memoryview(b'abcefg')
>>> v[1]
98
>>> v[-1]
103
>>> v[1:4]
<memory at 0x7f3ddc9f4350>
>>> bytes(v[1:4])
b'bce'
Om format är en av de ursprungliga formatspecifikationerna från modulen struct stöds även indexering med ett heltal eller en tupel av heltal och returnerar ett enda element med rätt typ. Endimensionella minnesvyer kan indexeras med ett heltal eller en tupel med ett heltal. Flerdimensionella minnesvyer kan indexeras med tupler av exakt ndim heltal där ndim är antalet dimensioner. Nolldimensionella minnesvyer kan indexeras med den tomma tupeln.

Här är ett exempel med ett format som inte är byte:
>>> import array
>>> a = array.array('l', [-11111111, 22222222, -33333333, 44444444])
>>> m = memoryview(a)
>>> m[0]
-11111111
>>> m[-1]
44444444
>>> m[::2].tolist()
[-11111111, -33333333]
Om det underliggande objektet är skrivbart stöder minnesvyn endimensionell tilldelning av skivor. Storleksändring är inte tillåtet:
>>> data = bytearray(b'abcefg')
>>> v = memoryview(data)
>>> v.readonly
False
>>> v[0] = ord(b'z')
>>> data
bytearray(b'zbcefg')
>>> v[1:4] = b'123'
>>> data
bytearray(b'z123fg')
>>> v[2:3] = b'spam'
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: memoryview assignment: lvalue and rvalue have different structures
>>> v[2:6] = b'spam'
>>> data
bytearray(b'z1spam')
Endimensionella minnesvyer av hashable (skrivskyddade) typer med formaten ’B’, ’b’ eller ’c’ är också hashbara. Hash definieras som hash(m) == hash(m.tobytes()):
>>> v = memoryview(b'abcefg')
>>> hash(v) == hash(b'abcefg')
True
>>> hash(v[2:4]) == hash(b'ce')
True
>>> hash(v[::-2]) == hash(b'abcefg'[::-2])
True
Ändrad i version 3.3: Endimensionella minnesvyer kan nu skivas. Endimensionella minnesvyer med formaten ’B’, ’b’ eller ’c’ är nu hashable.

Ändrad i version 3.4: memoryview registreras nu automatiskt med collections.abc.Sequence

Ändrad i version 3.5: minnesvyer kan nu indexeras med tupel av heltal.

Ändrad i version 3.14: memoryview är nu en generic type.

memoryview har flera metoder:
__eq__(exporter)¶
En minnesvy och en PEP 3118 exportör är lika om deras former är likvärdiga och om alla motsvarande värden är lika när operandernas respektive formatkoder tolkas med struct syntax.

För den delmängd av struct formatsträngar som för närvarande stöds av tolist(), är v och w lika om v.tolist() == w.tolist():
>>> import array
>>> a = array.array('I', [1, 2, 3, 4, 5])
>>> b = array.array('d', [1.0, 2.0, 3.0, 4.0, 5.0])
>>> c = array.array('b', [5, 3, 1])
>>> x = memoryview(a)
>>> y = memoryview(b)
>>> x == a == y == b
True
>>> x.tolist() == a.tolist() == y.tolist() == b.tolist()
True
>>> z = y[::-2]
>>> z == c
True
>>> z.tolist() == c.tolist()
True
Om någon av formatsträngarna inte stöds av modulen struct, kommer objekten alltid att jämföras som olika (även om formatsträngarna och buffertinnehållet är identiska):
>>> from ctypes import BigEndianStructure, c_long
>>> class BEPoint(BigEndianStructure):
...     _fields_ = [("x", c_long), ("y", c_long)]
...
>>> point = BEPoint(100, 200)
>>> a = memoryview(point)
>>> b = memoryview(point)
>>> a == point
False
>>> a == b
False
Observera att, precis som med flyttal, v är w inte innebär v == w för memoryview-objekt.

Ändrad i version 3.3: Tidigare versioner jämförde råminnet utan att ta hänsyn till objektformatet och den logiska arraystrukturen.
tobytes(order='C')¶
Returnerar data i bufferten som en bytestring. Detta är likvärdigt med att anropa bytes-konstruktören på minnesvyn.
>>> m = memoryview(b"abc")
>>> m.tobytes()
b'abc'
>>> bytes(m)
b'abc'
För icke sammanhängande matriser är resultatet lika med den tillplattade listrepresentationen med alla element konverterade till bytes. tobytes() stöder alla formatsträngar, inklusive de som inte är i struct-modulsyntax.

Tillagd i version 3.8: order kan vara {’C’, ’F’, ’A’}. När order är ’C’ eller ’F’ konverteras data från den ursprungliga matrisen till C- eller Fortran-ordning. För sammanhängande vyer returnerar ’A’ en exakt kopia av det fysiska minnet. I synnerhet bevaras Fortran-ordningen i minnet. För icke-slutna vyer konverteras data först till C. order=None är samma sak som order=’C’.
hex(*, bytes_per_sep=1)¶

hex(sep, bytes_per_sep=1)
Returnerar ett strängobjekt som innehåller två hexadecimala siffror för varje byte i bufferten.
>>> m = memoryview(b"abc")
>>> m.hex()
'616263'
Tillagd i version 3.5.

Ändrad i version 3.8: I likhet med bytes.hex() har memoryview.hex() nu stöd för de valfria parametrarna sep och bytes_per_sep för att infoga separatorer mellan byte i hex-utdata.
tolist()¶
Returnera data i bufferten som en lista med element.
>>> memoryview(b'abc').tolist()
[97, 98, 99]
>>> import array
>>> a = array.array('d', [1.1, 2.2, 3.3])
>>> m = memoryview(a)
>>> m.tolist()
[1.1, 2.2, 3.3]
Ändrad i version 3.3: tolist() stöder nu alla ursprungliga format för enstaka tecken i modulsyntaxen struct samt flerdimensionella representationer.
toreadonly()¶
Returnerar en skrivskyddad version av memoryview-objektet. Det ursprungliga memoryview-objektet är oförändrat.
>>> m = memoryview(bytearray(b'abc'))
>>> mm = m.toreadonly()
>>> mm.tolist()
[97, 98, 99]
>>> mm[0] = 42
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: cannot modify read-only memory
>>> m[0] = 43
>>> mm.tolist()
[43, 98, 99]
Tillagd i version 3.8.
release()¶
Frigör den underliggande bufferten som exponeras av memoryview-objektet. Många objekt vidtar speciella åtgärder när en vy hålls på dem (t.ex. skulle en bytearray tillfälligt förbjuda storleksändring); därför är det praktiskt att anropa release() för att ta bort dessa begränsningar (och frigöra eventuella hängande resurser) så snart som möjligt.

Efter att denna metod har anropats ger alla ytterligare åtgärder på vyn upphov till ett ValueError (utom release() själv som kan anropas flera gånger):
>>> m = memoryview(b'abc')
>>> m.release()
>>> m[0]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: operation forbidden on released memoryview object
Protokollet för kontexthantering kan användas för en liknande effekt med hjälp av with-satsen:
>>> with memoryview(b'abc') as m:
...     m[0]
...
97
>>> m[0]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: operation forbidden on released memoryview object
Tillagd i version 3.2.
cast(format, /)¶

cast(format, shape, /)
Castar en minnesvy till ett nytt format eller en ny form. shape är som standard [byte_length//new_itemsize], vilket innebär att resultatvyn kommer att vara endimensionell. Returvärdet är en ny minnesvy, men själva bufferten kopieras inte. Stödda casts är 1D -> C-contiguous och C-contiguous -> 1D.

Målformatet är begränsat till ett inbyggt format med ett enda element i struct-syntax. Ett av formaten måste vara ett byteformat (’B’, ’b’ eller ’c’). Byte-längden på resultatet måste vara samma som den ursprungliga längden. Observera att alla byte-längder kan bero på operativsystemet.

Cast 1D/lång till 1D/unsigned bytes:
>>> import array
>>> a = array.array('l', [1,2,3])
>>> x = memoryview(a)
>>> x.format
'l'
>>> x.itemsize
8
>>> len(x)
3
>>> x.nbytes
24
>>> y = x.cast('B')
>>> y.format
'B'
>>> y.itemsize
1
>>> len(y)
24
>>> y.nbytes
24
Casta 1D/unsigned bytes till 1D/char:
>>> b = bytearray(b'zyz')
>>> x = memoryview(b)
>>> x[0] = b'a'
Traceback (most recent call last):
  ...
TypeError: memoryview: invalid type for format 'B'
>>> y = x.cast('c')
>>> y[0] = b'a'
>>> b
bytearray(b'ayz')
Cast 1D/bytes till 3D/ints till 1D/signed char:
>>> import struct
>>> buf = struct.pack("i"*12, *list(range(12)))
>>> x = memoryview(buf)
>>> y = x.cast('i', shape=[2,2,3])
>>> y.tolist()
[[[0, 1, 2], [3, 4, 5]], [[6, 7, 8], [9, 10, 11]]]
>>> y.format
'i'
>>> y.itemsize
4
>>> len(y)
2
>>> y.nbytes
48
>>> z = y.cast('b')
>>> z.format
'b'
>>> z.itemsize
1
>>> len(z)
48
>>> z.nbytes
48
Cast 1D/unsigned long till 2D/unsigned long:
>>> buf = struct.pack("L"*6, *list(range(6)))
>>> x = memoryview(buf)
>>> y = x.cast('L', shape=[2,3])
>>> len(y)
2
>>> y.nbytes
48
>>> y.tolist()
[[0, 1, 2], [3, 4, 5]]
Tillagd i version 3.3.

Ändrad i version 3.5: Källformatet är inte längre begränsat vid casting till en bytevy.
count(value, /)¶

Räkna antalet förekomster av värde.

Tillagd i version 3.14.

index(value, start=0, stop=sys.maxsize, /)¶

Returnerar index för den första förekomsten av värde (vid eller efter index start och före index stop).

Utlöser ett ValueError om värde inte kan hittas.

Tillagd i version 3.14.

Det finns också flera skrivskyddade attribut tillgängliga:

obj¶

Det underliggande objektet för minnesvyn:

>>> b  = bytearray(b'xyz')
>>> m = memoryview(b)
>>> m.obj is b
True

Tillagd i version 3.3.

nbytes¶

nbytes == product(shape) * itemsize == len(m.tobytes()). Detta är den mängd utrymme i bytes som matrisen skulle använda i en sammanhängande representation. Det är inte nödvändigtvis lika med len(m):

>>> import array
>>> a = array.array('i', [1,2,3,4,5])
>>> m = memoryview(a)
>>> len(m)
5
>>> m.nbytes
20
>>> y = m[::2]
>>> len(y)
3
>>> y.nbytes
12
>>> len(y.tobytes())
12

Flerdimensionella matriser:

>>> import struct
>>> buf = struct.pack("d"*12, *[1.5*x for x in range(12)])
>>> x = memoryview(buf)
>>> y = x.cast('d', shape=[3,4])
>>> y.tolist()
[[0.0, 1.5, 3.0, 4.5], [6.0, 7.5, 9.0, 10.5], [12.0, 13.5, 15.0, 16.5]]
>>> len(y)
3
>>> y.nbytes
96

Tillagd i version 3.3.

readonly¶: En bool som anger om minnet är skrivskyddat.

format¶: En sträng som innehåller formatet (i struct-modulstil) för varje element i vyn. En minnesvy kan skapas från exportörer med godtyckliga formatsträngar, men vissa metoder (t.ex. tolist()) är begränsade till ursprungliga format för enstaka element.

Ändrad i version 3.3: formatet 'B' hanteras nu enligt struct-modulens syntax. Detta innebär att memoryview(b'abc')[0] == b'abc'[0] == 97.

itemsize¶

Storleken i bytes för varje element i minnesvyn:

>>> import array, struct
>>> m = memoryview(array.array('H', [32000, 32001, 32002]))
>>> m.itemsize
2
>>> m[0]
32000
>>> struct.calcsize('H') == m.itemsize
True

ndim¶: Ett heltal som anger hur många dimensioner av en flerdimensionell array som minnet representerar.

shape¶: En tupel av heltal med längden ndim som ger formen på minnet som en N-dimensionell array.

Ändrad i version 3.3: En tom tupel i stället för None när ndim = 0.

strides¶: En tupel av heltal med längden ndim som anger storleken i bytes för att komma åt varje element för varje dimension i matrisen.

Ändrad i version 3.3: En tom tupel i stället för None när ndim = 0.

suboffsets¶: Används internt för matriser av PIL-typ. Värdet är endast informativt.

c_contiguous¶: En bool som anger om minnet är C-contiguous.

Tillagd i version 3.3.

f_contiguous¶: En bool som anger om minnet är Fortran contiguous.

Tillagd i version 3.3.

contiguous¶: En bool som anger om minnet är contiguous.

Tillagd i version 3.3.

Set-typer — `set`, `frozenset`¶

Ett set-objekt är en oordnad samling av distinkta hashable-objekt. Vanliga användningsområden är medlemskapstestning, borttagning av dubbletter från en sekvens och beräkning av matematiska operationer som intersektion, union, differens och symmetrisk differens. (För andra behållare se de inbyggda klasserna dict, list och tuple samt modulen collections)

Liksom andra samlingar stöder set x in set, len(set) och for x in set. Eftersom set är en oordnad samling registreras inte elementens position eller inmatningsordning. Följaktligen stöder inte set indexering, skivning eller annat sekvensliknande beteende.

Det finns för närvarande två inbyggda set-typer, set och frozenset. Typen set är mutabel — innehållet kan ändras med hjälp av metoder som add() och remove(). Eftersom den är föränderlig har den inget hashvärde och kan inte användas som vare sig nyckel i en ordbok eller som element i en annan uppsättning. Typen frozenset är oföränderlig och hashable — dess innehåll kan inte ändras efter att den skapats; den kan därför användas som en ordboksnyckel eller som ett element i en annan uppsättning.

Icke-tomma mängder (inte frozensets) kan skapas genom att placera en kommaseparerad lista med element inom hakparenteser, till exempel: {'jack', 'sjoerd'}, utöver konstruktören set.

Konstruktörerna för båda klasserna fungerar på samma sätt:

class set(iterable=(), /)¶

class frozenset(iterable=(), /)¶

Returnerar ett nytt set eller frozenset-objekt vars element är hämtade från iterable. Elementen i en uppsättning måste vara hashable. För att representera mängder av mängder måste de inre mängderna vara frozenset-objekt. Om iterable inte anges returneras en ny tom uppsättning.

Uppsättningar kan skapas på flera sätt:

Använd en kommaseparerad lista med element inom hakparenteser: {'jack', 'sjoerd'}
Använd en set-förståelse: {c för c i 'abracadabra' om c inte finns i 'abc'}
Använd typkonstruktören: set(), set('foobar'), set(['a', 'b', 'foo'])

Instanser av set och frozenset tillhandahåller följande operationer:

len(s): Returnera antalet element i uppsättningen s (kardinalitet för s).

x in s: Testa x för medlemskap i s.

x not in s: Testa x för icke-medlemskap i s.

isdisjoint(other, /)¶: Returnerar True om mängden inte har några element gemensamma med andra. Mängder är disjunkta om och endast om deras intersektion är den tomma mängden.

issubset(other, /)¶
set <= other: Testa om varje element i uppsättningen finns i other.

set < other: Testa om mängden är en korrekt delmängd av annan, dvs. mängd <= annan och mängd != annan.

issuperset(other, /)¶
set >= other: Testa om alla element i other finns med i uppsättningen.

set > other: Testa om mängden är en korrekt övermängd av annan, det vill säga mängd >= annan och mängd != annan.

union(*others)¶
set | other | ...: Returnera en ny uppsättning med element från uppsättningen och alla andra.

intersection(*others)¶
set & other & ...: Returnerar en ny uppsättning med element som är gemensamma för uppsättningen och alla andra.

difference(*others)¶
set - other - ...: Returnera en ny uppsättning med element i uppsättningen som inte finns i de andra.

symmetric_difference(other, /)¶
set ^ other: Returnerar en ny uppsättning med element i antingen uppsättningen eller annan men inte båda.

copy()¶: Returnerar en ytlig kopia av uppsättningen.

Observera att icke-operatorversionerna av metoderna union(), intersection(), difference(), symmetric_difference(), issubset() och issuperset() accepterar vilken iterabel som helst som argument. Däremot kräver deras operatorbaserade motsvarigheter att deras argument är mängder. Detta utesluter felbenägna konstruktioner som set('abc') & 'cbs' till förmån för det mer läsbara set('abc').intersection('cbs').

Både set och frozenset stöder jämförelser mellan mängder. Två mängder är lika om och endast om varje element i varje mängd ingår i den andra (varje mängd är en delmängd av den andra). En mängd är mindre än en annan mängd om och endast om den första mängden är en riktig delmängd av den andra mängden (är en delmängd, men inte lika). En mängd är större än en annan mängd om och endast om den första mängden är en korrekt övermängd av den andra mängden (är en övermängd, men inte lika).

Instanser av set jämförs med instanser av frozenset baserat på deras medlemmar. Till exempel returnerar set('abc') == frozenset('abc') True och det gör även set('abc') in set([frozenset('abc')]).

Jämförelserna mellan delmängder och likheter kan inte generaliseras till en total ordningsfunktion. Till exempel, två icke-tomma disjunkta mängder är inte lika och är inte delmängder av varandra, så alla av följande returnerar False: a<b, a==b, eller a>b.

Eftersom mängder endast definierar partiell ordning (relationer mellan delmängder) är resultatet av metoden list.sort() odefinierat för listor med mängder.

Set-element måste, precis som nycklar i ordböcker, vara hashable.

Binära operationer som blandar set-instanser med frozenset returnerar typen av den första operanden. Till exempel: frozenset('ab') | set('bc') returnerar en instans av frozenset.

Följande tabell listar operationer som är tillgängliga för set och som inte gäller för oföränderliga instanser av frozenset:

update(*others)¶
set |= other | ...: Uppdatera uppsättningen genom att lägga till element från alla andra.

intersection_update(*others)¶
set &= other & ...: Uppdatera uppsättningen och behåll endast de element som finns i den och alla andra.

difference_update(*others)¶
set -= other | ...: Uppdatera uppsättningen och ta bort element som finns i andra.

symmetric_difference_update(other, /)¶
set ^= other: Uppdatera uppsättningen och behåll endast element som finns i endera uppsättningen, men inte i båda.

add(elem, /)¶: Lägg till element elem i uppsättningen.

remove(elem, /)¶: Tar bort elementet elem från uppsättningen. Utlöser KeyError om elem inte finns med i uppsättningen.

discard(elem, /)¶: Ta bort elementet elem från uppsättningen om det finns där.

pop()¶: Tar bort och returnerar ett godtyckligt element från uppsättningen. Utlöser KeyError om uppsättningen är tom.

clear()¶: Ta bort alla element från uppsättningen.

Observera att de icke-operatoriska versionerna av metoderna update(), intersection_update(), difference_update() och symmetric_difference_update() accepterar vilken iterabel som helst som argument.

Observera att argumentet elem till metoderna __contains__(), remove() och discard() kan vara en uppsättning. För att underlätta sökningen efter en motsvarande frozenset skapas en tillfällig sådan från elem.

Mappningstyper — `dict`¶

Ett mapping-objekt mappar hashable-värden till godtyckliga objekt. Mappningar är muterbara objekt. Det finns för närvarande bara en standardmappningstyp, dictionary. (För andra behållare se de inbyggda klasserna list, set och tuple samt modulen collections)

En dictionaries nycklar är nästan godtyckliga värden. Värden som inte är hashable, det vill säga värden som innehåller listor, dictionaries eller andra föränderliga typer (som jämförs med värde snarare än med objektidentitet) får inte användas som nycklar. Värden som jämför lika (t.ex. 1, 1.0 och True) kan användas omväxlande för att indexera samma ordbokspost.

class dict(**kwargs)¶

class dict(mapping, /, **kwargs)

class dict(iterable, /, **kwargs)

Returnerar en ny ordbok som initierats från ett valfritt positionsargument och en eventuellt tom uppsättning nyckelordsargument.

Ordböcker kan skapas på flera olika sätt:

Använd en kommaseparerad lista med nyckel: värde-par inom hakparenteser: {'jack': 4098, 'sjoerd': 4127} eller {4098: 'jack', 4127: 'sjoerd'}
Använd en dict-förståelse: {}, {x: x ** 2 for x in range(10)}
Använd typkonstruktören: dict(), dict([('foo', 100), ('bar', 200)]), dict(foo=100, bar=200)

Om inget positionsargument anges skapas en tom ordbok. Om ett positionsargument anges och det definierar en keys()-metod, skapas en ordbok genom att anropa __getitem__() på argumentet med varje nyckel som returneras från metoden. Annars måste det positionella argumentet vara ett iterable-objekt. Varje objekt i iterabeln måste själv vara en iterabel med exakt två element. Det första elementet i varje objekt blir en nyckel i den nya ordboken och det andra elementet blir motsvarande värde. Om en nyckel förekommer mer än en gång blir det sista värdet för den nyckeln motsvarande värde i den nya ordboken.

Om nyckelordsargument anges läggs nyckelordsargumenten och deras värden till i den ordbok som skapats utifrån positionsargumentet. Om en nyckel som läggs till redan finns, ersätter värdet från nyckelordsargumentet värdet från positionsargumentet.

Att ange nyckelordsargument som i det första exemplet fungerar bara för nycklar som är giltiga Python-identifierare. Annars kan alla giltiga nycklar användas.

Dictionaries jämförs lika om och endast om de har samma (nyckel, värde)-par (oavsett ordning). Orderjämförelser (’<’, ’<=’, ’>=’, ’>’) ger upphov till TypeError. För att illustrera skapande av ordlistor och likhet returnerar följande exempel alla en ordlista som är lika med {"one": 1, "two": 2, "three": 3}:

>>> a = dict(one=1, two=2, three=3)
>>> b = {'one': 1, 'two': 2, 'three': 3}
>>> c = dict(zip(['one', 'two', 'three'], [1, 2, 3]))
>>> d = dict([('two', 2), ('one', 1), ('three', 3)])
>>> e = dict({'three': 3, 'one': 1, 'two': 2})
>>> f = dict({'one': 1, 'three': 3}, two=2)
>>> a == b == c == d == e == f
True

Att ange nyckelordsargument som i det första exemplet fungerar bara för nycklar som är giltiga Python-identifierare. Annars kan alla giltiga nycklar användas.

Ordböcker bevarar inmatningsordningen. Observera att uppdatering av en nyckel inte påverkar ordningen. Nycklar som läggs till efter radering infogas i slutet.

>>> d = {"one": 1, "two": 2, "three": 3, "four": 4}
>>> d
{'one': 1, 'two': 2, 'three': 3, 'four': 4}
>>> list(d)
['one', 'two', 'three', 'four']
>>> list(d.values())
[1, 2, 3, 4]
>>> d["one"] = 42
>>> d
{'one': 42, 'two': 2, 'three': 3, 'four': 4}
>>> del d["two"]
>>> d["two"] = None
>>> d
{'one': 42, 'three': 3, 'four': 4, 'two': None}

Ändrad i version 3.7: Ordningsföljden i ordboken är garanterad att vara insättningsordning. Detta beteende var en implementationsdetalj i CPython från 3.6.

Det här är de operationer som ordböcker stöder (och därför bör anpassade mappningstyper också stödja):

list(d): Returnerar en lista med alla nycklar som används i ordlistan d.

len(d): Returnerar antalet objekt i ordlistan d.

d[key]

Returnerar objektet i d med nyckel key. Utlöser ett KeyError om nyckel inte finns i kartan.

Om en subklass av dict definierar en metod __missing__() och key inte finns, anropar operationen d[key] den metoden med nyckeln key som argument. Operationen d[key] returnerar eller väcker sedan det som returneras eller väcks av anropet __missing__(key). Inga andra operationer eller metoder anropar __missing__(). Om __missing__() inte är definierad, uppstår KeyError. __missing__() måste vara en metod; den kan inte vara en instansvariabel:

>>> class Counter(dict):
...     def __missing__(self, key):
...         return 0
...
>>> c = Counter()
>>> c['red']
0
>>> c['red'] += 1
>>> c['red']
1

Exemplet ovan visar en del av implementationen av collections.Counter. En annan __missing__ metod används av collections.defaultdict.

d[key] = value: Sätt d[key] till värde.

del d[key]: Tar bort d[nyckel] från d. Utlöser ett KeyError om key inte finns i kartan.

key in d: Returnerar True om d har en nyckel key, annars False.

key not in d: Motsvarar inte nyckel i d.

iter(d): Returnerar en iterator över nycklarna i ordlistan. Detta är en genväg till iter(d.keys()).

clear()¶: Ta bort alla objekt från ordlistan.

copy()¶: Returnerar en ytlig kopia av ordlistan.

classmethod fromkeys(iterable, value=None, /)¶

Skapa en ny ordbok med nycklar från iterable och värden satta till value.

fromkeys() är en klassmetod som returnerar en ny ordbok. value är som standard None. Alla värden hänvisar bara till en enda instans, så det är i allmänhet inte meningsfullt att värde är ett föränderligt objekt, t.ex. en tom lista. För att få distinkta värden, använd en dict comprehension istället.

get(key, default=None, /)¶: Returnerar värdet för key om key finns i ordlistan, annars default. Om default inte anges är standardvärdet None, så att den här metoden aldrig ger upphov till ett KeyError.

items()¶: Returnerar en ny vy av ordbokens objekt ((nyckel, värde)-par). Se dokumentation av view-objekt.

keys()¶: Returnerar en ny vy av nycklarna i ordlistan. Se dokumentation av view-objekt.

pop(key, /)¶
pop(key, default, /): Om key finns i ordlistan, ta bort den och returnera dess värde, annars returneras default. Om default inte anges och key inte finns i ordlistan, uppstår ett KeyError.

popitem()¶

Tar bort och returnerar ett (nyckel, värde)-par från ordlistan. Paren returneras i LIFO-ordning.

popitem() är användbart för att destruktivt iterera över en ordbok, vilket ofta används i set-algoritmer. Om ordlistan är tom ger anrop av popitem() upphov till ett KeyError.

Ändrad i version 3.7: LIFO-ordning är nu garanterad. I tidigare versioner kunde popitem() returnera ett godtyckligt nyckel/värde-par.

reversed(d): Returnerar en omvänd iterator över nycklarna i ordlistan. Detta är en genväg till reversed(d.keys()).

Tillagd i version 3.8.

setdefault(key, default=None, /)¶: Om key finns i ordlistan returneras dess värde. Om inte, infoga key med ett värde av default och returnera default. default är som standard None.

update(**kwargs)¶

update(mapping, /, **kwargs)

update(iterable, /, **kwargs)

Uppdatera ordboken med nyckel/värdepar från mapping eller iterable och kwargs, och skriv över befintliga nycklar. Returnera None.

update() accepterar antingen ett annat objekt med en keys()-metod (i vilket fall __getitem__() anropas med varje nyckel som returneras från metoden) eller en iterabel med nyckel/värde-par (som tupler eller andra iterabler av längd två). Om nyckelordsargument anges uppdateras sedan ordlistan med dessa nyckel/värde-par: d.update(red=1, blue=2).

values()¶

Returnerar en ny vy av ordbokens värden. Se dokumentation av view-objekt.

En jämlikhetsjämförelse mellan en dict.values() vy och en annan kommer alltid att returnera False. Detta gäller även när man jämför dict.values() med sig själv:

>>> d = {'a': 1}
>>> d.values() == d.values()
False

d | other: Skapa en ny ordbok med de sammanslagna nycklarna och värdena i d och other, som båda måste vara ordböcker. Värdena i other prioriteras när d och other delar nycklar.

Tillagd i version 3.9.

d |= other: Uppdaterar ordlistan d med nycklar och värden från other, som kan vara antingen en mapping eller en iterable av nyckel/värde-par. Värdena i other prioriteras när d och other delar nycklar.

Tillagd i version 3.9.

Ordböcker och ordboksvyer är reversibla

>>> d = {"one": 1, "two": 2, "three": 3, "four": 4}
>>> d
{'one': 1, 'two': 2, 'three': 3, 'four': 4}
>>> list(reversed(d))
['four', 'three', 'two', 'one']
>>> list(reversed(d.values()))
[4, 3, 2, 1]
>>> list(reversed(d.items()))
[('four', 4), ('three', 3), ('two', 2), ('one', 1)]

Ändrad i version 3.8: Ordböcker är nu reversibla.

Se även

types.MappingProxyType kan användas för att skapa en skrivskyddad vy av en dict.

Objekt för ordboksvisning¶

De objekt som returneras av dict.keys(), dict.values() och dict.items() är vyobjekt. De ger en dynamisk vy över ordbokens poster, vilket innebär att när ordboken ändras återspeglas dessa ändringar i vyn.

Dictionary-vyer kan itereras för att få fram sina respektive data och stödja medlemskapstester:

len(dictview): Returnerar antalet poster i ordlistan.

iter(dictview)

Returnerar en iterator över nycklar, värden eller objekt (representerade som tupler av (nyckel, värde)) i ordlistan.

Nycklar och värden itereras över i insättningsordning. Detta gör det möjligt att skapa (värde, nyckel)-par med hjälp av zip(): par = zip(d.values(), d.keys()). Ett annat sätt att skapa samma lista är par = [(v, k) for (k, v) in d.items()].

Om du itererar vyer medan du lägger till eller tar bort poster i ordlistan kan det leda till ett RuntimeError eller att du inte kan iterera över alla poster.

Ändrad i version 3.7: Ordboksordning är garanterad att vara insättningsordning.

x in dictview: Returnerar True om x finns i den underliggande ordbokens nycklar, värden eller objekt (i det senare fallet bör x vara en (nyckel, värde)-tupel).

reversed(dictview): Returnerar en omvänd iterator över nycklar, värden eller objekt i ordlistan. Vyn kommer att itereras i omvänd ordning efter införandet.

Ändrad i version 3.8: Ordboksvyerna är nu reversibla.

dictview.mapping: Returnerar en types.MappingProxyType som omsluter den ursprungliga ordlistan som vyn refererar till.

Tillagd i version 3.10.

Keys-vyer är set-liknande eftersom deras poster är unika och hashable. Objektvyer har också set-liknande operationer eftersom (nyckel, värde)-paren är unika och nycklarna är hashbara. Om alla värden i en items-vy också är hashbara kan items-vyn samverka med andra set. (Värdevyer behandlas inte som set-liknande eftersom posterna i allmänhet inte är unika) För set-liknande vyer är alla operationer som definieras för den abstrakta basklassen collections.abc.Set tillgängliga (t.ex. ==, < eller ^). Vid användning av set-operatorer accepterar set-liknande vyer alla iterabla som den andra operanden, till skillnad från sets som endast accepterar sets som indata.

Ett exempel på användning av ordboksvy:

>>> dishes = {'eggs': 2, 'sausage': 1, 'bacon': 1, 'spam': 500}
>>> keys = dishes.keys()
>>> values = dishes.values()

>>> # iteration
>>> n = 0
>>> for val in values:
...     n += val
...
>>> print(n)
504

>>> # keys and values are iterated over in the same order (insertion order)
>>> list(keys)
['eggs', 'sausage', 'bacon', 'spam']
>>> list(values)
[2, 1, 1, 500]

>>> # view objects are dynamic and reflect dict changes
>>> del dishes['eggs']
>>> del dishes['sausage']
>>> list(keys)
['bacon', 'spam']

>>> # set operations
>>> keys & {'eggs', 'bacon', 'salad'}
{'bacon'}
>>> keys ^ {'sausage', 'juice'} == {'juice', 'sausage', 'bacon', 'spam'}
True
>>> keys | ['juice', 'juice', 'juice'] == {'bacon', 'spam', 'juice'}
True

>>> # get back a read-only proxy for the original dictionary
>>> values.mapping
mappingproxy({'bacon': 1, 'spam': 500})
>>> values.mapping['spam']
500

Typer av kontexthanterare¶

Pythons with-sats stöder konceptet med en körtidskontext som definieras av en kontexthanterare. Detta implementeras med hjälp av ett par metoder som gör det möjligt för användardefinierade klasser att definiera en körtidskontext som anges innan satsens kropp exekveras och avslutas när satsen avslutas:

contextmanager.__enter__()¶

Anger körtidskontexten och returnerar antingen detta objekt eller ett annat objekt som är relaterat till körtidskontexten. Det värde som returneras av denna metod är bundet till identifieraren i as-klausulen i with-satser med hjälp av denna kontexthanterare.

Ett exempel på en kontexthanterare som returnerar sig själv är ett file object. Filobjekt returnerar sig själva från __enter__() så att open() kan användas som kontextuttryck i en with-sats.

Ett exempel på en kontexthanterare som returnerar ett relaterat objekt är den som returneras av decimal.localcontext(). Dessa hanterare sätter den aktiva decimalkontexten till en kopia av den ursprungliga decimalkontexten och returnerar sedan kopian. Detta gör att ändringar kan göras i den aktuella decimalkontexten i with-satsen utan att påverka koden utanför with-satsen.

contextmanager.__exit__(exc_type, exc_val, exc_tb)¶

Avslutar körtidskontexten och returnerar en boolesk flagga som anger om ett eventuellt undantag som inträffat ska undertryckas. Om ett undantag inträffade under exekveringen av with-satsen, innehåller argumenten undantagstyp, värde och spårningsinformation. Annars är alla tre argumenten None.

Om ett sant värde returneras från den här metoden kommer with-satsen att undertrycka undantaget och fortsätta exekveringen med den sats som följer omedelbart efter with-satsen. Annars fortsätter undantaget att spridas efter att den här metoden har avslutats. Undantag som inträffar under exekveringen av denna metod kommer att ersätta alla undantag som inträffade i with-satsens kropp.

Det undantag som skickas in bör aldrig återställas explicit - i stället bör denna metod returnera ett falskt värde för att ange att metoden slutfördes framgångsrikt och inte vill undertrycka det undantag som återställts. Detta gör det möjligt för kontexthanteringskod att enkelt upptäcka om en __exit__()-metod faktiskt har misslyckats eller inte.

Python definierar flera kontexthanterare för att stödja enkel trådsynkronisering, snabb stängning av filer eller andra objekt och enklare hantering av den aktiva decimala aritmetiska kontexten. De specifika typerna behandlas inte speciellt utöver deras implementering av kontexthanteringsprotokollet. Se modulen contextlib för några exempel.

Pythons generator och contextlib.contextmanager-dekoratorn ger ett bekvämt sätt att implementera dessa protokoll. Om en generatorfunktion dekoreras med dekoratorn contextlib.contextmanager kommer den att returnera en kontexthanterare som implementerar de nödvändiga metoderna __enter__() och __exit__(), snarare än den iterator som produceras av en odekorerad generatorfunktion.

Observera att det inte finns någon specifik plats för någon av dessa metoder i typstrukturen för Python-objekt i Python/C API. Tilläggstyper som vill definiera dessa metoder måste tillhandahålla dem som en normal Python-åtkomlig metod. Jämfört med omkostnaderna för att konfigurera körtidskontexten är omkostnaderna för en enda klassordboksuppslagning försumbara.

Typ Annotation Types — Generic Alias, Union ¶

De inbyggda kärntyperna för type annotations är Generic Alias och Union.

Generisk aliastyp¶

objekt av typen GenericAlias skapas i allmänhet genom subscripting av en klass. De används oftast med container classes, såsom list eller dict. Till exempel är list[int] ett GenericAlias-objekt som skapas genom att subskribera klassen list med argumentet int. GenericAlias-objekt är främst avsedda att användas med type annotations.

Anteckning

Det är i allmänhet bara möjligt att subskribera en klass om klassen implementerar den speciella metoden __class_getitem__().

Ett GenericAlias-objekt fungerar som en proxy för en generic type och implementerar parameteriserade generiska typer.

För en containerklass kan det eller de argument som anges i en subscription av klassen ange typen eller typerna av de element som ett objekt innehåller. Till exempel kan set[bytes] användas i typannoteringar för att beteckna en set där alla element är av typen bytes.

För en klass som definierar __class_getitem__() men som inte är en container, kommer argumenten till en prenumeration av klassen ofta att ange returtypen/returtyperna för en eller flera metoder som definieras på ett objekt. Exempelvis kan regular expressions användas på både datatypen str och bytes:

Om x = re.search('foo', 'foo'), kommer x att vara ett re.Match-objekt där returvärdena för x.group(0) och x[0] båda kommer att vara av typen str. Vi kan representera den här typen av objekt i typannoteringar med GenericAlias re.Match[str].
Om y = re.search(b'bar', b'bar'), (notera b för bytes), kommer y också att vara en instans av re.Match, men returvärdena för y.group(0) och y[0] kommer båda att vara av typen bytes. I typannoteringar skulle vi representera denna variation av re.Match objekt med re.Match[bytes].

GenericAlias-objekt är instanser av klassen types.GenericAlias, som också kan användas för att skapa GenericAlias-objekt direkt.

T[X, Y, ...]

Skapar en GenericAlias som representerar en typ T parametriserad av typerna X, Y, och mer beroende på vilken T som används. Till exempel en funktion som förväntar sig en list som innehåller float-element:

def average(värden: lista[float]) -> float:
    return sum(värden) / len(värden)

Ett annat exempel för mapping-objekt, med dict, som är en generisk typ som förväntar sig två typparametrar som representerar nyckeltypen och värdetypen. I detta exempel förväntar sig funktionen en dict med nycklar av typen str och värden av typen int:

def send_post_request(url: str, body: dict[str, int]) -> None:
    ...

De inbyggda funktionerna isinstance() och issubclass() accepterar inte GenericAlias-typer för sitt andra argument:

>>> isinstance([1, 2], list[str])
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: isinstance() argument 2 cannot be a parameterized generic

Pythons runtime upprätthåller inte typannoteringar. Detta gäller även generiska typer och deras typparametrar. När du skapar ett containerobjekt från en GenericAlias kontrolleras inte elementen i containern mot deras typ. Till exempel, följande kod är inte rekommenderad, men kommer att köras utan fel:

>>> t = list[str]
>>> t([1, 2, 3])
[1, 2, 3]

Dessutom raderar parametriserade generika typparametrar när objektet skapas:

>>> t = list[str]
>>> type(t)
<class 'types.GenericAlias'>

>>> l = t()
>>> type(l)
<class 'list'>

Anrop av repr() eller str() på en generisk visar den parametriserade typen:

>>> repr(list[int])
'list[int]'

>>> str(list[int])
'list[int]'

Metoden __getitem__() för generiska behållare kommer att ge upphov till ett undantag för att förhindra misstag som dict[str][str]:

>>> dict[str][str]
Traceback (most recent call last):
  ...
TypeError: dict[str] is not a generic class

Sådana uttryck är dock giltiga när typvariabler används. Indexet måste ha lika många element som det finns typvariabler i objektet GenericAlias:s __args__.

>>> from typing import TypeVar
>>> Y = TypeVar('Y')
>>> dict[str, Y][int]
dict[str, int]

Generiska standardklasser¶

Följande klasser i standardbiblioteket stöder parametriserade generiker. Denna lista är inte uttömmande.

tuple
lista
dict
set
frozenset
typ
asyncio.Future
asyncio.Task
collections.deque
samlingar.defaultdict
samlingar.OrderedDict
samlingar.Räknare
samlingar.ChainMap
collections.abc.Awaitable
collections.abc.Coroutine
collections.abc.AsyncIterable
collections.abc.AsyncIterator
collections.abc.AsyncGenerator
collections.abc.Iterable
collections.abc.Iterator
collections.abc.Generator
collections.abc.Reversible
collections.abc.Container
collections.abc.Collection
collections.abc.Callable
collections.abc.Set
collections.abc.MutableSet
collections.abc.Mapping
collections.abc.MutableMapping
collections.abc.Sequence
collections.abc.MutableSequence
collections.abc.MappingView
collections.abc.KeysView
collections.abc.ItemsView
collections.abc.ValuesView
contextlib.AbstractContextManager
contextlib.AbstractAsyncContextManager
dataklasser.fält
functools.cached_property
functools.partialmethod
os.PathLike
queue.LifoQueue
queue.Queue
queue.PriorityQueue
queue.SimpleQueue
re.mönster
re.Match
shelve.BsdDbShelf
shelve.DbfilenameShelf
shelve.Shelf
types.MappingProxyType
weakref.WeakKeyDictionary
weakref.WeakMethod
weakref.WeakSet
weakref.WeakValueDictionary

Särskilda attribut för `GenericAlias`-objekt¶

Alla parametriserade generics implementerar speciella skrivskyddade attribut.

genericalias.__origin__¶

Detta attribut pekar på den icke-parameteriserade generiska klassen:

>>> list[int].__origin__
<class 'list'>

genericalias.__args__¶

Detta attribut är en tuple (eventuellt av längd 1) av generiska typer som skickas till den ursprungliga __class_getitem__() av den generiska klassen:

>>> dict[str, list[int]].__args__
(<class 'str'>, list[int])

genericalias.__parameters__¶

Detta attribut är en latent beräknad tupel (eventuellt tom) av unika typvariabler som finns i __args__:

>>> from typing import TypeVar

>>> T = TypeVar('T')
>>> list[T].__parameters__
(~T,)

Anteckning

Ett GenericAlias-objekt med typing.ParamSpec-parametrar kanske inte har korrekta __parameters__ efter substitution eftersom typing.ParamSpec främst är avsedd för statisk typkontroll.

genericalias.__unpacked__¶: En boolean som är sann om aliaset har packats upp med operatorn * (se TypeVarTuple).

Tillagd i version 3.11.

Se även

PEP 484 - Tips om typ: Introduktion till Pythons ramverk för typannoteringar.
PEP 585 - Typhintning av generiska i standardsamlingar: Introducerar möjligheten att naturligt parametrisera standardbiblioteksklasser, förutsatt att de implementerar den speciella klassmetoden __class_getitem__().
Generiska läkemedel, användardefinierad generik och typing.Generic: Dokumentation om hur man implementerar generiska klasser som kan parametriseras vid körning och förstås av statiska typkontrollanter.

Tillagd i version 3.9.

Typ av fackförening¶

Ett union-objekt innehåller värdet av |-operationen (bitvis eller) på flera type-objekt. Dessa typer är främst avsedda för type annotations. Uttrycket unionstyp möjliggör en renare syntax för typhinting jämfört med subskription av typing.Union.

X | Y | ...

Definierar ett union-objekt som innehåller typerna X, Y, och så vidare. X | Y betyder antingen X eller Y. Det är ekvivalent med typing.Union[X, Y]. Till exempel förväntar sig följande funktion ett argument av typen int eller float:

def square(number: int | float) -> int | float:
    returnerar nummer ** 2

Anteckning

Operanden | kan inte användas vid körning för att definiera unioner där en eller flera medlemmar är en framåtriktad referens. Till exempel kommer int | "Foo", där "Foo" är en referens till en klass som ännu inte definierats, att misslyckas vid körning. För unioner som innehåller framåtriktade referenser ska hela uttrycket presenteras som en sträng, t.ex. "int | Foo".

union_object == other

Unionsobjekt kan testas för jämlikhet med andra unionsobjekt. Detaljerad information:

Unioner av unioner är tillplattade:

(int | str) | float == int | str | float

Överflödiga typer tas bort:
```
int | str | int == int | str
```
Vid jämförelse av fackföreningar ignoreras ordningen:
```
int | str == str | int
```

Den skapar instanser av typing.Union:

int | str == typing.Union[int, str]
typ(int | str) är typing.union

Valfria typer kan stavas som en union med None:
```
str | None == typing.Optional[str]
```

isinstance(obj, union_object)

issubclass(obj, union_object)

Anrop till isinstance() och issubclass() stöds också med ett unionsobjekt:

>>> isinstance("", int | str)
True

Däremot kan parameterized generics i unionsobjekt inte kontrolleras:

>>> isinstance(1, int | list[int])  # short-circuit evaluation
True
>>> isinstance([1], int | list[int])
Traceback (most recent call last):
  ...
TypeError: isinstance() argument 2 cannot be a parameterized generic

Den användardefinierade typen för union-objektet kan hämtas från typing.Union och användas för isinstance()-kontroller:

>>> import typing
>>> isinstance(int | str, typing.Union)
True
>>> typing.Union()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: cannot create 'typing.Union' instances

Anteckning

Metoden __or__() för typobjekt har lagts till för att stödja syntaxen X | Y. Om en metaklass implementerar __or__() kan unionen åsidosätta den:

>>> class M(type):
...     def __or__(self, other):
...         return "Hello"
...
>>> class C(metaclass=M):
...     pass
...
>>> C | int
'Hello'
>>> int | C
int | C

Se även

PEP 604 – PEP föreslår syntaxen X | Y och Union-typen.

Tillagd i version 3.10.

Ändrad i version 3.14: Union-objekt är nu instanser av typing.Union. Tidigare var de instanser av types.UnionType, som fortfarande är ett alias för typing.Union.

Andra inbyggda typer¶

Tolken har stöd för flera andra typer av objekt. De flesta av dessa stöder endast en eller två operationer.

Moduler¶

Den enda speciella operationen på en modul är attributåtkomst: m.name, där m är en modul och name ger åtkomst till ett namn som definieras i m:s symboltabell. Modulattribut kan tilldelas till. (Observera att import inte i strikt mening är en operation på ett modulobjekt; import foo kräver inte att ett modulobjekt med namnet foo existerar, utan snarare att det finns en (extern) definition för en modul med namnet foo någonstans)

Ett speciellt attribut för varje modul är __dict__. Detta är den ordbok som innehåller modulens symboltabell. Modifiering av denna dictionary kommer faktiskt att ändra modulens symboltabell, men direkt tilldelning till attributet __dict__ är inte möjligt (du kan skriva m.__dict__['a'] = 1, vilket definierar m.a till att vara 1, men du kan inte skriva m.__dict__ = {}). Att ändra __dict__ direkt är inte rekommenderat.

Moduler som är inbyggda i tolken skrivs på följande sätt: <modulen 'sys' (inbyggd)>. Om de laddas från en fil skrivs de som <modulen 'os' från '/usr/local/lib/pythonX.Y/os.pyc'>.

Klasser och klassinstanser¶

Se Objekt, värden och typer och Klassdefinitioner för dessa.

Funktioner¶

Funktionsobjekt skapas av funktionsdefinitioner. Den enda operationen på ett funktionsobjekt är att anropa det: func(argument-list).

Det finns egentligen två olika typer av funktionsobjekt: inbyggda funktioner och användardefinierade funktioner. Båda stöder samma operation (att anropa funktionen), men implementeringen är olika, därav de olika objekttyperna.

Se Definitioner av funktioner för mer information.

Metoder¶

Metoder är funktioner som anropas med hjälp av attributnotationen. Det finns två varianter: inbyggda metoder (t.ex. append() på listor) och klassinstansmetod. Inbyggda metoder beskrivs med de typer som stöder dem.

Om du anropar en metod (en funktion som definieras i en klassnamnrymd) via en instans får du ett speciellt objekt: ett bound method-objekt (även kallat instance method). När den anropas kommer den att lägga till argumentet self i argumentlistan. Bound methods har två speciella skrivskyddade attribut: m.__self__ är det objekt som metoden verkar på, och m.__func__ är den funktion som implementerar metoden. Anrop av m(arg-1, arg-2, ..., arg-n) är helt likvärdigt med anrop av m.__func__(m.__self__, arg-1, arg-2, ..., arg-n).

Liksom funktionsobjekt, stöder bundna metodobjekt att få godtyckliga attribut. Men eftersom metodattribut faktiskt lagras på det underliggande funktionsobjektet (method.__func__) är det inte tillåtet att ställa in metodattribut på bundna metoder. Försök att sätta ett attribut på en metod resulterar i ett AttributeError. För att kunna ställa in ett metodattribut måste du uttryckligen ställa in det på det underliggande funktionsobjektet:

>>> class C:
...     def method(self):
...         pass
...
>>> c = C()
>>> c.method.whoami = 'my name is method'  # can't set on the method
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'method' object has no attribute 'whoami'
>>> c.method.__func__.whoami = 'my name is method'
>>> c.method.whoami
'my name is method'

Se Instansmetoder för mer information.

Kodobjekt¶

Kodobjekt används av implementationen för att representera ”pseudokompilerad” körbar Python-kod, t.ex. en funktionskropp. De skiljer sig från funktionsobjekt eftersom de inte innehåller någon referens till sin globala exekveringsmiljö. Kodobjekt returneras av den inbyggda compile()-funktionen och kan extraheras från funktionsobjekt genom deras __code__-attribut. Se även modulen code.

Åtkomst till __code__ genererar ett auditing event object.__getattr__ med argumenten obj och "__code__".

Ett kodobjekt kan exekveras eller utvärderas genom att skicka det (i stället för en källsträng) till de inbyggda funktionerna exec() eller eval().

Se Standardtypens hierarki för mer information.

Typ av objekt¶

Typobjekt representerar de olika objekttyperna. Ett objekts typ nås med den inbyggda funktionen type(). Det finns inga speciella operationer på typer. Standardmodulen types definierar namn för alla inbyggda standardtyper.

Typer skrivs på detta sätt: <klass 'int'>.

Null-objektet¶

Detta objekt returneras av funktioner som inte uttryckligen returnerar ett värde. Det stöder inga speciella operationer. Det finns exakt ett null-objekt, med namnet None (ett inbyggt namn). type(None)() producerar samma singleton.

Det är skrivet som None.

Ellipsis-objektet¶

Detta objekt används vanligen vid skivning (se Skivor). Det stöder inga speciella operationer. Det finns exakt ett ellipsis-objekt, med namnet Ellipsis (ett inbyggt namn). type(Ellipsis)() producerar Ellipsis singleton.

Det skrivs som Ellipsis eller ....

Det icke implementerade objektet¶

Detta objekt returneras från jämförelser och binära operationer när de ombeds att använda typer som de inte stöder. Se Jämförelser för mer information. Det finns exakt ett NotImplemented-objekt. type(NotImplemented)() producerar singleton-instansen.

Den är skriven som NotImplemented.

Interna objekt¶

Se Standardtypens hierarki för denna information. Den beskriver stack frame objects, traceback objects, och slice objects.

Särskilda egenskaper¶

Implementationen lägger till några speciella skrivskyddade attribut till flera objekttyper, där de är relevanta. Vissa av dessa rapporteras inte av den inbyggda funktionen dir().

definition.__name__¶: Namnet på klassen, funktionen, metoden, deskriptorn eller generatorinstansen.

definition.__qualname__¶: Det qualified name på klassen, funktionen, metoden, deskriptorn eller generatorinstansen.

Tillagd i version 3.3.

definition.__module__¶: Namnet på den modul i vilken en klass eller funktion definierades.

definition.__doc__¶: Dokumentationssträngen för en klass eller funktion, eller None om den är odefinierad.

definition.__type_params__¶: typ-parametrarna för generiska klasser, funktioner och typ-alias. För klasser och funktioner som inte är generiska kommer detta att vara en tom tupel.

Tillagd i version 3.12.

Längdbegränsning för konvertering av heltalssträngar¶

CPython har en global gräns för konvertering mellan int och str för att motverka överbelastningsattacker. Denna gräns gäller endast för decimaltal eller andra talbaser som inte har två potenser. Hexadecimala, oktala och binära konverteringar är obegränsade. Gränsen kan konfigureras.

Typen int i CPython är ett tal av godtycklig längd som lagras i binär form (allmänt känt som ett ”bignum”). Det finns ingen algoritm som kan konvertera en sträng till ett binärt heltal eller ett binärt heltal till en sträng i linjär tid, om inte basen är en potens av 2. Även de mest kända algoritmerna för bas 10 har subkvadratisk komplexitet. Att konvertera ett stort värde som int('1' * 500_000) kan ta över en sekund på en snabb CPU.

Att begränsa konverteringsstorleken är ett praktiskt sätt att undvika CVE 2020-10735.

Gränsen tillämpas på antalet siffertecken i in- eller utdatasträngen när en icke-linjär konverteringsalgoritm skulle vara inblandad. Underscorer och tecknet räknas inte med i begränsningen.

När en operation skulle överskrida gränsen genereras ett ValueError:

>>> import sys
>>> sys.set_int_max_str_digits(4300)  # Illustrative, this is the default.
>>> _ = int('2' * 5432)
Traceback (most recent call last):
...
ValueError: Exceeds the limit (4300 digits) for integer string conversion: value has 5432 digits; use sys.set_int_max_str_digits() to increase the limit
>>> i = int('2' * 4300)
>>> len(str(i))
4300
>>> i_squared = i*i
>>> len(str(i_squared))
Traceback (most recent call last):
...
ValueError: Exceeds the limit (4300 digits) for integer string conversion; use sys.set_int_max_str_digits() to increase the limit
>>> len(hex(i_squared))
7144
>>> assert int(hex(i_squared), base=16) == i*i  # Hexadecimal is unlimited.

Standardgränsen är 4300 siffror enligt sys.int_info.default_max_str_digits. Den lägsta gräns som kan konfigureras är 640 siffror enligt sys.int_info.str_digits_check_threshold.

Verifiering:

>>> import sys
>>> assert sys.int_info.default_max_str_digits == 4300, sys.int_info
>>> assert sys.int_info.str_digits_check_threshold == 640, sys.int_info
>>> msg = int('578966293710682886880994035146873798396722250538762761564'
...           '9252925514383915483333812743580549779436104706260696366600'
...           '571186405732').to_bytes(53, 'big')
...

Tillagd i version 3.11.

Berörda API:er¶

Begränsningen gäller endast potentiellt långsamma konverteringar mellan int och str eller bytes:

int(sträng) med standardbas 10.
int(string, base) för alla baser som inte är en potens av 2.
str(heltal).
repr(heltal).
någon annan strängkonvertering till bas 10, till exempel f"{integer}", "{}".format(integer), eller b"%d" % integer.

Begränsningarna gäller inte för funktioner med en linjär algoritm:

int(sträng, bas) med bas 2, 4, 8, 16 eller 32.
int.from_bytes() och int.to_bytes().
hex(), oct(), bin().
Formatspecifikation Mini-språk för hex-, oktal- och binära tal.
str till float.
str till decimal.Decimal.

Konfigurera gränsvärdet¶

Innan Python startar kan du använda en miljövariabel eller en kommandoradsflagga för tolken för att konfigurera gränsen:

PYTHONINTMAXSTRDIGITS, t.ex. PYTHONINTMAXSTRDIGITS=640 python3 för att sätta gränsen till 640 eller PYTHONINTMAXSTRDIGITS=0 python3 för att inaktivera begränsningen.
-X int_max_str_digits, t.ex. python3 -X int_max_str_digits=640
sys.flags.int_max_str_digits innehåller värdet av PYTHONINTMAXSTRDIGITS eller -X int_max_str_digits. Om både env var och alternativet -X är inställda, har alternativet -X företräde. Ett värde på -1 indikerar att båda var oinställda, vilket innebär att ett värde på sys.int_info.default_max_str_digits användes under initialiseringen.

Från kod kan du inspektera den aktuella gränsen och sätta en ny med hjälp av dessa sys API:er:

sys.get_int_max_str_digits() och sys.set_int_max_str_digits() är en getter och setter för den tolkningsomfattande gränsen. Undertolkare har sin egen gräns.

Information om standard- och minimivärden finns i sys.int_info:

sys.int_info.default_max_str_digits är den kompilerade standardgränsen.
sys.int_info.str_digits_check_threshold är det lägsta accepterade värdet för gränsen (annat än 0 som inaktiverar den).

Tillagd i version 3.11.

Försiktighet

Att sätta en låg gräns kan leda till problem. Även om det är sällsynt finns det kod som innehåller heltalskonstanter i decimal i sin källa som överskrider minimigränsen. En konsekvens av att sätta gränsen är att Python-källkod som innehåller decimala heltalslitteraler som är längre än gränsen kommer att stöta på ett fel under parsning, vanligtvis vid starttid eller importtid eller till och med vid installationstid - när som helst en uppdaterad .pyc inte redan finns för koden. En lösning för källkod som innehåller så stora konstanter är att konvertera dem till hexadecimal form 0x eftersom den inte har någon gräns.

Testa din applikation noggrant om du använder en låg gräns. Se till att dina tester körs med gränsen inställd tidigt via miljön eller flaggan så att den gäller under uppstart och även under alla installationssteg som kan anropa Python för att förkompilera .py-källor till .pyc-filer.

Rekommenderad konfiguration¶

Standardvärdet sys.int_info.default_max_str_digits förväntas vara rimligt för de flesta applikationer. Om ditt program kräver en annan gräns, ställ in den från din huvudingångspunkt med Python-version agnostisk kod eftersom dessa API:er lades till i säkerhetsuppdateringar i versioner före 3.12.

Exempel:

>>> import sys
>>> if hasattr(sys, "set_int_max_str_digits"):
...     upper_bound = 68000
...     lower_bound = 4004
...     current_limit = sys.get_int_max_str_digits()
...     if current_limit == 0 or current_limit > upper_bound:
...         sys.set_int_max_str_digits(upper_bound)
...     elif current_limit < lower_bound:
...         sys.set_int_max_str_digits(lower_bound)

Om du behöver inaktivera det helt, ställ in det på 0.

Fotnoter

Inbyggda typer¶

Test av sanning och värde¶

Booleska operationer — and, or, not¶

Jämförelser¶

Numeriska typer — int, float, complex¶

Bitvisa operationer på heltalstyper¶

Ytterligare metoder för heltalstyper¶

Ytterligare metoder på Float¶

Ytterligare metoder för komplexa¶

Hashning av numeriska typer¶

Booleansk typ - bool¶

Iterator-typer¶

Typer av generatorer¶

Sekvenstyper — list, tuple, range¶

Vanliga sekvensoperationer¶

Oföränderliga sekvenstyper¶

Mutabla sekvenstyper¶

Listor¶

Tupler¶

Intervaller¶

Metoder för text- och binära sekvenstyper Sammanfattning¶

Textsekvenstyp — str¶

Strängmetoder¶

Formaterade strängbokstäver (f-strängar)¶

strängformatering i stil med printf¶

Binära sekvenstyper — bytes, bytearray, memoryview¶

Bytes-objekt¶

Bytearray-objekt¶

Bytes- och bytearrayoperationer¶

byteformatering i stil med printf¶

Minnesvy¶

Set-typer — set, frozenset¶

Mappningstyper — dict¶

Objekt för ordboksvisning¶

Typer av kontexthanterare¶

Typ Annotation Types — Generic Alias, Union¶

Generisk aliastyp¶

Generiska standardklasser¶

Särskilda attribut för GenericAlias-objekt¶

Typ av fackförening¶

Andra inbyggda typer¶

Moduler¶

Klasser och klassinstanser¶

Funktioner¶

Metoder¶

Kodobjekt¶

Typ av objekt¶

Null-objektet¶

Ellipsis-objektet¶

Det icke implementerade objektet¶

Interna objekt¶

Särskilda egenskaper¶

Längdbegränsning för konvertering av heltalssträngar¶

Berörda API:er¶

Konfigurera gränsvärdet¶

Rekommenderad konfiguration¶

Booleska operationer — `and`, `or`, `not`¶

Numeriska typer — `int`, `float`, `complex`¶

Booleansk typ - `bool`¶

Sekvenstyper — `list`, `tuple`, `range`¶

Textsekvenstyp — `str`¶

strängformatering i stil med `printf`¶

Binära sekvenstyper — `bytes`, `bytearray`, `memoryview`¶

byteformatering i stil med `printf`¶

Set-typer — `set`, `frozenset`¶

Mappningstyper — `dict`¶

Typ Annotation Types — Generic Alias, Union ¶

Särskilda attribut för `GenericAlias`-objekt¶