§2. Formaterad utdata. print() funktion. format() metod. Kommentarer i Python; Strängformatering: Formatoperatorer och format()-metoden

Programtext säger hur, och kommentarer bör förklara varför. Swaroop Chitlur ("A Byte of Python")

Källtextrader

Fysiska strängar

Fysisk sträng källfilen är en rad som slutar med en radavslutning (skrivs in genom att trycka på Enter-tangenten). Denna flagga är en plattformsspecifik specialtecken. På Unix används ASCII LF (radmatning), på Windows, ASCII CR LF (vagnretur följt av radmatning) och Macintosh, ASCII CR (vagnretur). Alla dessa formulär kan användas lika, oavsett plattform.

Booleska strängar

Python-programmet är uppdelat i flera logiska rader. boolesk sträng innehåller en eller flera fysiska strängar kopplade till språkets regler. (I interaktivt läge kommer fortsättningen av en logisk rad på en ny fysisk rad att börja med tecken...). En logisk linje är ett komplett påstående ( instruktion) språk.

Indrag i början av en rad

Inledande blanktecken (mellanslag och tabbar) i början av en rad används i Python för att definiera en grupp av satser som en enda enhet - en sammansatt sats eller block. Indrag inom ett block måste vara lika med teckenlängden annars kommer det att resultera i ett fel. För kompatibilitet mellan plattformar bör du inte använda en blandning av utrymmen och flikar. Till exempel:
Program 2.1

Från sköldpaddsimport* begin_fill() för i inom range(5): fd(150) för j i range(5): fd(50) left(144) left(144) end_fill() mainloop()

Notera. I framtiden kommer programmen att numreras i formatet: Program x.y, där x är numret på lektionen, y är numret på programmet i denna lektion.

Kommentarer

Kommentarer i Python börjar med tecknet "#". En kommentar slutar i slutet av en fysisk rad och markerar slutet på en logisk rad om inte en implicit linjekoppling används (se nedan). Kommentarer är för förklaringar eller programmerares anteckningar. Kommentarer hjälper andra programmerare att förstå innebörden av källkoden (se epigrafen). Kommentarer är också användbara när du felsöker kod och identifierar fel. Inom en kommentar kan du använda alla tecken, inklusive tjänste.

Kombinera flera fysiska strängar

