Python-strängformat ()

Metoden strängformat () formaterar den givna strängen till en trevligare utgång i Python.

Syntaxen för format()metoden är:

 mall.format (p0, p1,…, k0 = v0, k1 = v1,…)

Här är p0, p1, … positionella argument och k0, k1, … är nyckelordsargument med värden v0, v1, … respektive.

Och mall är en blandning av formatkoder med platshållare för argumenten.

Strängformat () Parametrar

format()metoden tar ett antal parametrar. Men är uppdelad i två typer av parametrar:

• Positionsparametrar - lista över parametrar som kan nås med parameterindex i lockiga hakparenteser(index)
• Nyckelordsparametrar - lista över parametrar av typ nyckel = värde, som kan nås med parameternyckel i lockiga parenteser(key)

Returvärde från strängformat ()

Den format()metoden returnerar den formaterade strängen.

Hur fungerar strängformat ()?

De format()läser den typ av argument som skickas till den och formaterar den enligt de formatkoder som definierats i strängen.

För positionella argument

Här är Argument 0 en sträng "Adam" och Argument 1 är ett flytande nummer 230.2346.

Obs! Argumentlistan börjar från 0 i Python.

Strängen "Hello (0), your balance is (1:9.3f)"är mallsträngen. Detta innehåller formatkoderna för formatering.

De lockiga hängslen är bara platshållare för argumenten som ska läggas. I exemplet ovan är (0) platshållare för "Adam" och (1: 9.3f) är platshållare för 230.2346.

Eftersom mallsträngen refererar till format()argument som (0)och (1)är argumenten positionella argument. De kan båda refereras utan siffrorna som ()och Python omvandlar dem internt till siffror.

Internt,

• Eftersom "Adam" är det 0: ^e argumentet placeras det i stället för (0). Eftersom (0)den inte innehåller några andra formatkoder, utför den inga andra åtgärder.
• Det är dock inte fallet för en ^st argument 230,2346. Här (1:9.3f)placerar 230.2346 på sin plats och utför operationen 9.3f.
• f anger att formatet handlar om ett flytnummer. Om det inte anges korrekt kommer det att ge ett fel.
• Delen före "." (9) anger minsta bredd / stoppning som numret (230.2346) kan ta. I detta fall tilldelas 230.2346 minst 9 platser inklusive ".".
  Om inget justeringsalternativ anges, justeras det till höger om de återstående platserna. (För strängar är den inriktad till vänster.)
• Delen efter "." (3) avkortar decimaldelen (2346) upp till det angivna numret. I det här fallet trunkeras 2346 efter tre platser.
  Återstående siffror (46) avrundas och matar ut 235.

För argument för nyckelord

Vi har använt samma exempel ovanifrån för att visa skillnaden mellan sökords- och positionsargument.

Här, istället för bara parametrarna, har vi använt ett nyckelvärde för parametrarna. Namnlösa: namn = "Adam" och blc = 230.2346.

Eftersom dessa parametrar refereras till av nycklarna som (namn) och (blc: 9.3f), är de kända som nyckelord eller namngivna argument.

Internt,

• Platshållaren (namn) ersätts med värdet på namnet - "Adam". Eftersom den inte innehåller några andra formatkoder placeras "Adam".
• För argumentet blc = 230.2346 ersätts platshållaren (blc: 9.3f) med värdet 230.2346. Men innan den byts ut, som tidigare exempel, utför den 9.3f-operation på den.
  Detta matar ut 230.235. Decimaldelen trunkeras efter tre platser och återstående siffror avrundas. På samma sätt tilldelas den totala bredden 9 och lämnar två mellanslag till vänster.

Grundläggande formatering med format ()

Den format()metod gör det möjligt att använda enkla platshållare för formatering.

Exempel 1: Grundformatering för standard-, positions- och nyckelordargument

 # default arguments print("Hello (), your balance is ().".format("Adam", 230.2346)) # positional arguments print("Hello (0), your balance is (1).".format("Adam", 230.2346)) # keyword arguments print("Hello (name), your balance is (blc).".format(name="Adam", blc=230.2346)) # mixed arguments print("Hello (0), your balance is (blc).".format("Adam", blc=230.2346))

Produktion

Hej Adam, din saldo är 230.2346. Hej Adam, din saldo är 230.2346. Hej Adam, din saldo är 230.2346. Hej Adam, din saldo är 230.2346.

Obs! Vid blandade argument måste sökordsargument alltid följa positionella argument.

Tal formateras med format ()

Du kan formatera nummer med formatspecifikationen nedan:

Exempel 2: Enkel nummerformatering

 # integer arguments print("The number is:(:d)".format(123)) # float arguments print("The float number is:(:f)".format(123.4567898)) # octal, binary and hexadecimal format print("bin: (0:b), oct: (0:o), hex: (0:x)".format(12))

Produktion

 Numret är: 123 Numret är: 123.456790 bin: 1100, okt: 14, hex: c

Exempel 3: Nummerformatering med stoppning för int och floats

 # integer numbers with minimum width print("(:5d)".format(12)) # width doesn't work for numbers longer than padding print("(:2d)".format(1234)) # padding for float numbers print("(:8.3f)".format(12.2346)) # integer numbers with minimum width filled with zeros print("(:05d)".format(12)) # padding for float numbers filled with zeros print("(:08.3f)".format(12.2346))

Produktion

