18 Most Common Python List Questions

Wat is een Python‑lijst precies?

Lijsten zijn een van de vier ingebouwde datastructuren in Python, naast tuples, dictionaries en sets. Ze worden gebruikt om een geordende verzameling items op te slaan, die verschillende types kunnen hebben, al is dat meestal niet zo. Komma’s scheiden de elementen binnen een lijst, die tussen vierkante haken staan. Zoals in dit voorbeeld:

# These list elements are all of the same type
zoo = ['bear', 'lion', 'panda', 'zebra']
print(zoo)

# But these list elements are not
biggerZoo = ['bear', 'lion', 'panda', 'zebra', ['chimpanzees', 'gorillas', 'orangutans', 'gibbons']]
print(biggerZoo)

Je ziet dat de tweede variabele biggerZoo een lijst is die lijkt op de variabele zoo. Maar je ziet ook dat biggerZoo nog een lijst bevat met verschillende soorten apen erin.

Aangezien lijsten in Python geordende collecties van items of objecten opslaan, kun je zeggen dat het sequentietypes zijn, precies omdat ze zich als een sequentie gedragen. Andere types die ook als sequentietype gelden, zijn strings en tuples.

Je vraagt je misschien af wat er zo bijzonder is aan sequentietypes. Simpel gezegd: het betekent dat het programma erover kan itereren! Daarom heten lijsten, strings, tuples en sets “iterables”.

Onthoud dat dit concept bijzonder belangrijk is en dat je het ook in andere programmeertalen kunt tegenkomen die in data science worden gebruikt, zoals Scala!

Nu gaan we echt aan de slag! Laten we dieper ingaan op vragen over lijsten die je als Python‑programmeur kunnen bezighouden. Hier is een lijst van alle vragen die we in deze tutorial beantwoorden:

1. Wanneer gebruik je Python‑lijsten en wanneer tuples, dictionaries of sets?

De inleiding lijkt vrij eenvoudig als je ze leest, maar zodra je aan een klein Pythonscript of een heel project werkt, is de keuze tussen een lijst of een ander sequentietype misschien minder duidelijk.

Toch is het essentieel om de juiste datastructuur voor je data te kiezen!

Lees verder om meer te weten te komen.

# Import the `collections` library
____ ____

# Check if a dictionary is hashable
print(isinstance({}, collections.Hashable))

# Check if a float is hashable
print(isinstance(0.125, collections.Hashable))

2. Hoe selecteer je een element uit een lijst

Als je goed met deze lijsten wilt werken, moet je weten hoe je ze benadert.

Je bezoekt lijsten meestal om bepaalde waarden te wijzigen, te updaten of te verwijderen, of om er een andere bewerking op uit te voeren. De manier waarop je lijsten en bij uitbreiding alle andere sequentietypes benadert, is met de indexoperator [ ]. Tussen de haken zet je een integer.

Een voorbeeld:

# Select the first list element
oneZooAnimal = biggerZoo[0]

# Print `oneZooAnimal`
print(____)

Voer de code uit en kijk wat je terugkrijgt. Je merkt dat het eerste element van de variabele biggerZoo wordt geretourneerd. Dat kan in het begin wat verwarrend zijn, maar indices beginnen bij 0 en niet bij 1.

# Pass -1 to the index operator on `biggerZoo`
monkeys = ___
print(monkeys)

# Pass -2 to the index operator on `biggerZoo`
zebra = ___
print(zebra)

# Run this code to trigger an "Index Out Of Range" Error
biggerZoo[6]

# Use the slice notation like this
someZooAnimals = biggerZoo[2: ]

# Print to see what you exactly select from `biggerZoo`
print(someZooAnimals)

# Try putting 2 on the other side of the colon
otherZooAnimals = biggerZoo[____]

# Print to see what you're getting back
print(otherZooAnimals)

# items start through the end (but the end is not included!)
a[start:end]

# items start through the rest of the array
a[start:]    

# items from the beginning through the end (but the end is not included!)
a[:end]Mogelijk gemaakt door

# start through not past end, by step
a[start:end:step]Mogelijk gemaakt door

# Print to see how the step value influences your result
print(biggerZoo[2::2])
print(biggerZoo[1::3])

