string — Vanliga strängoperationer

Källkod: Lib/string.py

Se även

Textsekvenstyp — str

Strängmetoder

Strängkonstanter

De konstanter som definieras i denna modul är:

string.ascii_letters

Konkateneringen av konstanterna ascii_lowercase och ascii_uppercase som beskrivs nedan. Detta värde är inte lokalberoende.

string.ascii_lowercase

De gemena bokstäverna 'abcdefghijklmnopqrstuvwxyz'. Detta värde är inte lokalberoende och kommer inte att ändras.

string.ascii_uppercase

De versala bokstäverna 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'. Detta värde är inte lokalberoende och kommer inte att ändras.

string.digits

Strängen '0123456789'.

string.hexdigits

Strängen '0123456789abcdefABCDEF'.

string.octdigits

Strängen '01234567'.

string.punctuation

Sträng av ASCII-tecken som betraktas som skiljetecken i C-landskapet: !"#$%&'()*+,-./:;<=>?@[\]^_`{|}~.

string.printable

Sträng med ASCII-tecken som anses vara skrivbara av Python. Detta är en kombination av digits, ascii_letter, punctuation, och whitespace.

Anteckning

Av designskäl returnerar string.printable.isprintable() False. I synnerhet är string.printable inte tryckbar i POSIX mening (se LC_CTYPE).

string.whitespace

En sträng som innehåller alla ASCII-tecken som betraktas som blanksteg. Detta inkluderar tecknen mellanslag, tabb, radmatning, retur, formmatning och vertikal tabb.

Anpassad strängformatering

Den inbyggda strängklassen ger möjlighet att göra komplexa variabelsubstitutioner och värdeformatering via metoden format() som beskrivs i PEP 3101. Klassen Formatter i modulen string gör att du kan skapa och anpassa dina egna formateringsbeteenden för strängar med samma implementering som den inbyggda metoden format().

class string.Formatter

Klassen Formatter har följande publika metoder:

format(format_string, /, *args, **kwargs)

Den primära API-metoden. Den tar en formatsträng och en godtycklig uppsättning positions- och nyckelordsargument. Det är bara ett omslag som anropar vformat().

Ändrad i version 3.7: Ett formatsträngargument är nu positionell-endast.

vformat(format_string, args, kwargs)

Denna funktion utför själva formateringsarbetet. Den exponeras som en separat funktion för fall där du vill skicka in en fördefinierad ordlista med argument, i stället för att packa upp och packa om ordlistan som enskilda argument med hjälp av syntaxen *args och **kwargs. vformat() gör arbetet med att bryta upp formatsträngen i teckendata och ersättningsfält. Den anropar de olika metoder som beskrivs nedan.

Dessutom definierar Formatter ett antal metoder som är avsedda att ersättas av underklasser:

parse(format_string)

Loopa över format_string och returnera en iterabel med tupler (literal_text, field_name, format_spec, conversion). Detta används av vformat() för att dela upp strängen i antingen bokstavlig text eller ersättningsfält.

Värdena i tupeln representerar konceptuellt ett spann med bokstavlig text följt av ett enda ersättningsfält. Om det inte finns någon bokstavlig text (vilket kan hända om två ersättningsfält förekommer i följd) kommer literal_text att vara en sträng med noll längd. Om det inte finns något ersättningsfält kommer värdena för field_name, format_spec och conversion att vara None. Värdet på field_name är oförändrat och automatisk numrering av icke-numrerade positionella fält görs av vformat().

get_field(field_name, args, kwargs)

Konverterar field_name till ett objekt som ska formateras. Automatisk numrering av field_name som returneras från parse() görs av vformat() innan denna metod anropas. Returnerar en tupel (obj, used_key). Standardversionen tar strängar av den form som definieras i PEP 3101, t.ex. ”0[name]” eller ”label.title”. args och kwargs är som de som skickas in till vformat(). Returvärdet used_key har samma betydelse som parametern key i get_value().

get_value(key, args, kwargs)

Hämtar ett givet fältvärde. Argumentet key är antingen ett heltal eller en sträng. Om det är ett heltal representerar det indexet för det positionella argumentet i args; om det är en sträng representerar det ett namngivet argument i kwargs.

Parametern args är inställd på listan över positionella argument till vformat(), och parametern kwargs är inställd på ordlistan över nyckelordsargument.

För sammansatta fältnamn anropas dessa funktioner endast för den första komponenten i fältnamnet; efterföljande komponenter hanteras genom normala attribut- och indexeringsoperationer.

