Python Language
Stringopmaak

Invoering

Syntaxis

• "{}". format (42) ==> "42"
• "{0}". Format (42) ==> "42"
• "{0: .2f}". Format (42) ==> "42.00"
• "{0: .0f}". Format (42.1234) ==> "42"
• "{answer}". formaat (no_answer = 41, answer = 42) ==> "42"
• "{answer: .2f}". formaat (no_answer = 41, answer = 42) ==> "42.00"
• "{[key]}". format ({'key': 'value'}) ==> "value"
• "{[1]}". Format (['zero', 'one', 'two']) ==> "one"
• "{answer} = {answer}". format (answer = 42) ==> "42 = 42"
• '' .join (['stack', 'overflow']) ==> "stack overflow"

Opmerkingen

Basisprincipes van tekenreeksopmaak

foo = 1
bar = 'bar'
baz = 3.14

U kunt str.format om uitvoer te formatteren. Bracket-paren worden vervangen door argumenten in de volgorde waarin de argumenten worden doorgegeven:

print('{}, {} and {}'.format(foo, bar, baz))
# Out: "1, bar and 3.14"

Indexen kunnen ook tussen de haakjes worden opgegeven. De cijfers komen overeen met indexen van de argumenten die zijn doorgegeven aan de functie str.format (gebaseerd op 0).

print('{0}, {1}, {2}, and {1}'.format(foo, bar, baz))
# Out: "1, bar, 3.14, and bar"
print('{0}, {1}, {2}, and {3}'.format(foo, bar, baz))
# Out: index out of range error

Benoemde argumenten kunnen ook worden gebruikt:

print("X value is: {x_val}. Y value is: {y_val}.".format(x_val=2, y_val=3))
# Out: "X value is: 2. Y value is: 3."

Er kan naar str.format worden verwezen wanneer ze worden doorgegeven in str.format :

class AssignValue(object):
    def __init__(self, value):
        self.value = value
my_value = AssignValue(6)
print('My value is: {0.value}'.format(my_value))  # "0" is optional
# Out: "My value is: 6"

Woordenboeksleutels kunnen ook worden gebruikt:

my_dict = {'key': 6, 'other_key': 7}
print("My other key is: {0[other_key]}".format(my_dict))  # "0" is optional
# Out: "My other key is: 7"

Hetzelfde geldt voor lijst- en tuple-indices:

my_list = ['zero', 'one', 'two']
print("2nd element is: {0[2]}".format(my_list))  # "0" is optional
# Out: "2nd element is: two"

Opmerking: Naast str.format biedt Python ook de modulo-operator % ook bekend als de string-opmaak- of interpolatie-operator (zie PEP 3101 ) - voor het formatteren van strings. str.format is een opvolger van % en biedt meer flexibiliteit, bijvoorbeeld door het gemakkelijker te maken om meerdere substituties uit te voeren.

In aanvulling op het argument van indexen, kunt u ook een format specificatie binnen de accolades. Dit is een uitdrukking die specifieke regels volgt en moet worden voorafgegaan door een dubbele punt ( : ). Raadpleeg de documentatie voor een volledige beschrijving van de opmaakspecificatie. Een voorbeeld van opmaakspecificatie is de uitlijningsrichtlijn :~^20 ( ^ staat voor centreeruitlijning, totale breedte 20, vul met ~ teken):

'{:~^20}'.format('centered')
# Out: '~~~~~~centered~~~~~~'

format maakt gedrag niet mogelijk met % , bijvoorbeeld herhaling van argumenten:

t = (12, 45, 22222, 103, 6)
print '{0} {2} {1} {2} {3} {2} {4} {2}'.format(*t)    
# Out: 12 22222 45 22222 103 22222 6 22222

Omdat format een functie is, kan het als argument worden gebruikt in andere functies:

number_list = [12,45,78]
print map('the number is {}'.format, number_list)
# Out: ['the number is 12', 'the number is 45', 'the number is 78']   
    