# Import `choice` from the `random` library
from ____ import ____

# Construct your `list` variable with a list of the first 4 letters of the alphabet
list = ['_','_','_','_']

# Print your random 'list' element
print(choice(list))

# Import `randrange` from the `random` library
from ____ import ____

# Construct your `randomLetters` variable with a list of the first 4 letters of the alphabet
randomLetters = ['_','_', '_', '_']

# Select a random index from 'randomLetters`
randomIndex = randrange(0,len(randomLetters))

# Print your random element from `random`
print(randomLetters[randomIndex])

3. Hoe zet je Python‑lijsten om naar andere datastructuren

Soms is een lijst niet precies wat je nodig hebt. In zulke gevallen wil je misschien weten hoe je je lijst omzet naar een geschiktere datastructuur. Hieronder vind je enkele veelvoorkomende transformatievragen met hun antwoorden.

# List of Strings to a String
listOfStrings = ['One', 'Two', 'Three']
strOfStrings = ''.join(listOfStrings)
print(strOfStrings)

# List Of Integers to a String
listOfNumbers = [1, 2, 3]
strOfNumbers = ''.join(str(n) for n in listOfNumbers)
print(strOfNumbers)

# Pass your list to `tuple()`
tuple(___)

# Transform your list into a set
set(___)

helloWorld = ['hello','world','1','2']Mogelijk gemaakt door

list(zip(helloWorld))

# Convert to a dictionary
helloWorldDictionary = dict(zip(helloWorld[0::2], helloWorld[1::2]))

# Print out the result
print(helloWorldDictionary)

a = [1, 2, 3, 4, 5]

# Create a list iterator object
i = iter(a)

# Zip and create a dictionary
print(dict(zip(i, i)))

4. Hoe bepaal je de grootte van je lijst in Python

Je kunt je lijst doorgeven aan de functie len() om de lengte terug te krijgen.

Test het hieronder! We hebben al een lijst justAList voor je gemaakt die je kunt gebruiken.

# Pass `justAList` to `len()`
len(____)

Let op dat de functie len() niet specifiek is voor lijsten, maar ook kan worden gebruikt met andere sequenties of collecties, zoals dictionaries, sets, strings, enz. Meer algemene ingebouwde functies vind je hier.

5. Wat is het verschil tussen de Python‑methoden append() en extend()?

Laten we deze vraag beginnen door terug te grijpen op het concept van een iterable dat we in de eerste sectie hebben uitgelegd:

Onthoud dat we zeggen dat een waarde iterable is wanneer je programma erover kan itereren. Met andere woorden: een iterable is een waarde die een sequentie van één of meer waarden voorstelt. Zoals je in de eerste sectie hebt gelezen, zijn lijsten sequenties en alle instanties van Pythons sequentietypes zijn iterables.

Tip: je kunt controleren of een variabele iterable is als deze de methode .__iter__ heeft, zoals in dit stukje code:

# This is your list
list = [5, 6, 7, 8, 9]

# Check whether it's iterable
list.__iter__

Voer de code hierboven uit en probeer nog wat simpele voorbeelden in de IPython‑shell!

Nu het concept van een iterable helder is, kunnen we het verschil tussen de twee methoden begrijpen. extend() neemt aan de ene kant een iterable (inderdaad: een lijst, set, tuple of string!) en voegt elk element van de iterable één voor één toe aan de lijst.

append() daarentegen voegt zijn argument als één enkel item aan het einde van de lijst toe. Dat betekent dat wanneer de functie append() een iterable als argument krijgt, die als één object wordt behandeld.

Bestudeer de onderstaande codeblokken en speel er zelf mee om de verschillen tussen deze twee methoden te begrijpen:

# Append [4,5] to `shortList`
shortList.append([4, 5])

# Use the print() method to show shortList
print(____)

# Extend `longerList` with [4,5]
longerList.extend([4, 5])

# Use the print() method to see longerList
print(____)

Je ziet dat extend() efficiënter is dan meerdere keren append() aanroepen.

6. Hoe concateneer je lijsten in Python

