Hoe String-formatters gebruiken in Python 3

###Inleiding

De str.format()-methode van de string-klasse in Python stelt je in staat om variabele-substituties en waarde-opmaak te doen. Hiermee kun je elementen binnen een string concateneren door middel van positionele opmaak.

Deze tutorial zal je begeleiden bij enkele veelvoorkomende toepassingen van formatters in Python, die kunnen helpen om je code en programma leesbaarder en gebruikersvriendelijker te maken.

Vereisten

Je moet Python 3 geïnstalleerd hebben en een programmeeromgeving hebben ingesteld op je computer of server. Als je nog geen programmeeromgeving hebt ingesteld, kun je verwijzen naar de installatie- en instelhandleidingen voor een lokale programmeeromgeving of voor een programmeeromgeving op je server die geschikt is voor je besturingssysteem (Ubuntu, CentOS, Debian, enzovoort).

##Het Gebruiken van Formatters

Formatters werken door een of meer vervangingsvelden of aanduidingen te plaatsen – gedefinieerd door een paar accolades {} – in een string en de str.format()-methode aan te roepen. Je geeft de waarde die je wilt samenvoegen met de string door aan de methode. Deze waarde wordt op dezelfde plaats doorgegeven als waar je aanduiding zich bevindt wanneer je het programma uitvoert.

Laten we een string afdrukken die een formatter gebruikt:

print("Sammy has {} balloons.".format(5))

Output
Sammy has 5 balloons.

In het bovenstaande voorbeeld hebben we een string geconstrueerd met een paar accolades als aanduiding:

"Sammy has {} balloons."

Vervolgens hebben we de str.format()-methode toegevoegd en de waarde van het gehele getal 5 aan die methode doorgegeven. Hierdoor wordt de waarde 5 in de string geplaatst op de plaats waar de accolades stonden:

Sammy has 5 balloons.

We kunnen ook een variabele toewijzen die gelijk is aan de waarde van een string met formatter-aanduidingen:

open_string = "Sammy loves {}."
print(open_string.format("open source"))

Output
Sammy loves open source.

In dit tweede voorbeeld hebben we de string "open source" aan de grotere string toegevoegd, waarbij we de accolades in de oorspronkelijke string hebben vervangen.

Formatters in Python stellen je in staat accolades te gebruiken als aanduidingen voor waarden die je zult doorgeven met de str.format()-methode.

##Formatters gebruiken met Meerdere Aanduidingen

U kunt meerdere paren accolades gebruiken bij het gebruik van formatters. Als we een andere variabele substitutie aan de bovenstaande zin willen toevoegen, kunnen we dat doen door een tweede paar accolades toe te voegen en een tweede waarde door te geven aan de methode:

new_open_string = "Sammy loves {} {}."                      #2 {} placeholders
print(new_open_string.format("open-source", "software"))    #Twee strings doorgeven aan de methode, gescheiden door een komma

Output
Sammy loves open-source software.

Om een andere substitutie toe te voegen, hebben we een tweede paar accolades toegevoegd aan de oorspronkelijke string. Vervolgens hebben we twee strings doorgegeven aan de str.format()-methode, gescheiden door een komma.

Op dezelfde manier kunnen we extra substituties toevoegen:

sammy_string = "Sammy loves {} {}, and has {} {}."                      #4 {} placeholders
print(sammy_string.format("open-source", "software", 5, "balloons"))    #Vier strings doorgeven aan de methode

Output
Sammy loves open-source software, and has 5 balloons.

In sammy_string hebben we 4 paren accolades toegevoegd als placeholders voor variabele substitutie. Vervolgens hebben we 4 waarden doorgegeven aan de str.format()-methode, waarbij we string- en integer-datatypes mixen. Elk van deze waarden is gescheiden door een komma.

##Herordening van Formatters met Positionele en Trefwoordargumenten

Wanneer we accolades leeg laten zonder enige parameters, zal Python de waarden die zijn doorgegeven via de str.format()-methode in volgorde vervangen. Zoals we tot nu toe hebben gezien, zal een formatterconstructie met twee lege accolades en twee doorgegeven waarden er als volgt uitzien:

print("Sammy the {} has a pet {}!".format("shark", "pilot fish"))

Output
Sammy the shark has a pet pilot fish!

