3.2. Tekststrenge

En tekststreng er alt mellem dobbelte eller enkelte anførselstegn

Tekststeng mellem dobbelte anførselstegn:
>>> print "Velkommen til Python!"
Velkommen til Python!

Tekststeng mellem enkelte anførselstegn: >>> print 'Velkommen til Python!' Velkommen til Python!

print "Tekststreng med \"dobbelte anførselstegn.\"" print 'En streng med "dobbelte anførselstegn."' print 'Tekststreng med \'enkelte anførselstegn.\'' print "En streng med 'enkelte anførselstegn.'" print """Strengen her har "dobbelte anførselstegn"og 'enkelte anførselstegn'. Du kan tilmed udskrive over flere linjer.""" print '''Denne streng har også "dobbelte"og 'enkelte' anførselstegn.'''

Anførselstegnene skal være samme slags: >>> 'Velkommen til Python! " SyntaxError: EOL while scanning single-quoted string

>>> "Velkommen til Python! ' SyntaxError: EOL while scanning single-quoted string

print "Velkommen\ntil\n\nPython!"

Strenge kan lægges sammen: >>> print "Velkommen " + 'til Python' Velkommen til Python

Strenge kan gentages: >>> print "Velkommen til Python! " * 3 Velkommen til Python! Velkommen til Python! Velkommen til Python!

>>> 'Velkommen til Python! ' * 3 'Velkommen til Python! Velkommen til Python! Velkommen til Python! '

Strenge kan sammenlignes: >>> "æøå" < "ÆØÅ" False >>> "ÆØÅ" < "æøå" True >>> >>> 'Python' < 'Pascal'<'ABC' < 'C' False >>> >>> 'ABC' > 'C' < 'Pascal' < 'Python' True >>> 'ABC' < 'C' < 'Pascal' < 'Python' False >>> 'ABC' == 'C' == 'Pascal' == 'Python' False >>> >>> 4 == "fire" False >>>

Strenge kan indskrives med raw_input: integer1 = raw_input( "Skriv et helt tal: " ) # read en streng integer1 = int( integer1 ) # Konverter strengen til heltal

heltal2 = raw_input( "Enter endnu et heltal: " ) # indskriv streng integer2 = int( heltal2 ) # et heltal og an integer er det samme

# Kopier indholdet i integer1 og heltal2 til sum sum = integer1 + heltal2

print "Summen af de to heltal er ", sum

Linjeskifte indsættes med \n >>> print "Velkommen\ntil\n\nPython!" Velkommen til

Python!

Tabulatorskifte indsættes med \t >>> print "Velkommen\ttil\t\tPython!" Velkommen til Python! Bemærk her at tekstfunktionerne oftes knyttes til tekststrengen som f.eks. streng.funktionsnavn()

# Skriv første streng og konverter til heltal tal1 = raw_input( "Indskriv første integer: " ) tal1 = int( tal1)

# Skriv anden streng og konverter til heltal tal2 = raw_input( "Indskriv anden integer: " ) tal2 = int( tal2)

if tal1 == tal2: print "%d er lig med %d" % ( tal1, tal2)

if tal1!= 2: print "%d er forskellig fra %d" % ( tal1, tal2)

if tal1< 2: print "%d er mindre end %d" % ( tal1, tal2)

if tal1> 2: print "%d er større end %d" % ( tal1, tal2)

if tal1<= 2: print "%d er mindre end eller lig med %d" % ( tal1, tal2)

if tal1>= 2: print "%d er større end eller lig med %d" % ( tal1, tal2)

>>> heltal = 414 >>> heltal 414 >>> print heltal 414 >>> print "Decimaltal %d" % heltal Decimaltal 414 >>> print "Hexadecimal tal %x" % heltal Hexadecimal tal 19e

>>> for i in range(1,10): ... print "Oktale tal: %o"%i ... Oktale tal: 1 Oktale tal: 2 Oktale tal: 3 Oktale tal: 4 Oktale tal: 5 Oktale tal: 6 Oktale tal: 7 Oktale tal: 10 Oktale tal: 11

>>> kommatal = 12.4 >>> print "Kommatal (float) %f" % kommatal Kommatal (float) 12.400000 >>> print "Forvalgt eksponent %e" % kommatal Forvalgt eksponentnotation 1.240000e+01

>>> # Udskriver med fordefineret tabulatorbredde 8 tegn >>> heltal = 414 >>> print "Højre justeret heltal (%8d)" % heltal Højre justeret heltal ( 414) >>> print "Venstre justeret heltal (%-8d)" % heltal Venstre justeret heltal (414 )