from datetime import datetime,timedelta
    
once_upon_a_time = datetime(2010, 7, 1, 12, 0, 0)
delta = timedelta(days=13, hours=8,  minutes=20)
    
gen = (once_upon_a_time + x * delta for x in xrange(5))
    
print '\n'.join(map('{:%Y-%m-%d %H:%M:%S}'.format, gen))
#Out: 2010-07-01 12:00:00
#     2010-07-14 20:20:00
#     2010-07-28 04:40:00
#     2010-08-10 13:00:00
#     2010-08-23 21:20:00

Uitlijning en opvulling

'{:~<9s}, World'.format('Hello')
# 'Hello~~~~, World'

'{:~>9s}, World'.format('Hello')
# '~~~~Hello, World'

'{:~^9s}'.format('Hello')
# '~~Hello~~'

'{:0=6d}'.format(-123)
# '-00123'

Opmerking: u kunt dezelfde resultaten bereiken met de tekenreeksfuncties ljust() , rjust() , center() , zfill() , maar deze functies zijn verouderd sinds versie 2.5.

Letterlijke notaties (f-string)

Tekenreeksen in letterlijke indeling zijn geïntroduceerd in PEP 498 (Python 3.6 en hoger), zodat u f aan het begin van een letterlijke tekenreeks kunt plaatsen om .format effectief toe te passen met alle variabelen in de huidige scope.

>>> foo = 'bar'
>>> f'Foo is {foo}'
'Foo is bar'

Dit werkt ook met meer geavanceerde tekenreeksen, inclusief uitlijning en puntnotatie.

>>> f'{foo:^7s}'
'  bar  '

Opmerking: de f'' verwijst niet naar een bepaald type zoals b'' voor bytes of u'' voor unicode in python2. De formatie wordt onmiddellijk aangebracht, wat resulteert in een normale roering.

De opmaakreeksen kunnen ook worden genest :

>>> price = 478.23
>>> f"{f'${price:0.2f}':*>20s}"
'*************$478.23'

De uitdrukkingen in een f-string worden in de volgorde van links naar rechts geëvalueerd. Dit is alleen detecteerbaar als de uitdrukkingen bijwerkingen hebben:

>>> def fn(l, incr):
...    result = l[0]
...    l[0] += incr
...    return result
...
>>> lst = [0]
>>> f'{fn(lst,2)} {fn(lst,3)}'
'0 2'
>>> f'{fn(lst,2)} {fn(lst,3)}'
'5 7'
>>> lst
[10]

Stringopmaak met datetime

Elke klasse kan zijn eigen syntaxis voor tekenreeksopmaak configureren via de __format__ methode. Een type in de standaard Python-bibliotheek dat hier handig gebruik van maakt, is het datetime type, waarbij men strftime achtige opmaakcodes direct binnen str.format kan gebruiken:

>>> from datetime import datetime
>>> 'North America: {dt:%m/%d/%Y}.  ISO: {dt:%Y-%m-%d}.'.format(dt=datetime.now())
'North America: 07/21/2016.  ISO: 2016-07-21.'

Een volledige lijst met lijst met datetime-formatteerders is te vinden in de officiële documentatie .

Formatteren met Getitem en Getattr

Elke datastructuur die __getitem__ ondersteunt __getitem__ kan zijn geneste structuur hebben:

person = {'first': 'Arthur', 'last': 'Dent'} 
'{p[first]} {p[last]}'.format(p=person) 
# 'Arthur Dent'

U kunt getattr() openen met getattr() :

class Person(object):
    first = 'Zaphod'
    last = 'Beeblebrox'

'{p.first} {p.last}'.format(p=Person())
# 'Zaphod Beeblebrox'

Float opmaak

>>> '{0:.0f}'.format(42.12345)
'42'

>>> '{0:.1f}'.format(42.12345)
'42.1'

