Python Language
Strängmetoder

Syntax

• str.capitalize () -> str
• str.casefold () -> str [endast för Python> 3.3]
• str.center (bredd [, fillchar]) -> str
• str.count (sub [, start [, slut]]) -> int
• str.decode (kodning = "utf-8" [, fel]) -> unicode [endast i Python 2.x]
• str.encode (kodning = "utf-8", fel = "strikt") -> byte
• str.endswith (suffix [, start [, slut]]) -> bool
• str.expandtabs (tabsstorlek = 8) -> str
• str.find (sub [, start [, slut]]) -> int
• str.format (* args, ** kwargs) -> str
• str.format_map (mapping) -> str
• str.index (sub [, start [, slut]]) -> int
• str.isalnum () -> bool
• str.isalpha () -> bool
• str.isdecimal () -> bool
• str.isdigit () -> bool
• str.isidentifier () -> bool
• str.islower () -> bool
• str.isnumeric () -> bool
• str.isprintable () -> bool
• str.isspace () -> bool
• str.istitle () -> bool
• str.isupper () -> bool
• str.join (iterable) -> str
• str.ljust (bredd [, fillchar]) -> str
• str.lower () -> str
• str.lstrip ([chars]) -> str
• statiska str.maketrans (x [, y [, z]])
• str.partition (sep) -> (head, sep, tail)
• str.replace (gammal, ny [, räkna]) -> str
• str.rfind (sub [, start [, slut]]) -> int
• str.rindex (sub [, start [, slut]]) -> int
• str.rjust (bredd [, fillchar]) -> str
• str.rpartition (sep) -> (huvud, sep, svans)
• str.rsplit (sep = Ingen, maxsplit = -1) -> lista över strängar
• str.rstrip ([chars]) -> str
• str.split (sep = Ingen, maxsplit = -1) -> lista över strängar
• str.splitlines ([keepends]) -> lista över strängar
• str.startswith (prefix [, start [, slut]]) -> bok
• str.strip ([chars]) -> str
• str.swapcase () -> str
• str.title () -> str
• str.translate (tabell) -> str
• str.upper () -> str
• str.zfill (bredd) -> str

Anmärkningar

Ändra bokstäver i en sträng

Pythons strängtyp tillhandahåller många funktioner som verkar på aktivering av en sträng. Dessa inkluderar :

• str.casefold
• str.upper
• str.lower
• str.capitalize
• str.title
• str.swapcase

Med strängar av unicode (standard i Python 3) är dessa operationer inte 1: 1-mappningar eller reversibla. De flesta av dessa operationer är avsedda för visningsändamål, snarare än för normalisering.

"XßΣ".casefold()
# 'xssσ'

"XßΣ".lower()
# 'xßς'

str.upper()

str.upper tar varje tecken i en sträng och konverterar det till dess stora ekvivalent, till exempel:

"This is a 'string'.".upper()
# "THIS IS A 'STRING'."

str.lower()

str.lower gör motsatsen; den tar varje karaktär i en sträng och konverterar den till dess motsvarande små bokstäver:

"This IS a 'string'.".lower()
# "this is a 'string'."

str.capitalize()

str.capitalize returnerar en str.capitalize av strängen, det vill säga det gör att det första tecknet har versaler och resten mindre:

"this Is A 'String'.".capitalize() # Capitalizes the first character and lowercases all others
# "This is a 'string'."

str.title()

str.title returnerar titeln kapslad version av strängen, det vill säga varje bokstav i början av ett ord görs med versaler och alla andra görs med små bokstäver:

"this Is a 'String'".title()
# "This Is A 'String'"

str.swapcase()

str.swapcase returnerar ett nytt str.swapcase där alla små bokstäver byts till versaler och alla stora bokstäver till små bokstäver:

"this iS A STRiNG".swapcase() #Swaps case of each character
# "THIS Is a strIng"

Användning som str klassmetoder

Det är värt att notera att dessa metoder kan anropas antingen på strängobjekt (som visas ovan) eller som en klassmetod i str klassen (med ett uttryckligt samtal till str.upper , etc.)

