Python Data Structures Tutorial

Gegevensstructuren zijn een manier om data te organiseren en op te slaan zodat je er efficiënt bij kunt en ermee kunt werken. Ze definiëren de relatie tussen de data en de bewerkingen die je op de data kunt uitvoeren. Er zijn veel verschillende soorten gegevensstructuren gedefinieerd die het data scientists en computer engineers gemakkelijker maken om zich te concentreren op het grotere geheel van het oplossen van grotere problemen, in plaats van te verdwalen in de details van databeschrijving en -toegang.

In deze tutorial leer je over de verschillende Python-gegevensstructuren en zie je hoe ze worden geïmplementeerd:

• Abstract Data Type en gegevensstructuren
• Primitieve gegevensstructuren
  • Integers
  • Float
  • Strings
  • Boolean
• Niet-primitieve gegevensstructuren
  • Arrays
  • Lists
  • Tuples
  • Dictionary
  • Sets
  • Files

In onze gratis cursus Intro to Python for Data Science leer je meer over het gebruik van Python specifiek in de data science-context. De cursus geeft een introductie tot de basisconcepten van Python. Je ontdekt er methods, functies en het NumPy-pakket.

Abstract Data Type and Data Structures

Zoals je in de inleiding las, helpen gegevensstructuren je te focussen op het grotere geheel in plaats van te verdwalen in de details. Dit staat bekend als data-abstrahering.

Gegevensstructuren zijn eigenlijk een implementatie van Abstract Data Types of ADT. Deze implementatie vereist een fysieke weergave van data met behulp van een verzameling programmeerconstructies en basistypen.

Over het algemeen kun je gegevensstructuren in de informatica onderverdelen in twee categorieën: primitieve en niet-primitieve gegevensstructuren. De eerste zijn de eenvoudigste vormen om data te representeren, terwijl de laatste geavanceerder zijn: ze bevatten primitieve gegevensstructuren binnen complexere structuren voor speciale doeleinden.

Primitive Data Structures

Dit zijn de meest primitieve of basale gegevensstructuren. Het zijn de bouwstenen voor datamanipulatie en ze bevatten pure, eenvoudige waarden. Python heeft vier primitieve variabele typen:

• Integers
• Float
• Strings
• Boolean

In de volgende secties leer je er meer over!

Integers

Je kunt een integer gebruiken om numerieke data te representeren en, specifieker, gehele getallen van min oneindig tot oneindig, zoals 4, 5 of -1.

Float

"Float" staat voor 'floating point number'. Je gebruikt het voor rationale getallen, meestal met een decimaal, zoals 1.11 of 3.14.

Bekijk de volgende DataCamp Light Chunk en probeer enkele integer- en float-bewerkingen uit!

Let op dat je in Python het type van de variabele of je data niet expliciet hoeft op te geven. Dat komt omdat het een dynamisch getypeerde taal is. Dynamisch getypeerde talen zijn talen waarin het type data dat een object kan opslaan veranderlijk is.

String

Strings zijn reeksen letters, woorden of andere tekens. In Python maak je strings door een reeks tekens tussen enkele of dubbele aanhalingstekens te plaatsen. Bijvoorbeeld: 'cake', "cookie", enz.

Je kunt ook de +-operatie toepassen op twee of meer strings om ze te concateneren, zoals in het onderstaande voorbeeld:

x = 'Cake'
y = 'Cookie'
x + ' & ' + y

'Cake & Cookie'

Hier zijn enkele andere basisbewerkingen die je met strings kunt uitvoeren; Zo kun je * gebruiken om een string een bepaald aantal keren te herhalen:

# Repeat
x * 2

'CakeCake'

Je kunt strings ook slicen, wat betekent dat je delen van strings selecteert:

# Range Slicing
z1 = x[2:]  

print(z1)

# Slicing
z2 = y[0] + y[1]

ke
Co

Let op dat strings ook alfanumerieke tekens kunnen zijn, maar dat de +-operatie nog steeds wordt gebruikt om strings te concateneren.

x = '4'
y = '2'

x + y

'42'