>>> '{0:.3f}'.format(42.12345)
'42.123'

>>> '{0:.5f}'.format(42.12345)
'42.12345'

>>> '{0:.7f}'.format(42.12345)
'42.1234500'

Hetzelfde geldt voor andere verwijzingen:

>>> '{:.3f}'.format(42.12345)
'42.123'

>>> '{answer:.3f}'.format(answer=42.12345)
'42.123'

Zwevende puntnummers kunnen ook worden opgemaakt in wetenschappelijke notatie of als percentages:

>>> '{0:.3e}'.format(42.12345)
'4.212e+01'

>>> '{0:.0%}'.format(42.12345)
'4212%'

U kunt ook de notaties {0} en {name} combineren. Dit is vooral handig als u alle variabelen wilt afronden op een vooraf opgegeven aantal decimalen met 1 declaratie :

>>> s = 'Hello'
>>> a, b, c = 1.12345, 2.34567, 34.5678
>>> digits = 2

>>> '{0}! {1:.{n}f}, {2:.{n}f}, {3:.{n}f}'.format(s, a, b, c, n=digits)
'Hello! 1.12, 2.35, 34.57'

Numerieke waarden opmaken

De methode .format() kan een getal in verschillende indelingen interpreteren, zoals:

>>> '{:c}'.format(65)    # Unicode character
'A'

>>> '{:d}'.format(0x0a)  # base 10
'10'

>>> '{:n}'.format(0x0a)  # base 10 using current locale for separators
'10'

Gehele getallen opmaken voor verschillende basen (hex, oct, binair)

>>> '{0:x}'.format(10) # base 16, lowercase - Hexadecimal
'a'

>>> '{0:X}'.format(10) # base 16, uppercase - Hexadecimal
'A'

>>> '{:o}'.format(10) # base 8 - Octal
'12'

>>> '{:b}'.format(10) # base 2 - Binary
'1010'

>>> '{0:#b}, {0:#o}, {0:#x}'.format(42) # With prefix
'0b101010, 0o52, 0x2a'

>>> '8 bit: {0:08b}; Three bytes: {0:06x}'.format(42) # Add zero padding
'8 bit: 00101010; Three bytes: 00002a'

Gebruik opmaak om een RGB-float-tuple te converteren naar een kleuren hex-string:

>>> r, g, b = (1.0, 0.4, 0.0)
>>> '#{:02X}{:02X}{:02X}'.format(int(255 * r), int(255 * g), int(255 * b))
'#FF6600'

Alleen gehele getallen kunnen worden geconverteerd:

>>> '{:x}'.format(42.0)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: Unknown format code 'x' for object of type 'float'

Aangepaste opmaak voor een klasse

Notitie:

Alles onder geldt voor de str.format methode, evenals de format functie. In de onderstaande tekst zijn de twee uitwisselbaar.

Voor elke waarde, die aan de doorgegeven format functie, Python zoekt naar een __format__ methode voor dat argument. Uw eigen aangepaste klasse kunnen dus hun eigen __format__ methode om te bepalen hoe de format functie te geven en het formaat van uw klas en het is attributen.

Dit is anders dan de __str__ methode, omdat u in de __format__ methode rekening kunt houden met de opmaaktaal, inclusief uitlijning, veldbreedte, enz. En zelfs (als u dat wilt) uw eigen opmaakspecificaties en uw eigen opmaaktaalextensies kunt implementeren. 1

object.__format__(self, format_spec)

Bijvoorbeeld :

# Example in Python 2 - but can be easily applied to Python 3