Så till exempel skulle fältuttrycket ”0.name” göra att get_value() anropas med ett key-argument på 0. Attributet name kommer att sökas upp efter att get_value() har returnerats genom att anropa den inbyggda funktionen getattr().

Om indexet eller nyckelordet hänvisar till ett objekt som inte existerar, bör ett IndexError eller KeyError visas.

check_unused_args(used_args, args, kwargs)

Implementera kontroll av oanvända argument om så önskas. Argumenten till denna funktion är uppsättningen av alla argumentnycklar som faktiskt refererades till i formatsträngen (heltal för positionella argument och strängar för namngivna argument), och en referens till args och kwargs som skickades till vformat. Uppsättningen av oanvända args kan beräknas från dessa parametrar. check_unused_args() antas ge upphov till ett undantag om kontrollen misslyckas.

format_field(value, format_spec)

format_field() anropar helt enkelt den globala inbyggda format(). Metoden tillhandahålls så att underklasser kan åsidosätta den.

convert_field(value, conversion)

Konverterar värdet (returnerat av get_field()) givet en konverteringstyp (som i den tupel som returneras av metoden parse()). Standardversionen förstår konverteringstyperna ’s’ (str), ’r’ (repr) och ’a’ (ascii).

Format String Syntax

Metoden str.format() och klassen Formatter har samma syntax för formatsträngar (även om underklasser i fallet med Formatter kan definiera sin egen syntax för formatsträngar). Syntaxen är relaterad till syntaxen för formaterade strängkonstanter och mallsträngkonstanter, men den är mindre sofistikerad och stöder i synnerhet inte godtyckliga uttryck i interpolationer.

Formatsträngar innehåller ”ersättningsfält” som omges av hakparenteser {}. Allt som inte finns inom hakparenteser betraktas som bokstavlig text, som kopieras oförändrad till utdatan. Om du behöver inkludera ett parentestecken i den bokstavliga texten kan det undvikas genom att dubblera: {{ och }}.

Grammatiken för ett ersättningsfält är som följer:

replacement_field: "{" [field_name] ["!" conversion] [":" format_spec] "}"
field_name:        arg_name ("." attribute_name | "[" element_index "]")*
arg_name:          [identifier | digit+]
attribute_name:    identifier
element_index:     digit+ | index_string
index_string:      <any source character except "]"> +
conversion:        "r" | "s" | "a"
format_spec:       format-spec:format_spec

I mindre formella termer kan ersättningsfältet börja med ett field_name som anger det objekt vars värde ska formateras och infogas i utdata i stället för ersättningsfältet. field_name följs eventuellt av ett conversion-fält, som föregås av ett utropstecken '!', och ett format_spec, som föregås av ett kolon ':'. Dessa anger ett icke-standardformat för ersättningsvärdet.

Se även avsnittet Formatspecifikation Mini-språk.

Själva field_name inleds med ett arg_name som antingen är ett tal eller ett nyckelord. Om det är ett tal hänvisar det till ett positionellt argument och om det är ett nyckelord hänvisar det till ett namngivet nyckelordsargument. Ett arg_name behandlas som ett tal om ett anrop till str.isdecimal() på strängen skulle returnera true. Om de numeriska arg_namnen i en formatsträng är 0, 1, 2, … i följd, kan de alla utelämnas (inte bara vissa) och siffrorna 0, 1, 2, … infogas automatiskt i den ordningen. Eftersom arg_name inte är citatavgränsat är det inte möjligt att ange godtyckliga ordboksnycklar (t.ex. strängarna '10' eller ':-]') inom en formatsträng. arg_name kan följas av valfritt antal index- eller attribututtryck. Ett uttryck av formen '.name' väljer det namngivna attributet med hjälp av getattr(), medan ett uttryck av formen '[index]' gör en indexuppslagning med hjälp av __getitem__().

Ändrad i version 3.1: De positionella argumentspecifikationerna kan utelämnas för str.format(), så '{} {}'.format(a, b) är likvärdigt med '{0} {1}'.format(a, b).

Ändrad i version 3.4: De positionella argumentspecifikationerna kan utelämnas för Formatter.

Några enkla exempel på formatsträngar:

"Först ska du räkna till {0}"  # Referenser första positionella argumentet
"Ge mig en {}"                   # Hänvisar implicit till det första positionella argumentet
"Från {} till {}"                   # Samma som "Från {0} till {1}"
"Mitt uppdrag är {name}"              # Refererar till nyckelordsargumentet 'namn'
"Vikt i ton {0.weight}"       # 'weight'-attribut för första positionsargumentet
"Förstörda enheter: {players[0]}"   # Första elementet i nyckelordsargumentet 'players'.