Python heeft veel ingebouwde methods of helperfuncties om strings te manipuleren. Een substring vervangen, bepaalde woorden in een alinea kapitaliseren, de positie van een string binnen een andere string vinden: het zijn enkele veelvoorkomende stringbewerkingen. Bekijk er een paar:

Strings kapitaliseren

str.capitalize('cookie')

'Cookie'

Haal de lengte van een string in tekens op. Let op: spaties tellen ook mee in het eindresultaat:

str1 = "Cake 4 U"
str2 = "404"
len(str1)

8

Controleren of een string alleen uit cijfers bestaat

str1.isdigit()

False

str2.isdigit()

True

Delen van strings vervangen door andere strings

str1.replace('4 U', str2)

'Cake 404'

Substrings in andere strings vinden; Retourneert de laagste index of positie binnen de string waarop de substring wordt gevonden:

str1 = 'cookie'
str2 = 'cook'
str1.find(str2)

0

De substring

'cook'

wordt aan het begin gevonden van

'cookie'

. Daarom verwijs je naar de positie binnen

'cookie'

waarop je die substring vindt. In dit geval wordt

0

geretourneerd omdat je posities begint te tellen vanaf 0!

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

12

Op dezelfde manier wordt de substring

'cook'

gevonden op positie 12 binnen

'I got you a cookie'

. Onthoud dat je vanaf 0 begint te tellen en dat spaties meetellen voor de posities!

Een uitputtende lijst van stringmethods in Python vind je hier.

Boolean

Dit ingebouwde datatype kan de waarden True en False aannemen, wat ze vaak uitwisselbaar maakt met de integers 1 en 0. Booleans zijn nuttig in conditionele en vergelijkingsuitdrukkingen, zoals in de volgende voorbeelden:

x = 4
y = 2
x == y

False

x > y

True

x = 4
y = 2
z = (x==y) # Comparison expression (Evaluates to false)
if z: # Conditional on truth/false value of 'z'
    print("Cookie")
else: print("No Cookie")

No Cookie

Data Type Conversion

Soms werk je met iemands anders code en moet je bijvoorbeeld een integer naar een float converteren of omgekeerd. Of je ontdekt dat je een integer gebruikte terwijl je eigenlijk een float nodig hebt. In zulke gevallen kun je het datatype van variabelen converteren!

Om het type van een object in Python te controleren, gebruik je de ingebouwde functie type(), zoals in de onderstaande codelijnen:

i = 4.0
type(i)

float

Wanneer je het type van een entiteit van het ene datatype naar het andere verandert, heet dat "typecasten". Er zijn twee soorten dataconversies mogelijk: impliciet, ook wel coercion genoemd, en expliciet, vaak casting genoemd.

Implicit data type conversion

Dit is een automatische dataconversie en de compiler handelt dit voor je af. Bekijk de volgende voorbeelden:

# A float
x = 4.0 

# An integer
y = 2 

# Divide `x` by `y`
z = x/y

# Check the type of `z`
type(z)

float

In het bovenstaande voorbeeld hoefde je het datatype van y niet expliciet te wijzigen om deling met een float uit te voeren. De compiler deed dit impliciet voor je.

Dat is makkelijk!

Explicit data type conversion

Dit type dataconversie is door de gebruiker gedefinieerd, wat betekent dat je de compiler expliciet moet vertellen om het datatype van bepaalde entiteiten te veranderen. Bekijk de onderstaande code om dit volledig te begrijpen:

x = 2
y = "The Godfather: Part "
fav_movie = y + x

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

TypeError                                 Traceback (most recent call last)

<ipython-input-51-b8fe90df9e0e> in <module>()
      1 x = 2
      2 y = "The Godfather: Part "
----> 3 fav_movie = y + x


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

Het bovenstaande voorbeeld gaf een fout omdat de compiler niet begrijpt dat je probeert te concateneren of op te tellen vanwege de gemengde datatypen. Je probeert een integer en een string bij elkaar op te tellen.

Er is een duidelijke mismatch.

Om dit op te lossen, moet je eerst de int naar een string converteren om te kunnen concateneren.

Let op dat het niet altijd mogelijk is om een datatype naar een ander te converteren. Enkele ingebouwde conversiefuncties die je hier kunt gebruiken zijn: int(), float() en str().

