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()
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.
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.
Du kan finde flere oplysninger om listeforståelser og generatorudtryk i følgende artikel.
- Relaterede artikler:Sådan bruger du Python list comprehensions
