Sammenkædning og sammenføjning af strenge i Python: +-operatorer, sammenføjningsfunktioner osv.

Følgende er en beskrivelse af, hvordan man sammenkæder og sammenføjer strenge str i Python.

Sammenkædning og sammenlægning af flere strenge: +,+=operatør
Sammenkædning og kombination af tal og strenge: +,+=operatør,str(),format(),f-streng
Sammenkædning og kombination af lister (arrays) af strenge til en enkelt streng:join()
Sammenkædning og kombination af lister (arrays) af tal til en enkelt streng:join(),str()

Table of Contents

Sammenkædning og sammenlægning af flere strenge: +, +=operatør
Sammenkædning af tal og strenge\kædning: +,+=operatør,str(),format(),f-streng
Sammenkædning og sammenføjning af lister (arrays) af strenge: join()
Sammenkædning og kombination af lister (arrays) af tal som strenge: join(),str()

Sammenkædning og sammenlægning af flere strenge: +, +=operatør

forbindelse: +operatør

Operatoren ++ kan bruges til at sammenkæde følgende stringliteraler og stringvariabler

'…'
“…”

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

forbindelse: +=operatør

Operatoren +=, en kumulativ tildelingsoperator, kan også bruges. Strengvariablen på venstre side sammenkædes med strengen på højre side, og den tildeles og opdateres.

s1 += s2
print(s1)
# aaabbb

Hvis du vil tilføje en streng til slutningen af en strengvariabel, skal du blot behandle strengvariablen og enhver strenglitteral (eller en anden strengvariabel) med operatoren +=.

s = 'aaa'

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

Fortløbende sammenkædning af strengliteraler

Hvis du blot skriver strenglitteraler ved siden af hinanden, vil strenglitteralerne blive sammenkædet.

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

Det er acceptabelt at have et mellemrum mellem to linjer eller et linjeskift med backslash (betragtes som en fortsættelse).

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

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

Der findes en teknik til at bruge dette til at skrive lange strenge på flere linjer i koden.

Relaterede artikler:Skrivning af lange strenge på flere linjer i Python

Denne skrivemetode er ikke mulig for strengvariabler.

# s = s1 s2 s3
# SyntaxError: invalid syntax

Sammenkædning af tal og strenge\kædning: +,+=operatør,str(),format(),f-streng

En +-operation af en anden type resulterer i en fejl.

s1 = 'aaa'
s2 = 'bbb'

i = 100
f = 0.25

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

Hvis du vil sammenkæde en numerisk værdi (f.eks. heltalstype int eller flydepunktstype float) med en streng, skal du konvertere den numeriske værdi til en strengtype med str() og derefter sammenkæde dem med +-operatoren (eller +=-operatoren).

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

Hvis du ønsker at konvertere et tals format, f.eks. nulstilling eller decimaler, skal du bruge funktionen format() eller stringmetoden 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

Det er naturligvis også muligt at indlejre værdien af en variabel direkte i en streng uden formatering. Dette er enklere at skrive end at bruge operatoren +.

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

Se følgende artikel for nærmere oplysninger om, hvordan du angiver formatet.

Relaterede artikler:Formatkonvertering i Python, format (0-fyldning, eksponentiel notation, hexadecimal, osv.)

Siden Python 3.6 er der også blevet indført en mekanisme kaldet f-strings (f-string), som er endnu enklere at skrive end 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

Sammenkædning og sammenføjning af lister (arrays) af strenge: join()

Strengmetoden join() kan bruges til at sammenkæde en liste af strenge til en enkelt streng.

str.join(iterable) — Built-in Types — Python 3.10.2 Documentation

Sådan skrives det på følgende måde.

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

Kald join()-metoden med “streng at indsætte mellem” og giv [liste over strenge, der skal sammenkædes] som et argument.

Hvis der anvendes en tom streng, vil [liste over strenge, der skal sammenkædes] simpelthen blive sammenkædet, hvis der anvendes et komma, vil strengene blive kommasepareret, og hvis der anvendes et newline-tegn, vil hvert enkelt strengelement blive 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

Selv om der her kun er givet et eksempel på en liste, kan andre iterable objekter, f.eks. tupler, også angives som argumenter til join().

I modsætning til join() bruges split() til at opdele en streng, der er afgrænset af en bestemt afgrænser, og få den som en liste.

Sammenkædning og kombination af lister (arrays) af tal som strenge: join(),str()

Der opstår en fejl, hvis argumentet til join() er en liste, hvis elementer ikke er strings.

l = [0, 1, 2]

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

Hvis du vil sammenkæde en liste af tal til en enkelt streng, skal du anvende funktionen str() på hvert element i listens forståelsesnotation for at konvertere tallene til en streng og derefter sammenføje dem med join().

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

Det kan også skrives som et generatorudtryk, som er en generatorversion af list comprehensions. Generatorudtryk er omsluttet af parenteser, men parenteserne kan udelades, hvis generatorudtrykket er det eneste argument for en funktion eller metode.

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

Generatorudtryk har generelt den fordel, at de bruger mindre hukommelse end listeforståelser, men der er ingen særlig fordel ved at bruge generatorudtryk, da join() konverterer generatorer til lister i sin interne behandling. Faktisk er det en smule hurtigere at bruge list comprehensions fra starten.