x = 2
y = "The Godfather: Part "
fav_movie = (y) + str(x)
print(fav_movie)

The Godfather: Part 2

Non-Primitive Data Structures

Niet-primitieve typen zijn de meer verfijnde leden van de familie van gegevensstructuren. Ze slaan niet slechts één waarde op, maar een collectie waarden in verschillende formaten.

In de traditionele informatica worden de niet-primitieve gegevensstructuren onderverdeeld in:

• Arrays
• Lists
• Files

Array

Om te beginnen: arrays in Python zijn een compacte manier om basistypen te verzamelen; alle elementen in een array moeten van hetzelfde datatype zijn. Arrays zijn in Python echter niet zo populair als in andere talen zoals C++ of Java.

In het algemeen, wanneer men in Python over arrays spreekt, bedoelt men eigenlijk lists. Toch is er een fundamenteel verschil, en dat zul je zo zien. In Python kun je arrays zien als een efficiëntere manier om een bepaald soort lijst op te slaan. Dit type lijst heeft echter elementen van hetzelfde datatype.

In Python worden arrays ondersteund door de array-module en moeten ze worden geïmporteerd voordat je ze initialiseert en gebruikt. De elementen die in een array worden opgeslagen, zijn beperkt in hun datatype. Het datatype wordt gespecificeerd tijdens het aanmaken van de array en aangegeven met een typecode, een enkel teken zoals de I die je hieronder ziet:

import array as arr
a = arr.array("I",[3,6,9])
type(a)

array.array

De pagina met Python Array-documentatie biedt meer informatie over de verschillende typecodes en de functionaliteit van de array-module.

List

Lists in Python worden gebruikt om collecties van heterogene items op te slaan. Ze zijn mutabel, wat betekent dat je hun inhoud kunt wijzigen zonder hun identiteit te veranderen. Je herkent lists aan de vierkante haken [ en ] die elementen bevatten, gescheiden door een komma ,. Lists zijn ingebouwd in Python: je hoeft ze niet apart aan te roepen.

x = [] # Empty list
type(x)

list

x1 = [1,2,3]
type(x1)

list

x2 = list([1,'apple',3])
type(x2)

list

print(x2[1])

apple

x2[1] = 'orange'
print(x2)

[1, 'orange', 3]

Let op: zoals je in het bovenstaande voorbeeld met x1 hebt gezien, kunnen lists ook homogene items bevatten en voldoen ze dus aan de opslagfunctionaliteit van een array. Dit is prima, tenzij je specifieke bewerkingen op deze collectie wilt toepassen.

Python biedt veel methods om met lists te werken. Nieuwe items toevoegen, items verwijderen, en een lijst sorteren of omkeren zijn veelvoorkomende list-bewerkingen. Laten we er een paar in actie zien:

• Voeg 11 toe aan de lijst list_num met append(). Standaard wordt dit getal aan het einde van de lijst toegevoegd.

list_num = [1,2,45,6,7,2,90,23,435]
list_char = ['c','o','o','k','i','e']

list_num.append(11) # Add 11 to the list, by default adds to the last position
print(list_num)

[1, 2, 45, 6, 7, 2, 90, 23, 435, 11]

• Gebruik insert() om 11 in te voegen op index of positie 0 in de lijst list_num

list_num.insert(0, 11)
print(list_num)

[11, 1, 2, 45, 6, 7, 2, 90, 23, 435, 11]

• Verwijder het eerste voorkomen van 'o' uit list_char met remove()

list_char.remove('o') 
print(list_char)

['c', 'o', 'k', 'i', 'e']

• Verwijder het item op index -2 uit list_char

list_char.pop(-2) # Removes the item at the specified position
print(list_char)

['c', 'o', 'k', 'e']

list_num.sort() # In-place sorting
print(list_num)

[1, 2, 2, 6, 7, 11, 11, 23, 45, 90, 435]

list.reverse(list_num)
print(list_num)

[435, 90, 45, 23, 11, 11, 7, 6, 2, 2, 1]

Als je meer wilt weten over Python-lists, loop dan door de tutorial 18 Most Common Python List Questions!

Arrays vs. Lists