Fältet conversion orsakar en typkooperation före formateringen. Normalt görs jobbet med att formatera ett värde av __format__()-metoden för själva värdet. I vissa fall är det dock önskvärt att tvinga en typ att formateras som en sträng, vilket åsidosätter dess egen definition av formatering. Genom att konvertera värdet till en sträng innan __format__() anropas, kringgås den normala formateringslogiken.

Tre konverteringsflaggor stöds för närvarande: '!s' som anropar str() på värdet, '!r' som anropar repr() och '!a' som anropar ascii().

Några exempel:

"Harold är en smart {0!s}"        # Anropar str() på argumentet först
"Ta fram det heliga {name!r}"    # Anropar repr() på det första argumentet
"Mer {!a}"                      # Anropar ascii() på det första argumentet

Fältet format_spec innehåller en specifikation av hur värdet ska presenteras, inklusive detaljer som fältbredd, justering, utfyllnad, decimalprecision och så vidare. Varje värdetyp kan definiera sitt eget ”minispråk för formatering” eller tolkning av format_spec.

De flesta inbyggda typer stöder ett gemensamt formateringsminispråk, som beskrivs i nästa avsnitt.

Ett format_spec-fält kan också innehålla nästlade ersättningsfält. Dessa nästlade ersättningsfält kan innehålla fältnamn, konverteringsflagga och formatspecifikation, men djupare nästling är inte tillåten. Ersättningsfälten inom format_spec ersätts innan strängen format_spec tolkas. Detta gör att formateringen av ett värde kan specificeras dynamiskt.

Se avsnittet Exempel på format för några exempel.

Formatspecifikation Mini-språk

”Formatspecifikationer” används inom ersättningsfält som ingår i en formatsträng för att definiera hur enskilda värden presenteras (se Format String Syntax, f-strängar och t-strängar). De kan också skickas direkt till den inbyggda funktionen format(). Varje formatterbar typ kan definiera hur formatspecifikationen ska tolkas.

De flesta inbyggda typer implementerar följande alternativ för formatspecifikationer, även om vissa av formateringsalternativen endast stöds av de numeriska typerna.

En allmän konvention är att en tom formatspecifikation ger samma resultat som om du hade anropat str() på värdet. En icke-tom formatspecifikation ändrar vanligtvis resultatet.

Den allmänna formen för en standardformatspecificerare är:

format_spec:             [options][width_and_precision][type]
options:                 [[fill]align][sign]["z"]["#"]["0"]
fill:                    <any character>
align:                   "<" | ">" | "=" | "^"
sign:                    "+" | "-" | " "
width_and_precision:     [width_with_grouping][precision_with_grouping]
width_with_grouping:     [width][grouping]
precision_with_grouping: "." [precision][grouping] | "." grouping
width:                   digit+
precision:               digit+
grouping:                "," | "_"
type:                    "b" | "c" | "d" | "e" | "E" | "f" | "F" | "g"
                         | "G" | "n" | "o" | "s" | "x" | "X" | "%"

Om ett giltigt align-värde anges kan det föregås av ett fill-tecken som kan vara vilket tecken som helst och som standard är ett mellanslag om det utelämnas. Det är inte möjligt att använda en bokstavlig hakparentes (”{” eller ”}”) som fill-tecken i en formatted string literal eller vid användning av metoden str.format(). Det är dock möjligt att infoga en hakparentes med ett nästlat ersättningsfält. Denna begränsning påverkar inte funktionen format().

Betydelsen av de olika inriktningsalternativen är följande:

Alternativ

Betydelse

'<'

Tvingar fältet att vara vänsterjusterat inom det tillgängliga utrymmet (detta är standard för de flesta objekt).

'>'

Tvingar fältet att vara högerjusterat inom det tillgängliga utrymmet (detta är standard för siffror).

'='

Tvingar utfyllnaden att placeras efter tecknet (om sådant finns) men före siffrorna. Detta används för att skriva ut fält i formen ’+000000120’. Detta justeringsalternativ är endast giltigt för numeriska typer, exklusive complex. Det blir standard för siffror när ’0’ omedelbart föregår fältbredden.

'^'

Tvingar fältet att centreras inom det tillgängliga utrymmet.