str.upper("This is a 'string'")
# "THIS IS A 'STRING'"

Detta är mest användbart vid tillämpningen av dessa metoder för att många strängar på en gång i säga, en map

map(str.upper,["These","are","some","'strings'"])
# ['THESE', 'ARE', 'SOME', "'STRINGS'"]

Dela upp en sträng baserad på en avgränsare i en lista med strängar

str.split(sep=None, maxsplit=-1)

str.split tar en sträng och returnerar en lista över underlag i den ursprungliga strängen. Beteendet varierar beroende på om sep argumentet tillhandahålls eller utelämnas.

Om sep inte tillhandahålls, eller är None , då uppdelningen sker överallt där det finns blank. Ledande och efterföljande vitrum ignoreras emellertid, och flera på varandra följande blankstegstecken behandlas på samma sätt som ett enda vitrumstecken:

>>> "This is a sentence.".split()
['This', 'is', 'a', 'sentence.']

>>> " This is    a sentence.  ".split()
['This', 'is', 'a', 'sentence.']

>>> "            ".split()
[]

sep parametern kan användas för att definiera en avgränsningssträng. Den ursprungliga strängen delas där avgränsningssträngen inträffar och själva avgränsaren kasseras. Flera upprepade avgränsare inte behandlas på samma sätt som en enda händelse, utan snarare leda till tomma strängar som ska skapas.

>>> "This is a sentence.".split(' ')
['This', 'is', 'a', 'sentence.']

>>> "Earth,Stars,Sun,Moon".split(',')
['Earth', 'Stars', 'Sun', 'Moon']

>>> " This is    a sentence.  ".split(' ')
['', 'This', 'is', '', '', '', 'a', 'sentence.', '', '']

>>> "This is a sentence.".split('e')
['This is a s', 'nt', 'nc', '.']

>>> "This is a sentence.".split('en')
['This is a s', 't', 'ce.']

Standardvärdet är att dela på varje förekomst av avgränsaren, men maxsplit parametern begränsar antalet uppdelningar som inträffar. Standardvärdet -1 betyder ingen gräns:

>>> "This is a sentence.".split('e', maxsplit=0)
['This is a sentence.']

>>> "This is a sentence.".split('e', maxsplit=1)
['This is a s', 'ntence.']

>>> "This is a sentence.".split('e', maxsplit=2)
['This is a s', 'nt', 'nce.']

>>> "This is a sentence.".split('e', maxsplit=-1)
['This is a s', 'nt', 'nc', '.']

str.rsplit(sep=None, maxsplit=-1)

str.rsplit ("höger split") skiljer sig från str.split ("vänster split") när maxsplit anges. Delningen börjar i slutet av strängen snarare än i början:

>>> "This is a sentence.".rsplit('e', maxsplit=1)
['This is a sentenc', '.']

>>> "This is a sentence.".rsplit('e', maxsplit=2)
['This is a sent', 'nc', '.']

Obs : Python specificerar det maximala antalet uppdelade split, medan de flesta andra programmeringsspråk anger det maximala antalet underlag som skapats. Detta kan skapa förvirring vid porting eller jämförelse av kod.

Byt ut alla förekomster av en substring med en annan substring

Pythons str har också en metod för att ersätta förekomster av en substräng med en annan substräng i en given sträng. För mer krävande fall kan man använda re.sub .

str.replace(old, new[, count]) :

str.replace tar två old och new argument som innehåller den old understrängen som ska ersättas av den new understrängen. Den valfria argument count anger antalet byten som ska göras:

För att exempelvis ersätta 'foo' med 'spam' i följande sträng kan vi ringa str.replace med old = 'foo' och new = 'spam' :

>>> "Make sure to foo your sentence.".replace('foo', 'spam')
"Make sure to spam your sentence."

Om den givna strängen innehåller flera exempel som matchar det old argumentet, ersätts alla händelser med värdet som levereras i new :

>>> "It can foo multiple examples of foo if you want.".replace('foo', 'spam')
"It can spam multiple examples of spam if you want."

såvida vi naturligtvis inte ger ett värde för count . I detta fall kommer count händelser att ersättas:

>>> """It can foo multiple examples of foo if you want, \
... or you can limit the foo with the third argument.""".replace('foo', 'spam', 1)
'It can spam multiple examples of foo if you want, or you can limit the foo with the third argument.'

str.format och f-strängar: Formatera värden i en sträng

Python tillhandahåller stränginterpolering och formateringsfunktioner genom str.format funktionen, introducerad i version 2.6 och f-strängar introducerade i version 3.6.

Följande variabler:

i = 10
f = 1.5
s = "foo"
l = ['a', 1, 2]
d = {'a': 1, 2: 'foo'}

Följande uttalanden är alla likvärdiga

"10 1.5 foo ['a', 1, 2] {'a': 1, 2: 'foo'}"

>>> "{} {} {} {} {}".format(i, f, s, l, d)

>>> str.format("{} {} {} {} {}", i, f, s, l, d)

>>> "{0} {1} {2} {3} {4}".format(i, f, s, l, d)

>>> "{0:d} {1:0.1f} {2} {3!r} {4!r}".format(i, f, s, l, d)

>>> "{i:d} {f:0.1f} {s} {l!r} {d!r}".format(i=i, f=f, s=s, l=l, d=d)

>>> f"{i} {f} {s} {l} {d}"

>>> f"{i:d} {f:0.1f} {s} {l!r} {d!r}"

Som referens stöder Python också kvalificeringar i C-stil för strängformatering. Exemplen nedan är likvärdiga med ovanstående, men str.format versionerna är att föredra på grund av fördelar med flexibilitet, notationskonsistens och utdragbarhet:

"%d %0.1f %s %r %r" % (i, f, s, l, d)

"%(i)d %(f)0.1f %(s)s %(l)r %(d)r" % dict(i=i, f=f, s=s, l=l, d=d)

Stödet som används för interpolering i str.format kan också numreras för att minska dubblering vid formatering av strängar. Till exempel är följande likvärdiga:

"I am from Australia. I love cupcakes from Australia!"

>>> "I am from {}. I love cupcakes from {}!".format("Australia", "Australia")

>>> "I am from {0}. I love cupcakes from {0}!".format("Australia")

Medan den officiella pytondokumentationen är, som vanligt noggrann, har pyformat.info en stor uppsättning exempel med detaljerade förklaringar.

Dessutom kan { och } tecken undkommas med hjälp av dubbla parenteser:

"{'a': 5, 'b': 6}"

>>> "{{'{}': {}, '{}': {}}}".format("a", 5, "b", 6)

>>> f"{{'{'a'}': {5}, '{'b'}': {6}}"

Se Strängformatering för ytterligare information. str.format() föreslogs i PEP 3101 och f-strängar i PEP 498 .

Räknar antal gånger en substring visas i en sträng

En metod är tillgänglig för att räkna antalet förekomster av en understräng i en annan sträng, str.count .

str.count(sub[, start[, end]])

str.count returnerar en int som indikerar antalet icke överlappande förekomster av sub-string sub i en annan sträng. De valfria argumenten start och end anger början och slutet där sökningen kommer att ske. Som standard start = 0 och end = len(str) betyder att hela strängen kommer att sökas:

>>> s = "She sells seashells by the seashore."
>>> s.count("sh")
2
>>> s.count("se")
3
>>> s.count("sea")
2
>>> s.count("seashells")
1

Genom att ange ett annat värde för start , end vi få en mer lokaliserad sökning och räkna till exempel om start är lika med 13 samtalet till:

>>> s.count("sea", start)
1

är ekvivalent med:

>>> t = s[start:]
>>> t.count("sea")
1

Testa början och slutet av en sträng

För att testa början och slutet av en given sträng i Python kan man använda metoderna str.startswith() och str.endswith() .

str.startswith(prefix[, start[, end]])

Som namnet antyder används str.startswith för att testa om en given sträng börjar med de givna tecknen i prefix .

>>> s = "This is a test string"
>>> s.startswith("T")
True
>>> s.startswith("Thi")
True
>>> s.startswith("thi")  
False