Nu je lists in Python hebt gezien, vraag je je misschien af waarom je arrays überhaupt nodig hebt. De reden is dat ze fundamenteel verschillen in de bewerkingen die je erop kunt uitvoeren. Met arrays kun je eenvoudig bewerkingen uitvoeren op alle items individueel, wat bij lists niet altijd het geval is. Hier is een illustratie:

array_char = array.array("u",["c","a","t","s"])
array_char.tostring()
print(array_char)

array('u', 'cats')

Je kon de functie tostring() toepassen op array_char omdat Python weet dat alle items in een array van hetzelfde datatype zijn en de bewerking zich daarom op elk element hetzelfde gedraagt. Arrays kunnen dus erg handig zijn bij een grote verzameling homogene datatypen. Omdat Python de typedetails van elk element niet afzonderlijk hoeft te onthouden, kunnen arrays voor sommige toepassingen sneller zijn en minder geheugen gebruiken dan lists.

Het is ook de moeite waard om de NumPy-array te noemen als we het over arrays hebben. NumPy-arrays worden in de data science-wereld veel gebruikt om met multidimensionale arrays te werken. Ze zijn over het algemeen efficiënter dan de array-module en Python-lists. Het lezen en schrijven van elementen in een NumPy-array is sneller en ze ondersteunen "gevectoriseerde" operaties zoals elementgewijze optelling. Ook werken NumPy-arrays efficiënt met grote, sparse datasets. Wil je meer leren, bekijk dan DataCamps Python Numpy Array Tutorial.

Hier is wat code om te beginnen met NumPy-array:

import numpy as np

arr_a = np.array([3, 6, 9])
arr_b = arr_a/3 # Performing vectorized (element-wise) operations 
print(arr_b)

[ 1.  2.  3.]

arr_ones = np.ones(4)
print(arr_ones)

[ 1.  1.  1.  1.]

multi_arr_ones = np.ones((3,4)) # Creating 2D array with 3 rows and 4 columns
print(multi_arr_ones)

[[ 1.  1.  1.  1.]
 [ 1.  1.  1.  1.]
 [ 1.  1.  1.  1.]]

Traditioneel kan de list-gegevensstructuur verder worden onderverdeeld in lineaire en niet-lineaire gegevensstructuren. Stacks en Queues worden "lineaire gegevensstructuren" genoemd, terwijl Graphs en Trees "niet-lineaire gegevensstructuren" zijn. Deze structuren en hun concepten kunnen relatief complex zijn, maar worden veel gebruikt vanwege hun gelijkenis met modellen uit de echte wereld. Je krijgt in deze tutorial een glimp van deze onderwerpen.

Let op: in een lineaire gegevensstructuur zijn de data-items sequentieel, oftewel lineair, geordend. De data-items worden achter elkaar serieel doorlopen en alle items in een lineaire gegevensstructuur kunnen in één run worden doorlopen. In niet-lineaire gegevensstructuren zijn de data-items niet sequentieel geordend. Dat betekent dat elementen met meer dan één element verbonden kunnen zijn om een speciale relatie tussen deze items weer te geven. Mogelijk kunnen niet alle items in een niet-lineaire gegevensstructuur in één run worden doorlopen.

Stacks

Een stack is een container van objecten die worden ingevoegd en verwijderd volgens het Last-In-First-Out (LIFO)-principe. Denk aan een situatie bij een etentje met een stapel borden: borden worden altijd bovenop de stapel toegevoegd of verwijderd. In de informatica wordt dit concept gebruikt voor het evalueren van expressies en syntax-parsing, het plannen van algoritmen/routines, enzovoort.

Stacks kun je in Python implementeren met lists. Wanneer je elementen toevoegt aan een stack, heet dat een push-operatie, terwijl het verwijderen van een element een pop-operatie heet. Let op dat je in Python daadwerkelijk een pop()-methode tot je beschikking hebt wanneer je met stacks werkt:

# Bottom -> 1 -> 2 -> 3 -> 4 -> 5 (Top)
stack = [1,2,3,4,5] 
stack.append(6) # Bottom -> 1 -> 2 -> 3 -> 4 -> 5 -> 6 (Top)
print(stack)

[1, 2, 3, 4, 5, 6]