Om lijsten te concateneren gebruik je de operator +. Die geeft je een nieuwe lijst die de concatenatie is van je twee lijsten, zonder de originelen te wijzigen.

Let op dat concatenatie en append verwarrend kunnen zijn. append() verschilt van de operator +, die op zijn beurt erg lijkt op de methode extend(), maar niet helemaal hetzelfde is… Bij append() en extend() wijzig je je oorspronkelijke lijst, terwijl je met de operator + een nieuwe lijstvariabele kunt maken.

Test dit zelf en vergelijk met de voorbeelden uit het vorige codeblok:

# Concatenate `shortList` with `[4,5]`
plusList = shortList + [4,5]

#Use the `print()` method to see `plusList`
print(____)

7. Hoe sorteer je een lijst in Python

Er zijn twee heel eenvoudige manieren om de waarden in je lijsten oplopend of aflopend te sorteren:

• Je gebruikt de methode sort()
• Of je gebruikt de functie sorted() en geeft er een lijst aan door

De functie sorted() kan worden toegepast op elk Iterable object, wat betekent dat ook strings, sets en dictionaries worden geaccepteerd wanneer je ze doorgeeft!

Tip: probeer het zelf! We hebben al twee lijsten gemaakt, rooms en orders, die je met de twee bovenstaande technieken kunt sorteren :)

# Use sort() on the rooms list
____.sort()

# Print out rooms to see the result
print(____)

# Now use the sorted() function on orders
sorted(____)

# Print out orders
print(____)

Let op hoe je oorspronkelijke lijst is gewijzigd nadat je de sortering hebt uitgevoerd. Gebruik dit bij voorkeur wanneer je je oorspronkelijke lijst niet meer nodig hebt.

8. Hoe kloon of kopieer je een lijst in Python

Er zijn veel manieren om een lijst te klonen of te kopiëren:

• Je kunt je originele lijst slicen en opslaan in een nieuwe variabele: newList = oldList[:]
• Je kunt de ingebouwde functie list() gebruiken: newList = list(oldList)
• Je kunt de bibliotheek copy gebruiken:
  • Met de methode copy(): newList = copy.copy(oldList)
  • Als je lijst objecten bevat en je die ook wilt kopiëren, gebruik dan copy.deepcopy(): copy.deepcopy(oldList)

Probeer het hieronder! We hebben al een lijst groceries voor je gemaakt om te kopiëren en met je vrienden te delen.

# Copy the grocery list by slicing and store it in the `newGroceries` variable
newGroceries = groceries[__]

# Copy the grocery list with the `list()` function and store it in a `groceriesForFriends` variable
groceriesForFriends = list(____)

# Import the copy library as c
import ____ as __

# Create a `groceriesForFamily` variable and assign the copied grocery list to it
groceriesForFamily =  c.copy(____)

# Use `deepcopy()` and assign the copied list to a `groceriesForKids` variable
groceriesForKids= c.deepcopy(____)

Let op dat wanneer je de ‘simpele’ kopieermethoden gebruikt, je originele lijsten worden gewijzigd. Gebruik je echter de methode deepcopy(), dan wordt dit voorkomen. Voer de onderstaande code uit om te zien wat er gebeurt:

# This is your list
objectList = ['a','b',['ab','ba']]

# Copy the `objectList`
copiedList = objectList[:]

# Change the first list element of `copiedList`
copiedList[0] = 'c'

# Go to the third element (the nested list) and change the second element
copiedList[2][1] = 'd'

# Print out the original list to see what happened to it
print(objectList)

Voor wie al een stap verder is met lijsten in Python, biedt de volgende sectie simpele antwoorden op complexe vragen.

Maar voor wie zich afvraagt wat er voorbij lijsten ligt en welke voordelen bibliotheken bieden in plaats van de ingebouwde lijststructuur, is de volgende sectie zeker handig.

Lees verder om meer te ontdekken!

9. Hoe werkt list comprehension in Python?

List comprehension is, simpel gezegd, een elegante manier om je lijsten te construeren. Het mooiste voor wie van wiskunde houdt: ze lijken sterk op wiskundige lijsten. Oordeel zelf:

[x**2 for x in range(10)]