Het eerste paar accolades wordt vervangen door de stringwaarde van "shark", en het tweede paar wordt vervangen door de stringwaarde van "pilot fish".

De waarden die binnen de methode bestaan, zien er als volgt uit:

("shark", "pilot fish")

Ze zijn in feite het tupelgegevenstype en elke afzonderlijke waarde die in het tuple is opgenomen, kan worden aangeroepen met zijn indexnummer, dat begint met het indexnummer 0.

We kunnen deze indexnummers doorgeven aan de accolades die dienen als de aanduidingen in de oorspronkelijke string:

print("Sammy the {0} has a pet {1}!".format("shark", "pilot fish"))

In het bovenstaande voorbeeld zal de uitvoer zijn wat we krijgen zonder indexnummers door te geven aan de accolades omdat we de waarden in het tuple in volgorde oproepen:

Output
Sammy the shark has a pet pilot fish!

Maar als we de indexnummers omkeren met de parameters van de aanduidingen, kunnen we de waarden die aan de string worden doorgegeven, omkeren:

print("Sammy the {1} has a pet {0}!".format("shark", "pilot fish"))

Output
Sammy the pilot fish has a pet shark!

Als u een indexnummer van 2 aanroept in een tuple die waarden heeft op indexposities 0 en 1, roept u dus een waarde aan die buiten bereik is. Wanneer u een indexnummer aanroept dat buiten bereik is, ontvangt u een foutmelding:

print("Sammy the {2} has a pet {1}!".format("shark", "pilot fish"))

Output
IndexError: tuple index out of range

De foutmelding die we zien, verwijst naar het tuple dat alleen waarden heeft op indexnummers 0 en 1, waardoor indexnummer 2 buiten bereik valt.

Laten we een paar meer aanduidingen en een paar meer waarden toevoegen om aan hen door te geven, zodat we beter kunnen begrijpen hoe we formatters opnieuw kunnen ordenen. Hier is eerst een nieuwe string met vier aanduidingen:

print("Sammy is a {}, {}, and {} {}!".format("happy", "smiling", "blue", "shark"))

Output
Sammy is a happy, smiling and blue shark!

Zonder parameters worden de waarden die aan de str.format()-methode worden doorgegeven, geconcateneerd in de string in volgorde.

De stringwaarden die in het tuple zijn opgenomen, komen overeen met de volgende indexnummers:

Laten we de indexnummers van de waarden gebruiken om de volgorde te veranderen waarin ze verschijnen in de string:

print("Sammy is a {3}, {2}, and {1} {0}!".format("happy", "smiling", "blue", "shark"))

Output
Sammy is a shark, blue, and smiling happy!

Aangezien we zijn begonnen met indexnummer 3, hebben we eerst de laatste waarde van "shark" genoemd. De andere indexnummers die als parameters zijn opgenomen, veranderen de volgorde waarin de woorden verschijnen binnen de oorspronkelijke string.

Naast positionele argumenten kunnen we ook trefwoordargumenten introduceren die worden aangeroepen met hun trefwoordnaam:

print("Sammy the {0} {1} a {pr}.".format("shark", "made", pr = "pull request"))

Output
Sammy the shark made a pull request.

Dit voorbeeld toont het gebruik van een trefwoordargument dat wordt gebruikt met positionele argumenten. We kunnen het trefwoordargument pr invullen naast positionele argumenten, en deze argumenten verplaatsen om de resulterende string te wijzigen:

print("Sammy the {pr} {1} a {0}.".format("shark", "made", pr = "pull request"))

Output
Sammy the pull request made a shark.

Positionele en trefwoordargumenten die worden gebruikt met stringformatters geven ons meer controle over het manipuleren van onze oorspronkelijke strings door herordenen.

## Type specificeren

We kunnen meer parameters opnemen binnen de accolades van onze syntaxis. We zullen de syntaxis van de opmaakcode gebruiken {veldnaam: conversie}, waarbij veldnaam het indexnummer van het argument voor de str.format()-methode specificeert die we hebben behandeld in de herordeningssectie, en conversie verwijst naar de conversiecode van het gegevenstype dat u gebruikt met de formatter.