De valfria argumenten start och end anger start- och slutpunkter från vilka testningen kommer att börja och slutas. I följande exempel, genom att ange ett startvärde på 2 vår sträng att sökas från position 2 och därefter:

>>> s.startswith("is", 2)
True

Detta ger True eftersom s[2] == 'i' och s[3] == 's' .

Du kan också använda en tuple att kontrollera om det börjar med någon av en uppsättning strängar

>>> s.startswith(('This', 'That'))
True
>>> s.startswith(('ab', 'bc'))
False

str.endswith(prefix[, start[, end]])

str.endswith liknar exakt str.startswith med den enda skillnaden är att den söker efter avslutande tecken och inte starttecken. För att testa om en sträng slutar på ett fullständigt stopp kan man till exempel skriva:

>>> s = "this ends in a full stop."
>>> s.endswith('.')
True
>>> s.endswith('!')
False

som med startswith mer än ett tecken kan användas som avslutande sekvens:

>>> s.endswith('stop.')
True
>>> s.endswith('Stop.')
False

Du kan också använda en tuple att kontrollera om det slutar med någon av en uppsättning strängar

>>> s.endswith(('.', 'something'))
True
>>> s.endswith(('ab', 'bc'))
False

Testa vad en sträng består av

Pythons str innehåller också ett antal metoder som kan användas för att utvärdera innehållet i en sträng. Dessa är str.isalpha , str.isdigit , str.isalnum , str.isspace . Bokstäver kan testas med str.isupper , str.islower och str.istitle .

str.isalpha

str.isalpha tar inga argument och returnerar True om alla tecken i en given sträng är alfabetiska, till exempel:

>>> "Hello World".isalpha()  # contains a space
False
>>> "Hello2World".isalpha()  # contains a number
False
>>> "HelloWorld!".isalpha()  # contains punctuation
False
>>> "HelloWorld".isalpha()
True

Som ett kantfall utvärderar den tomma strängen till False när den används med "".isalpha() .

str.isupper , str.islower , str.istitle

Dessa metoder testar versalerna i en given sträng.

str.isupper är en metod som returnerar True om alla tecken i en given sträng är stora och False annars.

>>> "HeLLO WORLD".isupper()
False
>>> "HELLO WORLD".isupper()
True
>>> "".isupper()
False

Omvänt är str.islower en metod som returnerar True om alla tecken i en given sträng är små och False annars.

>>> "Hello world".islower()
False
>>> "hello world".islower()
True
>>> "".islower()
False

str.istitle returnerar True om den givna strängen är titelhasad; det vill säga, varje ord börjar med ett stort tecken följt av små bokstäver.

>>> "hello world".istitle()
False
>>> "Hello world".istitle()
False
>>> "Hello World".istitle()
True
>>> "".istitle()
False

str.isdecimal , str.isdigit , str.isnumeric

str.isdecimal returnerar om strängen är en sekvens med decimala siffror, lämplig för att representera ett decimaltal.

str.isdigit inkluderar siffror som inte är i en form som är lämplig för att representera ett decimaltal, såsom superskriptsiffror.

str.isnumeric innehåller alla värden, även om inte siffror, till exempel värden utanför intervallet 0-9.

            isdecimal    isdigit   isnumeric

12345        True        True       True
១2߃໔5        True        True       True
①²³🄅₅       False       True       True
⑩⒓          False       False      True
Five         False       False      False

Bytestringar ( bytes i Python 3, str i Python 2), stöder endast isdigit , som bara kontrollerar för grundläggande ASCII-siffror.

Som med str.isalpha den tomma strängen till False .

str.isalnum

Detta är en kombination av str.isalpha och str.isnumeric , specifikt utvärderar det till True om alla tecken i den givna strängen är alfanumeriska , det vill säga de består av alfabetiska eller numeriska tecken:

>>> "Hello2World".isalnum()
True
>>> "HelloWorld".isalnum()
True
>>> "2016".isalnum()
True
>>> "Hello World".isalnum()  # contains whitespace
False

str.isspace

Utvärderar till True om strängen bara innehåller blankstegstecken.

>>> "\t\r\n".isspace()
True
>>> " ".isspace()
True