Wat betekent dit? Je neemt alle getallen van 0 tot 10, waarbij 10 niet is inbegrepen, en vermenigvuldigt elk van die getallen met 2. Voer de code hierboven uit en kijk of het resultaat overeenkomt met je verwachting.

Niet te moeilijk, toch? Laten we een stapje verder gaan!

Stel dat je dezelfde lijst als daarvoor wilt maken, maar alleen de getallen wilt vermenigvuldigen die deelbaar zijn door 2. Ook dat is eenvoudig met list comprehension:

[x**2 for x in range(10) if x%2==0]

Je voegt gewoon een conditie toe, aangegeven door if, aan je oorspronkelijke expressie. Als die conditie WAAR is, wordt het getal in aanmerking genomen om met 2 te worden vermenigvuldigd. In dit geval is onze conditie dat het getal deelbaar is door 2 (zonder rest).

In meer algemene zin kun je list comprehension ook gebruiken om je lijsten te transformeren naar andere lijsten. Klinkt wat lastiger, toch?

Bekijk dit voorbeeld:

myList = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
[(lambda x: x*x)(x) for x in myList]

In dit voorbeeld heb je al een lijst myList die je transformeert via list comprehension: opnieuw zie je for x in myList; voor elk element in myList wordt een bewerking uitgevoerd.

Vervolgens zie je (lambda x: x*x). Simpel gehouden: lambda‑functies zijn anonieme functies die tijdens runtime worden geconstrueerd. Aangezien dat stukje code hier vooral ter indicatie dient, kun je je focussen op x*x.

Je ziet dat deze functie één element neemt en het met zichzelf vermenigvuldigt. Het is een anonieme functie, dus je moet je lijstelement doorgeven om ervoor te zorgen dat de lambda‑functie die als input neemt. Daarom zie je (lambda x: x*x)(x).

Met andere woorden, je zou de hele tweede regel van het bovenstaande codeblok kunnen herschrijven als:

f = lambda x: x*x
[f(x) for x in range(10)]Mogelijk gemaakt door

Waarin je eerst je lambda‑functie definieert die een element met zichzelf vermenigvuldigt, en je in de tweede regel je lijstelement doorgeeft om elk element met zichzelf te vermenigvuldigen.

Let op dat naast list comprehensions ook set‑ en dictionary‑comprehensions bestaan.

Dat was al best wat, maar er valt nog veel meer te ontdekken over list comprehension.

Lees de volgende veelgestelde vragen om meer te leren over geneste list comprehension en om meer praktische voorbeelden te zien van wat list comprehension voor je Python‑code kan betekenen!

10. Hoe tel je het aantal voorkomens van een item in een lijst in Python

Omdat lijsten, in tegenstelling tot sets, niet de uniciteitsvoorwaarde hebben, wil je misschien weten hoe vaak een bepaald item in je lijst voorkomt, maar ook hoe vaak elk item wordt aangetroffen.

Hieronder vind je de antwoorden op beide vragen!

# Count the occurrences of the number 4
print([1, 2, 9, 4, 5, 4, 1].count(4))

# Count the occurrences of the letter "a"
list = ["d", "a", "t", "a", "c", "a", "m", "p"]
list.count("a")

list= ["a","b","b"]
[[x,list.count(x)] for x in set(list)]

# Import `Counter` from the `collections` library
from collections import Counter

# This is your list
list = ["a","b","b"]

# Pass `list` to `Counter()`
Counter(list)

11. Hoe splits je een Python‑lijst in gelijke stukken

Om je lijst op te splitsen in delen van gelijke grootte, kun je de functie zip() gebruiken in combinatie met iter():

# Your list `x`
x = [1,2,3,4,5,6,7,8,9]

# Split `x` up in chunks of 3
y = zip(*[iter(x)]*3)

# Use `list()` to print the result of `zip()`
list(y)

De code hierboven werkt als volgt:

• iter() is een iterator over een sequentie.
• [iter(x)] * 3 produceert een lijst met drie listiterator-objecten: elke listiterator is een iterator over x.
• de * die vóór alles aan de functie zip() wordt doorgegeven, pakt de sequentie uit tot argumenten, zodat je dezelfde iterator drie keer doorgeeft aan zip(), en er telkens één item uit wordt gehaald.