streng = "Streng formatering" >>> heltal = 25 >>> print "Gennemtving 8 cifre i heltal %.8d" % heltal Gennemtving 8 cifre i heltal 00000025

>>> kommatal = 12.1 >>> print "Gennemtving 6 cifre efter komme i float %.6f " % kommatal Gennemtving 6 cifre efter komme i float 12.100000

>>> streng = "I alle de riger og lande..." >>> print "(%.15s) (%.5s)" % ( streng, streng ) (I alle de riger) (I all)

En streng er en liste. Her udskrives streng som liste: >>> s = "Dette er en streng." >>> l = len(s) # len finder strenglængde >>> for i in range(0,l): ... print s[i], ... D e t t e e r e n s t r e n g .

eks. 1 capitalize() funktionen konverterer strengens første bogstav til "stort" bogstav.

>>> import string >>> "dette er en mulig anvendelse".capitalize() 'Dette er en mulig anvendelse'

eks. 2 Eksempel 1 på en anden måde

>>> import string
>>> streng = "rødgrød med fløde er godt."
>>> streng.capitalize()
'R\xf8dgr\xf8d med fl\xf8de er godt.'
ELLER:
>>> print streng.capitalize()
Rødgrød med fløde er godt.

De fleste af de mange andre tekstfunktioner anvendes svarende til eksempel 1 og 2 ovenfor. BEMÆRK hvordan de danske specialtegn erstattes med hexadecimale værdier i den første udskrift. Det skyldes, at Python benytter 2 forskellige funktioner i immediate mode ved returneringen str() og repr(), hvad følgende kan vise:

>>> print str("rødgrød med fløde er godt.")
rødgrød med fløde er godt.
>>> print repr("rødgrød med fløde er godt.")
'r\xf8dgr\xf8d med fl\xf8de er godt.'

eks. 3 center(bredde)funktionen placerer en delstreng i en streng, hvis længde angives af det tal, der indsættes i parameterlisten her markeret med variablen bredde.

>>> import string
>>> streng = "Rønne er hovedstaden på Bornholm."
>>> s = streng.center(60)
>>> s
'             R\xf8nne er hovedstaden p\xe5 Bornholm.              '
>>> print s
             Rønne er hovedstaden på Bornholm.

Samme eksempel mere "naturlig":
>>> import string
>>> print "Rønne er hovedstaden på Bornholm.".center(60)
             Rønne er hovedstaden på Bornholm.

eks. 4// count(delstreng,begyndMed,slutMed) tæller antal forekomster af delstreng i streng.

>>> import string
>>> streng = "Rønne og Åkirkeby er to bornholmske byer."
>>> # Da der ikke er angivet hverken start- eller slutpunkt
>>> # tælles der op i hele strengen.
>>> streng.count("e")
5
>>> streng.count("e",6,15)
1

Eller:
>>> import string
>>> "Rønne og Åkirkeby er to bornholmske byer.".count("e")
5

eks. 5 endswith(delstreng, startplads, slutplads) funktionen fortæller, det den siger - om det er sandt/falskt at strengen slutter delstrengen. Som vi har set andre steder, så er 1 lig med sand, mens 0 betyder falsk.

>>> import string
>>> streng = "Hammershus er Nordeuropas største borgruin."
>>> streng.endswith(".")
1
>>> streng.endswith("n",10, len(streng) - 1)
1
>>> streng.endswith("n",10,12)
0

Eller:
>>> import string
>>> s1 = "Hammershus er Nordeuropas største borgruin.".endswith(".")
>>> strenglengde = len("Hammershus er Noreuropas største borgruin")
>>> s2 = "Hammershus er Nordeuropas største borgruin.".endswith("n",10,strenglengde)
>>> s3 = "Hammershus er Nordeuropas største borgruin.".endswith("n",10,12)
>>> print s1, s2, s3
True True False
>>> s1, s2, s3
(True, True, False)

Det første af de to eksempler er udført i Python 2.2, det sidste i Python 2.3 derfor forskellen i returneringen af sandhedsværdierne.

eks. 6// expandtabs([antalTomme]) returnerer en ny streng, hvori alle tabulatorstop er erstattet af mellemrum. Det valgfrie argument antalTomme specificerer antal mellemrum der erstatter en tabulatorindrykning. Det forvalgte antal er 8 tegn mellem hvert tabulatorstop. Bemærk \t for tabulator.

