Python String-tutorial

String slicing in Python

Omdat strings een reeks tekens zijn, kun je er net als bij Python-lijsten of -tuples via slicing en indexering toegang toe krijgen. Strings worden geïndexeerd per teken in de string en de indexering begint bij 0:

In de bovenstaande string is het eerste teken C en heeft het index 0. Het laatste teken is een punt ., het 16e teken in de string. Je kunt de tekens ook in omgekeerde richting benaderen vanaf -1, wat betekent dat je ook -1 als index kunt gebruiken om . in de string te benaderen. Er staat ook een spatie tussen Chocolate en cookie; dat is ook onderdeel van de string en heeft zijn eigen index, in dit geval de 9e. Je kunt dit controleren met slicing.

Omdat elk teken in een Python-string een bijbehorend indexnummer heeft, kun je strings op dezelfde manieren benaderen en manipuleren als andere sequentiële datatypes. Slicing is een techniek in Python waarmee je een specifiek element of een subset van elementen uit een containerobject kunt ophalen aan de hand van hun indexwaarden. Slicing bespaart je het schrijven van lussen om de indexen van je string af te gaan om bepaalde substrings te vinden of te benaderen.

snack = "Chocolate cookie."
print(snack[0])
print(snack[9])
print(snack[-1])

C

.

Stel dat je de substring 'cookie' uit de onderstaande string wilde halen. Hoe zou je dat doen?

In zulke gevallen gebruik je range slicing.

De syntaxis voor range slicing is als volgt: [Startindex (inclusief): Stopindex (exclusief)]

snack = "Chocolate cookie."
print(snack[10:16])

cookie

Je kunt dit ook doen met een negatieve waarde voor de stopindex:

print(snack[10:-1]) # -1: omdat de stopindex bij slicing wordt uitgesloten.

cookie

Slicen zonder stopindex betekent dat je de tekens vanaf de startindex tot en met de allerlaatste index in de zin pakt. Op dezelfde manier betekent slicen zonder startindex dat je vanaf de allereerste index in de string tot aan de stopindex gaat:

# Stopwaarde niet opgegeven
print(snack[0:]) 

# Startwaarde niet opgegeven (stopwaarde uitgesloten volgens syntaxis)
print(snack[:-1])

# Dit mag ook
print(snack[:])

Chocolate cookie.
Chocolate cookie
Chocolate cookie.

String slicing kan ook een derde parameter accepteren, de stride, die aangeeft hoeveel tekens je vooruit wilt gaan nadat het eerste teken uit de string is opgehaald. De waarde van stride is standaard 1.

Laten we stride in actie zien om het beter te begrijpen:

number_string = "1020304050"
print(number_string[0:-1:2])

12345

Tip: Iets heel tofs dat je met striding kunt doen, is een string omkeren:

print(number_string[::-1]) #

0504030201

De waarde -1 voor de stride laat je beginnen bij het laatste teken en vervolgens één teken per keer teruglopen.

Als je -2 opgeeft, begin je bij het laatste teken en spring je twee tekens per keer:

print(number_string[::-2]) #

00000

Veelvoorkomende stringoperaties

Slicing en range slicing zijn de meest gebruikte bewerkingen op strings. Er is ook stringconcatenatie, wat net zo eenvoudig is als optellen:

string1 = 'Chocolate'
string2 = 'cookie'

snack = string1 + " " + string2
print(snack)

Chocolate cookie

Dit werkt echter niet als je een string probeert te concatenaten met een ander datatype.

cost = 15
string1 = "The total in Euro is: "

bill = string1 + cost
print(bill)

---------------------------------------------------------------------------

TypeError                                 Traceback (most recent call last)

<ipython-input-218-7d5c5248b927> in <module>()
      2 string1 = "The total in Euro is: "
      3 
----> 4 bill = string1 + cost
      5 print(bill)


TypeError: Can't convert 'int' object to str implicitly

Hier probeerde je een string te concatenaten met een integerwaarde, wat niet is toegestaan. De interpreter kan niet impliciet begrijpen of je eenvoudige integeroptelling of stringconcatenatie probeert uit te voeren. Probeer dit nu eens:

bill = string1 + str(cost)
print(bill)

The total in Euro is: 15