stack.pop() # Bottom -> 1 -> 2 -> 3 -> 4 -> 5 (Top)
stack.pop() # Bottom -> 1 -> 2 -> 3 -> 4 (Top)
print(stack)

[1, 2, 3, 4]

Queue

Een queue is een container van objecten die worden ingevoegd en verwijderd volgens het First-In-First-Out (FIFO)-principe. Een uitstekend voorbeeld in de echte wereld is de rij bij een loket, waar mensen worden geholpen in volgorde van aankomst, en wie het eerst komt, gaat ook het eerst weg. Queues kunnen veel verschillende vormen hebben.

Lists zijn niet efficiënt om een queue te implementeren, omdat append() en pop() aan het einde van een lijst niet snel zijn en geheugenverschuiving kosten. Ook invoegen aan het einde en verwijderen aan het begin van een lijst is niet zo snel, omdat dit een verschuiving in de elementposities vereist.

Graphs

Een grafiek (graph) in de wiskunde en informatica zijn netwerken die bestaan uit knopen, ook wel vertices genoemd, die al dan niet met elkaar verbonden zijn. De lijnen of het pad dat twee knopen verbindt, heet een edge. Als de edge een specifieke stroomrichting heeft, is het een gerichte grafiek, waarbij de gerichte edge een arc heet. Als er geen richtingen zijn gespecificeerd, heet de grafiek ongericht.

Dit klinkt misschien erg theoretisch en kan vrij complex worden als je dieper graaft. Toch zijn grafen een belangrijk concept, zeker in data science, en worden ze vaak gebruikt om real-life problemen te modelleren. Sociale netwerken, moleculaire studies in chemie en biologie, kaarten en aanbevelingssystemen steunen allemaal op grafen en grafentheorie.

Hier vind je een eenvoudige implementatie van een grafiek met behulp van een Python-dictionary om je op weg te helpen:

graph = { "a" : ["c", "d"],
          "b" : ["d", "e"],
          "c" : ["a", "e"],
          "d" : ["a", "b"],
          "e" : ["b", "c"]
        }

def define_edges(graph):
    edges = []
    for vertices in graph:
        for neighbour in graph[vertices]:
            edges.append((vertices, neighbour))
    return edges

print(define_edges(graph))

[('a', 'c'), ('a', 'd'), ('b', 'd'), ('b', 'e'), ('c', 'a'), ('c', 'e'), ('e', 'b'), ('e', 'c'), ('d', 'a'), ('d', 'b')]

Je kunt coole dingen doen met grafen, zoals kijken of er een pad bestaat tussen twee knopen of het kortste pad tussen twee knopen vinden, cycli in de grafiek bepalen.

Het beroemde "travelling salesman problem" gaat er in feite over om de kortst mogelijke route te vinden die elke knoop precies één keer bezoekt en terugkeert naar het startpunt. Soms hebben de knopen of bogen van een grafiek gewichten of kosten; je kunt dit zien als het toekennen van een moeilijkheidsgraad aan een wandeling, en je bent dan geïnteresseerd in het vinden van het goedkoopste of gemakkelijkste pad.

Trees

Een boom in de echte wereld is een levend wezen met wortels in de grond en takken die de bladeren en vruchten dragen. De takken van de boom spreiden zich op een min of meer georganiseerde manier uit. In de informatica worden bomen gebruikt om te beschrijven hoe data soms is georganiseerd, behalve dat de root bovenaan staat en de takken en bladeren naar beneden uitwaaieren: de boom wordt omgekeerd getekend vergeleken met de echte boom.

Om wat extra notatie te introduceren: de root staat altijd bovenaan de boom. In de metafoor zijn de andere knopen die volgen de takken en de laatste knoop in elke tak heet een blad. Je kunt je elke tak voorstellen als een kleinere boom op zich. De root wordt vaak de ouder (parent) genoemd en de knopen waarnaar hij verwijst, heten zijn kinderen. Knopen met dezelfde ouder heten siblings. Zie je waarom dit ook een stamboom wordt genoemd?