>>> import string

>>> t = "En streng\t streng"
>>> t
'En streng\t streng'
>>> t.expandtabs(30)
'En streng                      streng'

eks. 7 find(delstreng,startplads, slutplads) viser en delstrengs position i en streng.

>>> import string
>>> streng = "Børnene leger i skolegården."
>>> streng.find("ø")
1
>>> streng.find("å")
22

Hvis du tæller efter, synes det som om Python er gal på den - kan Python ikke regne? Jo, men det er vist et faktum i alle normale computersprog, at en streng er en form for tabel, og så er den god nok, for det er vist også fast, at en tabels første værdi er placeret som tabelelement nummer nul. Det betyder, at ø reelt er element nummer 1 og å element nummer 22 som vist ovenfor. Du kan opnå den "rigtige" position således:

>>> streng.find("ø") + 1
2

Funktionen returnerer -1, hvis ikke delstrengen findes.
>>> streng.find("ø",2,)
-1

eks. 8 index(delstreng, startplads, slutplads) viser en delstrengs position i en streng. Udfører samme funktion som find(delstreng, startplads, slutplads), men i stedet for at returnere -1 returneres en ValueError exception, hvis ikke delstrengen findes i strengen.

>>> import string
>>> streng = "Børnene leger i skolegården."
>>> streng.index("ø")
1
>>> streng.index("å")
22
>>> streng.index("q")
Traceback (most recent call last):
  File "<stdin>", line 1, in ?
ValueError: substring not found in string.index

Python melder to ting 1: fejlen findes i linje 1 (tabelcelle 2) og 2: delstrengen "ø" blev ikke fundet.

eks. 9 isalnum() returnerer 1 (sand), hvis strengen ene og alene indeholder alfanummeriske tegn (bogstaver og tal) ellers returneres nul.

>>> import string
>>> streng = "Bornholm2003"
>>> streng.isalnum()
1
>>> streng = "Bornholm 2003"
>>> streng.isalnum()
0

Der er en ASCII 32 (mellemrum) i strengen derfor 0.

eller:
>>> import string
>>> print "Bornholm2003".isalnum(),"Bornholm 2003".isalnum()
True False

eks. 10 isalpha() returnerer 1 hvis strengen ene og alene indeholder alfabetiske karakterer (bogstaver) ellers returneres 0

>>> import string
>>> streng = "Børnenelegeriskolegården"
>>> streng.isalpha()
1
>>> streng = "Børnene leger i skolegården."
>>> streng.isalpha()
0

eks. 11 isdigit() returnerer 1, hvis strengen ene og alene indeholder tal, ellers returneres 0.

>>> import string
>>> streng ="0123456789"
>>> streng.isdigit()
1
>>> streng ="0123456789 "
>>> streng.isdigit()
0
>>> streng ="0.123456789"
>>> streng.isdigit()
0

eks. 12 islower() funktionen returnerer 1, hvis alle bogstaver i strengen er "små".

>>> import string
>>> streng = "det er efterår nu"
>>> streng.islower()
1
>>> streng = "Det er efterår nu"
>>> streng.islower()
0
>>> streng = "vi er i efteråret 2003"
>>> streng.islower()
1

eller:
>>> import string
>>> "vi er i efteråret 2003.".islower()
True

eks. 13 isspace() returnerer 1, hvis strengen ene og alene indeholder tomme (ASCII 32) ellers returneres 0.

>>> streng = ""
>>> streng.isspace()
0
>>> streng = " "
>>> streng.isspace()
1
>>> streng = "    "
>>> streng.isspace()
1
>>> streng = " 1 "
>>> streng.isspace()
0
>>> streng = " K "
>>> streng.isspace()
0

eks. 14 istitle() I en engelsk bogtittel begynder det enkelte ord (som regel) med "store" bogstaver, deraf funktionsnavnet. Selve funktionen returnerer derfor 1, hvis der ene og alene forekommer "store" bogstaver som de enkelte ords første bogstav ellers returneres 0. Det kan føre til, at selv velkendte stavemåder kan returnere nul og omvendt, hvad dette eksempel vil vise:

>>> # Først den forkerte stavemåde:
>>> streng = "Suse Linux"
>>> streng.istitle()
1
>>> # Så den rigtige stavemåde:
>>> import string
>>> streng = "SuSE Linux"
>>> streng.istitle()
0

eks. 15// isupper() funktionen returnerer 1, hvis alle bogstaver i strengen er "store".

