Ik heb onlangs vernomen dat de blog af en toe wordt gevonden door te zoeken naar “wat betekent %s in Python.” Ik weet nog dat ik, toen ik Python begon te leren, snelle en duidelijke antwoorden wilde (zoals: "Houd me niet voor de gek, wijs me met je vinger"). Dit artikel is voor degenen die ongeduldig zijn.

Inhoudsopgave

Eerst een paar voorbeelden

Lijnopmaak:
>>> naam = "Vasya" >>> print "Mijn naam is %s" % (naam) Mijn naam is Vasya Geeft de grootte van de velden aan (er staan ​​vijf spaties vóór "Vasya", d.w.z. tien tekens in totaal): > >> print "Mijn naam is %10s. Dat is mijn naam." % (naam) Mijn naam is Vasya. Dat is mijn naam. Hetzelfde, maar links uitgelijnd: >>> print "Mijn naam is %-10s. Dat is mijn naam." % (naam) Mijn naam is Vasya. Dat is mijn naam. Wanneer dit nuttig kan zijn: >>> drinks = ("Long Island": 3, "Bloody Mary": 2, "Margarita":4) >>> print "%-15s%-5s" % ("Naam", "Aantal") Naam Aantal >>> voor k,v in drinks.items(): ... print "%-15s%-3s" % (k, v) ... Bloody Mary 2 Long Island 3 Margarita 4 Als je het gehele deel van een getal moet afdrukken:
>>> num = 12,34 >>> print "%d" % (num) 12 Geshuffeld:
>>> leeftijd = 25 >>> print "Mijn naam is %s. Ik ben %d." % (naam, leeftijd) Mijn naam is Vasya. Ik ben 25.

Nu kort hoe de %-operator werkt

De opmaakexpressie kan grofweg in drie delen worden verdeeld:

format_definition + % + object(en)

De notaties %s, %d, %g, etc. zijn datatypeformaten. Als u bekend bent met C, is dit dezelfde syntaxis die wordt gebruikt voor het afdrukken van printf() .

Specificaties van verschillende typen Python-gegevens worden gegeven in de volgende tabel:

Formaat	Betekenis
"D"	Geheel decimaal getal.
"i"	Geheel decimaal getal.
"O"	Octaal getal.
"u"	Het verouderde type is hetzelfde als "d" .
"X"	Hexadecimaal getal(kleine letters).
"X"	Hexadecimaal getal (hoofdletters).
"e"	Echt nummer in exponentiële vorm (kleine letters).
"E"	Reëel getal in wetenschappelijke notatie (hoofdletters).
"F"
"F"	Reëel getal in decimale vorm.
"G"	Echt nummer. Gebruikt de notatie "f" of "e". kleine letters.
"G"	Echt nummer. Gebruikt de indeling "F" of "E". hoofdletter.
"C"	Eén teken (of cijfer).
"R"	rep() .
"S"	De regel waarin eventuele Python-object geconverteerd met str() .
"%"	Het argument wordt niet geconverteerd, alleen het symbool "%" wordt uitgevoerd.

Ingebouwde functieformaat()

Het werkt als volgt: str.format()

In de tekenreeks staan ​​"vervangingsvelden" tussen accolades () . Alles wat niet tussen haakjes staat, wordt gezien als platte tekst, die ongewijzigd worden gekopieerd. Om karakters in tekst over te brengen krullende beugels, worden ze gedupliceerd: (( en )).
Vervangingsvelden zijn als volgt opgemaakt:

Vervangingsveld::= "(" [veldnaam] ["!" conversie] [: specificatie] ")" veldnaam::= argument_naam ("." attribuutnaam | "[" element_nummer "]")* argument_naam::= [ Identiteitskaart | geheel getal] attribuutnaam::= identificatie element_index::= geheel getal | tekenreeksindex string_index::=<любой символ кроме "]">+ conversie::= "r" | "s" # str of repr spec::=<описано ниже>Waar
spec::= [[stub]align][sign][#][width][,][.precision][type] stub::=<любой символ>uitlijning::= "<" | ">" | "=" | "^" teken::= "+" | "-" | " " breedte::= geheel getal # veldbreedte precisie::= geheel getal # decimalen type::= "b" | " c" |. "d" |. "e" |. %" Het wordt als volgt geschreven: >>> print """\n(0) ... Ik zat op de muur... (0) ... Ik viel in mijn slaap.""".format( "Humpty Dumpty") Humpty Dumpty Zat op de muur Humpty Dumpty viel in zijn slaap.

Zoals u kunt zien, is deze methode veel flexibeler dan de operator "%", omdat we dezelfde waarden in elke volgorde kunnen hergebruiken. Je kunt ook benoemde argumenten doorgeven, en dan zullen we er niet naar verwijzen met cijfers, maar met namen.

Nog een opmaakvoorbeeld:

>>> toc = (... ("Eerste hoofdstuk", "3"), ... ("Tweede hoofdstuk", "150") ...) >>> voor regel in toc: ... print( "(:.

De programmatekst vertelt hoe, en het commentaar moet uitleggen waarom. Swaroop Chitlur ("Een byte van Python")

Bronlijnen

Fysieke snaren

Fysieke reeks bronbestand- dit is een regel die eindigt met een regelbeëindigingsteken (ingevoerd door op te drukken Voer sleutel in). Dit teken is speciaal karakter, platformafhankelijk. Op Unix gebruikt het ASCII LF (line feed), op Windows gebruikt het ASCII CR LF (carriage return gevolgd door line feed), en op Macintosh gebruikt het ASCII CR (carriage return). Al deze vormen kunnen op dezelfde manier worden gebruikt, ongeacht het platform.

Logische snaren

Een Python-programma is verdeeld in verschillende logische regels. Booleaanse tekenreeks bevat een of meer fysieke strings die zijn verbonden door de regels van de taal. (IN interactieve modus de voortzetting van een logische regel op een nieuwe fysieke regel begint met de karakters...). Een logische regel is een volledige verklaring ( instructies) taal.

Inspringing aan het begin van een regel

Presentatoren witruimte tekens(spaties en tabs) aan het begin van een regel worden in Python gebruikt om een ​​groep instructies als geheel te definiëren: een samengestelde instructie of blok. Inspringingen binnen een blok moeten gelijk zijn aan de tekenlengte, anders resulteert dit in een fout. Voor compatibiliteit op verschillende platforms Gebruik geen combinatie van spaties en tabs. Bijvoorbeeld:
Programma 2.1

Van schildpad import* begin_fill() for i binnen bereik(5): fd(150) voor j binnen bereik(5): fd(50) left(144) left(144) end_fill() mainloop()

Opmerking. In de toekomst worden programma's genummerd in het formaat: Programma x.y, waarbij x het lesnummer is, y het programmanummer in deze les.

Opmerkingen

Opmerkingen in Python beginnen met het teken “#”. Een commentaar eindigt aan het einde van een fysieke regel en betekent het einde van een logische regel, tenzij er een impliciete lijnverbinding wordt gebruikt (zie hieronder). Opmerkingen zijn bedoeld ter verduidelijking of voor opmerkingen van de programmeur. Opmerkingen helpen u de betekenis te begrijpen broncode andere programmeurs (zie epigraaf). Opmerkingen zijn ook nuttig voor foutopsporing programmacode en het identificeren van fouten. Binnen een opmerking kunt u alle tekens gebruiken, inclusief servicetekens.

Het combineren van meerdere fysieke strings

Twee (of meer) fysieke strings kunnen worden gecombineerd tot één logische string met behulp van een backslash ("\"), namelijk wanneer een fysieke string eindigt met een "\"-teken en deze geen deel uitmaakt van de string (d.w.z. niet binnen " " ) of een opmerking, wordt de volgende fysieke regel toegevoegd om één logische regel te vormen. Het teken “\” moet worden gevolgd door een regelbeëindiger (d.w.z. de fysieke regel moet eindigen). Bijvoorbeeld:

Als 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

Opmerking. Binnen een letterlijke tekenreeks heeft het ontsnappen aan de bzk-slash geen effect, maar "\\" vermindert het aantal "\"-tekens dat wordt uitgevoerd met 1:

Afdrukken("\ ") afdrukken("\\ ") afdrukken("\\\ ") afdrukken("\\\\") \ \ \\ \\

Impliciete aaneenschakeling van fysieke strings

Uitdrukkingen tussen haakjes, vierkante haakjes of accolades kunnen over meerdere fysieke regels worden gesplitst zonder gebruik te maken van een backslash. Bijvoorbeeld:
Programma 2.2

A = "Mijn naam is - " b = input("Je naam: ") c = "\nMijn naam is " d = input("Je leeftijd: ") e = "jaren." print(a, # "Mijn naam is " b, # De naam die je hebt ingevoerd c, # "Mijn naam is " d, # De leeftijd die je hebt ingevoerd e # "jaar")

print()-functie

Programma 2.2 gebruikt de print() functie om gegevens op het display weer te geven. Als de methode format() niet wordt gebruikt (zie hieronder), wordt de functie gebruikt voor uitvoer zonder formaten. printfunctie heeft argumenten die de uitvoer leesbaar kunnen maken. Over het algemeen heeft de functie de volgende argumenten:

Print(*objects, sep=" ", end="\n", file=sys.stdout, flush=False)

• *objecten - door komma's gescheiden objecten (variabelen, tekenreeksen, constanten) waarvan de waarden moeten worden weergegeven
• sep=" " - scheidingsteken (standaard - spatie)
• end="\n" - eindteken (standaard - einderegelteken)
• file=sys.stdout - uitvoer naar een bestand. Het bestandsobject moet een object zijn met een write(str)-methode. print() kan alleen worden gebruikt voor tekstbestanden.
• flush=False - geforceerd leegmaken van de uitvoerbuffer (standaard niet, omdat dit meestal door het bestand wordt bepaald).

Bijvoorbeeld:
Programma 2.3 print("2", "+", "2", "= ") print("4") print("2", "+", "2", "= ", end="") print(" 4") print("2", "+", "2", "= ", sep="\n") print("4")

Programma-uitvoer:

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

format() methode

De functie print() heeft een belangrijk nadeel: hij heeft geen argumenten waarmee hij geformatteerde uitvoer kan produceren. Om gegevens met een specifieke opmaak uit te voeren, moet u de methode format() gebruiken.
Mini-tutorial over deze methode op de documentatiepagina's
Opmerking. Python heeft geen tekengegevenstype, dus een enkel teken wordt ook als een string behandeld.
Syntaxis van de format()-methode:

"(:format_spec)".format()

waarbij format_spec de formaatspecificatie is:
[#][.precisie]
Ziet er best eng uit, maar maak je geen zorgen! Meestal wordt er een beperkt aantal opmaakelementen gebruikt, en ze zijn allemaal optioneel!
Doel van opmaakelementen:

• fill - filler-teken (elk teken)
• uitlijnen - uitlijnen. Waarden: "" | "=" | "^"
• teken - tekenuitvoer. Waarden: "+" | "-" | " "
• # - uitvoervoorvoegsel voor binair, octaal en hexadecimaal formaat (d.w.z. 0x, 0o of 0b)
• 0 - opvulling met voorloopnullen voor numerieke typen wanneer uitlijning niet expliciet is opgegeven
• breedte - breedte van het uitvoerveld (geheel getal)
• grouping_option - plaatsscheidingsteken "," of "_". Niet gebruikt voor de Russische landinstelling (voor deze doeleinden wordt het formaat “n” gebruikt)
• .precision - aantal fractionele cijfers (punt is vereist, gevolgd door een geheel getal)
• type - type uitvoerwaarde (zie onderstaande tabel).

Typeaanduidingen

Symbool	Beschrijving
B	Binair formaat. Geeft een getal weer in het binaire getalsysteem
C	Converteert een geheel getaluitvoer naar het overeenkomstige Unicode-teken
D	Decimaal geheel getal
e	Getal in exponentieel (wetenschappelijk) formaat, e - kleine letters
E	Getal in exponentieel formaat (zwevende komma, wetenschappelijk), E - hoofdletters
F	Vast puntnummer
F	Vaste kommanummers, NAN en INF (niet getal en oneindig) worden in hoofdletters gedrukt
G	Algemeen getalformaat. Voor een gegeven precisie p >= 1 wordt dit getal afgerond op p significante cijfers en wordt het resultaat vervolgens opgemaakt als een vast punt of wetenschappelijke notatie, afhankelijk van de grootte.
G	Hetzelfde als "g", maar alfabetische tekens worden in hoofdletters weergegeven
N	Hetzelfde als "d", behalve dat de huidige landinstelling wordt gebruikt om de juiste scheidingstekens in te voegen.
O	Nummer binnen octaal systeem gegist bestek
S	Tekenreekstype (standaard)
X	Hexadecimaal getal
X	Hetzelfde als "x", maar alfabetische tekens worden in hoofdletters weergegeven
%	De waarde wordt weergegeven als een percentage (vermenigvuldigd met 100 en er wordt een “%”-symbool toegevoegd)
Geen	Vergelijkbaar met "g", behalve dat de notatie met een vast punt wordt gebruikt als het getal dat is ten minsteéén cijfer na de komma. De standaardprecisie is zo hoog als nodig is om een ​​bepaalde waarde weer te geven.

Vlaggen gebruikt voor uitlijning:

• > - Lijn het object naar rechts uit
• ^ - Middenuitlijning

Bijvoorbeeld:
Programma 2.4 afdrukken("(:<10}".format("Я")) print("{:^10}".format("Я")) print("{:>10).format("I"))

Programma-uitvoer:

ik ik ik

Verklaring van het probleem: Gebruik het symbool “*” om de volgende afbeelding weer te geven:

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

Oplossing: we zullen het symbool “*” weergeven met centrale uitlijning:
Programma 2.5

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

U kunt meerdere formaatspecificaties gebruiken voor een of meer uitvoerwaarden van de verschillende objecten die in de formaatmethode worden vermeld. Elke specificatie moet worden ingesloten in een aparte () . Tussen de specificaties tussen () kan een willekeurig aantal verschillende scheidingstekens voorkomen. Hierdoor kunt u elke complexe opmaak uitvoeren met behulp van duidelijke en begrijpelijke hulpmiddelen. Bijvoorbeeld.
Verklaring van het probleem: Geef de volgende afbeelding weer:

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

Gebruik geen spatie- of tabtekens!
Oplossing:
Programma 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("*********")

Het is gemakkelijk op te merken dat dit programma hetzelfde object meerdere keren weergeeft. Met de methode format() kunt u de verzameling opgesomde objecten als een lijst beschouwen en dienovereenkomstig indexering gebruiken om het gewenste object opnieuw weer te geven. Vervolgens kan deze code als volgt worden herschreven:

Afdrukken("*********") 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("** ** *****")

Opmerking. Het eerste element van de lijst heeft index 0. Wanneer er voor één object meerdere formaatspecificaties worden gebruikt, dan moet voor elk ervan het eerste teken in de specificatie worden gevolgd door het indexteken van het uitvoerobject (in in dit geval- hij is de enige, dus overal staan ​​nullen).
Laten we de taak ingewikkelder maken om de basisprincipes van het werken met de format() -methode te versterken.
Probleemstelling: Druk het woord "WERELD" af met het symbool "*". Gebruik geen spatie- of tabtekens.

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

Oplossing:
Programma 2.7

Afdrukken("(0:1)(0:>6)(0:>2)(0:>6)(1:>6)".format("*","*****")) afdrukken ("(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("*"))

Dit programma gebruikt 5 tot 7 formaatspecificaties voor één of twee uitvoerobjecten. In de onderstaande afbeelding wordt uitgelegd hoe indexering voor elke specificatie wordt gebruikt.

Huiswerk

Voer de volgende tekeningen uit met behulp van de format()-methode en de print()-functie:

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

• Vertaling

Ik breng onder de aandacht van Habra-lezers en Python-fans een vertaling van een nogal omvangrijk artikel over stringopmaak. Het verhaal zal waar zijn en de hint erin zal zijn dat conservatieven soms iets nieuws moeten overwegen, zelfs als de gewoonte zich koppig verzet.

Anticiperend op de nieuwsgierigheid van lezers die geneigd zijn vragen buiten het onderwerp te stellen, zal ik zeggen dat de foto indirect verband houdt met Python, hoewel niet de meest aangename. Ik stel voor om het waarom als huiswerk te zoeken.

Ik wacht op commentaar over ontwerpfouten en typefouten in een persoonlijk bericht - ik heb genoeg van het traditionele rumoer.

Ik schrijf al jaren in Python. Maar helemaal aan het begin van deze reis was ik geïnteresseerd in het leren opmaken van tekenreeksen in Perl-stijl. Laat me je eraan herinneren dat Perl (en veel opdrachtregelinterpreters op Unix) twee soorten letterlijke tekenreeksen ondersteunt: met enkele aanhalingstekens (wanneer de tekenreeks wordt afgedrukt zoals deze is) en dubbele aanhalingstekens waarbij hun waarden worden vervangen door variabelen. In Perl kun je bijvoorbeeld iets schrijven als:

$naam = "Reuven"; print "Hallo, $naam\n";
En het programma zal dienovereenkomstig "Hallo, Reuven" schrijven.

Letterlijke tekenreeksen in Python zijn niet afhankelijk van het type aanhalingstekens en de variabelen daarin worden nooit uitgebreid naar hun waarden. Om dit te bereiken wordt traditioneel de %-operator gebruikt voor strings. In deze context kijkt de operator naar de lijn links ervan en telt hoeveel waarden hij moet vervangen door de waarden van de overeenkomstige variabelen rechts ervan. Het resultaat van de bewerking is een nieuwe regel met de waarden van de variabelen ingevoegd in plaats van de tijdelijke aanduidingen. Bijvoorbeeld:

>>> naam = "Reuven" >>> "Hallo, %s" % naam "Hallo, Reuven"
Deze Python-code werkt redelijk goed en geeft een persoonlijke begroeting weer. Dus ondanks mijn vele jaren oefenen met Python, was ik behoorlijk tevreden met het gebruik van deze syntaxis. Ja, het is niet erg aardig en nee, ik heb nooit rekening gehouden met een berg printf-modifiers die de opmaak beïnvloeden. Ik bedoel, ik gebruikte altijd de "s"-modifier (uitvoer als string) en het was voor mij voldoende dat Python de argumenten impliciet naar de string castte.

Maar binnen op dit moment het feit dat de %-syntaxis buiten gebruik wordt gesteld of op zijn minst wordt afgeschaft. Er staat een opmerking op de python-dev mailinglijst dat deze tot minstens 2022 in de 2.x branch zal blijven bestaan, maar er wordt niets gezegd over de 3.x branch, dus ondersteuning voor deze syntaxis zal binnenkort worden verwijderd en dat is niet het geval. aanbevolen om het te gebruiken. Het werd vervangen door de str.format-methode.

In mijn Python-tutorials noemde ik altijd str.format, maar dan in specifieke voorbeelden Vaker wel dan niet, vertrouwde ik nog steeds op%. Ik raadde studenten zelfs aan om % te gebruiken, omdat ik het persoonlijk veel eenvoudiger vond.

Maar het aanhoudende gevoel dat ik iets verkeerd deed en misschien zelfs mijn studenten misleidde, bracht mij ertoe om str.format eens nader te bekijken. Tijdens mijn onderzoek kwam ik bij de volgende conclusies: 1) Het is niet ingewikkelder dan % en in sommige toepassingen zelfs eenvoudiger; 2) Ik heb de mogelijkheden van str.format nooit volledig benut, maar ze zijn erg handig, ondanks de tijd die het kost om ze te leren.

Laten we beginnen met de eenvoudigste. Laten we ‘Goedemorgen’ tegen iemand zeggen en hem of haar bij zijn voor- en achternaam noemen, ervan uitgaande dat deze is opgeslagen in de variabelen ‘eerste’ en ‘laatste’. Op de oude manier zouden we dit doen:

>>> eerste = "Reuven" >>> laatste = "Lerner" >>> "Goedemorgen, %s %s" % (eerste, laatste) "Goedemorgen, Reuven Lerner"
Zelfs in dit voorbeeld komen we een van de problemen met de %-syntaxis tegen: we hebben nu twee variabelen, en om ze allebei te kunnen gebruiken, moeten we er een tupel van maken. Vanuit Python-oogpunt is dit logisch, maar ik verzeker je dat dit voor veel studenten zeer verrassend is.

Hoe zou dit voorbeeld eruitzien in het geval van str.format? Vrij gelijkaardig:

>>> "Goedemorgen, () ()".format(eerste, laatste) "Goedemorgen, Reuven Lerner"
Houd er rekening mee dat we het principe enigszins hebben gewijzigd. Nu is dat niet zo binaire operator bovenstaande strings, en een methode van een stringobject dat een aantal parameters accepteert. Dit is logischer en consistenter. Voor dezelfde studenten leek de %-operator in mijn voorbeelden op een toevoeging aan print, en niet op een bewerking op strings. De notatie met ".format" achter de regel maakt het duidelijker dat dit een methode is die specifiek is voor die regel.

Zoals u waarschijnlijk al weet, geeft het voorkomen van “() ()” in de regel aan dat str.format twee parameters moet hebben, waarvan de waarden in de regel worden ingevoegd in de volgorde waarin ze aan de methode worden doorgegeven . Er zijn twee argumenten, dus er moeten twee keer () in de regel voorkomen. Dit is iets moeilijker te begrijpen, omdat accolades in Python mensen wijzen op woordenboeken, en lege accolades er niet erg mooi uitzien. Maar dat is oké, ik kan ermee leven en heb het vrij gemakkelijk geaccepteerd.

Het punt waarop str.format het eerste voordeel ten opzichte van % laat zien, is wanneer het nodig is om parameters in omgekeerde volgorde te gebruiken. In feite is er helemaal geen manier om dit te bereiken met %s. Het is ook niet mogelijk om de waarde van één variabele meer dan één keer te gebruiken. Wanneer we str.format gebruiken, kunnen we de vervangingsvolgorde eenvoudig wijzigen:

>>> "Goedemorgen, (1) (0)".format(eerste, laatste) "Goedemorgen, Lerner Reuven"
Houd er rekening mee dat als ik lege haakjes “() ()” had gebruikt, de vervanging zou hebben plaatsgevonden in dezelfde volgorde waarin de parameters aan de methode waren doorgegeven. Je kunt je de parameters voorstellen als een reeks die helemaal opnieuw is geïndexeerd, en als ik de volgorde wil veranderen, plaats ik eenvoudigweg de noodzakelijke indices van deze reeks tussen accolades. Ons allereerste voorbeeld met str.format kan als volgt worden geschreven:

>>> "Goedemorgen, (0) (1)".format(eerste, laatste) "Goedemorgen, Reuven Lerner"
Houd er rekening mee dat we door het expliciet specificeren van indexen niet langer kunnen vertrouwen op automatische indexering.

Natuurlijk kunt u ook een reeks uit een lijst gebruiken met de operator *:

>>> namen = ("Reuven", "Lerner") >>> "Goedemorgen, () ()".format(*names) "Goedemorgen, Reuven Lerner"
U kunt ook benoemde argumenten gebruiken:

>>> "Goedemorgen, (eerste) (laatste)".format(first="Reuven", last="Lerner") "Goedemorgen, Reuven Lerner"
Vooral deze optie vind ik leuk. Benoemde parameters zijn explicieter (als dat het geval is). goede namen), en het gebruik van (eerste) en (laatste) is redelijk leesbaar - vooral vergeleken met %(eerste)s, wat nodig is met de %-operator

Benoemde parameters kunnen ook vanuit het woordenboek worden uitgebreid met behulp van de ** operator:

>>> person = ("first":Reuven", "last":Lerner") >>> "Goedemorgen, (eerste) (laatste)".format(**person) "Goedemorgen, Reuven Lerner"
Ik beschreef dit allemaal aan mijn studenten en was behoorlijk verrast hoeveel meer ze op hun gemak waren met deze syntaxis. En het werd prettiger om zelf te werken.

Er moet worden vermeld dat benoemde en positionele argumenten technisch gezien samen kunnen worden gebruikt. Maar het is beter om dit niet te doen:

>>> persoon = ("first":Reuven", "last":Lerner") >>> "Goed (0), (eerste) (laatste).format("ochtend", **persoon) " Goed morgen, Reuven Lerner"

Ik heb je gewaarschuwd.

Wat str.format mogelijk mist, is... eh... opmaak. Het slechte nieuws is dat str.format compleet andere regels heeft om te bepalen hoe de uitvoer moet worden geformatteerd. Goed nieuws- deze regels zijn vrij gemakkelijk te bestuderen en te begrijpen.

Laten we weer eenvoudig beginnen: als u een string met een bepaalde lengte moet uitvoeren, voeg dan na de naam van de variabele een dubbele punt (:) toe en vervolgens het aantal tekens. Dus om mijn naam weer te geven en deze op te vullen tot tien tekens met spaties, zou ik dit moeten doen:

>>> "Uw naam is (naam:10)".format(name="Reuven") "Uw naam is Reuven"
(Merk op dat de regel wordt opgevuld met spaties na de naam.)

Als u de uitlijning wilt instellen op rechterkant blok - het > teken wordt gebruikt tussen: en het nummer:

>>> "Uw naam is (naam:>10)".format(name="Reuven") "Uw naam is Reuven"
En ja, via het bordje kun je expliciet aangeven dat ik links uitlijning wil<
Als u de waarde in het midden van het blok wilt weergeven, gebruik dan in plaats van< и >het ^-symbool wordt gebruikt:

>>> "Uw naam is (naam:*^10)".format(name="Reuven") "Uw naam is **Reuven**"
De tekst is min of meer duidelijk, maar hoe zit het met de cijfers? Persoonlijk vond ik het moeilijk om me voor te stellen hoe het zou werken, maar alles bleek vrij eenvoudig. Voor eenvoudige uitvoer getallen gebruiken we een syntaxis die lijkt op tekenreeksen:

>>> "De prijs is $(getal)..format(getal=123) "De prijs is $123."
Maar voor cijfers geldt het wel meer modifiers dan voor strings. Om bijvoorbeeld een getal weer te geven binair voeg de modificator “b” toe, indien in hexadecimaal - de modificator “x”:

>>> "De prijs is $(getal:b)".format(getal=5) "De prijs is $101." >>> "De prijs is $(getal:x)".format(getal=123) "De prijs is $7 miljard."
Natuurlijk kan het getal met voorloopnullen worden geschreven:

>>> "Uw oproep is belangrijk voor ons. U bent oproep #(nummer:05).".format(nummer=123) "Uw oproep is belangrijk voor ons. U bent oproep #00123."
Merk op dat je binnen () geen uitvoerbare Python-code kunt gebruiken - in plaats daarvan wordt een eenvoudige microtaal voorgesteld die afzonderlijk is en verschilt van Python als geheel. Er zijn ook kleine uitzonderingen. Ten eerste kunt u de waarden van attributen/eigenschappen verkrijgen met behulp van een punt, en ten tweede kunt u de waarde van een object verkrijgen door te indexeren met behulp van .

Bijvoorbeeld:

>>> class Foo(object): def __init__(self): self.x = 100 >>> f = Foo() >>> "Je nummer is (o.x)".format(o=f) "Je nummer is 100"n
We hebben het attribuut "x" van het object "f" ontvangen. Dit object is toegankelijk via de naam "o" in de string. U kunt een attribuut krijgen, maar u kunt het niet uitvoeren:

>>> "Je naam is (naam.upper())".format(name="Reuven") AttributeError: "str" ​​object heeft geen attribuut "upper()"
Ik heb geprobeerd “name.upper()” uit te voeren, ervan uitgaande dat de juiste methode zou worden aangeroepen, maar Python staat niet toe dat code op deze locatie wordt uitgevoerd en behandelt “upper()” als een attribuut samen met de haakjes. Zonder de haakjes krijg je gewoon een stringrepresentatie van de functie/methode:

>>> "Je naam is (naam.upper)".format(name="Reuven") "Je naam is "
Met vierkante haken kunt u een element van een itereerbaar object (lijst, string) per index nemen. Maar segmentbewerkingen worden niet ondersteund:

>>> "Je favoriete nummer is (n)..format(n=nummers) "Je favoriete nummer is 3."
Maar:

>>> "Je favoriete nummers zijn (n)..format(n=numbers) ValueError: Ontbrekende "]" in formatstring
Het kan ook worden gebruikt om woordenboekitems op naam op te halen, maar de naam wordt zonder aanhalingstekens ingevoerd:

>>> person = ("first":Reuven", "last":Lerner") >>> "Uw naam is (p)".format(p=persoon) "Uw naam is Reuven."
Wanneer we aanhalingstekens proberen te gebruiken, krijgen we een uitzondering...

>>> "Uw naam is (p["eerste"])..format(p=persoon) KeyError: ""eerste""
Niet alle toepassingen van str.format worden hier vermeld - sterker nog, elk type heeft een specificatie van opmaakregels. De precisieoptie voor getallen met drijvende komma is bijvoorbeeld niet beschikbaar voor tekenreeksen.

U kunt zelfs uw eigen opmaakregels voor objecten in uw klassen toevoegen, zodat ze een specifieke uitvoermethode en modifiers hebben om deze aan te passen.

Als u dit onderwerp in meer detail wilt bestuderen, moet u beginnen met PEP 3101, waar str.format wordt beschreven. Ik kan ook de presentatie van Eric Smith aanbevelen, met een redelijk goede samenvatting over dit onderwerp. Er zijn ook goede voorbeelden over hoe u kunt overschakelen van het gebruik van % naar str.format in de Python-documentatie

Ik hoop dat je ervan genoten hebt!

Tot nu toe hebben we twee uitvoermethoden gebruikt: de waarden van expressies interactief uitvoeren en de printinstructie gebruiken (de derde methode is de write()-methode van bestandsobjecten).

Er is vaak een verlangen om te hebben meer controle over het formatteren van de uitvoer in plaats van eenvoudigweg waarden uit te voeren, gescheiden door een spatie. Uiteraard kunt u de snaren zelf bewerken: met behulp van de slice- en join-bewerkingen kunt u elk arrangement creëren dat u maar kunt bedenken. Strings beschikken over methoden waarmee ze kunnen worden opgevuld met spaties tot de vereiste kolombreedte 1 . Een andere manier is om de %-operator met een string als linkerargument te gebruiken. De %-operator interpreteert de string aan de rechterkant als een formatstring, in de stijl van de sprintf()-functie in C, die moet worden toegepast op het juiste argument, en retourneert een string die het resultaat van de opmaak bevat.

Natuurlijk blijft er nog een vraag over: hoe krijg je een stringrepresentatie voor de waarden verschillende soorten? Gelukkig biedt Python de mogelijkheid om een ​​waarde van elk type naar een string te converteren: met behulp van de str() functie. In feite biedt de taal twee functies voor het verkrijgen van een tekenreeksrepresentatie: repr() (hetzelfde effect kan eenvoudig worden bereikt door de uitdrukking tussen aanhalingstekens te plaatsen: `expr` ) en str() . De eerste methode wordt bijvoorbeeld door de tolk gebruikt om de waarden van uitdrukkingen in de interactieve modus af te drukken, de tweede wordt gebruikt om argumenten af ​​te drukken met behulp van de print-instructie. De functie str() retourneert waar mogelijk de meest geschikte representatie voor uitvoer, en de functie repr() retourneert de expressie die het meest geschikt is voor interactieve invoer. Hier zijn enkele voorbeelden:

>>> x = 10 * 3,14

Het getal 31.4 kan niet exact binair worden weergegeven, dus:

>>>x
31.400000000000002

De functie str() zal het getal echter met redelijke nauwkeurigheid afdrukken:

>>> j = 200*200
>>> s = "De waarde van x is " + str(x) + \
... ", de waarde van y is " + str(y) + "..."
>>> afdrukken
De x-waarde is 31,4, de y-waarde is 40.000...

Er worden lange gehele getallen in geschreven Python-taal met het achtervoegsel "L". Sinds versie 1.6 voert de functie str() dit niet uit:

>>> herhaling(1000L)
"1000L"
>>>str(1000L)
"1000"

De stringweergave kan ook voor andere typen worden verkregen:

>>>p=
>>> ps = repr(p)
>>>ps
""
>>> `x, y, ("spam", "eieren")`
"(31.400000000000002, 40000, ("spam", "eieren"))"

De functie repr() (of `` ) voegt aanhalingstekens toe en schrijft speciale tekens met behulp van escape-reeksen:

>>> hallo = "hallo, wereld\n"
>>> Hallo afdrukken
Hallo, wereld

>>> hallo = `hallo`
>>> Hallo afdrukken
"Hallo wereld\n"

Laten we een tabel met vierkanten en kubussen op de twee beschreven manieren weergeven:

>>> voor x binnen bereik(1, 11):
... print str(x).rjust(2), str(x*x).rjust(3),
... # Let op de afsluitende komma
... print str(x*x*x).rjust(4)
...
1 1 1
2 4 8
3 9 27
4 16 64
5 25 125
6 36 216
7 49 343
8 64 512
9 81 729
10 100 1000

>>> voor x binnen bereik(1,11):
... print "%2d %3d %4d" % (x, x*x, x*x*x)
...
1 1 1
2 4 8
3 9 27
4 16 64
5 25 125
6 36 216
7 49 343
8 64 512
9 81 729
10 100 1000

(Merk op dat er één spatie tussen de kolommen is toegevoegd door de printinstructie.)

Dit voorbeeld demonstreert het gebruik van de rjust() string-methode, die een string rechts uitlijnt binnen een veld met de opgegeven breedte, en deze opvult met spaties aan de linkerkant. De methoden ljust() en center() werken op dezelfde manier. Ze voeren niets uit - ze retourneren alleen een nieuwe regel. Als de oorspronkelijke regel te lang is, wordt deze niet afgekapt maar ongewijzigd geretourneerd: het is meestal beter om de kolomindeling onoverzichtelijk te maken dan om af te drukken ongeldige waarde. (Als je het echt wilt bijsnijden, gebruik dan de slice-operator: "s.ljust(n)".)

De functie zfill(), gedefinieerd in de stringmodule, kan ook nuttig zijn, die een string met een getal aan de linkerkant opvult met nullen, waardoor plus- en mintekens correct worden afgehandeld:

>>> importreeks
>>> string.zfill("12", 5)
"00012"
>>> string.zfill("-3.14", 7)
"-003.14"
>>> string.zfill("3.14159265359", 5)
"3.14159265359"

Het gebruik van de %-operator ziet er ongeveer zo uit:

>>> wiskunde importeren
>>> print "PI-waarde is ongeveer %5.3f." %\
... wiskunde.pi
De PI-waarde is ongeveer 3,142.

Als u meerdere waarden op een regel moet weergeven, wordt een tupel als rechteroperand gebruikt:

>>> tabel = ("Sjoerd": 4127, "Jack": 4098, "Dcab": 7678)
>>> voor naam, telefoon in table.items():
... print "%-10s ==> %10d" % (naam, telefoon)
...
Dcab ==> 7678
Jack ==> 4098
Sjoerd ==> 4127

De meeste formaten werken precies hetzelfde als in C. Als de argumenttypen echter niet overeenkomen met het format, cast de tolk ze naar vereiste soort(een expressie van welk type dan ook kan bijvoorbeeld worden geconverteerd naar een string met behulp van de ingebouwde functie str()) of, als dit niet mogelijk is, genereert een uitzondering 2. U kunt * gebruiken om de veldbreedte of precisie als afzonderlijke parameter op te geven.

Merk op dat als het juiste argument een tuple is, het Altijd een lijst met argumenten overwogen:

>>> def f(x):
... print "De waarde "%s" is doorgegeven aan de functie" % x
...
>>> f(1)

>>> f()

>>> # wordt niet geïnterpreteerd zoals je had verwacht
...f((1,))
De waarde "1" is doorgegeven aan de functie
>>> # fout
...f((1, 2))
Traceback (meest recente oproep laatste):
Bestand" ", regel 2, in
Bestand" ", regel 2, in f
TypeError: niet alle argumenten worden geconverteerd tijdens het formatteren van de tekenreeks

In dit geval zou het betrouwbaarder zijn om een ​​tupel bestaande uit één element als de juiste operand te gebruiken:

>>> def f(x):
... print "De waarde "%s" is doorgegeven aan de functie" % (x,)
...
>>> # Nu is alles correct
...f((1,))
De functie krijgt de waarde "(1,)" doorgegeven
>>> f((1, 2))
De functie krijgt de waarde "(1, 2)" doorgegeven
>>> f(1)
De waarde "1" is doorgegeven aan de functie
>>> f()
De functie krijgt de waarde "" doorgegeven

In het geval dat lange rijen formaat, wilt u mogelijk naar variabelen verwijzen op naam in plaats van op hun positie. Dit kan gedaan worden met behulp van uitgebreide notatie in de vorm %(name)format, bijvoorbeeld:

>>> tabel = ("Sjoerd": 4127, "Jack": 4098, "Dcab": 8637678)
>>> print "Jack: %(Jack)d; Sjoerd: %(Sjoerd)d; Dcab: %(Dcab)d" % tabel
Jack: 4098; Sjoerd: 4127; Dcab: 8637678

Deze notatie is vooral handig in combinatie met de ingebouwde functie vars(), die een woordenboek retourneert met de variabelen in het huidige bereik.

Opmerkingen

In dit stadium beschikken we al over een vrij uitgebreide set tools en kunnen we tamelijk “ingewikkelde” code schrijven. Na het schrijven van een code van enkele tientallen regels, zal deze na slechts een paar dagen behoorlijk moeilijk te lezen zijn. Het zal voor andere mensen nog moeilijker zijn om het te lezen.
En als je je dat inbeeldt grote projecten megabytes aan tekstbestanden met code, dan worden ze nog moeilijker te lezen. Deze situatie wordt gered door opmerkingen in de code. Programmeurs laten deze opmerkingen achter zodat ze na verloop van tijd een of ander stukje code kunnen verduidelijken en enkele acties kunnen beschrijven die in bepaalde delen van de programmacode voorkomen. Voor uw collega’s en voor u zal dit de leesbaarheid van de code enorm vergemakkelijken.

Er zijn twee soorten commentaar in Python: enkelregelig en meerregelig. Een commentaar van één regel begint met het "#"-symbool, kan op een afzonderlijke regel staan ​​of de regel eindigen met de code, maar moet uit één regel bestaan, d.w.z. Mag niet in twee regels worden opgesplitst. Het kan een regel code beëindigen, maar het kan niet in het midden van een regel tussen twee stukjes code staan. Bijvoorbeeld:

i = 0 # Teller voor lus

# De lus wordt uitgevoerd op basis van de bovenstaande voorwaarde

Commentaar dat uit meerdere regels bestaat, wordt tussen drievoudige aanhalingstekens """ geplaatst. Ze kunnen in verschillende regels worden opgesplitst en behoorlijk lang zijn. U kunt zelfs een essay schrijven. Een commentaar met meerdere regels moet beginnen met nieuwe lijn en kan op andere lijnen doorgaan. Bijvoorbeeld:

"""We doorlopen de lijst om het vereiste element te vinden

Na het vinden verbreken we de lus en slaan we het resultaat op in de variabele x

Als noodzakelijk onderdeel wordt niet gevonden, wij informeren de gebruiker hierover"""

Houd er rekening mee dat een commentaar van één regel met dezelfde inspringing moet beginnen als de code van het overeenkomstige blok, anders zal er een trackback zijn. Ook commentaar met meerdere regels, moet beginnen met een inspringing die geschikt is voor het codeblok. Volgende regels van het commentaar hoeven niet langer in te springen; de inspringing mag alleen vóór de aanhalingstekens """ staan ​​die het commentaar openen.

Beginnende programmeurs, en niet alleen beginners, schrijven vaak voor de hand liggende dingen in de commentaren, zoiets als "Ik heb hier een variabele x gedeclareerd." Probeer opmerkingen te vermijden die de ondernomen actie dupliceren. menselijke taal. Voordat u een opmerking schrijft, kunt u uzelf de volgende vragen stellen: “Waar is dit stukje code voor?”, “Welk doel dien ik met dit stukje code?”, “Wat doe ik met dit stukje code?”, "Wat is er niet voor de hand liggend aan dit stukje code?" ... Een soortgelijke reeks vragen zal helpen bij het construeren van de juiste opmerking, wat de code in de toekomst echt zal helpen begeleiden en leesbaarder zal maken.

Operators voor tekenreeksopmaak

Met de uitdrukking ‘een regel opmaken’ bedoelen we nu het uitbreiden van de waarden van variabelen op een regel, I.E. Wanneer er behoefte is aan een bepaalde regel, voegt u de waarden van sommige variabelen in. Voorheen deden we dit met behulp van "+" - tekenreeksen samenvoegen en "," numerieke uitdrukkingen schrijven na tekenreeksen. Het zag er op zijn minst lelijk uit.

>>> a = "Hallo"

>>> b = "schat"

>>> a + " " + b

Er zijn er 2 standaard methoden het uitbreiden van de waarden van variabelen in een string. Nu zullen we het hebben over de manier waarop opmaak wordt gedaan met behulp van opmaakoperatoren. Deze methode is ouder, achterhaald, het minst handig en onwenselijk in gebruik, maar wordt vaak gebruikt in oudere code.

Laten we eens kijken volgende optie:

>>> a = "Vasya"

>>> print "Hallo %s" % a

Hallo Vasya

Wat gebeurt er? Alles is vrij eenvoudig. De %s-operator in onze regel wordt vervangen door een variabele die rechts van het %-teken na onze regel staat.

Laten we naar een ander voorbeeld kijken:

>>> naam = "Vasya"

>>> achternaam = "Pupkin"

>>> leeftijd = 25

>>> print "Voornaam %s, achternaam %s, leeftijd %d" % (naam,achternaam,leeftijd)

Voornaam Vasya, achternaam Pupkin, 25 jaar

Merk allereerst op dat als er meer dan één variabele is, we deze doorgeven in tuple(). Het is je misschien ook opgevallen dat ik de waarden van stringvariabelen heb doorgegeven met de operator %s, en een variabele die naar een getal verwijst met behulp van de operator %d. Dat is de enige manier waarop het werkt. Elke operator kan een waarde uitbreiden bepaald soort: %s - tekenreeks, %d - getal, enz. Meer gedetailleerde lijst operatoren worden hieronder gegeven.

De eerste vraag die zich voordoet is: “Hoe kunnen we de waarde van één variabele meerdere keren op één regel afdrukken?” Het antwoord ligt voor de hand: we zullen deze variabele zo vaak in de tuple moeten doorgeven en in de volgorde waarin we de waarden van deze variabelen in onze string uitbreiden. Het is onhandig en lastig. We moeten variabelen altijd in een strikte volgorde schrijven die overeenkomt met hun uitbreiding door operatoren in de regel, en ze indien nodig zelfs herhalen.

Lijst met opmaakoperatoren:

"%d", "%i", "%u"

Decimaal getal.

Getal in het octale getalsysteem.

Nummer binnen hexadecimaal systeem Cijfers (kleine letters).

Nummer in hexadecimaal getalsysteem (hoofdletters).

Een getal met drijvende komma met een exponent (exponent in kleine letters).

Een getal met drijvende komma met een exponent (exponent in hoofdletters).

Zwevende-kommagetal (normaal formaat).

Drijvende-kommagetal. met exponent (exponent in kleine letters) als deze kleiner is dan -4 of precisie, anders normaal formaat.

Drijvende-kommagetal. met exponent (exponent in hoofdletters) als deze kleiner is dan -4 of precisie, anders normaal formaat.

Symbool (een reeks van één teken of een cijfer - een symboolcode).

Tekenreeks (python letterlijk).

Tekenreeks (zoals normaal waargenomen door de gebruiker).

Opmaakoperatoren (optioneel)

Hier zal ik het kort demonstreren extra functies opmaakoperatoren.

Conversiespecificaties worden in de volgende volgorde geschreven:

2. Sleutel (optioneel), bepaalt welk argument van de waarde zal worden vervangen.

3. Conversievlaggen.

4. Minimale veldbreedte. Indien *, wordt de waarde uit het tupel gehaald.

5. Nauwkeurigheid, begint met "." en vervolgens - de gewenste nauwkeurigheid.

6. Lengteaanpasser (optioneel).

7. Type (zie tabel hierboven).

>>> print ("%(taal)s heeft %(number)03d aanhalingstekens." % ("taal": "Python", "nummer": 2))

Python heeft 002 soorten aanhalingstekens.

Conversievlaggen:

De waarde gebruikt een alternatieve vorm.

De vrije ruimte wordt gevuld met nullen.

De vrije ruimte wordt opgevuld met spaties aan de rechterkant.

De vrije ruimte wordt opgevuld met spaties aan de linkerkant.

>>> "%.2s" % "Hallo!"

>>> "%.*s" % (2, "Hallo!")

>>> "%-10d" % 25

>>> "%+10f" % 25

>>> "%+10s" % "Hallo"

Het heeft geen zin om deze mogelijkheden nader te onderzoeken vanwege het zeldzame gebruik ervan.

format() tekenreeksopmaakmethode

De opmaakoperatoren zijn vervangen door de stringmethode. formaat(). Deze methode is veel flexibeler, handiger en veelzijdiger in gebruik. Laten we eens kijken naar het gebruik ervan om de waarden van variabelen in een string uit te breiden.

>>> naam = "Vasya"

>>> achternaam = "Pupkin"

>>> leeftijd = 25

>>> print "() (), leeftijd ()".format(naam,achternaam,leeftijd)

Vasya Pupkin, 25 jaar

Alles is hier heel duidelijk. Accolades () bepalen waar de variabelen moeten worden uitgebreid in de string, en aan de format()-methode geven we de variabelen door die moeten worden uitgebreid. Op het eerste gezicht is er niets veranderd vergeleken met de opmaakoperatoren. We hebben nog steeds geen controle over onze inzet. Het enige verschil is dat we niet langer een aantal operatoren hoeven te onthouden om waarden uit te breiden verschillende soorten. Niets, dit is nog maar het begin. Laten we de functionaliteit consequent vergroten. Laten we de volgende optie overwegen:

>>> naam = "Vasya"

>>> achternaam = "Pupkin"

>>> leeftijd = 25

>>> print "(0) (1), leeftijd (2)".format(naam,achternaam,leeftijd)

Vasya Pupkin, 25 jaar

Er is niets veranderd, maar er zijn enkele cijfers toegevoegd aan onze accolades. Laten we eens kijken naar het volgende voorbeeld:

>>> print "(1) (0), leeftijd (2)".format(naam,achternaam,leeftijd)

Pupkin Vasya, 25 jaar

De uitvoerreeks is gewijzigd. We hebben de waarden verwisseld. Het is je misschien opgevallen dat we de variabelen die we in de methode hebben ingevoerd niet hoefden om te wisselen, maar alleen de getallen tussen de accolades (). Deze getallen zijn een soort indices van de variabelen die we in onze lijn willen uitbreiden. In het laatste voorbeeld hebben we de variabele uitgebreid onder index 1, vervolgens 0 en 2, d.w.z. De tweede, eerste en derde variabelen worden doorgegeven aan de methode. Dit betekent dat we, door de indices aan te geven van de variabelen die aan de methode zijn doorgegeven, deze kunnen uitbreiden in de volgorde die we nodig hebben. We kunnen de waarde van één variabele ook meerdere keren op een regel weergeven door de index meerdere keren tussen accolades aan te geven.

>>> print "(1) (1), leeftijd (2)".format(naam,achternaam,leeftijd)

Pupkin Pupkin, 25 jaar

Mee eens, dit is veel flexibeler en handige manier tekenreeksopmaak versus opmaakoperatoren. Maar de flexibiliteit van deze methode voor het uitbreiden van variabele waarden houdt daar niet op. Laten we eens kijken naar de optie van benoemde argumenten.

>>> a = "Vasya"

>>> b = "Pupkin"

>>> print "(naam) (achternaam), leeftijd (leeftijd)".format(leeftijd=c,naam=a,achternaam=b)

Vasya Pupkin, 25 jaar

Dit is nog interessanter. De benodigde gegevens bevonden zich onder de betekenisloze variabelen a, b en c. Toen we deze variabelen in onze methode doorgaven, gaven we ze betekenisvolle namen zoals (naam=variabele) en gebruikten we die namen vervolgens tussen onze accolades ().

Voor de formatmethode kunnen we een lijst met waarden doorgeven en deze binnen onze string uitbreiden. Dit gebeurt als volgt:

>>> l = ["Vasya", "Pupkin", 25]

["Vasya", "Pupkin", 25]

>>> print "(0) (1), leeftijd (2)".format(*l)

Vasya Pupkin, 25 jaar

Alles is hier meer dan duidelijk. We hebben een lijst doorgegeven en toegang gekregen tot de elementen ervan via index, maar bij het doorgeven van de lijst hebben we een “*”-teken vóór de variabele gespecificeerd, wat de methode format() expliciet vertelde dat we de elementen van deze lijst zouden uitbreiden. Wat gebeurt er als we de "*" weglaten voordat we het lijstargument opgeven?

>>> print "(0) (1), leeftijd (2)".format(l)

Traceback (meest recente oproep laatste):

Bestand " ", regel 1, in

IndexError: tupelindex buiten bereik

De methode wist niet dat we een lijst hadden doorgegeven en probeerde zelf de gebruikelijke argumenten te zoeken onder de indexen 1 en 2, die we in de regel hadden benaderd.

Op dezelfde manier kunnen we een woordenboek doorgeven aan de format() methode.

>>> db = ("naam"Vasya", "achternaam"Pupkin", "leeftijd":25)

("achternaam": "Pupkin", "leeftijd": 25, "naam": "Vasya")

>>> print "(naam) (achternaam), leeftijd (leeftijd)".format(**db)

Vasya Pupkin, 25 jaar

Dit lijkt erg op het doorgeven van benoemde argumenten, met als enige verschil dat we een woordenboek aan onze methode hebben doorgegeven. Als we vóór het doorgeven van de lijst één asterisk “*” hebben opgegeven, plaatsen we voordat we het woordenboek doorgeven twee sterretjes “**” vóór het argument in de methode format() en verwijzen we tussen de accolades van de regel naar de sleutels van het doorgegeven woordenboek om hun waarden uit te breiden.

We hebben alle opties bekeken voor het uitbreiden van variabelen in een string met behulp van de format() -methode. In de toekomst raad ik je ten zeerste aan deze methode te gebruiken in plaats van formatteringsoperatoren, omdat Deze methode is nieuwer, flexibeler en officiële bronnen adviseren ons om deze methode te volgen.

format() methode (optioneel)

Vervolgens zal ik aanvullende functies van de string format() -methode bieden. Uitgebreidere informatie over deze methode, je kunt kijken in het artikel over Habré, of in officiële documentatie door Python.

Aandacht! Wat volgt is een fragment van een artikel over de format() methode

Laten we weer eenvoudig beginnen: als u een string met een bepaalde lengte moet uitvoeren, voeg dan na de naam van de variabele een dubbele punt (:) toe en vervolgens het aantal tekens. Dus om mijn naam weer te geven en deze op te vullen tot tien tekens met spaties, zou ik dit moeten doen:

>>> "Uw naam is (naam:10)".format(name="Reuven")

"Je naam is Reuven"

(Merk op dat de regel wordt opgevuld met spaties na de naam.)

Als u de uitlijning aan de rechterkant van het blok wilt instellen, gebruikt u het > teken tussen: en het nummer:

>>> "Uw naam is (naam:>10)".format(name="Reuven")

"Je naam is Reuven"

En ja, via het bordje kun je expliciet aangeven dat ik links uitlijning wil<

Als u de waarde in het midden van het blok wilt weergeven, gebruik dan in plaats van< и >het ^-symbool wordt gebruikt:

>>> "Je naam is (naam:*^10)".format(name="Reuven")

"Je naam is **Reuven**"

De tekst is min of meer duidelijk, maar hoe zit het met de cijfers? Persoonlijk vond ik het moeilijk om me voor te stellen hoe het zou werken, maar alles bleek vrij eenvoudig. Om eenvoudig getallen uit te voeren, gebruiken we een syntaxis die lijkt op tekenreeksen:

>>> "De prijs is $(getal)..format(getal=123)