Dit komt doordat je expliciet een integer naar een string hebt geconverteerd en daarna hebt geconcateneerd. Wil je meer leren over datatypeconversies? Bekijk dan deze tutorial.

Om een string te herhalen, gebruik je de *-bewerking.

single_word = 'hip '
line1 = single_word * 2 + 'hurray! '
print(line1 * 3)

hip hip hurray! hip hip hurray! hip hip hurray! 

Je kunt ook op lidmaatschap testen in een string met in en not in:

sub_string1 = 'ice'
sub_string2 = 'glue'
string1 = 'ice cream'
if sub_string in string1:
    print("There is " + sub_string + " in " + string1)
if sub_string2 not in string1:
    print("Phew! No " + sub_string2 + " in " + string1)

There is ice in ice cream
Phew! No glue in ice cream

Python biedt veel ingebouwde methoden of helperfuncties om strings te manipuleren. Het vervangen van een substring, bepaalde woorden in een alinea kapitaliseren, de positie van een string binnen een andere string vinden: het zijn voorbeelden van bewerkingen die je met deze ingebouwde methoden kunt doen.

Bekijk er een paar in detail:

• str.capitalize(): retourneert een kopie van de string met het eerste teken als hoofdletter.

str.capitalize('cookie')

'Cookie'

• str.islower(): geeft true terug als alle tekens in de string kleine letters zijn, anders false.

snack = 'cookie'
snack.islower()

True

• str.find(substring): retourneert de laagste index in de string waar de substring wordt gevonden. Je kunt ook de begin- en eindindex binnen de string opgeven waarnaar je de substring wilt laten zoeken. Geeft -1 terug als de substring niet wordt gevonden.

str1 = 'I got you a cookie'
str2 = 'cook'
str1.find(str2)

12

• str.count(substring): telt hoe vaak een substring in de string voorkomt. Je kunt ook de begin- en stopindex voor de string opgeven.

str1 = 'I got you a cookie, do you like cookies?'
str2 = 'cookie'
str1.count(str2)

2

• str.isspace(): retourneert True als er alleen witruimtetekens in de string staan, anders false. Witruimtetekens zijn tekens zoals spatie, tab, nieuwe regel, enz.

Dit kan handig zijn bij het werken met real-life datasets, die tijdens de conversie van het ene formaat naar het andere niet altijd correcte spatiëring coderen.

str_space = '   '
str_space.isspace()

True

str_tab = '\t'
str_tab.isspace()

True

str_nextline = '''\n'''
str_nextline.isspace()

True

Let op: Vielen de \t, \n hierboven je op? Dat zijn escape-tekens. Ze beginnen met een \ (backslash). Intern worden ze niet geïnterpreteerd als normale strings, maar als speciale tekens die iets anders voorstellen. Bijvoorbeeld: \t staat voor een tab. Er zijn veel meer escape-tekens en je kunt er meer over lezen in onze Python Regex-tutorial.

• str.lstrip(): verwijdert alle leidende witruimte in een string. Dit is nog een functie die handig kan zijn wanneer je met real-life datasets werkt.

str1 = " I can't hear you. Are you alright? "
str2 = " Yes, all is good."
str3 = str1.lstrip() + str2.lstrip()
print(str3)

I can't hear you. Are you alright? Yes, all is good.

• str.isdigit(): retourneert True als de string alleen cijfers bevat en False anders.

number_string = "1020304050"
number_string.isdigit()

True

• str.replace(substring, new): vervangt alle voorkomens van de substring in de string door new. Je kunt ook een derde argument max definiëren, dat hoogstens max voorkomens van de substring in de string vervangt. Onthoud dat dit geen in-place vervanging is; de onveranderlijke eigenschap blijft gelden en er wordt daadwerkelijk een nieuwe string gevormd.

string1 = 'hip hip hurray! hip hip hurray! hip hip hurray!'
string2 = string1.replace('hip', 'Hip')
print(string1)
print(string2)

hip hip hurray! hip hip hurray! hip hip hurray!
Hip Hip hurray! Hip Hip hurray! Hip Hip hurray!

string1.replace('hip', 'Hip', 2)

'Hip Hip hurray! hip hip hurray! hip hip hurray!'