>>> import string
>>> streng = "SuSE Linux" # normale skrivemåde
>>> streng.isupper()
0
>>> streng = "SUSE LINUX" # unormal skrivemåde
>>> streng.isupper()
1
>>> streng = "SUSE LINUX 8.2"
>>> streng.isupper()
1

eks. 16 join(sekvens) knytter en strengliste (eller en delstreng) sammen med streng som "ordstyrer" og danner en lang streng.

>>> import string
>>> strengliste  = ["1","2","3","4","5","6"]
>>> streng
'123456'

eller: >>> streng = "".join(strengliste) + str(89) >>> streng '12345689'

eller:
>>> ". listeelement   ".join(strengliste) + ". listeelement."
'1. listeelement   2. listeelement   3. listeelement
4. listeelement   5. listeelement   6. listeelement.'
>>>

eks. 17 ljust(bredde) ligner center(bredde) funktionen, hvis anvendelse tidligere er vist. Her placeres delstrengen bare venstrejusteret i den tomme streng, hvis længde angives med breddeargumentet.

>>> import string
>>> streng = "Venstrejusteret".ljust(20)
>>> streng
'Venstrejusteret     '

eks. 18// lower() lower() konverterer alle bogstaver til "små".

>>> import string
>>> "DETTE ER KUN EN TESTSTRENG".lower()
'dette er kun en teststreng'

"Der skal 12 til et dusin.".lower()
'der skal 12 til et dusin.'

eks. 19// lstrip() fjerner tomme (ASCII 32) i strengens begyndelse - venstre side.

>>> import string
"    Dette er en teststreng.".lstrip()
'Dette er en teststreng.'

eks. 20 replace(gamle,nye,maksimale) erstatter en "gammel" tekstsreng med en ny. Hvis du ikke ønsker at udskifte samtlig eksistende "gamle" med nye, kan et maksimalt antal udskiftninger angives.

>>> import string
>>> "En plads i haven".replace("hav","sol")
'En plads i solen'

>>> 20 udskiftninger er ikke mulig, da der kun er 1
>>> "En plads i haven".replace("hav","sol",20)
'En plads i solen'

eks. 21 rfind(delstreng , startplads, slutplads) finder positionen af den sidste delstreng i en streng. Hvis delstrengen ikke findes returneres -1.

>>> import string
>>> streng = "Der er en klippefast grund til at besøge Bornholm."
>>> streng.rfind("e")
39

eller:
>>> import string
>>> "Der er en klippefast grund til at besøge Bornholm.".rfind("e")
39

eller:
>>> import string
>>> l = len("Der er en klippefast grund til at besøge Bornholm.")
>>> "Der er en klippefast grund til at besøge Bornholm.".rfind("e",len(streng) - 10,l)
-1

eks. 22 rindex(delstreng,startpunkt,slutpunkt) virker fuldstændig som rfind funktionen, men i stedet for at returnere -1, hvis delstrengen ikke findes returneres en ValueError.

>>> import string
>>> streng = "Tidligere anvendtes Dueoddes sand i timeglas."
>>> streng.rindex("i")
37
>>> streng.rindex("ven")
12
>>> streng.rindex("dk")
Traceback (most recent call last):
  File "<stdin>", line 1, in ?
ValueError: substring not found in string.rindex

Fejlmeldingen siger, at delstrengen "dk" ikke findes i streng.

eks. 23// rjust(bredde) svarer til center(bredde) og ljust(bredde) bortset fra at delstrengen her placeres højrejusteret i strengen.

>>> import string
>>> "h".rjust(30)
'                             h' # Et enkelt bogstav er også en streng.

eks. 24// rstrip() fjerner tomme (ASCII 32) i HØJRE side af en streng.

>>> # Python 2.2 afvikling:
>>> import string
>>> "    En unødvendig lang streng        ".rstrip()
'    En un\xf8dvendig lang streng'
>>> # Python 2.3 afvikling:
>>> import string
>>> print "    En unødvendig lang streng        ".rstrip()
    En unødvendig lang streng

eks. 25 split(seperator) Opdeler tekststreng i delstrenge, der indsættes i liste. Hvis ikke der indsættes seperator deles ved ASCII 32 (mellemrum).

>>> import string
>>> "Dette er kun en teststreng.".split()
['Dette', 'er', 'kun', 'en', 'teststreng.']

>>> "Dette\n er\n kun\n en teststreng.".split("\n")
['Dette', ' er', ' kun', ' en teststreng.']