Två (eller flera) fysiska strängar kan kombineras till en logisk sträng med ett snedstreck (omvänt snedstreck, "\"), nämligen när den fysiska strängen slutar med ett "\"-tecken och den inte är en del av strängen (dvs. en ” “) eller kommentar, lägger den till nästa fysiska rad för att bilda en logisk rad. Tecknet "\" måste följas av radsluttecknet (dvs. den fysiska raden måste sluta). Till exempel:

Om 1900< year < 2100 and 1 <= month <= 12 \ and 1 <= day <= 31 and 0 <= hour < 24 \ and 0 <= minute < 60 and 0 <= second < 60: # Успешная проверка даты return 1

Notera. Inuti en bokstavlig sträng har det ingen effekt att undvika omvänt snedstreck, men "\\" minskar antalet "\"-tecken som matas ut med 1:

Print("\ ") print("\\ ") print("\\\ ") print("\\\\") \ \ \\ \\

Implicit sammanlänkning av fysiska strängar

Uttryck med parenteser, parenteser eller lockiga parenteser kan delas över flera fysiska linjer utan att använda ett omvänt snedstreck. Till exempel:
Program 2.2

A = "Mitt namn är - " b = input("Ditt namn är: ") c = "\nJag är - " d = input("Din ålder är: ") e = "år." print(a, # "Mitt namn är " b, # Namnet du skrev in c, # "Jag heter " d, # Åldern du angav e # "år")

print() funktion

Program 2-2 använder funktionen print() för att visa data. Om metoden format() inte används (se nedan), används funktionen för att mata ut utan format. Utskriftsfunktionen har argument som kan göra utdata läsbar. I allmänhet har funktionen följande argument:

Skriv ut(*objekt, sep=" ", end="\n", file=sys.stdout, flush=False)

• *objekt - kommaseparerade objekt (variabler, strängar, konstanter) vars värden ska visas
• sep=" " - separator (standard är blanksteg)
• end="\n" - sluttecken (standard - radsluttecken)
• file=sys.stdout - utdata till en fil. Filobjektet måste vara ett objekt med en write(str)-metod. print() kan endast användas för textfiler.
• flush=False - påtvingad tömning av utgångsbufferten (standard - nej, eftersom det vanligtvis bestäms av filen).

Till exempel:
Program 2.3 print("2", "+", "2", "= ") print("4") print("2", "+", "2", "= ", end="") print(" 4") print("2", "+", "2", "= ", sep="\n") print("4")

Programutgång:

2 + 2 = 4 2 + 2 = 4 2 + 2 = 4

format() metod

Funktionen print() har en betydande nackdel - den har inga argument som tillåter formaterad utdata. För att mata ut data med specifik formatering måste du använda format()-metoden.
En miniguide till denna metod på dokumentationssidorna
Notera. Det finns ingen teckendatatyp i python, så ett enstaka tecken behandlas också som en sträng.
Syntaxen för metoden format() är:

"(:format_spec).format()

där format_spec är formatspecifikation:
[#][.precision]
Ser ganska skrämmande ut, men oroa dig inte! Vanligtvis används ett begränsat antal formateringselement, och alla är valfria!
Syftet med formateringselement:

• fylla - fylla tecken (vilket tecken som helst)
• align - alignment. Värden: "" | "=" | "^"
• tecken - teckenutgång. Värden: "+" | "-" | " "
• # - utdataprefix för binärt, oktalt och hexadecimalt format (dvs. 0x , 0o eller 0b)
• 0 - utfyllnad med inledande nollor för numeriska typer när justering inte är explicit inställd
• bredd - bredd på utdatafältet (heltal)
• grouping_option - sifferavgränsare "," eller "_" . Används inte för det ryska språket (formatet "n" används för dessa ändamål)
• .precision - antal decimaler (prick krävs, följt av heltal)
• typ - typ av utdatavärde (se tabell nedan).

Typbeteckningar

Symbol	Beskrivning
b	binärt format. Visar ett tal binärt
c	Konverterar ett utgående heltal till motsvarande unicode-tecken
d	Decimalt heltal
e	Tal i exponentiellt (vetenskapligt) format, e - gemener
E	Tal i exponentiellt (flytande komma, vetenskapligt) format, E - versaler
f	Fast punktnummer
F	Fast punktnummer, NAN och INF (ej nummer och oändlighet) skrivs ut med versaler
g	Allmänt nummerformat. För den givna precisionen p >= 1, avrundas detta tal till p signifikanta siffror och formateras sedan som antingen fixpunkt eller vetenskaplig notation, beroende på storleken.
G	Samma som "g", men alfabetiska tecken visas med versaler
n	Samma som 'd', förutom att den aktuella språkinställningen används för att infoga lämpliga avgränsare.
o	Tal i oktalt talsystem
s	Strängtyp (standard)
x	Hexadecimalt tal
X	Samma som "x", endast alfabetiska tecken visas med versaler
%	Värdet visas som en procentsats (multipliceras med 100 och symbolen "%" läggs till)
Ingen	Liknar "g", förutom att fixpunktsnotation används när talet har minst en siffra efter decimalkomma. Standardprecisionen är så hög som nödvändigt för att representera ett visst värde.

Flaggor som används för justering:

• > - Rikta in objektet till höger
• ^ - Mittinriktning

Till exempel:
Program 2.4 skriva ut("(:<10}".format("Я")) print("{:^10}".format("Я")) print("{:>10)".format("Jag"))

Programutgång:

jag jag jag

Problembeskrivning: Använd symbolen "*" för att visa följande figur:

* *** ***** ******* ********* ***********

Lösning: vi kommer att visa symbolen "*" med mittinriktning:
Program 2.5

Print("(:^11)".format("*")) print("(:^11)".format("***")) print("(:^11)".format("* ****")) print("(:^11)".format("*******")) print("(:^11)".format("******* **")) print("***************")

Du kan använda flera formatspecifikationer för ett eller flera utdatavärden för de olika objekten som anges i formatmetoden. Varje specifikation måste bifogas i separata () . Det kan finnas ett godtyckligt antal olika avgränsande tecken mellan specifikationer omslutna i (). Detta gör att du kan utföra godtyckligt komplex formatering med tydliga och begripliga verktyg. Till exempel.
Problemformulering: Visa följande figur:

********** ********** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ********** **********

Använd inte mellanslag och tabbtecken!
Lösning:
Program 2.6

Print("**********") print("**********") print("(:)(:>8)".format("**", "**")) print("(:)(:>8)".format("**", "**")) print("(:)(:>4)(:>4)". format("**", "**", "**")) print("(:)(:>4)(:>4)".format("**", "**", "* *")) print("(:)(:>8)".format("**", "**")) print("(:)(:>8)".format("**", "**")) print("**********") print("**********")

Det är lätt att se att i detta program visas samma objekt flera gånger. Metoden format() låter dig betrakta en uppsättning uppräknade objekt som en lista och följaktligen använda indexering för att visa det önskade objektet igen. Sedan kan denna kod skrivas om enligt följande:

Print("**********") print("**********") print("(0:)(0:>8)".format("** ")) print("(0:)(0:>8)".format("**")) print("(0:)(0:>4)(0:>4)".format(" **")) print("(0:)(0:>4)(0:>4)".format("**")) print("(0:)(0:>8)".format ("**")) print("(0:)(0:>8)".format("**")) print("**********") print("** ********")

Notera. Det första elementet i listan har index 0. När flera formatspecifikationer används för ett objekt, då för var och en av dem, måste indextecknet för utdataobjektet följa det första tecknet i specifikationen (i detta fall är det det enda ett, så nollor finns överallt).
Låt oss komplicera uppgiften för att konsolidera grunderna för att arbeta med metoden format().
Problemformulering: Visa ordet "WORLD" med symbolen "*". Använd inte mellanslag och tabbtecken.

* * * * ***** ** ** * ** * * * * * * * * ***** * * ** * * * * * * *

Lösning:
Program 2.7

Print("(0:1)(0:>6)(0:>2)(0:>6)(1:>6)".format("*","*****")) print ("(0:1)(0:>5)(1:>2)(0:>6)(1:>2)(1:>5)".format("**","*") ) print("(0:1)(0:>3)(0:>3)(0:>2)(0:>3)(0:>3)(1:>6)".format(" *","*****")) print("(0:1)(0:>6)(1:>3)(0:>5)(0:>2)".format("* ","**")) print("(0:1)(0:>6)(0:>2)(0:>6)(0:>2)".format("*"))

Detta program använder 5 till 7 formatspecifikationer för ett eller två utdataobjekt. Figuren nedan förklarar hur indexering används för varje specifikation.

Läxa

Skriv ut följande bilder med format()-metoden och print()-funktionen:

1. * ** *** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ************* ************** 2. ***** * ** *** **** ***** ****** ******* ******** ********* ********** *********** ********************* ******************* **************** 3. * *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** * 4. * * * * * * * * * * * * * * * * * * * * * * * ** * ** * * * * * * * * * * *** * *** ******* * * * ***

• Översättning

Jag uppmärksammar Habra-läsare och pytonfans på översättningen av en ganska omfattande artikel om strängformatering. Sagan kommer att vara sann, och tipset kommer att vara att konservativa ibland bör överväga något nytt, även om vanan envist gör motstånd.

Förutse nyfikenheten hos läsare som tenderar att ställa frågor utanför samtalsämnet, jag kommer att säga att bilden är indirekt relaterad till python, men inte den mest trevliga. Jag föreslår att hitta varför som läxor.

Jag väntar på kommentarer om fel i designen och stavfel i en personlig - traditionell habraplyushki från mig.

Jag har skrivit i python i många år. Men i början av denna resa var jag intresserad av att lära mig att formatera strängar i Perl-stilen. Låt mig påminna dig om att Perl (och många Unix kommandoradstolkar) stöder två typer av strängliteraler - med enkla citattecken (när strängen skrivs ut som den är), och dubbla citattecken där deras värden ersätts med variabler. I Perl, till exempel, kan du skriva något som:

$name = "Reuven"; print "Hej, $namn\n";
Och programmet kommer följaktligen att skriva "Hej, Reuven".

Strängliteraler i python beror inte på typen av citattecken och variablerna i dem utökas aldrig till sina värden. För att uppnå detta har %-operatorn för strängar traditionellt använts. I detta sammanhang tittar operatören på strängen till vänster och räknar hur många värden som behöver ersättas av värdena för motsvarande variabler till höger. Resultatet av operationen är en ny rad med värdena för variablerna infogade i stället för platshållarna. Till exempel:

>>> name = "Reuven" >>> "Hej, %s" % namn "Hej, Reuven"
Denna python-kod fungerar bra och skriver ut en personlig hälsning. Så trots mina många års praktik med python - var jag ganska nöjd med användningen av denna syntax. Ja, det är inte särskilt snyggt och nej, jag har aldrig tänkt på ett berg av printf-modifierare som påverkar formateringen. Jag menar, jag använde alltid "s"-modifieraren (utdata som en sträng) och det räckte för mig att python implicit kastade argumenten till strängen.

Men för tillfället är faktumet att %-syntaxen är utfasad, eller åtminstone utfasad. Python-dev-sändlistan noterar att den kommer att leva i 2.x-grenen till åtminstone 2022, men ingenting sägs om 3.x-grenen, så stödet för denna syntax kommer snart att tas bort och det är inte önskvärt att använda den. Den ersattes av metoden str.format.

I mina pytonlektioner nämnde jag alltid str.format, men i specifika exempel var allt oftare beroende av %. Jag uppmuntrade till och med eleverna att använda % eftersom jag personligen tyckte att det var mycket lättare.

Men den ihärdiga känslan av att jag gjorde något fel och kanske till och med vilseledde mina elever fick mig att studera str.format närmare. Under forskningens gång kom jag till följande slutsatser: 1) Det är inte mer komplicerat än % och till och med lättare i vissa tillämpningar; 2) Jag har aldrig använt str.formats funktioner till sin fulla potential, och de är väldigt praktiska trots den tid det tar att lära sig dem.

Låt oss börja med det enklaste. Låt oss säga "God morgon" till någon och tilltala dem med deras för- och efternamn, förutsatt att de är lagrade i variablerna "först" och "sist". På det gamla sättet skulle vi göra så här:

>>> första = "Reuven" >>> sista = "Lerner" >>> "God morgon, %s %s" % (första, sista) "God morgon, Reuven Lerner"
Även i det här exemplet stöter vi på ett av %-syntaxproblemen - vi har nu två variabler, och för att kunna använda båda måste vi göra en tupel av dem. Ur pytonsynpunkt är detta logiskt, men jag försäkrar er att många elever är mycket förvånade över detta.

Hur skulle detta exempel se ut när det gäller str.format? Ganska lika:

>>> "God morgon, () ()".format(första, sista) "God morgon, Reuven Lerner"
Observera att vi har ändrat principen något. Nu är detta inte en binär operator på strängar, utan en metod för strängobjektet som tar ett antal parametrar. Detta är logiskt och mer konsekvent. För samma elever såg operatorn % i mina exempel ut som ett tillägg till utskrift, inte en strängoperation. ".format"-notationen efter strängen gör det mer uppenbart att detta är en metod som är specifik för den strängen.

Som du säkert redan vet säger förekomster av "() ()" i en sträng till str.format att ta två parametrar, vars värden kommer att infogas i strängen i den ordning de skickas till metoden. Det finns två argument, så det bör finnas två förekomster av () i strängen. Detta är lite svårare att förstå, eftersom lockiga hängslen i Python tipsar folk om ordböcker, och tomma hängslen ser inte särskilt snygga ut. Men det är okej, jag kan leva med det och accepterade det ganska lätt.

Den punkt där str.format visar den första fördelen över % är när den behöver använda parametrar i omvänd ordning. Faktum är att med %s finns det inget sätt att uppnå detta alls. Det är inte heller möjligt att använda värdet av samma variabel mer än en gång. När vi använder str.format kan vi enkelt ändra ersättningssekvensen:

>>> "God morgon, (1) (0)".format(första, sista) "God morgon, Lerner Reuven"
Observera att om jag använde tomma parenteser "() ()", så skulle ersättningen ske i samma ordning som parametrarna skickas till metoden. Du kan föreställa dig parametrarna som en sekvens indexerad från noll, och om jag vill ändra ordningen, lägger jag helt enkelt ner de nödvändiga indexen för denna sekvens inom parentes. Vårt allra första exempel med str.format kan skrivas så här:

>>> "God morgon, (0) (1)".format(första, sista) "God morgon, Reuven Lerner"
Observera att genom att uttryckligen ange index kan vi inte längre förlita oss på automatisk indexering.

Naturligtvis kan du också använda en sekvens från en lista med *-operatorn:

>>> names = ("Reuven", "Lerner") >>> "God morgon, () ()".format(*names) "God morgon, Reuven Lerner"
Du kan också använda namngivna argument:

>>> "God morgon, (första) (sista)".format(first="Reuven", last="Lerner") "God morgon, Reuven Lerner"
Jag gillar särskilt det här alternativet. Namngivna parametrar är mer explicita (om de har bra namn) och att använda (första) och (sista) är ganska läsbar - speciellt jämfört med %(first)s som behövs med %-operatorn

Namngivna parametrar kan också utökas från en ordbok med **-operatorn:

>>> person = ("first":"Reuven", "last":"Lerner") >>> "God morgon, (första) (sista)".format(**person) "God morgon, Reuven Lerner"
Jag beskrev allt detta för mina elever och blev ganska förvånad över hur bekväma de är med den här syntaxen. Ja, och det blev trevligare att jobba.

Det bör nämnas att namngivna och positionella argument tekniskt sett kan användas tillsammans. Men det är bättre att inte göra så här:

>>> person = ("first":"Reuven", "last":"Lerner") >>> "Bra (0), (första) (sista)".format("morgon", **person) " God morgon Reuven Lerner"

Jag varnade.

Det som kan saknas i str.format är... ahem... formatering. Den dåliga nyheten är att str.format har helt andra regler för hur man formaterar utdata. Den goda nyheten är att dessa regler är ganska lätta att lära sig och förstå.

Låt oss börja enkelt igen: om du behöver skriva ut en sträng med en given längd, lägg till ett kolon (:) efter variabelnamnet och sedan antalet tecken. Så för att skriva ut mitt namn och fylla det upp till tio tecken med mellanslag, skulle jag göra så här:

>>> "Ditt namn är (namn:10)".format(name="Reuven") "Du heter Reuven "
(Observera att strängen är utfylld med mellanslag efter namnet.)

Om du behöver ställa in justeringen på blockets högra sida, använd tecknet > mellan: och numret:

>>> "Ditt namn är (namn:>10)".format(name="Reuven") "Du heter Reuven"
Och ja, du kan uttryckligen ange att jag vill ha vänsterjustering med hjälp av tecknet<
Om du behöver visa värdet i mitten av blocket, då istället för< и >symbolen ^ används:

>>> "Ditt namn är (namn:*^10)".format(name="Reuven") "Ditt namn är **Reuven**"
Texten är mer eller mindre tydlig, men hur är det med siffrorna? Personligen var det svårt för mig att föreställa mig hur det skulle fungera, men allt visade sig vara ganska okomplicerat. För en enkel utmatning av tal använder vi en syntax som liknar strängar:

>>> "Priset är $(number).".format(number=123) "Priset är $123."
Men det finns fler modifierare för siffror än för strängar. Till exempel, för att visa ett tal i binär form, lägg till "b"-modifieraren, om den är hexadecimal - "x"-modifieraren:

>>> "Priset är $(number:b).".format(number=5) "Priset är $101." >>> "Priset är $(antal:x).".format(number=123) "Priset är $7 miljarder."
Naturligtvis kan nummerinmatningen kompletteras med inledande nollor:

>>> "Ditt samtal är viktigt för oss. Du är ring #(nummer:05).".format(nummer=123) "Ditt samtal är viktigt för oss. Du är ring #00123."
Observera att körbar python-kod inte kan användas inuti () - istället erbjuds ett enkelt mikrospråk, separat och annorlunda än python som helhet. Det finns också små undantag. För det första kan du få värdena för attribut/egenskaper genom en punkt, och för det andra kan du få värdet på ett objekt genom att indexera med .

Till exempel:

>>> klass Foo(objekt): def __init__(self): self.x = 100 >>> f = Foo() >>> "Ditt nummer är (ox)".format(o=f) "Ditt nummer är 100"n
Vi fick "x"-attributet för "f"-objektet. Detta objekt är tillgängligt med namnet "o" inuti strängen. Du kan få ett attribut, men du kan inte köra det:

>>> "Ditt namn är (name.upper())".format(name="Reuven") AttributeError: "str" ​​​​object har inget attribut "upper()"
Jag försökte "name.upper()" förutsatt att lämplig metod skulle anropas, men python tillåter inte kod att köras på den platsen och behandlar "upper()" som ett attribut tillsammans med parenteser. Utan parentes får du bara en strängrepresentation av funktionen/metoden:

>>> "Ditt namn är (name.upper)".format(name="Reuven") "Du heter "
Med hakparenteser kan du ta ett element av ett itererbart objekt (lista, sträng) efter index. Men segmentoperationer stöds inte:

>>> "Ditt favoritnummer är (n).".format(n=numbers) "Ditt favoritnummer är 3."
Men:

>>> "Dina favoritnummer är (n).".format(n=numbers) ValueError: Saknar "]" i formatsträngen
Det kan också användas för att hämta inlägg i ordboken efter namn, men namnet skrivs in utan citattecken:

>>> person = ("first":"Reuven", "last":"Lerner") >>> "Ditt namn är (p).".format(p=person) "Ditt namn är Reuven."
När vi försöker använda citat får vi ett undantag ...

>>> "Ditt namn är (p["first").".format(p=person) KeyError: ""first""
Alla användningar av str.format är inte listade här - i själva verket har varje typ en formateringsregelspecifikation. Till exempel är precisionsalternativet för flyttalnummer inte tillgängligt för strängar.

Du kan till och med lägga till anpassade formateringsregler till dina klassobjekt så att de har en specifik renderingsstil och modifierare för att anpassa den.

Om du vill utforska detta ämne mer i detalj bör du börja med PEP 3101, som beskriver str.format. Jag kan också rekommendera Eric Smiths presentation med en ganska bra sammanfattning om detta ämne. Det finns också bra exempel på hur man byter från att använda % till str.format i python-dokumentationen

Jag hoppas att du gillade det!

Str.format()-strängmetoden låter dig utföra variabelsubstitution, formatera värden och sammanfoga element till en enda sträng med hjälp av positionsformatering, vilket gör programkoden mer läsbar och bekväm.

Denna handledning täcker de grundläggande strängformateringsteknikerna i Python.

formatmetod

Formatmetoden str.format() lägger till en eller flera platshållare till en sträng, som definieras av klammerparenteser (()). Du kan skicka vilket värde som helst till metoden som du vill infoga i strängen. När programmet körs kommer detta värde att läggas till strängen på den plats där de lockiga hängslen är.

Till exempel:

print("Jag har () äpplen.".format(5))
Jag har 5 äpplen.

Ovanstående rad använder lockiga hängslen:

"Jag har () äpplen."

Metoden str.format() har ett värde på 5. Det kommer att infoga det värdet i den medföljande strängen i stället för de lockiga klammerparenteserna.

apple_string = "Jag har()."
print(apple_string.format("5 äpplen"))
Jag har 5 äpplen.

Nu har formatmetoden infogat strängen "5 äpplen" i stället för platshållaren.

Flera utbyte

Du kan använda flera platshållare i en sträng. Försök att lägga till ytterligare ett par lockiga hängslen till strängen och ett annat värde till metoden.

new_apple_string = "Jag älskar () ()." #2 () substitut
print(new_apple_string.format("röd", "äpplen")) #Värden måste separeras med kommatecken
Jag älskar röda äpplen.

Metoden str.format() kan skicka flera strängar; för att göra detta måste du separera dem med kommatecken, som visas i exemplet ovan.

Prova att lägga till några fler platshållare i strängen:

my_string = "Jag älskar () (), och har () ()." #4 () substitut
print(my_string.format("röd", "äpplen", 5, "äpplen")) #4 rader i metoden
Jag älskar röda äpplen och har 5 äpplen.

Positionella och namngivna argument

Om lockiga klammerparenteser skickas utan några parametrar kommer Python att infoga värdena som skickas med metoden str.format() i ordning, som i de tidigare exemplen. Låt oss titta på ett annat exempel:

print("Min vän () har ett husdjur ()!".format("Sam", " bevingad dinosaurie"))
Min vän Sam har en husdjursbevingad dinosaurie!

Det första paret lockiga hängslen ersätts av metodens första värde, det andra paret av det andra värdet. Metodvärden ser ut så här:

("Sam", "bevingad dinosaurie")

Denna data är en tupel. Alla värden på en tuppel kan anropas med hjälp av ett index - ett serienummer (med början från 0).

Du kan använda dessa index i lockiga hängslen:

print("Min vän (0) har ett husdjur (1)!".format("Sam", " bevingad dinosaurie"))

Detta kommer att returnera samma resultat:

Min vän Sam har en husdjursbevingad dinosaurie!

Försök nu att byta index:

print("Min vän (1) har ett husdjur (0)!".format("Sam", " bevingad dinosaurie"))
Min vän bevingade dinosaurie har ett husdjur Sam!

Om du anropar ett värde med index 2, och det inte finns något värde med detta index i metoden, kommer programmet att returnera ett fel. Till exempel:

print("Min vän (2) har ett husdjur (1)!".format("Sam", " bevingad dinosaurie"))
IndexError: tuppelindex utanför intervallet

Detta betyder att det begärda indexet ligger utanför tupelns intervall (i detta fall siffror mellan 0 och 1).

Lägg till några fler platshållare och värden, till exempel:

print("Tom är en (), () och () ()!".format("glad", "ler", "lång", "man"))
Tom är en glad, leende och lång man!

Utan ytterligare parametrar kommer metoden str.format() att infoga värdena i ordning.

Tupelvärden har följande index:

Försök att ändra ordningen i vilken värden skrivs in i en rad med hjälp av index:

print("Tom är en (3), (2) och (1) (0)!".format("glad", "ler", "lång", "man"))
Tom är en man, lång och ler glad!

Förutom positionsargument finns det även namngivna argument. Dessa argument kan kallas vid namn. Till exempel:

print("Tom (0) (1) a (pr).".format("har", "gjort", pr = "pull request"))
Tom har gjort en pull-begäran.

Det namngivna argumentet pr kan användas tillsammans med positionsargument. Positionella och namngivna argument låter dig ändra ordningen i vilken värden skrivs in i en sträng:

print("Tom (pr) (1) a (0).".format("har", "gjort", pr = "pull request"))
Tom pull begäran gjort en har.

Typer

Du kan lägga till fler parametrar till lockiga hängslen. Försök att använda syntaxen (fältnamn:konvertering), där fältnamn anger indexet för metodargumentet str.format() och konvertering är datatypen, med en kod med ett tecken som Python använder. Här använder vi följande kod:

• s - sträng
• d - decimaltal (decimal)
• f - flyttalnummer (flytande)

Försök att skicka ett heltal som ett flyttal med metoden genom att lägga till typen f.

print("Sam åt (0:f) procent av en (1)!".format(75, "pizza"))
Sam åt 75 000 000 procent av en pizza!

I de första klammerparenteserna användes syntaxen (fältnamn:konvertering), i resten av platshållarna används endast indexnumret.

Du kan begränsa antalet nollor efter pricken. Genom att ange typen av f kan du valfritt ange värdets precision; för att göra detta, lägg till en punkt, ange sedan antalet siffror som ska gå efter decimalkomma, och sedan själva typen.

Tänk på det här exemplet:

print("Sam åt (0:.3f) procent av en pizza!".format(75.765367))
Sam åt 75,765 procent av en pizza!

Som du kan se, även om det finns 6 tecken efter punkten i värdet, visas endast tre tecken i strängen.

Försök att minska antalet tecken efter punkten till ett.

print("Sam åt (0:.1f) procent av en pizza!".format(75.765367))
Sam åt 75,8 procent av en pizza!

Formatmetoden kommer att runda talet upp till 75,8.

Prova att ändra datatypen till decimaltal:

print("Sam åt (0:.d) procent av en pizza!".format(75.765367))
ValueError: Okänd formatkod "d" för objekt av typen "float"

För att bara mata ut heltal och utelämna alla tecken efter punkten, använd:

print("Sam åt (0:.0f) procent av en pizza!".format(75.765367))

I det här fallet kommer flyttalstalet inte att bli ett heltal.

Variabel indragning

För att skapa utfyllnad i platshållare kan du helt enkelt öka storleken på fältet med ytterligare alternativ. Denna funktion låter dig organisera en stor mängd data visuellt.

För att göra detta, lägg till längden på fältet (i tecken) i hängslen efter indexet, åtskilda av ett kolon. Till exempel:

print("Tom har (0:4) rött (1:10)!".format(5, "äpplen"))
Sammy har 5 röda äpplen!

Som standard är strängar vänsterjusterade i ett fält och siffror är högerjusterade. Detta kan ändras med symboler:

• < — выравнивание по левому краю;
• ^ - mittinriktning;
• > - högerjustering.

Tecknet anges efter kolon. Till exempel, för att justera objektet i de första krulliga klammerparenteserna till vänster och i den andra - mot mitten, skulle du skriva:

print("Tom har (0:<4} red {1:^10}!".format(5, "apples"))
Sammy har 5 röda äpplen!

Som standard fyller Python ledigt utrymme i ett fält med mellanslag. Du kan välja en annan karaktär att fylla. Det måste anges omedelbart efter kolon. Till exempel:

print("(:*^20s)".format("Hallå"))
***** Hej ********

Dessa alternativ kan kombineras med andra alternativ, till exempel:

print("Sam åt (0:5.0f) procent av en pizza!".format(75.765367))
Sam åt 76 procent av en pizza!

De krulliga parenteserna indikerar index, längden på fältet i tecken, sedan antalet tecken efter punkten och datatypen.

Variabler

Nu kan du skicka heltal, flytande tal och strängar till metoden str.format().

Metoden str.format() kan också fungera med variabler.

Tänk på det här exemplet:

blöjor=8
print("Tommy har () äpplen idag!".format(nÄpplen))
Tommy har 8 äpplen idag!

En variabel kan också användas istället för den ursprungliga strängen, till exempel:

tommy = "Tommy har () äpplen idag!"
blöjor=8
print(tommy.format(nApples))
Tommy har 8 äpplen idag!

Variabler kan ersätta alla delar av syntaxen. Detta gör det lättare att arbeta med användarinput.

Dataorganisation

Formateringsfunktioner låter dig strukturera en stor mängd data. För att göra utdata läsbar kan du öka fältstorleken och ändra justeringen.

Tänk på ett typiskt Python-exempel som kommer att mata ut siffran "i", "i*i" och "i*i*i" i intervallet 3 till 12:

för i inom intervallet(3,13):
print(i, i*i, i*i*i)
3 9 27
4 16 64
5 25 125
6 36 216
7 49 343
8 64 512
9 81 729
10 100 1000
11 121 1331
12 144 1728

Denna slutsats ser tydlig ut, men på grund av skiftningarna i den nedre delen uppstår förvirring. Och ju fler tecken det finns i numret, desto större blir skiftet. Som ett resultat kommer en sådan slutsats att vara obekväm att läsa.

Försök att formatera det:

för i inom intervallet(3,13):
print("(:3d) (:4d) (:5d)".format(i, i*i, i*i*i))

I det här fallet innehåller de lockiga hängslen inget index. Efter kolon kommer omedelbart storleken på fältet, sedan datatypen (d). Således kommer det att finnas minst ett ledigt tecken i varje kolumn.

3 9 27
4 16 64
5 25 125
6 36 216
7 49 343
8 64 512
9 81 729
10 100 1000
11 121 1331
12 144 1728

Du kan också ställa in samma antal tecken i varje kolumn.

för i inom intervallet(3,13):
print("(:6d) (:6d) (:6d)".format(i, i*i, i*i*i))
3 9 27
4 16 64
5 25 125
6 36 216
7 49 343
8 64 512
9 81 729
10 100 1000
11 121 1331
12 144 1728

Du kan också ändra justeringen med hjälp av symboler<, ^ и >, ändra datatypen, lägg till index.

Slutsats

Formatering i Python är ett bekvämt och effektivt sätt att sammanfoga strängar och organisera data visuellt. Formateringsmetoderna är ganska enkla, men deras syntax är inte alltid uppenbar. Men med dem kan du skicka variabler till en sträng och göra utdata läsbar.

Taggar:

Från och med version 3.6 introducerade Python en ny strängtyp − f-strängar, som bokstavligen betyder "formaterad sträng". Dessa rader förbättrar kodens läsbarhet och är också snabbare än andra formateringsmetoder. F-strängar specificeras med det bokstavliga "f" före citattecken.

>>> "vanlig sträng" >>> f"f-sträng"

f-strängar är det femte sättet (sic!) för strängformatering i Python, vilket är mycket likt att använda format()-metoden.

Låt oss komma ihåg alla 5 sätten att formatera.

5 sätt att formatera strängar

1. Sammankoppling. Ett grovt sätt att formatera där vi bara limmar ihop flera rader med en additionsoperation:

>>> namn = "Dmitry" >>> ålder = 25 >>> print("Mitt namn är " + namn + ". Jag är " + str(ålder) + " år gammal.") >>>

2. % formatering. Det mest populära sättet, som flyttade till Python från C-språket. Du kan skicka värden till en sträng genom listor och tupler, samt använda en ordbok. I det andra fallet placeras värdena inte efter position, utan efter namn.

>>> namn = "Dmitry" >>> ålder = 25 >>> print("Mitt namn är %s. Jag är %d år gammal." % (namn, ålder)) >>> Jag heter Dmitry. Jag är 25 år. >>> print("Mitt namn är %(name)s. Jag är %(age)d år gammal." % ("namn": namn, "ålder": ålder)) >>> Jag heter Dmitry. Jag är 25 år.

3. Mallsträngar. Denna metod dök upp i Python 2.4 som en ersättning för %-formatering (PEP 292), men blev inte populär. Stöder överföring av värden efter namn och använder $-syntax som i PHP.

>>> från strängimport Mall >>> namn = "Dmitry" >>> ålder = 25 >>> s = Mall ("Mitt namn är $name. Jag är $age år gammal.") >>> print(s) .substitute( namn=namn, ålder=ålder)) >>> Jag heter Dmitry. Jag är 25 år.