class Example(object):
    def __init__(self,a,b,c):
        self.a, self.b, self.c = a,b,c

    def __format__(self, format_spec):
        """ Implement special semantics for the 's' format specifier """
        # Reject anything that isn't an s
        if format_spec[-1] != 's':
            raise ValueError('{} format specifier not understood for this object', format_spec[:-1])

        # Output in this example will be (<a>,<b>,<c>)
        raw = "(" + ",".join([str(self.a), str(self.b), str(self.c)]) + ")"
        # Honor the format language by using the inbuilt string format
        # Since we know the original format_spec ends in an 's' 
        # we can take advantage of the str.format method with a 
        # string argument we constructed above
        return "{r:{f}}".format( r=raw, f=format_spec )

inst = Example(1,2,3)
print "{0:>20s}".format( inst )
# out :              (1,2,3)
# Note how the right align and field width of 20 has been honored.

Notitie:

Als uw aangepaste klasse een aangepaste niet over __format__ methode en een instantie van de klasse wordt doorgegeven aan de format -functie, zal python2 altijd gebruik maken van de return waarde van de __str__ methode of __repr__ methode om te bepalen wat te drukken (en indien noch bestaan dan is de standaard repr wordt gebruikt), en u moet de formatteereenheid s gebruiken om dit te formatteren. Met python3, om uw aangepaste klasse aan het passeren format -functie, moet u bepalen __format__ methode op uw aangepaste klasse.

Geneste opmaak

Sommige indelingen kunnen aanvullende parameters aannemen, zoals de breedte van de opgemaakte tekenreeks of de uitlijning:

>>> '{:.>10}'.format('foo')
'.......foo'

Deze kan ook worden verschaft als parameters format nesten meer {} in het {} :

>>> '{:.>{}}'.format('foo', 10)
'.......foo'
'{:{}{}{}}'.format('foo', '*', '^', 15)
'******foo******'

In het laatste voorbeeld wordt de opmaakreeks '{:{}{}{}}' gewijzigd in '{:*^15}' (dwz 'midden en pad met * tot totale lengte van 15') voordat deze op de werkelijke string 'foo' om op die manier te worden opgemaakt.

Dit kan handig zijn in gevallen waarin parameters vooraf niet bekend zijn, bijvoorbeeld bij het uitlijnen van tabelgegevens:

>>> data = ["a", "bbbbbbb", "ccc"]
>>> m = max(map(len, data))
>>> for d in data:
...     print('{:>{}}'.format(d, m))
      a
bbbbbbb
    ccc

Opvullende en afgeknotte snaren, gecombineerd

Stel dat u variabelen in een kolom van 3 tekens wilt afdrukken.

Opmerking: verdubbeling van { en } ontsnapt eraan.

s = """

pad
{{:3}}             :{a:3}:

truncate
{{:.3}}            :{e:.3}:

combined
{{:>3.3}}          :{a:>3.3}:
{{:3.3}}           :{a:3.3}:
{{:3.3}}           :{c:3.3}:
{{:3.3}}           :{e:3.3}:
"""

print (s.format(a="1"*1, c="3"*3, e="5"*5))

Output:

pad
{:3}             :1  :

truncate
{:.3}            :555:

combined
{:>3.3}          :  1:
{:3.3}           :1  :
{:3.3}           :333:
{:3.3}           :555:

Genoemde tijdelijke aanduidingen

Opmaakreeksen kunnen benoemde tijdelijke aanduidingen bevatten die worden geïnterpoleerd met behulp van trefwoordargumenten om op format .

Een woordenboek gebruiken (Python 2.x)

>>> data = {'first': 'Hodor', 'last': 'Hodor!'}
>>> '{first} {last}'.format(**data)
'Hodor Hodor!'

Een woordenboek gebruiken (Python 3.2+)

>>> '{first} {last}'.format_map(data)
'Hodor Hodor!'

str.format_map maakt het mogelijk om woordenboeken te gebruiken zonder ze eerst uit te pakken. Ook wordt de data (mogelijk een aangepast type) gebruikt in plaats van een nieuw ingevuld dict .

Zonder woordenboek:

>>> '{first} {last}'.format(first='Hodor', last='Hodor!')
'Hodor Hodor!'