Wacht. Die laatste stap is nog niet duidelijk.

Ik neem je stap voor stap mee:

1. Je hebt drie listiterator‑objecten, die je je zo kunt voorstellen:

[1,2,3,4,5,6,7,8,9], [1,2,3,4,5,6,7,8,9], [1,2,3,4,5,6,7,8,9]

2. De eerste keer pakt zip() telkens één element van de lijst, wat je dit oplevert:

[1][2][3]

Let op dat de iterator‑objecten voor je bijhouden welk element het volgende is!

3. De tweede keer worden elementen toegevoegd aan de drie net gemaakte lijsten, en eindig je met:

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

4. De laatste keer volg je dezelfde procedure en krijg je:

[1, 4, 7], [2, 5, 8], [3, 6, 9]

5. Deze drie lijsten bij elkaar “zippen” geeft je:

[1, 2, 3], [4, 5, 6], [7, 8, 9]

Wil je deze logica in een functie gieten, volg dan deze aanpak:

# Method to split up your lists into chunks
def chunks(list, chunkSize):
    """Yield successive chunkSize-sized chunks from list."""
    for i in range(0, len(list), chunkSize):
        yield list[i:i + chunkSize]

# Use your `chunks` function to print out chunks of the same size
import pprint
pprint.print(list(chunks(range(10, 75), 10)))

Je functie chunks() krijgt een lijst en een chunkgrootte als input. Vervolgens print hij: “Yield successive (jouw chunk‑grootte)-sized chunks from list” (dus de lijst die je aan chunks() geeft).

Daarna zie je range(0, len(list), chunkSize): deze lijst start op 0 en eindigt op de lengte van je lijst. De stapwaarde is gelijk aan de chunkSize die je aan chunks() doorgeeft.

Voor elk element in deze door range() geconstrueerde lijst yield je een stuk van de oorspronkelijke lijst, beginnend op de index die is gegeven en eindigend op index + chunkgrootte.

Bijvoorbeeld: als index 0 door de for‑loop gaat, wordt [0:2] gegeven. In de volgende iteratie gaat index 2 door de for‑loop (onthoud de stapwaarde!) en wordt [2:4] uit je oorspronkelijke lijst teruggegeven.

Let op dat je pprint() of pretty print gebruikt om je resultaat te printen.

Je kunt ook gewoon list comprehension gebruiken in plaats van een functie te schrijven:

12. Hoe loop je over een lijst in Python

Je kunt eenvoudig door elke lijst loopen met een for‑loop. Voor wie minder met for‑loops heeft gewerkt: een for‑loop laat je een actie uitvoeren voor elk element in je lijst.

In Python ziet een for‑loop er zo uit:

# This is your list
mylist = [[1,2,3],[4,5,6,7],[8,9,10]]

# Loop over your list and print all elements that are of size 3
for x in mylist:
      if len(x)==3:
        print(x)

Je hebt een lijst mylist, en je geeft Python de opdracht te controleren of de lengte van elk lijst­element gelijk is aan 3. Omdat onze lijsten twee lijsten bevatten die elk drie elementen hebben, namelijk [1,2,3] en [8, 9,10], worden alleen deze geprint.

Let op hoe x in het bovenstaande codeblok kan worden vervangen door element, listElement of welke naam je maar wilt. Probeer het in de console!

Je ziet dat het resultaat de indices van de elementen niet toont. Als je wilt itereren over een lijst met gebruik van de index, kan dat zo:

# This is your list
myList = [3,4,5,6]

# Loop over `myList` and print tuples of all indices and values 
for i, val in enumerate(myList):
     print(i, val)

Aangezien je niet alleen de lijst­elementen, maar ook hun index wilt printen, moet je dat uiteraard in je for‑loop aangeven. Daarom gebruiken we enumerate(myList), dat een index en een waarde retourneert. Logischerwijs laten we dat ook in het begin van het for‑statement zien: je ziet i, val om duidelijk te maken dat we een index en een waarde verwachten.

Let op dat je ook list comprehension kunt gebruiken om over een lijst te loopen. Hier worden de resultaten al geprint zonder dat je print() hoeft aan te roepen:

[x for x in myList if len(x)==3]

13. Hoe maak je platte lijsten van lijsten

Om van een lijst‑van‑lijsten een simpele lijst te maken, kun je de functie sum() gebruiken. Vergeet niet je lijst en een lege lijst door te geven:

# Your initial list of lists
list = [[1,2],[3,4],[5,6]]

# Flatten out your original list of lists with `sum()`
sum(list, [])

Je kunt ook twee andere aanpakken gebruiken om je lijsten te flatten:

# You can reduce the lists of lists of lists like this
from functools import reduce
print(reduce(lambda x,y: x+y,listOfLists))

# Or you can use list comprehension
print([item for sublist in listOfLists for item in sublist])

• Je gebruikt ofwel de methode reduce(), waaraan je een lambda‑functie doorgeeft. De methode reduce() zorgt ervoor dat je iterable wordt gereduceerd tot één waarde. Hoe die wordt gereduceerd, bepaal je met de functie die je doorgeeft. In dit geval geef je aan dat je de elementen cumulatief wilt optellen: [1,2] wordt opgeteld bij [3,4] en dit resultaat wordt opgeteld bij [5,6]. Visueel weergegeven:

([1,2]+[3,4])+[5,6]Mogelijk gemaakt door

Onthoud dat de operator + lijsten concateneert.

• De tweede optie om platte lijsten te maken uit lijsten‑van‑lijsten is list comprehension gebruiken. Deze geneste for‑loop is niet de makkelijkste. Het komt erop neer dat je eerst sublist in list neemt, dus [1, 2], [3, 4], [5, 6], en vervolgens item for item in sublist overweegt, waarbij je elk item uit de sublijst print.

Een andere manier om deze geneste list comprehension te bekijken, is hem herschrijven als een gewone for‑loop:

list1 = []

for sublist in list:
  for item in sublist:
    list1.append(item)Mogelijk gemaakt door

14. Hoe krijg je de intersectie van twee Python‑lijsten

# Intersect both lists with list comprehension
intersection = [list(filter(lambda x: x in list1, sublist)) for sublist in list2]

# Print the result of the intersection
print(____)

# An intersection of both lists, stored in `intersection`
intersection = [[x for x in sublist if x in list1] for sublist in list2]

# Print the result of the intersection
print(intersection)

# Make use of the list and set data structures
print(list(set(list1) & set(list2)))

# Use `intersection()`
print(list(set(list1).intersection(list2)))

15. Hoe verwijder je duplicaten uit een lijst in Python

Zoals in de eerste sectie van deze blogpost beschreven, kies je het best een set als je een unieke verzameling ongeordende items wilt opslaan.

Om van elk iterable een set te maken, geef je het simpelweg door aan de ingebouwde functie set(). Heb je later weer een echte lijst nodig, dan kun je de set net zo goed doorgeven aan de functie list().

Onthoud dat een iterable een lijst, dictionary, … kan zijn. Controleer of een variabele een iterable is door er de methode .__iter__ op toe te passen.

Het volgende voorbeeld laat duidelijk zien hoe je set() gebruikt om alle duplicaten uit je lijst te verwijderen:

# Your list with duplicate values
duplicates = [1, 2, 3, 1, 2, 5, 6, 7, 8]

# Print the unique `duplicates` list
print(list(set(duplicates)))

# A list with small numbers 
smallNumbers = [1, 2, 3]

# Print the unique `duplicates` list without the small numbers
list(set(duplicates) - set(smallNumbers))

Zoals je aan het laatste resultaat ziet, blijft de oorspronkelijke volgorde van je lijst niet behouden nadat je de set‑elementen van smallNumbers aftrekt. Zoals je nu weet zijn sets zelf ongeordende collecties, dus elke volgorde die je in je lijst had, gaat verloren. Wanneer je je set weer omzet naar een lijst, wordt er een willekeurige volgorde voor je gemaakt.

Is de volgorde van je elementen belangrijk, dan moet je een andere methode gebruiken. Deze pagina behandelt dat onderwerp in meer detail.

16. Waarom NumPy in plaats van Python‑lijsten?