4. Formatera med metoden format(). Denna metod introducerades i Python 3 som en ersättning för %-formatering. Det stöder också att skicka värden efter position och namn.

>>> namn = "Dmitry" >>> ålder = 25 >>> print("Jag heter (). Jag är () år gammal.".format(namn, ålder) >>> Jag heter Dmitry. Jag är 25 år gammal. > >> print("Jag heter (namn) Jag är (ålder) år gammal.".format(ålder=ålder, namn=namn) >>> Jag heter Dmitry. Jag är 25 år gammal .

5. f-strängar. Formatering introducerad i Python 3.6 (PEP 498). Denna metod liknar formatering med format()-metoden, men är mer flexibel, mer läsbar och snabbare.

>>> namn = "Dmitry" >>> ålder = 25 >>> print(f"Mitt namn är (namn) Jag är (ålder) år gammal.") >>> Jag heter Dmitry. Jag är 25 år.

Dyk ner i f-strängar

f-strängar gör en mycket enkel sak - de tar värdena för variablerna som finns i det aktuella omfånget och ersätter dem i strängen. I själva raden behöver du bara ange namnet på denna variabel med hängslen.

>>> namn = "Dmitry" >>> ålder = 25 >>> print(f"Mitt namn är (namn) Jag är (ålder) år gammal.") >>> Jag heter Dmitry. Jag är 25 år.

f-strängar stöder även avancerad nummerformatering:

>>> från matteimport pi >>> print(f"Value of pi: (pi:.2f)") >>> Värde av pi: 3.14

Med f-strängar kan du formatera ett datum utan att anropa strftime()-metoden:

>>> från datetime import datetime as dt >>> now = dt.now() >>> print(f"Aktuell tid (nu:%d.%m.%Y %H:%M)") >>> Aktuell tid 24.02.2017 15:51

De stöder grundläggande aritmetiska operationer. Ja, precis i raderna:

>>> x = 10 >>> y = 5 >>> print(f"(x) x (y) / 2 = (x * y / 2)") >>> 10 x 5 / 2 = 25,0

Låter dig komma åt listvärden efter index:

>>> planeter = ["Mercury", "Venus", "Earth", "Mars"] >>> print(f"Vi lever inte på planeten (planeter)") >>> Vi lever inte på planeten jorden

Och även till elementen i ordboken med nyckel:

>>> planet = ("namn": "Jorden", "radius": 6378000) >>> print(f"Planet (planet["namn"]). Radie (planet["radius"]/1000) km. ") >>> Planeten Jorden. Radie 6378,0 km.

Dessutom kan du använda både sträng- och numeriska tangenter. Precis som i vanlig Python-kod:

>>> siffror = (0: "noll", "ett": "ett") >>> print(f"0 - (siffror), 1 - (siffror["ett"])") >>> 0 - noll, 1 - ett

Du kan anropa objektmetoder i f-strängar:

>>> namn = "Dmitry" >>> print(f"Namn: (namn.upper())") >>> Namn: DMITRY

Och även anropsfunktioner:

>>> print(f"13 / 3 = (runda(13/3))") >>> 13 / 3 = 4

f-strängar är ett mycket flexibelt och kraftfullt verktyg för att skapa en mängd olika mönster.

Se PEP498 för alla funktioner hos f-strängar.

Prestanda

F-strängar är inte bara flexibla, utan också snabba. Och för att jämföra prestanda för olika formateringsmetoder, förberedde jag två mallar:

• enkel, där du bara behöver infoga två värden: en sträng och ett nummer;
• svår, vars data samlas in från olika variabler, och inuti finns en konvertering av datumet, ett reellt tal samt avrundning.

Den sista enkla raden är:

Hej, jag heter Dmitry. Jag är 27 år gammal.

Den komplexa utgångslinjen är:

Idag är det 2017-02-24.
Vi lever på planeten jorden. Dess radie är 6378 km och massan är 5.973e+24
Rotationsperioden för planeten runt solen är 365 dagar.