Observera att om inte en minsta fältbredd har definierats, kommer fältbredden alltid att vara lika stor som de data som ska fylla fältet, så att justeringsalternativet inte har någon betydelse i det här fallet.

Alternativet sign är endast giltigt för nummertyper och kan vara något av följande:

Alternativ

Betydelse

'+'

Anger att ett tecken ska användas för både positiva och negativa tal.

'-'

Anger att ett tecken endast ska användas för negativa tal (detta är standardbeteendet).

tid

Anger att ett inledande mellanslag ska användas för positiva tal och ett minustecken för negativa tal.

Alternativet 'z' tvingar negativa nollvärden i flyttal till positiva nollvärden efter avrundning till formatets precision. Detta alternativ är endast giltigt för presentationstyper med flyttal.

Ändrad i version 3.11: Alternativet 'z' lades till (se även PEP 682).

Alternativet '#' gör att den ”alternativa formen” används vid konverteringen. Den alternativa formen definieras på olika sätt för olika typer. Detta alternativ är endast giltigt för heltal, float och komplexa typer. För heltal, när binär, oktal eller hexadecimal utdata används, lägger detta alternativ till respektive prefix '0b', '0o', '0x' eller '0X' till utdatavärdet. För float och complex gör den alternativa formen att resultatet av konverteringen alltid innehåller ett decimaltecken, även om inga siffror följer efter det. Normalt visas ett decimaltecken i resultatet av dessa omvandlingar endast om det följs av en siffra. För konverteringarna 'g' och 'G' tas dessutom inte de efterföljande nollorna bort från resultatet.

width är ett decimalt heltal som definierar den minsta totala fältbredden, inklusive eventuella prefix, separatorer och andra formateringstecken. Om inget anges kommer fältbredden att bestämmas av innehållet.

När ingen explicit justering anges, möjliggör teckenmedveten nollställning för numeriska typer, utom complex, om fältet width föregås av ett nolltecken ('0'). Detta motsvarar ett fill-tecken av '0' med en alignment-typ av '='.

Ändrad i version 3.10: Om fältet width föregås av '0' påverkar det inte längre standardinriktningen för strängar.

precision är ett decimalt heltal som anger hur många siffror som ska visas efter decimaltecknet för presentationstyperna 'f' och 'F', eller före och efter decimaltecknet för presentationstyperna 'g' eller 'G'. För presentationstyper med strängar anger fältet den maximala fältstorleken - med andra ord, hur många tecken som kommer att användas från fältinnehållet. precision är inte tillåtet för presentationstyper för heltal.

Alternativet grouping efter fälten width och precision anger en siffergruppsavskiljare för heltal respektive bråkdelar av ett tal. Den kan vara en av följande:

Alternativ

Betydelse

','

Infogar ett kommatecken var 3:e siffra för heltalspresentationstypen 'd' och flyttalspresentationstyper, exklusive 'n'. För andra presentationstyper stöds inte detta alternativ.

'_'

Infogar ett understreck var 3:e siffra för heltalspresentationstypen 'd' och flyttalspresentationstyper, utom 'n'. För heltalspresentationstyperna 'b', 'o', 'x' och 'X' infogas understreck var 4:e siffra. För andra presentationstyper stöds inte detta alternativ.

För en lokalt anpassad separator, använd presentationstypen 'n istället.

Ändrad i version 3.1: Lagt till alternativet ',' (se även PEP 378).

Ändrad i version 3.6: Alternativet '_' lades till (se även PEP 515).

Ändrad i version 3.14: Stöd alternativet gruppering för bråkdelen.

Slutligen avgör typ hur data ska presenteras.

De tillgängliga strängpresentationstyperna är:

Typ

Betydelse

's'

Format för strängar. Detta är standardtypen för strängar och kan utelämnas.

Ingen

Samma som 's'.

De tillgängliga presentationstyperna för heltal är:

Typ

Betydelse

'b'

Binärt format. Utmatning av talet i bas 2.

'c'

Tecken. Konverterar heltalet till motsvarande unicode-tecken före utskrift.

'd'

Decimalt heltal. Utmatning av talet i bas 10.

'o'

Oktalformat. Utmatning av talet i bas 8.

'x'

Hex-format. Utmatar talet i bas 16, med små bokstäver för siffrorna över 9.

'X'

Hex-format. Utmatar talet i bas 16, med versaler för siffrorna över 9. Om '#' anges kommer prefixet '0x' också att skrivas med versaler till '0X'.

'n'

