Aaneenschakelen en samenvoegen van strings in Python: + operatoren, join functies, enz.

Bedrijf

Hier volgt een beschrijving van het aaneenschakelen en samenvoegen van string str in Python.

  • Samenvoegen en samenvoegen van meerdere strings: +,+=operator
  • Aaneenschakelen en combineren van getallen en tekenreeksen: +,+=operator,str(),format(),f-string
  • Aaneenschakelen en combineren van lijsten (arrays) van tekenreeksen tot een enkele tekenreeks:join()
  • Samenvoegen en combineren van lijsten (arrays) van getallen tot een enkele tekenreeks:join(),str()

Samenvoegen en samenvoegen van meerdere strings: +, +=operator

aansluiting: +operator

De operator ++ kan worden gebruikt om de volgende tekenreeks-literalen en tekenreeks-variabelen aan elkaar te koppelen

  • '…'
  • “…”
s = 'aaa' + 'bbb' + 'ccc'
print(s)
# aaabbbccc

s1 = 'aaa'
s2 = 'bbb'
s3 = 'ccc'

s = s1 + s2 + s3
print(s)
# aaabbbccc

s = s1 + s2 + s3 + 'ddd'
print(s)
# aaabbbcccddd

aansluiting: +=operator

De operator +=, een cumulatieve toewijzingsoperator, kan ook worden gebruikt. De tekenreeksvariabele aan de linkerkant wordt aaneengeschakeld met de tekenreeks aan de rechterkant, en wordt toegewezen en bijgewerkt.

s1 += s2
print(s1)
# aaabbb

Als je een string wilt toevoegen aan het einde van een string-variabele, verwerk je gewoon de string-variabele en een string-literal (of een andere string-variabele) met de += operator.

s = 'aaa'

s += 'xxx'
print(s)
# aaaxxx

Opeenvolgende aaneenschakeling van string-literalen

Als je eenvoudigweg string-literalen naast elkaar schrijft, zullen de string-literalen aan elkaar worden gekoppeld.

s = 'aaa''bbb''ccc'
print(s)
# aaabbbccc

Tussen twee regels mag een spatie staan of een backslash regeleinde (wordt beschouwd als een voortzetting).

s = 'aaa'  'bbb'    'ccc'
print(s)
# aaabbbccc

s = 'aaa'\
    'bbb'\
    'ccc'
print(s)
# aaabbbccc

Er is een techniek om dit te gebruiken om lange strings op meerdere regels in de code te schrijven.

Deze schrijfmethode is niet mogelijk voor stringvariabelen.

# s = s1 s2 s3
# SyntaxError: invalid syntax

Numerieke en string aaneenschakeling: +,+=operator,str(),format(),f-string

Een + bewerking van een ander type resulteert in een fout.

s1 = 'aaa'
s2 = 'bbb'

i = 100
f = 0.25

# s = s1 + i
# TypeError: must be str, not int

Indien je een numerieke waarde (bv. integer type int of floating-point type float) wil aaneenschakelen met een string, converteer dan de numerieke waarde naar een string type met str() en voeg ze dan samen met de + operator (of += operator).

s = s1 + '_' + str(i) + '_' + s2 + '_' + str(f)
print(s)
# aaa_100_bbb_0.25

Als u het formaat van een getal wilt omzetten, zoals nulvulling of decimalen, gebruikt u de functie format() of de string-methode format().

s = s1 + '_' + format(i, '05') + '_' + s2 + '_' + format(f, '.5f')
print(s)
# aaa_00100_bbb_0.25000

s = '{}_{:05}_{}_{:.5f}'.format(s1, i, s2, f)
print(s)
# aaa_00100_bbb_0.25000

Natuurlijk is het ook mogelijk om de waarde van een variabele direct in te sluiten in een string zonder opmaak. Dit is eenvoudiger te schrijven dan de + operator te gebruiken.

s = '{}_{}_{}_{}'.format(s1, i, s2, f)
print(s)
# aaa_100_bbb_0.25

Zie het volgende artikel voor details over hoe het formaat te specificeren.

Sinds Python 3.6 is er ook een mechanisme geïntroduceerd, f-string genaamd, dat nog eenvoudiger te schrijven is dan format().

s = f'{s1}_{i:05}_{s2}_{f:.5f}'
print(s)
# aaa_00100_bbb_0.25000

s = f'{s1}_{i}_{s2}_{f}'
print(s)
# aaa_100_bbb_0.25

Aaneenschakelen en samenvoegen van lijsten (arrays) van tekenreeksen: join()

De string methode join() kan worden gebruikt om een lijst van strings samen te voegen tot een enkele string.

Het volgende is hoe je het schrijft.

'String to be inserted between'.join([List of strings to be concatenated])

Roep join() methode aan met 'string om tussen te voegen' en geef [lijst van strings om samen te voegen] door als argument.

Als een lege tekenreeks wordt gebruikt, wordt [lijst van aan elkaar te koppelen tekenreeksen] gewoon aan elkaar gekoppeld, als een komma wordt gebruikt, worden de tekenreeksen door komma's gescheiden, en als een newline-teken wordt gebruikt, wordt elk tekenreekselement newlined.

l = ['aaa', 'bbb', 'ccc']

s = ''.join(l)
print(s)
# aaabbbccc

s = ','.join(l)
print(s)
# aaa,bbb,ccc

s = '-'.join(l)
print(s)
# aaa-bbb-ccc

s = '\n'.join(l)
print(s)
# aaa
# bbb
# ccc

Hoewel hier alleen een voorbeeld van een lijst wordt gegeven, kunnen andere iterabele objecten zoals tupels ook als argumenten voor join() worden opgegeven.

In tegenstelling tot join(), wordt split() gebruikt om een string, begrensd door een specifiek scheidingsteken, te splitsen en als lijst te verkrijgen.

Samenvoegen en combineren van lijsten (arrays) van getallen als tekenreeksen: join(),str()

Er treedt een fout op als het argument voor join() een lijst is waarvan de elementen geen strings zijn.

l = [0, 1, 2]

# s = '-'.join(l)
# TypeError: sequence item 0: expected str instance, int found

Om een lijst van getallen samen te voegen tot een enkele string, pas je de str() functie toe op elk element in de lijstbegripnotatie om de getallen om te zetten in een string, en voeg je ze vervolgens samen met join().

s = '-'.join([str(n) for n in l])
print(s)
# 0-1-2

Het kan ook geschreven worden als een generator expressie, wat een generator versie is van lijst comprehensies. Generator expressies staan tussen haakjes, maar de haakjes kunnen worden weggelaten als de generator expressie het enige argument is voor een functie of methode.

s = '-'.join((str(n) for n in l))
print(s)
# 0-1-2

s = '-'.join(str(n) for n in l)
print(s)
# 0-1-2

Generator expressies hebben over het algemeen het voordeel dat ze minder geheugen gebruiken dan lijst comprehensies, maar er is geen specifiek voordeel aan het gebruik van generator expressies omdat join() generatoren omzet naar lijsten in zijn interne verwerking. In feite is het iets sneller om vanaf het begin lijst comprehensies te gebruiken.

Voor meer informatie over list comprehensions en generator expressies, zie het volgende artikel.

Copied title and URL