Ibland ser en sträng “tom” ut men vi vet inte om det beror på att det bara innehåller blanksteg eller inget tecken alls

>>> "".isspace()
False

För att täcka detta fall behöver vi ett ytterligare test

>>> my_str = ''
>>> my_str.isspace()
False
>>> my_str.isspace() or not my_str
True

Men det kortaste sättet att testa om en sträng är tom eller bara innehåller whitespace-tecken är att använda strip (utan några argument tar det bort alla ledande och efterföljande whitespace-tecken)

>>> not my_str.strip()
True

str.translate: Översätta tecken i en sträng

Python stöder en translate på str typen som gör att du kan specificera översättningstabellen (används för ersättningar) samt alla tecken som bör tas bort i processen.

str.translate(table[, deletechars])

maketrans metoden ( str.maketrans i Python 3 och string.maketrans i Python 2) låter dig skapa en översättningstabell.

>>> translation_table = str.maketrans("aeiou", "12345")
>>> my_string = "This is a string!"
>>> translated = my_string.translate(translation_table)
'Th3s 3s 1 str3ng!'

translate returnerar en sträng som är en översatt kopia av den ursprungliga strängen.

Du kan ställa in table argument till None om du bara behöver ta bort tecken.

>>> 'this syntax is very useful'.translate(None, 'aeiou')
'ths syntx s vry sfl'

Avlägsna oönskade ledande / efterföljande tecken från en sträng

Tre metoder tillhandahålls som erbjuder möjligheten att ta bort ledande och efterföljande tecken från en sträng: str.strip , str.rstrip och str.lstrip . Alla tre metoderna har samma signatur och alla tre returnerar ett nytt strängobjekt med oönskade tecken bort.

str.strip([chars])

str.strip verkar på en given sträng och avlägsnar (remsor) eventuella inledande eller avslutande tecken som finns i argument chars ; om chars inte levereras eller är None , tas alla vitrumstecken bort som standard. Till exempel:

>>> "    a line with leading and trailing space     ".strip() 
'a line with leading and trailing space'

Om chars levereras tas alla tecken i den bort från strängen, som returneras. Till exempel:

>>> ">>> a Python prompt".strip('> ')  # strips '>' character and space character 
'a Python prompt'

str.rstrip([chars]) och str.lstrip([chars])

Dessa metoder har liknande semantik och argument med str.strip() , deras skillnad ligger i den riktning de börjar från. str.rstrip() startar från strängens slut medan str.lstrip() delas från strängens början.

str.rstrip till exempel str.rstrip :

>>> "     spacious string      ".rstrip()
'     spacious string'

Medan du använder str.lstrip :

>>> "     spacious string      ".rstrip()
'spacious string      '

Jämförelse av obetydliga strängar i fall

Att jämföra sträng på ett okänsligt sätt verkar vara något som är trivialt, men det är det inte. Det här avsnittet behandlar endast unicode-strängar (standard i Python 3). Observera att Python 2 kan ha subtila svagheter i förhållande till Python 3 - den senare hanteringen av unicode är mycket mer fullständig.

Det första att notera att konverteringar i unicode inte är triviala. Det finns text för vilken text.lower() != text.upper().lower() , till exempel "ß" :

>>> "ß".lower()
'ß'

>>> "ß".upper().lower()
'ss'

Men låt oss säga att du ville slumpmässigt jämföra "BUSSE" och "Buße" . Heck, du vill antagligen också jämföra "BUSSE" och "BUẞE" lika - det är den nyare kapitalformen. Det rekommenderade sättet är att använda casefold :

>>> help(str.casefold)
"""
Help on method_descriptor:

casefold(...)
      S.casefold() -> str
    
     Return a version of S suitable for caseless comparisons.
"""

Använd inte bara lower . Om casefold inte är tillgängligt .upper().lower() göra .upper().lower() (men bara något).

Då bör du överväga accenter. Om din teckensnitt återgivare är bra, tror du antagligen "ê" == "ê" - men det gör inte:

>>> "ê" == "ê"
False

Det beror på att de faktiskt är det

>>> import unicodedata