Nummer. Detta är samma sak som 'd', förutom att den använder den aktuella lokala inställningen för att infoga lämpliga siffergruppsavskiljare.

Ingen

Samma som 'd'.

Förutom ovanstående presentationstyper kan heltal formateras med de flyttalspresentationstyper som anges nedan (utom 'n' och None). När detta görs används float() för att konvertera heltalet till ett flyttal före formateringen.

De tillgängliga presentationstyperna för float och decimal-värden är:

Typ

Betydelse

'e'

Vetenskaplig notation. För en given precision p, formaterar du talet i vetenskaplig notation med bokstaven ”e” som skiljer koefficienten från exponenten. Koefficienten har en siffra före och p siffror efter decimaltecknet, för totalt p + 1 signifikanta siffror. Om ingen precision anges används en precision på 6 siffror efter decimaltecknet för float, och alla koefficientsiffror visas för Decimal. Om p=0 utelämnas decimaltecknet om inte alternativet # används.

'E'

Vetenskaplig notation. Samma som 'e' förutom att det använder ett versalt ’E’ som separatortecken.

'f'

Notation med fast punkt. För en given precision p formateras talet som ett decimaltal med exakt p siffror efter decimaltecknet. Om ingen precision anges används en precision på 6 siffror efter decimalpunkten för float, och en precision som är tillräckligt stor för att visa alla koefficientsiffror för Decimal. Om p=0 utelämnas decimaltecknet om inte alternativet # används.

'F'

Fastpunktsnotation. Samma som 'f', men konverterar nan till NAN och inf till INF.

'g'

Allmänt format. För en given precision p >= 1 avrundas talet till p signifikanta siffror och sedan formateras resultatet antingen i fastpunktsformat eller i vetenskaplig notation, beroende på dess storlek. En precision på 0 behandlas som likvärdig med en precision på 1.

De exakta reglerna är som följer: anta att resultatet formaterat med presentationstyp 'e' och precision p-1 skulle ha exponent exp. Om då m <= exp < p, där m är -4 för flyttal och -6 för Decimals, formateras talet med presentationstypen 'f och precisionen p-1-exp. Annars formateras talet med presentationstyp 'e och precision p-1. I båda fallen tas obetydliga efterföljande nollor bort från signifikanten och decimaltecknet tas också bort om det inte finns några återstående siffror efter det, såvida inte alternativet '#' används.

Om ingen precision anges, används en precision på 6 signifikanta siffror för float. För Decimal bildas resultatets koefficient av koefficientsiffrorna i värdet; vetenskaplig notation används för värden som är mindre än 1e-6 i absolut värde och värden där platsvärdet för den minst signifikanta siffran är större än 1, och fastpunktsnotation används annars.

Positiv och negativ oändlighet, positiv och negativ noll och nans formateras som inf, -inf, 0, -0 respektive nan, oavsett precision.

'G'

Allmänt format. Samma som 'g' förutom att det växlar till 'E' om talet blir för stort. Representationerna av oändlighet och NaN är också versaler.

'n'

Nummer. Detta är samma sak som 'g', förutom att den använder den aktuella lokala inställningen för att infoga lämpliga siffergruppsavskiljare för den integrerade delen av ett nummer.

'%'

Procent. Multiplicerar talet med 100 och visas i fast format ('f'), följt av ett procenttecken.

Ingen

För float är detta som typen 'g', förutom att när fastpunktsnotation används för att formatera resultatet, innehåller det alltid minst en siffra efter decimalpunkten och växlar till den vetenskapliga notationen när exp >= p - 1. När precisionen inte är specificerad kommer den senare att vara så stor som behövs för att representera det givna värdet på ett korrekt sätt.

För Decimal är detta detsamma som antingen 'g' eller 'G' beroende på värdet av context.capitals för den aktuella decimalkontexten.

Den övergripande effekten är att matcha utdata från str() som ändrats av de andra formatmodifierarna.

Resultatet bör vara korrekt avrundat till en given precision p av siffror efter decimaltecknet. Avrundningssättet för float matchar det för round() builtin. För Decimal kommer avrundningssättet för den aktuella kontexten att användas.

De tillgängliga presentationstyperna för complex är desamma som för float ('%' är inte tillåtet). Både de reella och imaginära komponenterna i ett komplext tal formateras som flyttal, enligt den angivna presentationstypen. De separeras av det obligatoriska tecknet för den imaginära delen, och den senare avslutas med suffixet j. Om presentationstypen saknas kommer resultatet att motsvara resultatet från str() (komplexa tal med en reell del som inte är noll omges också av parenteser), eventuellt ändrat av andra formatmodifierare.

