Python virknes formāts ()

String format () metode formatē doto virkni jaukākā Python izvadē.

Metodes sintakse format()ir šāda:

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

Šeit p0, p1,… ir pozicionālie argumenti un, k0, k1, … ir atslēgvārdu argumenti ar attiecīgi v0, v1, …

Veidne ir formātu kodu maisījums ar argumentu vietturiem.

Virknes formāts () Parametri

format()metode ņem jebkuru parametru skaitu. Bet tas ir sadalīts divu veidu parametros:

• Pozicionālie parametri - saraksts ar parametriem, kuriem var piekļūt ar parametru indeksu cirtaino lencīšu iekšpusē(index)
• Atslēgvārdu parametri - tipa key = value parametru saraksts, kuriem var piekļūt ar parametra atslēgu cirtainajās iekavās(key)

Atgriezt vērtību no virknes formāta ()

format()Metode atgriež formatētu virkni.

Kā darbojas virknes formāts ()?

format()Nolasa argumentu nodoti to veidu un formātu to atbilstoši formāta kodiem definēti virknē.

Pozicionāliem argumentiem

Šeit arguments 0 ir virkne "Ādams" un 1. arguments ir peldošs skaitlis 230,2346.

Piezīme. Argumentu saraksts Python sākas ar 0.

Virkne "Hello (0), your balance is (1:9.3f)"ir veidnes virkne. Tajā ir formatēšanas formātu kodi.

Cirtainās lencītes ir tikai vietturi argumentu ievietošanai. Iepriekš minētajā piemērā (0) ir vietturis "Adam" un (1: 9.3f) ir vietturis skaitlim 230.2346.

Tā kā veidnes virkne atsaucas uz format()argumentiem kā (0)un (1), argumenti ir pozicionāli argumenti. Uz abiem var atsaukties arī bez skaitļiem, ()un Python tos iekšēji pārvērš skaitļos.

Iekšēji

• Tā kā "Adam" ir 0 ^th arguments, tas ir novietots vietā (0). Tā kā (0)tajā nav citu formātu kodu, tas neveic citas darbības.
• Tomēr tas nav gadījums 1 ^st arguments 230.2346. Šeit (1:9.3f)tā vietā ievieto 230.2346 un veic operāciju 9.3f.
• f norāda formātu, kas attiecas uz pludiņa skaitli. Ja tas nav pareizi norādīts, tas radīs kļūdu.
• Daļa pirms "." (9) norāda minimālo platumu / polsterējumu, kāds var būt skaitlim (230,2346). Šajā gadījumā 230,2346 tiek piešķirtas vismaz 9 vietas, ieskaitot "."
  Ja nav norādīta līdzināšanas opcija, tā tiek izlīdzināta pa labi no atlikušajām atstarpēm. (Stīgām tas ir izlīdzināts pa kreisi.)
• Daļa aiz "." (3) saīsina decimāldaļu (2346) līdz dotajam skaitlim. Šajā gadījumā 2346 tiek saīsināts pēc 3 vietām.
  Atlikušie skaitļi (46) ir noapaļoti, ievadot 235.

Atslēgvārdu argumentiem

Mēs izmantojām to pašu piemēru no augšas, lai parādītu atšķirību starp atslēgvārda un pozīcijas argumentiem.

Šeit parametru vietā esam izmantojuši atslēgas vērtību. Proti, vārds = "Ādams" un blc = 230,2346.

Tā kā uz šiem parametriem to atslēgas atsaucas kā (nosaukums) un (blc: 9.3f), tos sauc par atslēgvārdiem vai nosauktiem argumentiem.

Iekšēji

• Vietavietu (vārdu) aizstāj ar nosaukuma vērtību - "Ādams". Tā kā tajā nav citu formātu kodu, tiek ievietots "Adam".
• Argumentam blc = 230.2346 vietturi (blc: 9.3f) aizstāj ar vērtību 230.2346. Bet pirms tā nomaiņas, tāpat kā iepriekšējais piemērs, tas veic ar to operāciju 9.3f.
  Tas dod 230.235. Decimāldaļa tiek saīsināta pēc 3 vietām, un atlikušie cipari ir noapaļoti. Tāpat kopējam platumam tiek piešķirts 9, atstājot divas atstarpes pa kreisi.

Pamata formatēšana ar formātu ()

format()Metode ļauj izmantot vienkāršu vietturus formatējumu.

1. piemērs: noklusējuma, pozicionēšanas un atslēgvārdu argumentu pamata formatēšana

 # 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))

Rezultāts

Sveiks, Ādam! Jūsu bilance ir 230,2346. Sveiks, Ādam! Jūsu bilance ir 230,2346. Sveiks, Ādam! Jūsu bilance ir 230,2346. Sveiks, Ādam! Jūsu bilance ir 230,2346.

Piezīme . Jauktu argumentu gadījumā atslēgvārdu argumentiem vienmēr ir jāseko pozicionālajiem argumentiem.

Skaitļu formatēšana ar formātu ()

Skaitļus var formatēt, izmantojot tālāk norādīto formāta specifikatoru:

Example 2: Simple number formatting

 # 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))

Output

 The number is: 123 The number is:123.456790 bin: 1100, oct: 14, hex: c

Example 3: Number formatting with padding for int and 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))

Output

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

Here,

• in the first statement, (:5d) takes an integer argument and assigns a minimum width of 5. Since, no alignment is specified, it is aligned to the right.
• In the second statement, you can see the width (2) is less than the number (1234), so it doesn't take any space to the left but also doesn't truncate the number.
• Unlike integers, floats has both integer and decimal parts. And, the mininum width defined to the number is for both parts as a whole including ".".
• In the third statement, (:8.3f) truncates the decimal part into 3 places rounding off the last 2 digits. And, the number, now 12.235, takes a width of 8 as a whole leaving 2 places to the left.
• If you want to fill the remaining places with zero, placing a zero before the format specifier does this. It works both for integers and floats: (:05d) and (:08.3f).

Example 4: Number formatting for signed numbers

 # 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))

Output

+12.230000 -12.230000 12.230000 -12.230000 1 2. 2 3 0 0 0 0 - 1 2. 2 3 0 0 0 0

Skaitļu formatēšana ar izlīdzināšanu

Operatori and =tiek izmantoti izlīdzināšanai, kad numuriem tiek piešķirts noteikts platums.

5. piemērs: Skaitļu formatēšana ar kreisās, labās un centrālās izlīdzināšanu

 # 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))

Rezultāts

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

Piezīme. Kreisais izlīdzinājums, kas ir piepildīts ar nullēm veseliem skaitļiem, var radīt problēmas kā 3. piemērs, kas atgriež 12000, nevis 12.

Virknes formatēšana ar formātu ()

Kā skaitļus virknes var formatēt līdzīgi ar 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()))

 Citāti: 'kaķis', bez pēdiņām: kaķa repr: REPR, str: STR