Python Language
String methoden

Syntaxis

• str.capitalize () -> str
• str.casefold () -> str [alleen voor Python> 3.3]
• str.center (width [, fillchar]) -> str
• str.count (sub [, start [, einde]]) -> int
• str.decode (encoding = "utf-8" [, fouten]) -> unicode [alleen in Python 2.x]
• str.encode (encoding = "utf-8", errors = "strict") -> bytes
• str.endswith (achtervoegsel [, start [, einde]]) -> bool
• str.expandtabs (tabsize = 8) -> str
• str.find (sub [, start [, einde]]) -> int
• str.format (* args, ** kwargs) -> str
• str.format_map (mapping) -> str
• str.index (sub [, start [, einde]]) -> 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 (width [, fillchar]) -> str
• str.lower () -> str
• str.lstrip ([tekens]) -> str
• statische str.maketrans (x [, y [, z]])
• str.partition (sep) -> (kop, sep, staart)
• str.replace (oud, nieuw [, count]) -> str
• str.rfind (sub [, start [, einde]]) -> int
• str.rindex (sub [, start [, einde]]) -> int
• str.rjust (width [, fillchar]) -> str
• str.rpartition (sep) -> (kop, sep, staart)
• str.rsplit (sep = None, maxsplit = -1) -> lijst met strings
• str.rstrip ([tekens]) -> str
• str.split (sep = None, maxsplit = -1) -> lijst met strings
• str.splitlines ([keepends]) -> lijst met strings
• str.startswith (voorvoegsel [, start [, einde]]) -> boek
• str.strip ([tekens]) -> str
• str.swapcase () -> str
• str.title () -> str
• str.translate (tabel) -> str
• str.upper () -> str
• str.zfill (breedte) -> str

Opmerkingen

De hoofdletters van een string wijzigen

Het stringtype van Python biedt vele functies die werken op het gebruik van een hoofdletter. Waaronder :

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

Met Unicode-strings (de standaard in Python 3) zijn deze bewerkingen niet 1: 1-toewijzingen of omkeerbaar. De meeste van deze bewerkingen zijn bedoeld voor weergavedoeleinden, in plaats van voor normalisatie.

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

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

str.upper()

str.upper neemt elk karakter in een string en converteert het naar zijn hoofdletter equivalent, bijvoorbeeld:

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

str.lower()

str.lower doet het tegenovergestelde; het neemt elk teken in een string en converteert het naar het equivalent in kleine letters:

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

str.capitalize()

str.capitalize retourneert een versie met hoofdletter van de tekenreeks, dat wil zeggen dat het eerste teken een hoofdletter en de rest een lagere waarde heeft:

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

str.title()

str.title geeft de titelversie van de string terug, dat wil zeggen dat elke letter aan het begin van een woord in hoofdletters wordt geplaatst en alle andere in kleine letters:

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

str.swapcase()

str.swapcase retourneert een nieuw tekenreeksobject waarin alle kleine letters worden omgezet in hoofdletters en alle hoofdletters om kleine letters:

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

Gebruik als str class methoden

Het is vermeldenswaard dat deze methoden kunnen worden gebruikt op stringobjecten (zoals hierboven weergegeven) of als een klassenmethode van de str klasse (met een expliciete aanroep naar str.upper , enz.)

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

Dit is erg handig bij het aanbrengen van een van deze methoden om een groot aantal strings in een keer in zeg, een map functie.

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

Splits een tekenreeks op basis van een scheidingsteken in een lijst met tekenreeksen

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

str.split neemt een string en retourneert een lijst met subtekenreeksen van de oorspronkelijke string. Het gedrag verschilt afhankelijk van of het sep argument wordt gegeven of weggelaten.

Als er geen sep is, of None , vindt de splitsing plaats waar er witruimte is. Voorloop- en volgspaties worden echter genegeerd en meerdere opeenvolgende witruimtetekens worden op dezelfde manier behandeld als een enkel witruimteteken:

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

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

>>> "            ".split()
[]