>>> [unicodedata.name(char) for char in "ê"]
['LATIN SMALL LETTER E WITH CIRCUMFLEX']

>>> [unicodedata.name(char) for char in "ê"]
['LATIN SMALL LETTER E', 'COMBINING CIRCUMFLEX ACCENT']

Det enklaste sättet att hantera detta är unicodedata.normalize . Du vill förmodligen använda NFKD- normalisering, men känn dig fri att kontrollera dokumentationen. Då gör man det

>>> unicodedata.normalize("NFKD", "ê") == unicodedata.normalize("NFKD", "ê")
True

För att avsluta, här uttrycks detta i funktioner:

import unicodedata

def normalize_caseless(text):
    return unicodedata.normalize("NFKD", text.casefold())

def caseless_equal(left, right):
    return normalize_caseless(left) == normalize_caseless(right)

Gå med i en lista med strängar i en sträng

En sträng kan användas som separator för att ansluta en lista med strängar till en enda sträng med hjälp av metoden join() . Till exempel kan du skapa en sträng där varje element i en lista är separerat med ett mellanslag.

>>> " ".join(["once","upon","a","time"])
"once upon a time"

Följande exempel separerar strängelementen med tre bindestreck.

>>> "---".join(["once", "upon", "a", "time"])
"once---upon---a---time"

Strängmodulens användbara konstanter

Pythons string tillhandahåller konstanter för strängrelaterade operationer. För att använda dem, importera string :

>>> import string

string.ascii_letters :

Sammankoppling av ascii_lowercase och ascii_uppercase :

>>> string.ascii_letters
'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'

string.ascii_lowercase :

Innehåller alla små bokstäver ASCII-tecken:

>>> string.ascii_lowercase
'abcdefghijklmnopqrstuvwxyz'

string.ascii_uppercase :

Innehåller alla stora bokstäver ASCII-tecken:

>>> string.ascii_uppercase
'ABCDEFGHIJKLMNOPQRSTUVWXYZ'

string.digits :

Innehåller alla decimaltecken:

>>> string.digits
'0123456789'

string.hexdigits :

Innehåller alla hexsiffriga tecken:

>>> string.hexdigits
'0123456789abcdefABCDEF'

string.octaldigits :

Innehåller alla octalsiffriga tecken:

>>> string.octaldigits
'01234567'

string.punctuation :

Innehåller alla tecken som betraktas som skiljetecken i C språk:

>>> string.punctuation
'!"#$%&\'()*+,-./:;<=>?@[\\]^_`{|}~'

string.whitespace :

Innehåller alla ASCII-tecken som betraktas som mellanrum:

>>> string.whitespace
' \t\n\r\x0b\x0c'

I print(string.whitespace) kommer print(string.whitespace) att skriva ut de faktiska tecknen, använd str att få strängen tillbaka ovan.

string.printable :

Innehåller alla tecken som anses vara utskrivbara; en kombination av string.digits , string.ascii_letters , string.punctuation och string.whitespace .

>>> string.printable
'0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ!"#$%&\'()*+,-./:;<=>?@[\\]^_`{|}~ \t\n\r\x0b\x0c'

Omvänd en sträng

En sträng kan vändas med den inbyggda reversed() -funktionen, som tar en sträng och returnerar en iterator i omvänd ordning.

>>> reversed('hello')
<reversed object at 0x0000000000000000>
>>> [char for char in reversed('hello')]
['o', 'l', 'l', 'e', 'h']

reversed() kan lindas i ett samtal till ''.join() att skapa en sträng från iteratorn.

>>> ''.join(reversed('hello'))
'olleh'

När du använder reversed() kan vara mer läsbart för oinitierade Python-användare, är det snabbare och kortare att använda utökad skivning med ett steg på -1 . Försök här att implementera det som funktion:

>>> def reversed_string(main_string):
...     return main_string[::-1]
...
>>> reversed_string('hello')
'olleh'

Motivera strängar

Python tillhandahåller funktioner för att rättfärdiga strängar, vilket gör det möjligt för textfyllning att göra justering av olika strängar mycket enklare.

Nedan är ett exempel på str.ljust och str.rjust :