Exempel på format

Detta avsnitt innehåller exempel på syntaxen str.format() och jämförelser med den gamla formateringen %.

I de flesta fall liknar syntaxen den gamla %-formateringen, med tillägget {} och med : som används i stället för %. Till exempel kan '%03.2f' översättas till '{:03.2f}'.

Den nya formatsyntaxen stöder också nya och annorlunda alternativ, som visas i följande exempel.

Tillgång till argument genom position:

>>> '{0}, {1}, {2}'.format('a', 'b', 'c')
'a, b, c'
>>> '{}, {}, {}'.format('a', 'b', 'c')  # 3.1+ only
'a, b, c'
>>> '{2}, {1}, {0}'.format('a', 'b', 'c')
'c, b, a'
>>> '{2}, {1}, {0}'.format(*'abc')      # unpacking argument sequence
'c, b, a'
>>> '{0}{1}{0}'.format('abra', 'cad')   # arguments' indices can be repeated
'abracadabra'

Tillgång till argument med namn:

>>> 'Coordinates: {latitude}, {longitude}'.format(latitude='37.24N', longitude='-115.81W')
'Coordinates: 37.24N, -115.81W'
>>> coord = {'latitude': '37.24N', 'longitude': '-115.81W'}
>>> 'Coordinates: {latitude}, {longitude}'.format(**coord)
'Coordinates: 37.24N, -115.81W'

Tillgång till argumentens attribut:

>>> c = 3-5j
>>> ('The complex number {0} is formed from the real part {0.real} '
...  'and the imaginary part {0.imag}.').format(c)
'The complex number (3-5j) is formed from the real part 3.0 and the imaginary part -5.0.'
>>> class Point:
...     def __init__(self, x, y):
...         self.x, self.y = x, y
...     def __str__(self):
...         return 'Point({self.x}, {self.y})'.format(self=self)
...
>>> str(Point(4, 2))
'Point(4, 2)'

Tillgång till argumentens poster:

>>> coord = (3, 5)
>>> 'X: {0[0]};  Y: {0[1]}'.format(coord)
'X: 3;  Y: 5'

Ersätter %s och %r:

>>> "repr() shows quotes: {!r}; str() doesn't: {!s}".format('test1', 'test2')
"repr() shows quotes: 'test1'; str() doesn't: test2"

Rikta in texten och ange en bredd:

>>> '{:<30}'.format('left aligned')
'left aligned                  '
>>> '{:>30}'.format('right aligned')
'                 right aligned'
>>> '{:^30}'.format('centered')
'           centered           '
>>> '{:*^30}'.format('centered')  # use '*' as a fill char
'***********centered***********'

Ersätter %+f, %-f och % f och anger ett tecken:

>>> '{:+f}; {:+f}'.format(3.14, -3.14)  # show it always
'+3.140000; -3.140000'
>>> '{: f}; {: f}'.format(3.14, -3.14)  # show a space for positive numbers
' 3.140000; -3.140000'
>>> '{:-f}; {:-f}'.format(3.14, -3.14)  # show only the minus -- same as '{:f}; {:f}'
'3.140000; -3.140000'

Ersätter %x och %o och konverterar värdet till olika baser:

>>> # format also supports binary numbers
>>> "int: {0:d};  hex: {0:x};  oct: {0:o};  bin: {0:b}".format(42)
'int: 42;  hex: 2a;  oct: 52;  bin: 101010'
>>> # with 0x, 0o, or 0b as prefix:
>>> "int: {0:d};  hex: {0:#x};  oct: {0:#o};  bin: {0:#b}".format(42)
'int: 42;  hex: 0x2a;  oct: 0o52;  bin: 0b101010'

Använda kommatecken eller understreck som siffergruppsavskiljare:

>>> '{:,}'.format(1234567890)
'1,234,567,890'
>>> '{:_}'.format(1234567890)
'1_234_567_890'
>>> '{:_b}'.format(1234567890)
'100_1001_1001_0110_0000_0010_1101_0010'
>>> '{:_x}'.format(1234567890)
'4996_02d2'
>>> '{:_}'.format(123456789.123456789)
'123_456_789.12345679'
>>> '{:.,}'.format(123456789.123456789)
'123456789.123,456,79'
>>> '{:,._}'.format(123456789.123456789)
'123,456,789.123_456_79'