De parameter sep kan worden gebruikt om een scheidingstekenreeks te definiëren. De oorspronkelijke tekenreeks wordt gesplitst waar de scheidingsteken voorkomt en het scheidingsteken zelf wordt verwijderd. Meerdere opeenvolgende scheidingstekens worden niet hetzelfde behandeld als een enkele gebeurtenis, maar veroorzaken eerder lege tekenreeksen.

>>> "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.']

De standaardinstelling is splitsen bij elk voorkomen van het scheidingsteken, maar de parameter maxsplit beperkt het aantal splitsingen die optreden. De standaardwaarde van -1 betekent geen limiet:

>>> "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 ("right split") verschilt van str.split ("left split") wanneer maxsplit is opgegeven. Het splitsen begint aan het einde van de string in plaats van aan het begin:

>>> "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', '.']

Opmerking : Python geeft het maximale aantal uitgevoerde splitsingen aan , terwijl de meeste andere programmeertalen het maximale aantal gemaakte substrings specificeren. Dit kan verwarring veroorzaken bij het overdragen of vergelijken van code.

Vervang alle exemplaren van een substring door een andere substring

Het str type van Python heeft ook een methode voor het vervangen van exemplaren van een subtekenreeks door een andere subtekenreeks in een gegeven string. Voor meer veeleisende gevallen kan men re.sub .

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

str.replace neemt twee argumenten old en new met de old str.replace die moet worden vervangen door de new str.replace . Het optionele argument count geeft het aantal vervangingen worden gemaakt:

Om bijvoorbeeld 'foo' te vervangen door 'spam' in de volgende string, kunnen we str.replace met old = 'foo' en new = 'spam' :

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

Als de gegeven string meerdere voorbeelden bevat die overeenkomen met het old argument, worden alle exemplaren vervangen door de waarde die in new opgegeven:

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

tenzij we natuurlijk een waarde voor count . In dit geval worden count keren vervangen:

>>> """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 en f-strings: waarden opmaken in een string

Python biedt stringinterpolatie en opmaakfunctionaliteit via de str.format functie, geïntroduceerd in versie 2.6 en f-strings geïntroduceerd in versie 3.6.

Gegeven de volgende variabelen:

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

De volgende verklaringen zijn allemaal gelijkwaardig

"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}"

Ter referentie, Python ondersteunt ook kwalificaties in C-stijl voor stringopmaak. De onderstaande voorbeelden zijn gelijkwaardig aan die hierboven, maar de str.format versies hebben de voorkeur vanwege de voordelen in flexibiliteit, consistentie van notatie en uitbreidbaarheid:

"%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)

De accolades die worden gebruikt voor interpolatie in str.format kunnen ook worden genummerd om duplicatie te verminderen bij het formatteren van tekenreeksen. Het volgende is bijvoorbeeld gelijkwaardig:

"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")

Hoewel de officiële python-documentatie, zoals gebruikelijk, grondig genoeg is, heeft pyformat.info een groot aantal voorbeelden met gedetailleerde uitleg.

Bovendien kunnen de tekens { en } worden overgeslagen met dubbele haakjes:

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

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

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

Zie Stringopmaak voor meer informatie. str.format() werd voorgesteld in PEP 3101 en f-strings in PEP 498 .

Aantal keren geteld dat een substring in een string verschijnt

Er is een methode beschikbaar voor het tellen van het aantal str.count een subreeks voorkomt in een andere reeks, str.count .

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

str.count retourneert een int die het aantal niet-overlappende gebeurtenissen van de str.count - sub in een andere string aangeeft. De optionele argumenten start en end geven het begin en het einde aan waarin de zoekopdracht zal plaatsvinden. Standaard start = 0 en end = len(str) wat betekent dat de hele string wordt doorzocht:

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

Door een andere waarde voor start , end , kunnen we een meer gelokaliseerde zoekopdracht krijgen en bijvoorbeeld tellen als start gelijk is aan 13 de oproep voor:

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

is gelijk aan:

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

Test de begin- en eindtekens van een string

Om het begin en einde van een gegeven string in Python te testen, kan men de methoden str.startswith() en str.endswith() .

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

Zoals de naam al aangeeft, wordt str.startswith gebruikt om te testen of een bepaalde string begint met de gegeven tekens in het prefix .

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

De optionele argumenten start en end specificeren het begin- en eindpunt vanaf waar de test zal beginnen en eindigen. In het volgende voorbeeld, door een startwaarde van 2 onze string gezocht vanaf positie 2 en daarna:

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

Dit levert True omdat s[2] == 'i' en s[3] == 's' .

Je kunt ook een tuple om te controleren of deze begint met een van een reeks tekenreeksen

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

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

str.endswith is exact gelijk aan str.startswith met het enige verschil dat het zoekt naar str.startswith en niet naar str.startswith . Om bijvoorbeeld te testen of een string eindigt op een punt, zou men kunnen schrijven:

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

zoals bij startswith meer dan één tekens kunnen worden gebruikt als de eindsequentie:

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

Je kunt ook een tuple om te controleren of deze eindigt met een van een reeks tekenreeksen

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

Testen waaruit een string bestaat

Het str type van Python heeft ook een aantal methoden die kunnen worden gebruikt om de inhoud van een string te evalueren. Dit zijn str.isalpha , str.isdigit , str.isalnum , str.isspace . Hoofdlettergebruik kan worden getest met str.isupper , str.islower en str.istitle .

str.isalpha

str.isalpha neemt geen argumenten en retourneert True als alle tekens in een gegeven string alfabetisch zijn, bijvoorbeeld:

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

Als "".isalpha() wordt de lege string geëvalueerd als False bij gebruik met "".isalpha() .

str.isupper , str.islower , str.istitle

Deze methoden testen het hoofdlettergebruik in een gegeven string.

str.isupper is een methode die True retourneert als alle tekens in een gegeven string in hoofdletters en anders False zijn.

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

Omgekeerd is str.islower een methode die True retourneert als alle tekens in een gegeven string kleine letters zijn en anders False .

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

str.istitle retourneert True als de gegeven string de titel cased heeft; dat wil zeggen, elk woord begint met een hoofdletter gevolgd door kleine letters.

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

str.isdecimal , str.isdigit , str.isnumeric

str.isdecimal geeft terug of de string een reeks decimale cijfers is, geschikt om een decimaal getal weer te geven.

str.isdigit bevat cijfers die niet geschikt zijn om een decimaal getal weer te geven, zoals superscriptcijfers.

str.isnumeric bevat alle getalswaarden, zelfs als deze geen cijfers zijn, zoals waarden buiten het bereik 0-9.

            isdecimal    isdigit   isnumeric

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

Bytestrings ( bytes in Python 3, str in Python 2), ondersteunen alleen isdigit , die alleen controleert op basis-ASCII-cijfers.

Net als bij str.isalpha wordt de lege string als False geëvalueerd.

str.isalnum

Dit is een combinatie van str.isalpha en str.isnumeric , specifiek wordt geëvalueerd als True als alle tekens in de gegeven string alfanumeriek zijn , dat wil zeggen dat ze uit alfabetische of numerieke tekens bestaan:

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

str.isspace

Evalueert naar True als de tekenreeks alleen witruimtetekens bevat.

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

Soms ziet een string er "leeg" uit, maar we weten niet of het komt omdat het alleen witruimte of helemaal geen karakter bevat

>>> "".isspace()
False

Om dit geval te dekken, hebben we een aanvullende test nodig

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

Maar de kortste manier om te testen of een string leeg is of alleen witruimte-tekens bevat, is door strip te gebruiken (zonder argumenten verwijdert het alle voorloop- en volgstand-witruimte tekens)

>>> not my_str.strip()
True

str.translate: tekens in een string vertalen

Python ondersteunt een translate op het str type waarmee u de vertaaltabel (gebruikt voor vervangingen) kunt opgeven, evenals tekens die tijdens het proces moeten worden verwijderd.

str.translate(table[, deletechars])

Met de methode maketrans ( str.maketrans in Python 3 en string.maketrans in Python 2) kunt u een vertaaltabel genereren.

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

De translate retourneert een tekenreeks die een vertaalde kopie is van de oorspronkelijke tekenreeks.

U kunt het instellen table argument om None als je alleen nodig hebt om tekens te verwijderen.

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

Verwijderen van ongewenste voorloop- / volgkarakters uit een string

Er zijn drie methoden die de mogelijkheid bieden om voorloop- en str.strip uit een string te verwijderen: str.strip , str.rstrip en str.lstrip . Alle drie methoden hebben dezelfde handtekening en alle drie retourneren een nieuw tekenreeksobject zonder ongewenste tekens.

str.strip([chars])

str.strip werkt op een bepaalde string en verwijdert (strips) niet beginnen of eindigen tekens in het argument chars ; als chars niet is opgegeven of None , worden alle wittekens standaard verwijderd. Bijvoorbeeld:

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

Als chars worden opgegeven, worden alle tekens in de tekenreeks verwijderd, die wordt geretourneerd. Bijvoorbeeld:

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

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

Deze methoden hebben vergelijkbare semantiek en argumenten met str.strip() , hun verschil ligt in de richting van waaruit ze beginnen. str.rstrip() begint vanaf het einde van de string, terwijl str.lstrip() zich splitst vanaf het begin van de string.

Gebruik bijvoorbeeld str.rstrip :

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

Terwijl je str.lstrip :

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

Niet-hoofdlettergevoelige tekenreeksvergelijkingen

String op een ongevoelige manier vergelijken lijkt iets dat triviaal is, maar dat is het niet. In deze sectie worden alleen unicode-tekenreeksen behandeld (de standaard in Python 3). Merk op dat Python 2 subtiele zwakke punten kan hebben ten opzichte van Python 3 - de unicode-afhandeling van de latere versie is veel completer.

Het eerste dat opvalt, is dat conversies in hoofdletters en kleine letters in unicode niet triviaal zijn. Er is tekst waarvoor text.lower() != text.upper().lower() , zoals "ß" :

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

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

Maar laten we zeggen dat u "BUSSE" en "Buße" wilt vergelijken. Ach, je wilt waarschijnlijk ook "BUSSE" en "BUẞE" gelijk vergelijken - dat is de nieuwere kapitaalvorm. De aanbevolen manier is om casefold te gebruiken:

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

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

Gebruik niet alleen lower . Als casefold niet beschikbaar is, helpt .upper().lower() (maar slechts een beetje).

Dan moet u accenten overwegen. Als je lettertypeweergave goed is, denk je waarschijnlijk "ê" == "ê" - maar dat doet het niet:

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

Dit komt omdat ze eigenlijk zijn

>>> 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']

De eenvoudigste manier om hiermee om te gaan is unicodedata.normalize . U wilt waarschijnlijk NFKD- normalisatie gebruiken, maar voel u vrij om de documentatie te controleren. Dan doet men dat

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

Tot slot wordt dit uitgedrukt in functies:

import unicodedata

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

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

Voeg een lijst met strings samen in één string

Een tekenreeks kan worden gebruikt als scheidingsteken om een lijst met tekenreeksen samen te voegen tot één tekenreeks met behulp van de methode join() . U kunt bijvoorbeeld een tekenreeks maken waarbij elk element in een lijst wordt gescheiden door een spatie.

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

In het volgende voorbeeld worden de tekenreekselementen gescheiden met drie koppeltekens.

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

Nuttige constanten van de stringmodule

Python's string module biedt constanten voor strijkorkest daarmee samenhangende activiteiten. Importeer de string om ze te gebruiken:

>>> import string

string.ascii_letters :

Samenvoeging van ascii_lowercase en ascii_uppercase :

>>> string.ascii_letters
'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'

string.ascii_lowercase :

Bevat alle kleine letters ASCII-tekens:

>>> string.ascii_lowercase
'abcdefghijklmnopqrstuvwxyz'

string.ascii_uppercase :

Bevat alle ASCII-tekens in hoofdletters:

>>> string.ascii_uppercase
'ABCDEFGHIJKLMNOPQRSTUVWXYZ'

string.digits :

Bevat alle decimale tekens:

>>> string.digits
'0123456789'

string.hexdigits :

Bevat alle hexadecimale tekens:

>>> string.hexdigits
'0123456789abcdefABCDEF'

string.octaldigits :

Bevat alle octale tekens:

>>> string.octaldigits
'01234567'

string.punctuation :

Bevat alle tekens die als interpunctie worden beschouwd in de landinstelling C :

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

string.whitespace :

Bevat alle ASCII-tekens die als witruimte worden beschouwd:

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

In de print(string.whitespace) de eigenlijke tekens af, gebruik str om de bovenstaande string terug te krijgen.

string.printable :

Bevat alle tekens die als afdrukbaar worden beschouwd; een combinatie van string.digits , string.ascii_letters , string.punctuation en string.whitespace .

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

Een string omkeren

Een tekenreeks kan worden omgekeerd met de ingebouwde functie reversed() , die een tekenreeks gebruikt en een iterator in omgekeerde volgorde retourneert.

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

reversed() kan worden ingepakt in een aanroep van ''.join() om een string van de iterator te maken.

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

Hoewel het gebruik van reversed() mogelijk leesbaarder is voor niet-geïnitieerde Python-gebruikers, is het gebruik van uitgebreide slicing met een stap van -1 sneller en beknopter. Probeer het hier als functie te implementeren:

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

Rechtvaardig tekenreeksen

Python biedt functies voor het rechtvaardigen van tekenreeksen, waardoor tekstopvulling het uitlijnen van verschillende tekenreeksen veel gemakkelijker maakt.

Hieronder is een voorbeeld van str.ljust en 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 en rjust lijken erg op elkaar. Beide hebben een parameter width en een optionele parameter fillchar . Elke tekenreeks die door deze functies wordt gemaakt, is minstens zo lang als de parameter width die aan de functie is doorgegeven. Als de tekenreeks langer is dan de width , wordt deze niet afgekapt. Het fillchar argument, dat standaard het spatie-teken ' ' moet een enkel teken zijn, geen string met meerdere tekens.

De ljust functie ljust het einde van de string waarnaar het wordt opgeroepen op met de fillchar totdat het width tekens lang is. De rjust functie rjust het begin van de string op een vergelijkbare manier aan. Daarom verwijzen de l en r in de namen van deze functies naar de zijde waar de originele string, niet de fillchar , in de output string is geplaatst.

Conversie tussen str of bytes gegevens en Unicode-tekens

De inhoud van bestanden en netwerkberichten kan gecodeerde tekens vertegenwoordigen. Ze moeten vaak worden geconverteerd naar Unicode voor een juiste weergave.

In Python 2 moet u mogelijk str-gegevens converteren naar Unicode-tekens. De standaard ( '' , "" , enz.) Is een ASCII-reeks, waarbij waarden buiten het ASCII-bereik worden weergegeven als ontsnapte waarden. Unicode-reeksen zijn u'' (of u"" , enz.).

# 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

In Python 3 moet u mogelijk arrays van bytes (een 'byte literal' genoemd) omzetten in tekenreeksen van Unicode-tekens. De standaardwaarde is nu een Unicode-reeks, en bytestring-literalen moeten nu worden ingevoerd als b'' , b"" , enz. Een byte-letterlijke geeft True terug naar isinstance(some_val, byte) , ervan uitgaande dat some_val een string is die gecodeerd kan zijn als bytes.

# 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.

String bevat

Python maakt het uiterst intuïtief om te controleren of een string een bepaalde substring bevat. Gebruik gewoon de in operator:

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

Opmerking: het testen van een lege string resulteert altijd in True :

>>> "" in "test"
True