interstates_lengths = {
    5: (1381, 2222),
    19: (63, 102),
    40: (2555, 4112),
    93: (189,305),
}
for road, length in interstates_lengths.items():
    miles,kms = length
    print('{} -> {} mi. ({} km.)'.format(str(road).rjust(4), str(miles).ljust(4), str(kms).ljust(4)))

  40 -> 2555 mi. (4112 km.)
  19 -> 63   mi. (102  km.)
   5 -> 1381 mi. (2222 km.)
  93 -> 189  mi. (305  km.)

ljust och rjust är mycket lika. Båda har en width parameter och en valfri fillchar parameter. Varje sträng som skapats av dessa funktioner är åtminstone så länge som width parameter som skickades till funktionen. Om strängen är längre än width är den inte trunkerad. fillchar , som är standard som mellanslagstecken ' ' måste vara ett enda tecken, inte en sträng med flera karaktärer.

ljust funktionen ljust slutet av strängen som den kallas på med fillchar tills den är width lång. rjust funktionen rjust början av strängen på liknande sätt. Därför hänvisar l och r i namnen på dessa funktioner till den sida som den ursprungliga strängen, inte fillchar , är placerad i utsträngen.

Konvertering mellan str- eller bytesdata och unicode-tecken

Innehållet i filer och nätverksmeddelanden kan representera kodade tecken. De behöver ofta konverteras till unicode för korrekt visning.

I Python 2 kan du behöva konvertera str-data till Unicode-tecken. Standardvärdet ( '' , "" , etc.) är en ASCII-sträng, med alla värden utanför ASCII-intervallet visas som undkomna värden. Unicode-strängar är u'' (eller u"" , etc.).

# You get "© abc" encoded in UTF-8 from a file, network, or other data source

s = '\xc2\xa9 abc'  # s is a byte array, not a string of characters
                    # Doesn't know the original was UTF-8
                    # Default form of string literals in Python 2
s[0]                # '\xc2' - meaningless byte (without context such as an encoding)
type(s)             # str - even though it's not a useful one w/o having a known encoding

u = s.decode('utf-8')  # u'\xa9 abc'
                       # Now we have a Unicode string, which can be read as UTF-8 and printed properly
                       # In Python 2, Unicode string literals need a leading u
                       # str.decode converts a string which may contain escaped bytes to a Unicode string
u[0]                # u'\xa9' - Unicode Character 'COPYRIGHT SIGN' (U+00A9) '©'
type(u)             # unicode

u.encode('utf-8')   # '\xc2\xa9 abc'
                    # unicode.encode produces a string with escaped bytes for non-ASCII characters

I Python 3 kan du behöva konvertera matriser av byte (kallas 'byte letteral') till strängar av Unicode-tecken. Standard är nu en Unicode-sträng, och bytestring-bokstäver måste nu anges som b'' , b"" , etc. En byte-bokstav kommer att returnera True to isinstance(some_val, byte) , förutsatt att some_val är en sträng som kan kodas som byte.

# You get from file or network "© abc" encoded in UTF-8

s = b'\xc2\xa9 abc' # s is a byte array, not characters
                    # In Python 3, the default string literal is Unicode; byte array literals need a leading b
s[0]                # b'\xc2' - meaningless byte (without context such as an encoding)
type(s)             # bytes - now that byte arrays are explicit, Python can show that.

u = s.decode('utf-8')  # '© abc' on a Unicode terminal
                       # bytes.decode converts a byte array to a string (which will, in Python 3, be Unicode)
u[0]                # '\u00a9' - Unicode Character 'COPYRIGHT SIGN' (U+00A9) '©'
type(u)             # str
                    # The default string literal in Python 3 is UTF-8 Unicode

u.encode('utf-8')   # b'\xc2\xa9 abc'
                    # str.encode produces a byte array, showing ASCII-range bytes as unescaped characters.

Sträng innehåller

Python gör det extremt intuitivt att kontrollera om en sträng innehåller en given substring. Använd bara in operatören:

>>> "foo" in "foo.baz.bar"
True

Obs! Att testa en tom sträng resulterar alltid i True :

>>> "" in "test"
True