1 2 1 2 3 4 1 2. 2 3 5 0 0 0 1 2 0 0 1 2. 2 3 5

Här,

• i det första uttalandet, (:5d)tar ett heltalargument och tilldelar en minsta bredd på 5. Eftersom ingen inriktning anges är den inriktad till höger.
• I det andra uttalandet kan du se att bredden (2) är mindre än siffran (1234), så det tar inget utrymme åt vänster men trunkerar inte heller numret.
• Till skillnad från heltal har flottörer både heltal och decimaler. Och mininumbredden definierad till numret gäller för båda delarna som helhet inklusive "." .
• I det tredje uttalandet (:8.3f)avkortas decimaldelen till 3 platser som avrundar de två sista siffrorna. Och siffran, nu 12.235, tar en bredd på 8 som helhet och lämnar två platser åt vänster.
• Om du vill fylla de återstående platserna med noll placerar du en noll innan formatspecifikationen gör detta. Det fungerar både för heltal och flottör: (:05d)och (:08.3f).

Exempel 4: Nummerformatering för signerade nummer

 # show the + sign print("(:+f) (:+f)".format(12.23, -12.23)) # show the - sign only print("(:-f) (:-f)".format(12.23, -12.23)) # show space for + sign print("(: f) (: f)".format(12.23, -12.23))

Produktion

+12,230000 -12,230000 12,230000 -12,230000 1 2. 2 3 0 0 0 0 - 1 2. 2 3 0 0 0 0

Nummerformatering med justering

Operatorerna and =används för justering när de tilldelas en viss bredd till siffrorna.

Exempel 5: Nummerformatering med vänster, höger och mittjustering

 # integer numbers with right alignment print("(:5d)".format(12)) # float numbers with center alignment print("(:^10.3f)".format(12.2346)) # integer left alignment filled with zeros print("(:<05d)".format(12)) # float numbers with center alignment print("(:=8.3f)".format(-12.2346))

Produktion

1 2 1 2. 2 3 5 1 2 0 0 0 - 1 2. 2 3 5

Obs! Vänsterjustering fylld med nollor för heltal kan orsaka problem som det tredje exemplet som returnerar 12000 snarare än 12.

Strängformatering med format ()

Som nummer kan strängen formateras på ett liknande sätt med format().

Example 6: String formatting with padding and alignment

 # string padding with left alignment print("(:5)".format("cat")) # string padding with right alignment print("(:>5)".format("cat")) # string padding with center alignment print("(:^5)".format("cat")) # string padding with center alignment # and '*' padding character print("(:*^5)".format("cat"))

Output

 c a t c a t c a t * c a t * 

Example 7: Truncating strings with format()

 # truncating strings to 3 letters print("(:.3)".format("caterpillar")) # truncating strings to 3 letters # and padding print("(:5.3)".format("caterpillar")) # truncating strings to 3 letters, # padding and center alignment print("(:^5.3)".format("caterpillar"))

Output

 c a t c a t c a t 

Formatting class and dictionary members using format()

Python internally uses getattr() for class members in the form ".age". And, it uses __getitem__() lookup for dictionary members in the form "(index)".

Example 8: Formatting class members using format()

 # define Person class class Person: age = 23 name = "Adam" # format age print("(p.name)'s age is: (p.age)".format(p=Person()))

Output

 Adam's age is: 23 

Here, Person object is passed as a keyword argument p.

Inside the template string, Person's name and age are accessed using .name and .age respectively.

Example 9: Formatting dictionary members using format()

 # define Person dictionary person = ('age': 23, 'name': 'Adam') # format age print("(p(name))'s age is: (p(age))".format(p=person))

Output

 Adam's age is: 23 

Similar to class, person dictionary is passed as a keyword argument p.

Inside the template string, person's name and age are accessed using (name) and (age) respectively.

There's an easier way to format dictionaries in Python using str.format(**mapping).

 # define Person dictionary person = ('age': 23, 'name': 'Adam') # format age print("(name)'s age is: (age)".format(**person))

** is a format parameter (minimum field width).

Arguments as format codes using format()

You can also pass format codes like precision, alignment, fill character as positional or keyword arguments dynamically.

Example 10: Dynamic formatting using format()

 # dynamic string format template string = "(:(fill)(align)(width))" # passing format codes as arguments print(string.format('cat', fill='*', # dynamic float format template num = "(:(align)(width).(precision)f)" # passing format codes as arguments print(num.format(123.236,>

 * * c a t * * 1 2 3 . 2 4 

 import datetime # datetime formatting date = datetime.datetime.now() print("It's now: (:%Y/%m/%d %H:%M:%S)".format(date)) # complex number formatting complexNumber = 1+2j print("Real part: (0.real) and Imaginary part: (0.imag)".format(complexNumber)) # custom __format__() method class Person: def __format__(self, format): if(format == 'age'): return '23' return 'None' print("Adam's age is: (:age)".format(Person()))

 It's now: 2016/12/02 04:16:28 Real part: 1.0 and Imaginary part: 2.0 Adam's age is: 23 

 # __str__() and __repr__() shorthand !r and !s print("Quotes: (0!r), Without Quotes: (0!s)".format("cat")) # __str__() and __repr__() implementation for class class Person: def __str__(self): return "STR" def __repr__(self): return "REPR" print("repr: (p!r), str: (p!s)".format(p=Person()))

 Citat: 'katt', utan citat: katt repr: REPR, str: STR