Bomen helpen bij het definiëren van scenario's uit de echte wereld en worden overal gebruikt: van de gamewereld tot het ontwerpen van XML-parsers, en ook het PDF-ontwerpprincipe is op bomen gebaseerd. In data science vormt 'Decision Tree-based Learning' een groot onderzoeksgebied. Tal van bekende methoden zoals bagging en boosting gebruiken het boommodel om een voorspellend model te genereren. Spellen zoals schaken bouwen een enorme boom met alle mogelijke zetten om te analyseren en heuristieken toe te passen om een optimale zet te bepalen.

Je kunt een boomstructuur implementeren door de verschillende gegevensstructuren die je tot nu toe hebt gezien te combineren. Maar omwille van de eenvoud pakken we dit onderwerp in een ander artikel op.

class Tree:
    def __init__(self, info, left=None, right=None):
        self.info = info
        self.left  = left
        self.right = right

    def __str__(self):
        return (str(self.info) + ', Left child: ' + str(self.left) + ', Right child: ' + str(self.right))

tree = Tree(1, Tree(2, 2.1, 2.2), Tree(3, 3.1))
print(tree)

1, Left child: 2, Left child: 2.1, Right child: 2.2, Right child: 3, Left child: 3.1, Right child: None

Je hebt geleerd over arrays en ook de list-gegevensstructuur gezien. Python biedt echter veel verschillende soorten mechanismen voor gegevenverzamelingen en hoewel ze misschien niet in traditionele onderwerpen over gegevensstructuren in de informatica vallen, zijn ze het waard om te kennen, zeker in de context van Python:

• Tuples
• Dictionary
• Sets

Tuples

Tuples zijn een ander standaard sequentietype. Het verschil tussen tuples en lists is dat tuples immutabel zijn, wat betekent dat je, eenmaal gedefinieerd, geen waarden erin kunt verwijderen, toevoegen of bewerken. Dit kan handig zijn in situaties waarin je de controle wilt doorgeven aan iemand anders, maar niet wilt dat diegene de data in je collectie manipuleert, maar ze bijvoorbeeld alleen wil bekijken of bewerkingen wil uitvoeren op een kopie van de data.

Laten we zien hoe tuples worden geïmplementeerd:

x_tuple = 1,2,3,4,5
y_tuple = ('c','a','k','e')
x_tuple[0]

1

y_tuple[3]
x_tuple[0] = 0 # Cannot change values inside a tuple

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

TypeError                                 Traceback (most recent call last)

<ipython-input-74-b5d6da8c1297> in <module>()
      1 y_tuple[3]
----> 2 x_tuple[0] = 0 # Cannot change values inside a tuple


TypeError: 'tuple' object does not support item assignment

Dictionary

Dictionaries zijn precies wat je nodig hebt als je iets wilt implementeren dat lijkt op een telefoonboek. Geen van de gegevensstructuren die je eerder hebt gezien, is geschikt voor een telefoonboek.

Dan komt een dictionary van pas. Dictionaries bestaan uit key-valueparen. key wordt gebruikt om het item te identificeren en de value bevat, zoals de naam al doet vermoeden, de waarde van het item.

x_dict = {'Edward':1, 'Jorge':2, 'Prem':3, 'Joe':4}
del x_dict['Joe']
x_dict

{'Edward': 1, 'Jorge': 2, 'Prem': 3}

x_dict['Edward'] # Prints the value stored with the key 'Edward'.

1

Je kunt veel andere ingebouwde functionaliteiten toepassen op dictionaries:

len(x_dict)

3

x_dict.keys()

dict_keys(['Prem', 'Edward', 'Jorge'])

x_dict.values()

dict_values([3, 1, 2])

Deze code laat zien hoe je een Python-dictionary gebruikt om key-valueparen op te slaan en te benaderen.

Eerst roept de code de functie len() aan met x_dict als argument. Dit retourneert het aantal key-valueparen in de dictionary, namelijk 3.

Vervolgens roept de code de methode keys() aan op x_dict. Dit retourneert een view-object met de keys in de dictionary. In dit geval zijn de keys 'Prem', 'Edward' en 'Jorge', zoals de output aangeeft.

Daarna roept de code de methode values() aan op x_dict. Dit retourneert een view-object met de values in de dictionary. In dit geval zijn de waarden respectievelijk 3, 1 en 2, zoals de output laat zien.

Sets