Uttrycka en procentsats:

>>> points = 19
>>> total = 22
>>> 'Correct answers: {:.2%}'.format(points/total)
'Correct answers: 86.36%'

Använda typspecifik formatering:

>>> import datetime
>>> d = datetime.datetime(2010, 7, 4, 12, 15, 58)
>>> '{:%Y-%m-%d %H:%M:%S}'.format(d)
'2010-07-04 12:15:58'

Nesting-argument och mer komplexa exempel:

>>> for align, text in zip('<^>', ['left', 'center', 'right']):
...     '{0:{fill}{align}16}'.format(text, fill=align, align=align)
...
'left<<<<<<<<<<<<'
'^^^^^center^^^^^'
'>>>>>>>>>>>right'
>>>
>>> octets = [192, 168, 0, 1]
>>> '{:02X}{:02X}{:02X}{:02X}'.format(*octets)
'C0A80001'
>>> int(_, 16)
3232235521
>>>
>>> width = 5
>>> for num in range(5,12):
...     for base in 'dXob':
...         print('{0:{width}{base}}'.format(num, base=base, width=width), end=' ')
...     print()
...
    5     5     5   101
    6     6     6   110
    7     7     7   111
    8     8    10  1000
    9     9    11  1001
   10     A    12  1010
   11     B    13  1011

Strängar för mallar ($-strängar)

Anteckning

Den funktion som beskrivs här introducerades i Python 2.4; en enkel mallmetod baserad på reguljära uttryck. Den är äldre än str.format(), formaterade strängkonstanter och mallsträngkonstanter.

Det har inget att göra med mallsträngkonstanter (t-strings), som introducerades i Python 3.14. Dessa utvärderas till string.templatelib.Template-objekt, som finns i modulen string.templatelib.

Mallsträngar ger enklare strängsubstitutioner enligt beskrivningen i PEP 292. Ett primärt användningsområde för mallsträngar är för internationalisering (i18n) eftersom den enklare syntaxen och funktionaliteten i det sammanhanget gör det lättare att översätta än andra inbyggda strängformateringsfunktioner i Python. Som ett exempel på ett bibliotek som bygger på mallsträngar för i18n, se paketet flufl.i18n.

Mallsträngar stöder $-baserade substitutioner enligt följande regler:

  • $$ är en escape; den ersätts med en enda $.

  • $identifier namnger en substitutionsplatshållare som matchar en mappningsnyckel för "identifier". Som standard är "identifierare" begränsad till en alfanumerisk ASCII-sträng (inklusive understreck) som börjar med ett understreck eller en ASCII-bokstav. Det första icke-identifierande tecknet efter tecknet $ avslutar denna platshållarspecifikation.

  • ${identifier} är likvärdigt med $identifier. Det krävs när giltiga identifieringstecken följer efter platshållaren men inte är en del av platshållaren, t.ex. "${noun}ification".

Varje annan förekomst av $ i strängen kommer att resultera i att ett ValueError uppstår.

Modulen string tillhandahåller en klass Template som implementerar dessa regler. Metoderna i Template är:

class string.Template(template)

Konstruktören tar ett enda argument som är mallsträngen.

substitute(mapping={}, /, **kwds)

Utför mallsubstitutionen och returnerar en ny sträng. mapping är ett ordboksliknande objekt med nycklar som matchar platshållarna i mallen. Alternativt kan du ange nyckelordsargument, där nyckelorden är platshållarna. När både mapping och kwds anges och det finns dubbletter, har platshållarna från kwds företräde.

safe_substitute(mapping={}, /, **kwds)

Som substitute(), förutom att om platshållare saknas från mapping och kwds, istället för att ge upphov till ett KeyError undantag, kommer den ursprungliga platshållaren att visas i den resulterande strängen intakt. Dessutom, till skillnad från substitute(), kommer alla andra förekomster av $ helt enkelt att returnera $ istället för att ge upphov till ValueError.

Även om andra undantag fortfarande kan inträffa kallas den här metoden ”säker” eftersom den alltid försöker returnera en användbar sträng istället för att göra ett undantag. I en annan mening kan safe_substitute() vara allt annat än säker, eftersom den tyst ignorerar missbildade mallar som innehåller dinglande avgränsare, omatchade hängslen och livrem eller platshållare som inte är giltiga Python-identifierare.

is_valid()

Returnerar False om mallen har ogiltiga platshållare som gör att substitute() ger upphov till ValueError.

Tillagd i version 3.11.