Het conversietype verwijst naar de enkele karakters die Python gebruikt. De codes die we hier zullen gebruiken zijn s voor string, d om decimale gehele getallen (10-base) weer te geven, en f die we zullen gebruiken om floats weer te geven met decimalen. U kunt meer lezen over de Opmaak-Specificatie Mini-Taal via de officiële documentatie van Python 3.

Laten we een voorbeeld bekijken waarbij we een geheel getal doorgeven aan de methode, maar het als een float willen weergeven door het toevoegen van het conversietype-argument f:

print("Sammy ate {0:f} percent of a {1}!".format(75, "pizza"))

Output
Sammy ate 75.000000 percent of a pizza!

We hebben de syntax gebruikt van {veld_naam:conversie} voor het eerste vervangingsveld tussen accolades om een float uit te voeren. De tweede accolades gebruiken alleen de eerste parameter {veld_naam}.

In het bovenstaande voorbeeld worden veel cijfers weergegeven na de decimale punt, maar u kunt deze beperken. Wanneer u f specificeert voor float-waarden, kunt u ook de precisie van die waarde specificeren door een punt . toe te voegen gevolgd door het aantal cijfers na de decimaal dat u wilt opnemen.

Als Sammy 75.765367% van de pizza at, maar we hebben geen hoge nauwkeurigheid nodig, kunnen we het aantal cijfers na de decimaal beperken tot 3 door .3 toe te voegen vóór het conversietype f:

print("Sammy ate {0:.3f} percent of a pizza!".format(75.765367))

Output
Sammy ate 75.765 percent of a pizza!

Als we slechts één decimaal willen hebben, kunnen we de string en de methode als volgt herschrijven:

print("Sammy ate {0:.1f} percent of a pizza!".format(75.765367))

Output
Sammy ate 75.8 percent of a pizza!

Merk op dat het aanpassen van de precisie ervoor zal zorgen dat het getal wordt afgerond.

Hoewel we een getal zonder decimalen weergeven als een float, als we proberen de float naar een geheel getal te veranderen door de d conversietype te gebruiken, zullen we een foutmelding ontvangen:

print("Sammy ate {0:d} percent of a pizza!".format(75.765367))

Output
ValueError: Unknown format code 'd' for object of type 'float'

Als je wilt dat er geen decimalen worden getoond, kun je je formatter als volgt schrijven:

print("Sammy ate {0:.0f} percent of a pizza!".format(75.765367))

Output
Sammy ate 76 percent of a pizza!

Dit zal je float niet omzetten naar een geheel getal, maar in plaats daarvan het aantal getoonde decimalen beperken.

##Vervanging van variabele opvullen

Omdat de aanduidingen vervangingsvelden zijn, kun je ruimte toevoegen of rond een element ruimte creëren door het veldformaat te vergroten met behulp van extra parameters. Dit kan handig zijn wanneer we veel gegevens visueel moeten organiseren.

We kunnen een getal toevoegen om de veldgrootte (in termen van tekens) aan te geven na de dubbele punt : in de accolades van onze syntaxis:

print("Sammy has {0:4} red {1:16}!".format(5, "balloons"))

Output
Sammy has    5 red balloons        !

In het bovenstaande voorbeeld gaven we het nummer 5 een karakterveldgrootte van 4, en de string balloons een karakterveldgrootte van 16 (omdat het een lange string is).

Zoals we zien, worden strings standaard links uitgelijnd binnen het veld, en getallen worden rechts uitgelijnd. Dit kun je wijzigen door een uitlijningscode achter de dubbele punt te plaatsen. < zal de tekst in een veld links uitlijnen, ^ zal de tekst in het veld centreren, en > zal het rechts uitlijnen.

Laten we het getal links uitlijnen en de string centreren:

print("Sammy has {0:<4} red {1:^16}!".format(5, "balloons"))

Output
Sammy has 5    red     balloons    !

Nu zien we dat 5 links uitgelijnd is, ruimte biedend in het veld vóór rood, en ballonnen gecentreerd is in zijn veld met ruimte links en rechts ervan.

Standaard zal Python, wanneer we een veld groter maken met formatters, het veld vullen met spaties. We kunnen dat aanpassen naar een ander teken door het teken dat we willen gebruiken direct na de dubbele punt te specificeren:

print("{:*^20s}".format("Sammy"))

Output
*******Sammy********