In het algemeen lijken er vier redenen te zijn waarom Python‑programmeurs de voorkeur geven aan NumPy‑arrays boven lijsten in Python:

• omdat NumPy‑arrays compacter zijn dan lijsten.
• omdat lezen en schrijven sneller is met NumPy.
• omdat NumPy vaak handiger werkt, dankzij veel kant‑en‑klare vector‑ en matrixoperaties
• omdat NumPy efficiënter kan zijn doordat het efficiënter is geïmplementeerd.

17. Hoe maak je lege NumPy‑arrays

Als je alleen een lege NumPy‑array wilt maken, kun je het volgende uitvoeren:

import numpy
numpy.array([])

Wil je echter een NumPy‑array initialiseren, volg dan een van de volgende aanpakken:

# Make a NumPy array of four rows and two columns and filled with 0
numpy.zeros(shape=(4,2))

# Make a NumPy array of 1 values of three columns
numpy.ones(3)

# Make an empty NumPy array
numpy.empty(shape=(0,0))

Bekijk zeker deze documentatie als je op zoek bent naar andere manieren om je NumPy‑array te initialiseren.

18. Hoe doe je wiskunde met lijsten in Python

Vaak gebruiken we lijsten niet alleen om een verzameling waarden op te slaan, maar voeren we er ook wiskundige bewerkingen op uit. Deze sectie behandelt enkele veelgestelde vragen over rekenen met lijsten.

cost = [0.424, 0.4221, 0.4185, 0.4132, 0.413]
cases = [10, 20, 30, 40, 50]Mogelijk gemaakt door

for c in range(len(cost)):
   cost[c] = (cost[c] * cases[c] / sum(cases))
cost = sum(cost)
print(cost)

sum(cost[c] * cases[c] / sum(cases) for c in range(len(cost)))

sum(cost[c] * cases[c] for c in range(len(cost))) / sum(cases)

# See what `zip()` does to your `cost` and `cases`
print(list(zip(____, ____)))

# Calculate the weighted average
print(sum([x * y for x, y in zip(cost, cases)]) / sum(cases))

# Import numpy as np
import ____ as __

# Make a NumPy array
a = np.array([1,2,3,4,5])

# Return the 50th percentile of our NumPy array
p = np.percentile(a, 50)

#Print the result
print(____)

list1=[1, 2, 3]
list2=[4, 5, 6]Mogelijk gemaakt door

from operator import add
list(map(add, list1, list2))

[sum(x) for x in zip(list1, list2)]

# Import numpy as np
import ____ as __

# Make your lists into NumPy arrays
vector1 = np.array([1, 2, 3])
vector2 = np.array([4, 5, 6])

# Element-wise addition
sum_vector = vector1 + vector2 

# Print the result
print(____)

Wat is de volgende stap in je data‑science‑reis met Python?

Je bent aan het einde gekomen van onze interactieve tutorial over lijsten in Python. Het was behoorlijk wat stof en werk, maar je hebt het gehaald!

Lijsten zijn maar een klein, maar essentieel onderdeel van je data‑science‑reis met Python. Er valt nog zoveel meer te ontdekken! Onze interactieve cursus Intro to Python for Data Science is perfect als je meer wilt leren over Python en hoe het in data science wordt gebruikt: we beginnen bij de basis van Python en brengen je stap voor stap naar een gemiddeld niveau door je kennis te laten maken met NumPy. Perfect voor wie weinig ervaring heeft met (Python) programmeren!

Ben je al een meer gevorderde Python‑gebruiker, overweeg dan onze cursus Intermediate Python For Data Science, voor iedereen die zijn data‑science‑ en Python‑skills naar het volgende niveau wil tillen. Deze cursus brengt je zeker verder in je data‑science‑leertraject! De cursus introduceert je aan meer bibliotheken, zoals matplotlib en pandas, en concepten zoals logica, control flow en filtering, en bevat een data‑science‑casestudy om je skills te versterken.

Gebruik je al Python voor data science en wil je nog verder? Dan is onze cursus Importing Data Into Python interessant, of lees onze tutorialreeks The importance of preprocessing in data science and the machine learning pipeline!