eks. 26 split(seperator) Retuarnerer en liste af delstrenge dannet ved at dele den oprindelige streng ved hver seperator. Hvis seperatoren ikke anvendes eller er sat til None, deles strengen ved hver mellemrum (ASCII 32)

>>> import string
>>> "Tejn\nog\nGudjem\n er\nvelkendte turistbyer.".split()
['Tejn', 'og', 'Gudjem', 'er', 'velkendte', 'turistbyer.']
>>> "Tejn\nog\nGudjem\n er\nvelkendte turistbyer.".split("\n")
['Tejn', 'og', 'Gudjem', ' er', 'velkendte turistbyer.']

eks. 27 splitlines([1])returnerer en liste af delstrenge fremkommet ved at dele den oprindelige streng ved hver ny linje karakter. Hvis parameteret 1 indsættes bevares ny linje skiftet i delstrengene se nederste del af eksemplet.

>>> import string
>>> "Dette er\nen meget \nlang streng, \n der deles\ni delstrenge.".splitlines(1)
['Dette er\n', 'en meget \n', 'lang streng, \n', ' der deles\n', 'i delstrenge.']
>>> "Dette er en meget lang streng, der deles i delstrenge.".splitlines()
['Dette er en meget lang streng, der deles i delstrenge.']
>>> "Dette er\nen meget \nlang streng, \n der deles\ni delstrenge.".splitlines()
['Dette er', 'en meget ', 'lang streng, ', ' der deles', 'i delstrenge.']

eks. 28 startswith(delstreng,startpunkt,slutpunkt) returnerer 1, hvis strengen begynder med delstrengen ellers nul.

>>> import string
>>> "Denne streng er en violinstreng.".startswith("Den")
1
>>> "Denne streng er en violinstreng.".startswith("en")
0

eks. 29// strip() fjerner mellemrum i strengens begyndelse og slutning

>>> # Python 2.2 afvikling:
>>> import string
>>> "      Har du været på Christiansø?     ".strip()
'Har du v\xe6ret p\xe5 Christians\xf8?'
>>> import string
>>> "      Har du været på Christiansø?     ".strip()
'Har du v\xe6ret p\xe5 Christians\xf8?'
>>> print "      Har du været på Christiansø?     ".strip()
Har du været på Christiansø?

eks. 30// swapcase() konverterer alle "store" bogstaver til små og omvendt.

>>> import string
>>> "dANMARK ER VEL TRODS ALT ET GODT LAND.".swapcase()
'Danmark er vel trods alt et godt land.'
>>> "eR DANSKERNE ALT?".swapcase()
'Er danskerne alt?'

eks. 31 title() Returnerer en streng, hvori første bogstav af strengens enkeltord og kun dem er med stort begyndelsesbogstav.

>>> import string
>>> "er uldjyder lådne?".title()
'Er Uldjyder L\xe5dne?'

>>> "eR brAndMænd meget iltre?".title() 'Er Brandm\xe6nd Meget Iltre?'

eller:
>>> import string
>>> "er uldjyder lådne?".title()
'Er Uldjyder L\xe5dne?'
>>> s = "er uldjyder lådne?".title()
>>> print s
Er Uldjyder Lådne?

eks. 32// \upper() konverterer alle bogstaver til "store" bogstaver

>>> import string
>>> "var forfatteren nexø fra nexø?".upper()
'VAR FORFATTEREN NEX\xd8 FRA NEX\xd8?'

eller: >>> import string >>> "var forfatteren nexø fra nexø?".upper() 'VAR FORFATTEREN NEX\xd8 FRA NEX\xd8?' >>> print "var forfatteren nexø fra nexø?".upper() VAR FORFATTEREN NEXØ FRA NEXØ?

Brødmaskinen (slicing): >>> streng = "naturlig" >>> streng[4] 'r' >>> streng[0:2] 'na' >>> streng[2:4] 'tu' >>> streng[:2] 'na' >>> streng[2:] 'turlig' >>> 'u' + streng[1:] 'uaturlig' >>> streng[:2] + streng[2:] 'naturlig' >>> streng[:3] + streng[3:] 'naturlig' >>>

zfill funktionen gør det, den siger fylder op med zeros (nuller)
opfyldningen sker altid til venstre:
import string
string.zfill('12', 5)
'00012'
string.zfill('-3.14', 7)
'-003.14'
string.zfill('3.14159265359', 5)
'3.14159265359'