Sets zijn een collectie van onderscheidende (unieke) objecten. Ze zijn handig om lijsten te maken die alleen unieke waarden in de dataset bevatten. Het is een ongeordende, maar wel mutabele collectie; dit is erg behulpzaam bij het doorlopen van een grote dataset.

x_set = set('CAKE&COKE')
y_set = set('COOKIE')

print(x_set)

{'A', '&', 'O', 'E', 'C', 'K'}

print(y_set) # Single unique 'o'

{'I', 'O', 'E', 'C', 'K'}

print(x - y) # All the elements in x_set but not in y_set

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

NameError                                 Traceback (most recent call last)

<ipython-input-3-31abf5d98454> in <module>()
----> 1 print(x - y) # All the elements in x_set but not in y_set


NameError: name 'x' is not defined

print(x_set|y_set) # Unique elements in x_set or y_set or both

{'C', '&', 'E', 'A', 'O', 'K', 'I'}

print(x_set & y_set) # Elements in both x_set and y_set

{'O', 'E', 'K', 'C'}

De code maakt twee sets: x_set en y_set. Elke set wordt gemaakt door een tekenreeks als argument door te geven aan de functie set(). In dit geval wordt x_set gemaakt op basis van de string 'CAKE&COKE', terwijl y_set wordt gemaakt op basis van de string 'COOKIE'.

Vervolgens print de code elke set met de functie print(). De eerste print()-instructie print x_set, dat de unieke tekens uit de string 'CAKE&COKE' bevat. De output laat zien dat x_set de tekens 'A', '&', 'O', 'E', 'C' en 'K' bevat. Op dezelfde manier print de tweede print()-instructie y_set, met de unieke tekens uit de string 'COOKIE'. De output laat zien dat y_set de tekens 'I', 'O', 'E', 'C' en 'K' bevat.

De derde print()-instructie probeert de set van alle elementen in x_set die niet in y_set staan te printen. Deze regel resulteert echter in een NameError omdat de variabele x niet is gedefinieerd. Vermoedelijk had deze regel print(x_set - y_set) moeten zijn.

De vierde print()-instructie print de set met unieke elementen in x_set of y_set, of beide. De output laat zien dat de resulterende set alle unieke tekens uit zowel x_set als y_set bevat.

Tot slot print de vijfde print()-instructie de set met elementen die zowel in x_set als in y_set voorkomen. De output laat zien dat deze set de tekens 'O', 'E', 'K' en 'C' bevat.

Files

Bestanden maken traditioneel deel uit van gegevensstructuren. En hoewel big data gemeengoed is in de data science-industrie, zou een programmeertaal zonder de mogelijkheid om eerder opgeslagen informatie op te slaan en op te halen nauwelijks nuttig zijn. Je moet nog steeds alle data gebruiken die in bestanden in databases staat, en je leert hoe je dit doet.

De syntax om bestanden in Python te lezen en te schrijven lijkt op die van andere talen, maar is veel eenvoudiger te hanteren. Hier zijn enkele basisfuncties die je helpen met bestanden te werken in Python:

• open() om bestanden op je systeem te openen; de bestandsnaam is de naam van het te openen bestand;

• read() om volledige bestanden te lezen;

• readline() om één regel per keer te lezen;

• write() om een string naar een bestand te schrijven en het aantal geschreven tekens te retourneren; En

• close() om het bestand te sluiten.

# File modes (2nd argument): 'r'(read), 'w'(write), 'a'(appending), 'r+'(both reading and writing)
f = open('file_name', 'w')

# Reads entire file
f.read() 

# Reads one line at a time
f.readline() 

# Writes the string to the file, returning the number of char written
f.write('Add this line.') 

f.close()

Het tweede argument in de functie open() is de bestandsmodus. Hiermee geef je aan of je wilt lezen (r), schrijven (w), toevoegen (a) of zowel lezen als schrijven (r+).

Wil je meer leren over bestandsverwerking in Python, bekijk dan zeker deze pagina.

Conclusion

Gefeliciteerd met het einde van deze tutorial! Weer een onderwerp dichter bij je dromen om de data science-wereld te veroveren.

Als je interesse hebt: onze tweedelige Python Data Science Toolbox gaat dieper in op functies, iterators, lists, enz.