Een complete gids voor lege lijsten in Python

Python, met z’n veelzijdige datastructuren, is een krachtig hulpmiddel voor developers en data scientists. Onder deze structuren nemen lijsten een speciale plek in vanwege hun dynamische aard en gebruiksgemak. Dit artikel gaat in op het concept van lege lijsten in Python: hoe je ze maakt, veelvoorkomende use-cases en bewerkingen, met duidelijke stapsgewijze uitleg en praktische voorbeelden.

Zoek je meer info over dit onderwerp? Bekijk dan onze volledige Python Lists-tutorial.

Het korte antwoord: zo maak je een lege lijst in Python

Voor wie haast heeft: een lege lijst maken in Python is zo eenvoudig als vierkante haken [] gebruiken. Deze beknopte methode is niet alleen makkelijk te onthouden, maar ook efficiënt om een lijst te initialiseren voor verdere bewerkingen. Hier’s een voorbeeld waarin we een lege lijst my_list maken en (straks uitgebreider behandeld) de woorden ‘Python’ en ‘Rocks’ eraan toevoegen.

# Create an empty list called my_list
my_list = []
# Append the words 'Python' and 'Rocks' to it
my_list.append('Python')
my_list.append('Rocks')

# my_list is now ['Python', 'Rocks']Mogelijk gemaakt door

Lege lijsten in Python maken: twee methoden

Hoewel de korte sectie hierboven het gebruik van vierkante haken [] introduceerde als een snelle manier om een lege lijst te initialiseren, is het de moeite waard deze techniek in meer detail te bekijken om de elegantie en efficiëntie ervan te waarderen. Daarnaast biedt Python ook een explicietere alternatieve methode die aansluit bij bepaalde coding styles en eisen aan duidelijkheid.

Methode 1: Lege lijsten maken met []

Het gebruik van vierkante haken [] om een lege lijst te maken is kenmerkend voor Pythons ontwerpfilosofie, met de nadruk op eenvoud en leesbaarheid. Het vormt een schoon, intuïtief startpunt voor lijstbewerkingen. Zo initialiseer je een lege lijst met []:

# Initializing an empty list with square brackets
my_empty_list = []Mogelijk gemaakt door

Methode 2: De ingebouwde list()-functie van Python gebruiken

Als alternatief biedt Python de ingebouwde functie list() die, wanneer je die zonder argumenten aanroept, een lege lijst retourneert. Deze methode is net zo effectief, maar iets omslachtiger. Ze kan vooral nuttig zijn wanneer je leesbaarheid en explicietheid in de code vooropstelt. Hier’s een voorbeeld:

# Create an empty list using the list() function
my_empty_list = list()Mogelijk gemaakt door

Veelvoorkomende bewerkingen op lege lijsten

Weten hoe je lege lijsten bewerkt is cruciaal voor effectief programmeren in Python. Hier zijn een paar kernbewerkingen die je ongetwijfeld nodig hebt wanneer je met lege lijsten werkt.

Elementen toevoegen aan een lege lijst met .append()

Een lege lijst is niet erg handig als je er geen elementen aan kunt toevoegen. Om een element aan het einde van een lijst toe te voegen, gebruik je de methode .append(). In dit voorbeeld initialiseren we een lege lijst en voegen we de woorden ‘Python’, ‘Rocks!’ en ‘It’s easy to learn!’ toe aan de lijst my_list.

# Initialize an empty list
my_list = []

# Append elements
my_list.append('Python')
my_list.append('Rocks!')
my_list.append('It’s easy to learn!')

# `my_list` is now ['Python', 'Rocks!', 'It’s easy to learn!']Mogelijk gemaakt door

Een element op een specifieke plek in een lijst invoegen met .insert()

Een nadeel van .append() is dat het alleen elementen aan het einde van een lijst toevoegt — je hebt dus geen controle over de precieze positie van een nieuw element wanneer je .append() gebruikt. Met de methode .insert() kan dat wel. We gaan verder op het voorbeeld uit de vorige sectie en voegen ‘Truly’ in tussen ‘Python’ en ‘Rocks!’. Let op: Python gebruikt nulgebaseerde indexering, wat betekent dat de index van het eerste element van de lijst 0 is. Zie het voorbeeld voor meer details:

# Initialize an empty list
my_list = []

# Append elements
my_list.append('Python')
my_list.append('Rocks!')
my_list.append('It’s easy to learn!')

# `my_list` is now ['Python', 'Rocks!', 'It’s easy to learn!']

# Showcase zero-based indexing in Python
my_list[0] # Returns 'Python'
my_list[1] # Returns 'Rocks'
my_list[2] # Returns 'It's easy to learn!'

# Use the .insert() method to insert ’Truly’ between ’Python’ and ’Rocks!’
my_list.insert(1, 'Truly')
# `my_list` is now ['Python', 'Truly', 'Rocks', 'It’s easy to learn!']
Mogelijk gemaakt door

Meerdere elementen toevoegen met .extend()

Hoewel de methoden .append() en .insert() perfect zijn voor het toevoegen van individuele elementen aan een lijst, kun je met .extend() meerdere elementen in één keer toevoegen. Dit is vooral handig als je twee lijsten wilt samenvoegen of een verzameling elementen wilt toevoegen zonder erdoorheen te itereren. Voortbouwend op het vorige voorbeeld voegen we nog een paar beschrijvende woorden toe aan onze my_list om onze zin interessanter te maken:

# Reminder that `my_list` is ['Python', 'Truly', 'Rocks', 'It’s easy to learn!']

# Extend my_list with ['and', 'fun', 'to', 'use!']
my_list.extend(['and', 'fun', 'to', 'use!'])