• str.split(delimiter=""): splitst de string volgens de delimiter (spatie als die niet is opgegeven) en retourneert een lijst met substrings.

dessert = 'Cake, Cookie, Icecream'
list_dessert = string1.split(',')

Je vindt een uitputtende lijst met stringmethoden in Python hier.

Stringformatting

Python ondersteunt meerdere manieren om een string op te maken. In deze sectie leer je meer over deze manieren om strings op te maken!

% Formatting

De modulo % is een ingebouwde bewerking in Python. Deze staat bekend als de interpolatie-operator. Je moet % opgeven gevolgd door het datatype dat moet worden opgemaakt of geconverteerd. De %-bewerking vervangt vervolgens de '%datatype'-aanduiding door nul of meer elementen van het opgegeven datatype:

print("I bought %d Euro worth of %s!" %(200, 'cookies'))

I bought 200 Euro worth of cookies!

Je hebt %d gezien voor integers en %s voor strings. Enkele andere conversietypen zijn: o voor octale waarden, x voor hexadecimale waarden, f voor floating-point decimale notatie, c voor één enkel teken (accepteert een integer of een string met één teken).

De Formatter-klasse

De formatter-klasse is een van de ingebouwde stringklassen. Deze biedt de mogelijkheid om complexe variabelevervangingen en waardeopmaak te doen met de format()-methode. Je kunt je eigen stringopmaakgedrag maken en aanpassen door de publieke methoden te herschrijven: format(), vformat(). Er zijn ook methoden die bedoeld zijn om door subklassen te worden vervangen: parse(), get_field(), get_value(), check_unused_args(), format_field() en convert_field(). Voor de eenvoud bekijk je echter alleen de meest gebruikte functie format() in actie...

print("I bought {0} Euro worth of {1}!".format(200,'cookies')) #Accessing values by position

I bought 200 Euro worth of cookies!

print("I bought {total} Euro worth of {item}!".format(total = 200, item = 'cookies')) #Accessing values by name

I bought 200 Euro worth of cookies!

'{:#<10}'.format('Cake') #Left aligment for word 'Cake' according to right alignment, gaps filled with '#'

'Cake######'

'{:#^10}'.format('Cake') #Centre aligment for word 'Cake' according to right alignment, gaps filled with '#'

'###Cake###'

'{:#>10}'.format('Cake') #Right aligment for word 'Cake' according to right alignment, gaps filled with '#'

'######Cake'

for num in range(1,10): 
        print('{0:{width}}'.format(num, width=5), end=' ')

    1     2     3     4     5     6     7     8     9 

Template-strings

In plaats van de normale, op % gebaseerde vervangingen ondersteunen templates vervangingen op basis van $. De reden voor de introductie van templates in Python versie 2.4 was dat hoewel %-stringformatting krachtig en rijk is, deze foutgevoelig en vrij strikt is in de formaten die op '%' volgen, wat het complex maakt. Een veelgemaakte fout met %-formatting is het vergeten van het afsluitende formatkarakter, bijvoorbeeld de e in %(variabl)e.

Templates hebben enkele methoden: substitute() en safe_substitute(). Zo gebruik je ze:

from string import Template #First you will need to import 'Tempalte' class

money = dict(who = 'You', to_whom = 'baker')
Template('$who owe the $to_whom a total of $$100').substitute(money)

'You owe the baker a total of $100'

Zie je de $$ in het bovenstaande voorbeeld?

Dat komt omdat $$ in templates een escape-teken is dat wordt vervangen door één $. Dat is een van de regels voor templates. Een andere regel voor templates betreft hoe je de identifier binnen je template definieert: er is de gebruikelijke syntaxis $identifier, maar je hebt ook ${identifier}.

Dat betekent dat ${identifier} hetzelfde is als $identifier, maar kan worden gebruikt voor scenario's zoals:

word = dict(noun = 'feed')
Template('Please don\'t stop ${noun}ing me').substitute(word)

"Please don't stop feeding me"

Laten we bekijken hoe je substitute() en safe_substitute() kunt gebruiken.

fact = Template('$alter_ego is weak but wait till he transforms to $superhero!')
fact.substitute(alter_ego='Bruce Banner', superhero='Hulk')

'Bruce Banner is weak but wait till he transforms to Hulk!'