We accepteren de string die wordt doorgegeven aan str.format() op de indexpositie van 0 omdat we niet anders hebben gespecificeerd, inclusief de dubbele punt, en specificeren dat we * zullen gebruiken in plaats van een spatie om het veld op te vullen. We centreren de string met ^, specificeren dat het veld 20 tekens groot is, en geven ook aan dat we werken met een string-conversietype door s op te nemen.

We kunnen deze parameters combineren met andere parameters die we eerder hebben gebruikt:

print("Sammy ate {0:5.0f} percent of a pizza!".format(75.765367))

Output
Sammy ate    76 percent of a pizza!

In de parameters binnen de accolades hebben we het indexveldnummer van de float gespecificeerd en de dubbele punt opgenomen, de grootte van het veldnummer aangegeven en de punt opgenomen, het aantal plaatsen na de decimaalteken geschreven, en vervolgens het conversietype van f gespecificeerd.

##Het Gebruik van Variabelen

Tot nu toe hebben we integers, floats en strings doorgegeven aan de str.format() methode, maar we kunnen ook variabelen doorgeven via de methode. Dit werkt zoals elke andere variabele.

nBalloons = 8
print("Sammy has {} balloons today!".format(nBalloons))

Output
Sammy has 8 balloons today!

We kunnen variabelen gebruiken voor zowel de oorspronkelijke string als wat door de methode wordt doorgegeven:

sammy = "Sammy has {} balloons today!"
nBalloons = 8
print(sammy.format(nBalloons))

Output
Sammy has 8 balloons today!

Variabelen kunnen gemakkelijk worden vervangen voor elk onderdeel van onze opmaaksyntaxisconstructie. Dit maakt het gemakkelijker om mee te werken wanneer we gebruikers gegenereerde invoer ontvangen en die waarden toewijzen aan variabelen.

##Gebruik van Formatters om Gegevens te Organiseren

Formatters komen het beste tot hun recht wanneer ze worden gebruikt om veel gegevens op een visuele manier te organiseren. Als we databases aan gebruikers tonen, kan het gebruik van formatters om veldgrootte te vergroten en uitlijning aan te passen uw output leesbaarder maken.

Laten we eens kijken naar een typische for-lus in Python die i, i*i en i*i*i zal afdrukken in het bereik van 3 tot 12:

for i in range(3,13):
    print(i, i*i, i*i*i)

Output
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

Hoewel de output op een georganiseerde manier is, lopen de getallen in elkaar over in elkaars kolommen, waardoor de onderkant van de output minder leesbaar is. Als u werkt met een grotere dataset met veel kleine en grote getallen, kan dit een probleem vormen.

Laten we formatters gebruiken om meer ruimte te geven aan deze getallen:

for i in range(3,13):
    print("{:3d} {:4d} {:5d}".format(i, i*i, i*i*i))

Hier hebben we, tussen onze accolades, geen veldnaam toegevoegd voor het indexnummer en zijn we begonnen met de dubbele punt, gevolgd door het aantal voor de veldgrootte, en een d conversietype aangezien we met gehele getallen werken. In dit voorbeeld hebben we rekening gehouden met de grootte van elke verwachte output, waarbij we 2 extra tekenspaces hebben gegeven voor elk, afhankelijk van de maximale mogelijke getallengrootte, zodat onze output er als volgt uitziet:

Output
  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

We kunnen een consistent veldgroottegetal specificeren om zelfs kolommen te hebben, ervoor zorgend dat we de grotere getallen accommoderen:

for i in range(3,13):
    print("{:6d} {:6d} {:6d}".format(i, i*i, i*i*i))

Output
     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

We kunnen ook de uitlijning van de kolommen manipuleren door <, ^ en > toe te voegen voor tekstuitlijning, verander d in f om decimalen toe te voegen, verander veldnaamindexnummers, en meer om ervoor te zorgen dat we de gegevens weergeven zoals we willen.

##Conclusie

Het gebruik van formatters voor variabele substitutie kan een effectieve manier zijn om strings te concatenen en waarden en gegevens te organiseren. Formatters vertegenwoordigen een eenvoudige maar niet-descriptieve manier om variabele substituties in een string door te geven, en zijn nuttig om ervoor te zorgen dat de uitvoer leesbaar en gebruikersvriendelijk is.