get_identifiers()

Returnerar en lista över giltiga identifierare i mallen, i den ordning de först visas, och ignorerar eventuella ogiltiga identifierare.

Tillagd i version 3.11.

Template-instanser tillhandahåller också ett offentligt dataattribut:

template

Detta är det objekt som skickas till konstruktörens template-argument. I allmänhet bör du inte ändra det, men skrivskyddad åtkomst är inte påtvingad.

Här är ett exempel på hur man använder en mall:

>>> from string import Template
>>> s = Template('$who likes $what')
>>> s.substitute(who='tim', what='kung pao')
'tim likes kung pao'
>>> d = dict(who='tim')
>>> Template('Give $who $100').substitute(d)
Traceback (most recent call last):
...
ValueError: Invalid placeholder in string: line 1, col 11
>>> Template('$who likes $what').substitute(d)
Traceback (most recent call last):
...
KeyError: 'what'
>>> Template('$who likes $what').safe_substitute(d)
'tim likes $what'

Avancerad användning: Du kan härleda underklasser till Template för att anpassa syntaxen för platshållare, avgränsningstecken eller hela det reguljära uttryck som används för att analysera mallsträngar. För att göra detta kan du åsidosätta dessa klassattribut:

  • delimiter – Detta är den bokstavliga sträng som beskriver en platshållare som introducerar avgränsare. Standardvärdet är $. Observera att detta inte bör vara ett reguljärt uttryck, eftersom implementationen kommer att anropa re.escape() på denna sträng vid behov. Observera vidare att du inte kan ändra avgränsaren efter att klassen har skapats (dvs. en annan avgränsare måste anges i underklassens klassnamnrymd).

  • idpattern – Detta är det reguljära uttryck som beskriver mönstret för icke-braserade platshållare. Standardvärdet är det reguljära uttrycket (?a:[_a-z][_a-z0-9]*). Om detta anges och braceidpattern är None kommer detta mönster även att gälla för platshållare med klammer.

    Anteckning

    Eftersom standard flags är re.IGNORECASE, kan mönstret [a-z] matcha med vissa icke-ASCII-tecken. Det är därför vi använder den lokala a-flaggan här.

    Ändrad i version 3.7: braceidpattern kan användas för att definiera separata mönster som används inom och utanför hängslena.

  • braceidpattern – Detta är som idpattern men beskriver mönstret för platshållare med hakparenteser. Standardvärdet är None, vilket innebär att idpattern används (dvs. samma mönster används både inom och utanför hakparenteser). Om detta anges kan du definiera olika mönster för platshållare med och utan hakparenteser.

    Tillagd i version 3.7.

  • flags – De flaggor för reguljära uttryck som ska användas vid kompilering av det reguljära uttryck som används för att känna igen substitutioner. Standardvärdet är re.IGNORECASE. Observera att re.VERBOSE alltid kommer att läggas till flaggorna, så anpassade idpattern måste följa konventioner för verbala reguljära uttryck.

    Tillagd i version 3.2.

Alternativt kan du ange hela det reguljära uttrycksmönstret genom att åsidosätta klassattributet pattern. Om du gör detta måste värdet vara ett objekt för reguljära uttryck med fyra namngivna fångstgrupper. Fångstgrupperna motsvarar de regler som anges ovan, tillsammans med regeln om ogiltig platshållare:

  • escaped – Denna grupp matchar escape-sekvensen, t.ex. $$, i standardmönstret.

  • named – Denna grupp matchar det oskjutna platshållarnamnet; den bör inte inkludera avgränsaren i fångstgruppen.

  • braced – Denna grupp matchar platshållarnamnet som är omslutet av hakparenteser; den bör inte innehålla vare sig avgränsaren eller hakparenteser i den fångande gruppen.

  • invalid – Den här gruppen matchar alla andra avgränsningsmönster (vanligtvis en enda avgränsare) och den ska visas sist i det reguljära uttrycket.

Metoderna i denna klass kommer att ge ValueError om mönstret matchar mallen utan att någon av dessa namngivna grupper matchar.

Hjälpfunktioner

string.capwords(s, sep=None)

Dela upp argumentet i ord med str.split(), skriv varje ord med stor bokstav med str.capitalize() och sätt ihop orden med stor bokstav med str.join(). Om det valfria andra argumentet sep saknas eller är None, ersätts serier av blanksteg med ett enda blanksteg och inledande och avslutande blanksteg tas bort, annars används sep för att dela och sammanfoga orden.