hero = dict(alter_ego='Peter Parker')
fact.substitute(hero)

---------------------------------------------------------------------------

KeyError                                  Traceback (most recent call last)

<ipython-input-244-c82f6a2ebc02> in <module>()
      1 hero = dict(alter_ego='Peter Parker')
----> 2 fact.substitute(hero)


~/anaconda3/envs/tensorflow/lib/python3.5/string.py in substitute(*args, **kws)
    127             raise ValueError('Unrecognized named group in pattern',
    128                              self.pattern)
--> 129         return self.pattern.sub(convert, self.template)
    130 
    131     def safe_substitute(*args, **kws):


~/anaconda3/envs/tensorflow/lib/python3.5/string.py in convert(mo)
    117             named = mo.group('named') or mo.group('braced')
    118             if named is not None:
--> 119                 val = mapping[named]
    120                 # We use this idiom instead of str() because the latter will
    121                 # fail if val is a Unicode containing non-ASCII characters.


KeyError: 'superhero'

Het bovenstaande voorbeeld geeft een fout, omdat superhero niet is gedefinieerd. Probeer echter dit...

fact.safe_substitute(hero)

'Peter Parker is weak but wait till he transforms to $superhero!'

safe_substitute() is een van de voordelen van het gebruik van templates.

Waarom zoveel opties voor stringformatting, vraag je je af?

Het is vooral een kwestie van syntaxisvoorkeur. Het komt neer op een trade-off tussen eenvoud en uitgebreidheid, en hangt ook af van je vertrouwdheid met bestaande syntaxis. Het gebruik van % voor stringformatting voelt bijvoorbeeld natuurlijk voor mensen met een C-programmeerachtergrond. Templates in Python zijn eenvoudig te schrijven, terwijl format() uitgebreider kan zijn maar meer mogelijkheden biedt.

Geformatteerde string literal (f-string)

Dit is een andere methode voor stringformatting die is toegevoegd in Python versie 3.6. Een geformatteerde string literal of f-string is een string literal met de prefix 'f' of 'F'. Je kunt identifiers definiëren die je in je string gebruikt binnen accolades { }.

Waarom nóg een optie voor stringformatting? Praktisch en simpel is mooi, daarom!

Bekijk de onderstaande voorbeelden om te zien waarom f-strings echt de eenvoudigste en meest praktische manier zijn om strings in Python op te maken.

alter_ego = 'Peter Parker' superhero = 'spiderman' f'{alter_ego} is weak but wait till he transforms to {superhero}!'

Let op: De bovenstaande code werkt alleen met Python versie 3.6 en hoger. Om te controleren welke Python-versie je hebt geïnstalleerd, typ je: python -V in de terminal. Je kunt ook de sys-module binnen Python gebruiken. Doe dan simpelweg het volgende:

import sys
sys.version

Geformatteerde strings zijn eigenlijk expressies die tijdens runtime worden geëvalueerd, wat betekent dat je elke Python-expressie binnen de accolades van f-strings kunt gebruiken. Dat is een ander groot voordeel van f-strings.

f'{alter_ego} is weak but wait till he transforms to {superhero.capitalize()}!'

F-strings zijn nu al geweldig, toch? Maar wacht, het wordt nog beter... f-strings zijn ook sneller dan de andere drie methoden die je eerder hebt gezien. Dat komt doordat ze vooraf worden geparsed en opgeslagen in efficiënte bytecode voor snellere uitvoering.

Trek aan de juiste touwtjes!

Je bent aan het einde van de tutorial gekomen, gefeliciteerd! Je hebt gezien wat strings zijn, geleerd over string slicing en enkele bewerkingen gezien die je op strings kunt uitvoeren. Je hebt ook verschillende manieren gezien om strings op te maken. Maar onthoud: de sleutel tot het beheersen van elke techniek is oefenen!

Strings zijn een van de vele datatypen in Python. Bekijk DataCamp's cursus Data Types for Data Science om meer te leren over lijsten, dictionaries, tuples en sets. In deze cursus kun je je kennis van datatypen toepassen. Je gaat werken met transitiedata uit de grootstedelijke regio Chicago voor data science-doeleinden. Ga erheen om het zelf te zien...