# `my_list` is now ['Python', 'Truly', 'Rocks!', 'It’s easy to learn!', 'and', 'fun', 'to', 'use!']Mogelijk gemaakt door

In dit voorbeeld neemt .extend() een iterabele (zoals een lijst, set of tuple) en voegt elk element hiervan toe aan het einde van my_list, waardoor onze zin wordt uitgebreid.

Lijsten samenvoegen met +

Een andere manier om elementen van de ene lijst aan een andere toe te voegen is met de operator +, die twee lijsten concateneert. Deze methode is eenvoudig en wijzigt de originele lijsten niet, maar maakt in plaats daarvan een nieuwe lijst. Laten we een nieuwe lijst samenvoegen met onze bestaande my_list:

# Define a new list to concatenate
additional_words = ['Python is also', 'very versatile.']

# Concatenate lists using +
complete_sentence = my_list + additional_words

# `complete_sentence` now contains the elements of both lists
# `complete_sentence` is now ['Python', 'Truly', 'Rocks!', 'It’s easy to learn!', 'and', 'fun', 'to', 'use!', 'Python is also', 'very versatile.']
Mogelijk gemaakt door

In dit voorbeeld neemt .extend() een iterabele (zoals een lijst, set of tuple) en voegt elk element hiervan toe aan het einde van my_list, waardoor onze zin wordt uitgebreid.

Lijsten kopiëren met .copy()

Een lijst kopiëren is essentieel wanneer je de originele lijst wilt behouden voordat je de kopie wijzigt. De methode .copy() maakt een ondiepe kopie van de lijst: de lijst zelf wordt gedupliceerd, maar niet de diep geneste objecten erin. Laten we een kopie maken van my_list:

# Make a copy of `my_list`
my_list_copy = my_list.copy()

# Verify that `my_list_copy` is a separate object
assert my_list_copy is not my_list  # This will pass, confirming they are different objectsMogelijk gemaakt door

Met .copy() zorg je ervoor dat wijzigingen aan de gekopieerde lijst de originele lijst niet beïnvloeden.

De lijst leegmaken met .clear()

Soms wil je een lijst terugzetten naar de lege toestand en alle elementen verwijderen. Met de methode .clear() kan dat, waarbij de lijst in-place wordt aangepast. Laten we my_list leegmaken:

# Clear all elements from `my_list`
my_list.clear()

# `my_list` is now an empty list again
assert len(my_list) == 0  # This will pass, confirming the list is emptyMogelijk gemaakt door

De methode .clear() is vooral handig in situaties waarin je de lijst wilt hergebruiken of resetten zonder een nieuw lijstobject te maken.

Veelvoorkomende use-cases voor het initialiseren van lege Python-lijsten

Lege lijsten zijn onmisbaar in uiteenlopende programmeerscenario’s. Als je hun toepassingen begrijpt, kun je veel efficiënter coderen en problemen oplossen.

Dynamisch data opslaan in een lege lijst

In situaties waarin de hoeveelheid of het type data onvoorspelbaar is, zijn lege lijsten flexibele containers om informatie dynamisch te verzamelen. Neem een programma dat gebruikersinvoer leest totdat aan een bepaalde voorwaarde is voldaan. We weten dan niet hoeveel invoeren we krijgen, en met de methode .append() kunnen we dynamisch elementen toevoegen aan de lijst user_response.

# Initialize an empty list to store user input
user_responses = []

# Collect user input in a loop
while True:
    response = input("Enter your response (or type 'exit' to finish): ")
    if response.lower() == 'exit':
        break
    user_responses.append(response)

# User responses are now stored in `user_responses`Mogelijk gemaakt door

Resultaten opslaan in een lege lijst vanuit een For-lus

Bij het werken met lussen zijn lege lijsten van onschatbare waarde om resultaten van elke iteratie te verzamelen. Hier is een voorbeeld waarin we even getallen opslaan terwijl we door het bereik van 0 tot 20 lopen.

# Initialize an empty list to store even numbers
even_numbers = []

# Loop through a range of numbers and store even ones
for number in range(21):  # Upper limit 21 to include 20 in the range
    if number % 2 == 0: # if remainder when divided by 2 =0, store it in empty list
        even_numbers.append(number)

# `even_numbers` now contains even numbers from 0 to 20Mogelijk gemaakt door

Functie-uitvoer opslaan in lege lijsten

Wanneer je functies ontwerpt met variabele retourwaarden, kan het initialiseren en retourneren van een lege lijst op elegante wijze omgaan met scenario’s zonder resultaten. Hier lopen we bijvoorbeeld over een lijst met woorden en slaan we de woorden die beginnen met ‘A’ op in een lege lijst.

def find_strings_starting_with_a(strings):
    # Initialize an empty list to store strings that start with 'A'
    strings_starting_with_a = []
    
    # Iterate over the input list and append strings that start with 'A' to `strings_starting_with_a`
    for string in strings:
        if string.startswith('A'):
            strings_starting_with_a.append(string)
    
    return strings_starting_with_a

# Example usage
result = find_strings_starting_with_a(['Assert', 'Import', 'Function', 'Array', 'Arguments'])

# 'result' will contain ['Assert', 'Array', 'Arguments']Mogelijk gemaakt door

Conclusie

Kortom, het beheersen van lege lijsten en hun bewerkingen is cruciaal in Python, en maakt veelzijdige datamanipulatie mogelijk. Met append, insert, extend, concatenatie, kopiëren en leegmaken hebben we gezien hoe je lijsten in praktische scenario’s effectief beheert. Deze basisvaardigheden vormen de ruggengraat van Python-code, zodat je met gemak en creativiteit complexere problemen kunt aanpakken.

Je kunt meer leren over Python-lijsten en veel andere handige functies in onze Python Fundamentals skill track — ga vandaag nog aan de slag!