Lijsten splitsen in Python: basis- en geavanceerde methoden

Q: Wat is het verschil tussen het splitsen van een Python-lijst en partition()?

De partition() -methode retourneert drie tuples waarbij het scheidingsteken in het midden staat.

Python-lijsten zijn dynamische, muteerbare array-datatypen die worden gebruikt om geordende items op te slaan. Lijsten splitsen is een veelvoorkomende taak in Python en is essentieel om data efficiënt te manipuleren en analyseren.

Wil je meer leren over data-analyse? Volg dan de carrièreroute Data Analyst with Python om je skills aan te scherpen. Die gaat dieper in op verschillende manieren om lijsten in Python te splitsen, inclusief praktische voorbeelden en best practices.

Als je deze technieken beheerst, worden je scripts efficiënter en onderhoudsvriendelijker. Laten we beginnen.

Het korte antwoord: hoe split je een lijst in Python

De eenvoudigste manier om een lijst in Python te splitsen is door te slicen met de operator :. Zo kun je een lijst splitsen: split_list = my_list[:5], waarmee je de lijst splitst bij de vijfde index.
De rest van dit artikel verkent andere manieren om een lijst te splitsen, waaronder list comprehensions, itertools, numpy en meer. Elke methode heeft unieke voordelen en is geschikt voor verschillende use-cases, zoals we zullen zien.

De meest gebruikte methode: een lijst splitsen met slicing

Python-lijst op index splitsen is waarschijnlijk de meest voorkomende techniek. Met slicing wordt de Python-lijst in sublijsten gesplitst op de opgegeven index. Hieronder staat stap voor stap hoe je slicing in Python toepast.

Definieer de lijst: Stel, je hebt de lijst [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] en je wilt die splitsen op een specifieke index n.
Bepaal de splitindex: Geef de index n op waar je de lijst wilt slicen.
Maak de eerste slice: In de onderstaande code bevat first_slice de elementen vanaf het begin van de lijst tot, maar exclusief, index n.
Maak de tweede slice: second_slice bevat alle elementen van index n tot het einde van de lijst.

# Define a list of integers from 1 to 10
my_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

# Index where the list will be split
n = 4

# Slice the list from the beginning to the nth index (not inclusive)
first_slice = my_list[:n]

# Slice the list from the nth index to the end
second_slice = my_list[n:]

# Print the first slice of the list
print("First slice:", first_slice)

# Print the second slice of the list
print("Second slice:", second_slice)

# Expected output:
# First slice: [1, 2, 3, 4]
# Second slice: [5, 6, 7, 8, 9, 10]Mogelijk gemaakt door

Lijst-splitting in Python begrijpen

Lijst-slicing in Python houdt in dat je een sublijst of sublijsten uit de hoofdlist haalt. Als je een lijst in Python wilt splitsen, moet je de slicing-syntaxis begrijpen om de juiste sublijst te krijgen. De slicing-syntaxis is slice[start:stop:step].

Start geeft het startindex van de slicing aan.
Stop geeft het eindindex van de slicing aan.
Step geeft de intervallen tussen slicing aan (standaard 1).

# Define a list of integers from 1 to 10
my_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

# Slice the list from index 2 to 7 (index 2 inclusive, index 7 exclusive)
# This will include elements at index 2, 3, 4, 5, and 6
sublist = my_list[2:7]

# Print the sliced sublist
print(sublist) 

# Expected output: [3, 4, 5, 6, 7]Mogelijk gemaakt door

In de bovenstaande code loopt de slicing van index 2 tot en met index 6, omdat index 7 niet is inbegrepen.

De voordelen van Python-lijsten splitsen qua codeleesbaarheid en efficiëntie zijn onder meer:

Databeheer vereenvoudigen: Door data in behapbare stukken op te delen, kunnen data scientists eenvoudig trainings- en testdata scheiden voor machine learning.
Meer modulariteit: Functies schrijven met specifieke sublijsten verhoogt de modulariteit van je code.
Prestatieoptimalisatie: Werken met kleinere lijststukken levert snellere verwerking op dan werken met hele lijsten.
Betere geheugenefficiëntie: De methode maakt stukken zonder de onderliggende data te kopiëren, wat geheugen bespaart.

Verschillende technieken om lijsten in Python te splitsen

Er zijn verschillende manieren om een lijst in Python te splitsen. Hieronder staan veelvoorkomende voorbeelden die een data-practitioner in de praktijk kan tegenkomen.

Slicing gebruiken

Bij Python-lijst-slicing gebruik je de operator : om de lijst op de index te splitsen. Deze methode gebruikt indexering om het begin en einde van de slice te bepalen.

De verschillende slicing-technieken zijn onder andere:

Slicing met positieve index

Deze methode gebruikt positieve indexwaarden, van links naar rechts, om de elementen in de lijst te benaderen.

# Define a list of integers from 1 to 10
my_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

# Slice the list from index 2 to 7 (index 2 inclusive, index 7 exclusive)
# This will include elements at index 2, 3, 4, 5, and 6
sublist = my_list[2:7]

# Print the sliced sublist
print(sublist) 

# Expected output: [3, 4, 5, 6, 7]Mogelijk gemaakt door

Slicing met negatieve index

Deze Python-methode gebruikt negatieve indexwaarden, beginnend bij het laatste element in de lijst en lopend van rechts naar links.

# Define a list of integers from 1 to 10
my_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

# Slice the list to get the last 5 elements
sublist = my_list[-5:]

# Print the sliced sublist containing the last 5 elements
print(sublist)

# Slice the list to get all elements except the last 3
sublist = my_list[:-3]

# Print the sliced sublist containing all but the last 3 elements
print(sublist)

# Expected output:
# [6, 7, 8, 9, 10]
# [1, 2, 3, 4, 5, 6, 7]Mogelijk gemaakt door

De step-parameter gebruiken

Deze aanpak gebruikt een stapgrootte om de lijst te selecteren bij het benaderen van verschillende elementen.

# Define a list of integers from 1 to 10
my_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

# Slice the list to get every second element, starting from the beginning
sublist = my_list[::2]

# Print the sliced sublist containing every second element
print(sublist) 

# Slice the list to get every second element, starting from index 1
sublist = my_list[1::2]

# Print the sliced sublist containing every second element, starting from index 1
print(sublist) 

# Slice the list to get the elements in reverse order
sublist = my_list[::-1]

# Print the sliced sublist containing the elements in reverse order
print(sublist) 

# Expected output:
# [1, 3, 5, 7, 9]
# [2, 4, 6, 8, 10]
# [10, 9, 8, 7, 6, 5, 4, 3, 2, 1]Mogelijk gemaakt door

Indexen weglaten

Deze methode slice’t de Python-lijst door alleen de benodigde elementen te retourneren.

# Define a list of integers from 1 to 10
my_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

# Slice the list from the start to index 5 (index 5 not inclusive)
sublist = my_list[:5]

# Print the sliced sublist containing elements from the start to index 4
print(sublist) 

# Slice the list from index 5 to the end
sublist = my_list[5:]

# Print the sliced sublist containing elements from index 5 to the end
print(sublist) 

# Slice the list to get the entire list
sublist = my_list[:]

# Print the sliced sublist containing the entire list
print(sublist) 

# Expected output:
# [1, 2, 3, 4, 5]
# [6, 7, 8, 9, 10]
# [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]Mogelijk gemaakt door

List comprehensions gebruiken

Met een Python list comprehension kun je een lijst in stukken splitsen op basis van de waarden in de bestaande lijst.

# Define a function to split a list into chunks of a specified size
def split_list(lst, chunk_size):
    # Use a list comprehension to create chunks
    # For each index 'i' in the range from 0 to the length of the list with step 'chunk_size'
    # Slice the list from index 'i' to 'i + chunk_size'
    return [lst[i:i + chunk_size] for i in range(0, len(lst), chunk_size)]

# Define a list of integers from 1 to 15
my_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]

# Split the list into chunks of size 3 using the split_list function
chunks = split_list(my_list, 3)

# Print the resulting list of chunks
print(chunks)

# Expected output:
# [[1, 2, 3], [4, 5, 6], [7, 8, 9], [10, 11, 12], [13, 14, 15]]Mogelijk gemaakt door

De bovenstaande code splitst een Python-lijst in n stukken met grootte drie en retourneert een nieuwe lijst met deeltjes van 3 waarden.

Itertools gebruiken

Python-lijsten splitsen met itertools gebruikt de Python-module om data via iteratie te transformeren.

# Import the islice function from the itertools module
from itertools import islice
# Define a function to yield chunks of a specified size from an iterable
def chunks(iterable, size):
    # Create an iterator from the input iterable
    iterator = iter(iterable)
    
    # Loop over the iterator, taking the first element in each iteration
    for first in iterator:
        # Yield a list consisting of the first element and the next 'size-1' elements from the iterator
        yield [first] + list(islice(iterator, size - 1))

# Define a list of integers from 1 to 15
my_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]

# Convert the generator returned by the chunks function into a list of chunks
chunked_list = list(chunks(my_list, 3))

# Print the resulting list of chunks
print(chunked_list)

# Expected output:
# [[1, 2, 3], [4, 5, 6], [7, 8, 9], [10, 11, 12], [13, 14, 15]]Mogelijk gemaakt door

numpy gebruiken

De numpy-bibliotheek in Python is handig om arrays in sublijsten te splitsen. Met de functie .array_split() kun je splitsen op basis van het aantal gewenste delen.

# Import the numpy library and alias it as np
import numpy as np

# Define a list of integers from 1 to 15
my_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]

# Use numpy's array_split function to split the list into 3 chunks
chunks = np.array_split(my_list, 3)

# Convert each chunk back to a regular list and print the resulting list of chunks
print([list(chunk) for chunk in chunks])

# Expected output:
# [[np.int32(1), np.int32(2), np.int32(3), np.int32(4), np.int32(5)], [np.int32(6), np.int32(7), np.int32(8), np.int32(9), np.int32(10)], [np.int32(11), np.int32(12), np.int32(13), np.int32(14), np.int32(15)]]Mogelijk gemaakt door

Lijsten in stukken splitsen

Met de volgende Python-functie kun je ook een lijst in stukken splitsen. Deze stukken kunnen op maat zijn, afhankelijk van het aantal dat een gebruiker nodig heeft.

# Define a function to split a list into chunks of a specified size
def split_into_chunks(lst, chunk_size):
    chunks = []  # Initialize an empty list to store chunks
    
    # Iterate over the list with a step of chunk_size
    for i in range(0, len(lst), chunk_size):
        # Slice the list from index 'i' to 'i + chunk_size' and append it to chunks
        chunks.append(lst[i:i + chunk_size])
    
    return chunks  # Return the list of chunks

# Define a list of integers from 1 to 16
my_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16]

# Split the list into chunks of size 4 using the split_into_chunks function
chunks = split_into_chunks(my_list, 4)

# Print the resulting list of chunks
print(chunks)

# Expected output:
# [[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12], [13, 14, 15, 16]]Mogelijk gemaakt door

Lijsten splitsen op basis van voorwaarden

Als je een lijst in Python wilt splitsen, kun je regels/voorwaarden instellen voor de sublijst. Met deze methode maak je een sublijst die aan die voorwaarden voldoet.

# Define a list of integers from 1 to 15
my_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]

# List comprehension to filter elements divisible by 3
div_3 = [x for x in my_list if x % 3 == 0]

# List comprehension to filter elements not divisible by 3
not_div_3 = [x for x in my_list if x % 3 != 0]

# Print the list of elements divisible by 3
print(div_3)

# Print the list of elements not divisible by 3
print(not_div_3)

# Expected output:
# [3, 6, 9, 12, 15]
# [1, 2, 4, 5, 7, 8, 10, 11, 13, 14]Mogelijk gemaakt door

for-loops gebruiken

For-loops kunnen ook worden gebruikt om lijsten in Python te splitsen, zowel op basis van voorwaarden als via iteratie.

# Define a function to split a list into sub-lists of size n
def split_by_n(lst, n):
    # Use a list comprehension to create sub-lists
    # For each index 'i' in the range from 0 to the length of the list with step 'n'
    # Slice the list from index 'i' to 'i + n'
    return [lst[i:i + n] for i in range(0, len(lst), n)]

# Define a list of integers from 1 to 15
my_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]

# Split the list into sub-lists of size 5 using the split_by_n function
sub_lists = split_by_n(my_list, 5)

# Print the resulting list of sub-lists
print(sub_lists) 

# Expected output:
# [[1, 2, 3, 4, 5], [6, 7, 8, 9, 10], [11, 12, 13, 14, 15]]Mogelijk gemaakt door

De functie zip() gebruiken

Je kunt ook de functie zip() in Python gebruiken om lijsten te koppelen en zo te splitsen.

# Define two lists: list1 containing integers from 1 to 10, and list2 containing letters from 'a' to 'j'
list1 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
list2 = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j']

# Use the zip function to pair corresponding elements from list1 and list2 into tuples
paired = list(zip(list1, list2))

# Print the list of paired tuples
print(paired)

# Expected output:
# [(1, 'a'), (2, 'b'), (3, 'c'), (4, 'd'), (5, 'e'), (6, 'f'), (7, 'g'), (8, 'h'), (9, 'i'), (10, 'j')]Mogelijk gemaakt door

De functie enumerate() gebruiken

De functie enumerate() splitst Python-lijsten met indexvoorwaarden. Deze functie gebruikt iteratie om een lijst in gelijke stukken te splitsen.

# Define a list of integers from 1 to 15
my_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]

# Define the chunk size for splitting the list
chunk_size = 5

# Create a list of empty lists, one for each chunk
split_list = [[] for _ in range(chunk_size)]

# Iterate over the elements and their indices in my_list
for index, value in enumerate(my_list):
    # Calculate the index of the sublist where the current value should go using modulo operation
    sublist_index = index % chunk_size
    
    # Append the current value to the corresponding sublist in split_list
    split_list[sublist_index].append(value)

# Print the list of sublists after splitting my_list into chunks
print(split_list)

# Expected output:
# [[1, 6, 11], [2, 7, 12], [3, 8, 13], [4, 9, 14], [5, 10, 15]]Mogelijk gemaakt door

Python string naar lijst splitsen

De methode split() gebruiken

De methode split() splitst een string in Python in een lijst, op basis van een opgegeven scheidingsteken. De methode retourneert substrings afhankelijk van het aantal scheidingstekens in de string.

# Define a string
myString = "Goodmorning to you"

# Split the string into a list of words based on whitespace (default separator)
my_list = myString.split()

# Print the resulting list
print(my_list) 

# Expected output: ['Goodmorning', 'to', 'you']Mogelijk gemaakt door

De methode splitlines() gebruiken

De methode splitlines() splitst een string in een lijst in Python op basis van het regeleinde-teken.

# Define a string with newline characters
myString = "Goodmorning\nto\nyou"

# Split the string into a list of lines based on newline characters
my_list = myString.splitlines()

# Print the resulting list
print(my_list)

# Expected output: ['Goodmorning', 'to', 'you']Mogelijk gemaakt door

De methode partition() gebruiken

De methode partition() splitst strings in Python in lijsten met behulp van het opgegeven scheidingsteken. Deze methode retourneert drie delen: de string vóór het scheidingsteken, het scheidingsteken zelf en alles erna als lijst.

# Define a string with a delimiter '/'
myString = "Goodmorning/to you"

# Use the partition() method to split the string into three parts based on the first occurrence of '/'
my_list = myString.partition('/')

# Print the resulting tuple
print(my_list)

# Expected output: ('Goodmorning', '/', 'to you')Mogelijk gemaakt door

Reguliere expressies gebruiken

In Python kun je ook reguliere expressies gebruiken om een string in een lijst te splitsen. Het onderstaande voorbeeld laat zien hoe je dit met witruimte doet.

# Import the 're' module for regular expressions
import re

# Define a string
myString = "Goodmorning to you"

# Use re.split() to split the string based on whitespace ('\s' matches any whitespace character)
# Returns a list of substrings where the string has been split at each whitespace
my_list = re.split('\s', myString)

# Print the resulting list
print(my_list)

# Expected output: ['Goodmorning', 'to', 'you']Mogelijk gemaakt door

Vergelijkingstabel

Hier is een tabel zodat je in één oogopslag ziet wanneer verschillende technieken nuttig kunnen zijn. In de praktijk werkt dezelfde techniek vaak voor veel gevallen zonder grote prestatieverschillen, dus de opmerkingen over wanneer een bepaalde techniek het meest nuttig is, zijn enigszins overdreven.

Techniek	Use-case	Wanneer nuttig
Slicing	Een lijst splitsen op een specifieke index of indexbereik.	Nuttig voor eenvoudige, rechttoe-rechtaan splitsingen.
List comprehensions	Sublijsten maken op basis van waarden of voorwaarden in de lijst.	Nuttig voor complexere, criteriagebaseerde splitsingen.
itertools.islice	Een lijst in stukken splitsen van een opgegeven grootte met een iterator.	Nuttig voor het efficiënt verwerken van grote lijsten.
numpy.array_split	Arrays in sublijsten splitsen op basis van het gewenste aantal splitsingen.	Nuttig voor efficiënte verwerking van numerieke data.
Splitsen op basis van voorwaarden	Een lijst splitsen op basis van voorwaarden zoals deelbaarheid.	Nuttig om data in betekenisvolle sublijsten te scheiden.
For-loops	Door een lijst itereren om sublijsten van een specifieke grootte te maken.	Nuttig voor meer controle over het splitsingsproces.
zip()-functie	Elementen uit twee lijsten koppelen.	Nuttig om data uit twee gerelateerde lijsten te combineren.
enumerate()-functie	Lijsten splitsen met indexvoorwaarden, vaak in gelijke stukken.	Nuttig voor het maken van gelijk verdeelde sublijsten.
split()-methode	Strings in lijsten splitsen op basis van een opgegeven scheidingsteken.	Nuttig voor verwerking van tekstdata.
splitlines()-methode	Strings in lijsten splitsen op basis van regeleinden.	Nuttig bij het lezen van tekstdata met meerdere regels.
partition()-methode	Strings in drie delen splitsen op basis van een opgegeven scheidingsteken.	Nuttig voor specifieke tekstverwerkingssituaties.
Reguliere expressies	Regex gebruiken om strings in lijsten te splitsen op complexe patronen.	Nuttig voor geavanceerde tekstmanipulatie.

Veelvoorkomende valkuilen en hoe je ze vermijdt

Een data-professional kan een aantal veelvoorkomende fouten tegenkomen bij het splitsen van lijsten in Python. Hieronder staan enkele valkuilen en hoe je ze voorkomt.

Off-by-one-fouten

Een off-by-one-fout ontstaat bij basis-slicing wanneer je minder of meer indexen opneemt dan nodig in de lijst.

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

# Trying to get sublist from index 2 to 4, inclusive
sublist = my_list[2:5]  # Correct: my_list[2:5]
print(sublist)

# Incorrect usage:
sublist = my_list[2:4]  # Incorrect, excludes index 4
print(sublist)

# Expected output:
# [3, 4, 5]
# [3, 4]Mogelijk gemaakt door

Om deze fout te vermijden, is het belangrijk de indexeringsreeks in Python te begrijpen en te weten wat je moet in- of uitsluiten bij het indexeren.

Fouten met gebruikte pakketten

Je kunt ook fouten tegenkomen met pakketten, vooral wanneer de split-methode Python-modules vereist. Voorbeelden zijn de pakketten numpy, re en itertools. Zorg ervoor dat de pakketten correct zijn geladen en dat je compatibele versies gebruikt.

Randgevallen afhandelen

Randgevallen kunnen optreden bij het splitsen van lijsten in Python als je geen rekening houdt met bepaalde scenario’s. In het onderstaande fragment probeert een functie lijsten in stukken van 5 te splitsen terwijl de lijst slechts 4 items bevat.

import numpy as np

my_list = [1, 2, 3, 4]
chunks = np.array_split(my_list, 5)
print(chunks)

# Expected output: 
# [array([1]), array([2]), array([3]), array([4]), array([], dtype=int32)]Mogelijk gemaakt door

Om dit te voorkomen, gebruik je voorwaardelijke logica om het randgeval af te handelen, zoals hieronder.

import numpy as np

my_list = [1, 2, 3, 4]
if len(my_list) < 5:
    chunks = [my_list]
else:
    chunks = np.array_split(my_list, 5)
print(chunks)

# Expected output: [[1, 2, 3, 4]]Mogelijk gemaakt door

Speciale tekens afhandelen

Speciale tekens niet goed afhandelen kan ook tot fouten leiden bij het splitsen van stringlijsten in Python. Deze speciale tekens omvatten spaties, komma’s of alfanumerieke tekens.

Het voorbeeld hieronder laat zien hoe je dit voorkomt door het teken te specificeren waarop je de stringlijst splitst.

# Example list with special characters
my_list = ["apple, orange", "dog, mouse", "green, blue"]

# Splitting each string by the comma
split_list = [s.split(",") for s in my_list]
print(split_list)

# Expected output:
# [['apple', ' orange'], ['dog', ' mouse'], ['green', ' blue']]Mogelijk gemaakt door

Best practices en richtlijnen

Omdat lijsten splitsen in Python een veelgebruikte bewerking is in data-analyse, is het belangrijk een aantal praktijken te volgen voor efficiëntie. Aanbevelingen zijn onder andere:

Behoud waar mogelijk immutabiliteit: Als de originelijst niet mag worden aangepast, zorg er dan voor dat je slicing-bewerkingen de originelijst niet wijzigen. Slicing maakt nieuwe lijsten, dus dit is meestal geen probleem, maar wees alert bij complexere datastructuren.
Optimaliseer voor performance: Wees bij grote lijsten bedacht op prestatiegevolgen. Slicing is doorgaans efficiënt, maar onnodig kopiëren van grote lijsten kan tot bottlenecks leiden.
Houd rekening met randgevallen: Denk aan randgevallen zoals een lege lijst, splitsen aan het begin of einde van de lijst en ongeldige indexen. Zorg dat je code deze scenario’s netjes afhandelt.
Voorzie in foutafhandeling en validatie: Foutafhandeling is vooral belangrijk wanneer je een lijst in meerdere lijsten wilt splitsen in Python, zodat je code niet onverwachts breekt.

De cursus Python Programming van DataCamp biedt een uitgebreide uitleg over best practices om efficiënte code te schrijven, met aandacht voor veelvoorkomende concepten zoals foutafhandeling en performance.

Geavanceerde technieken voor het splitsen van lijsten

Je kunt lijsten op een geavanceerder niveau splitsen met methoden die meer controle en flexibiliteit bieden.

Lijst splitsen in meerdere lijsten

Je kunt de Python-lijst in meerdere lijsten splitsen door splitsingen op specifieke indexen op te geven. In de onderstaande code wordt de lijst bijvoorbeeld gesplitst bij index 2, 5, 7.

def split_at_indices(lst, indices):
    result = []
    prev_index = 0
    for index in indices:
        result.append(lst[prev_index:index])
        prev_index = index
    result.append(lst[prev_index:])
    return result

my_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
indices = [2, 5, 7]
split_lists = split_at_indices(my_list, indices)
print(split_lists)

# Expected output: [[1, 2], [3, 4, 5], [6, 7], [8, 9, 10]]Mogelijk gemaakt door

Lijst splitsen in gelijke delen

Je kunt ook een ingebouwde bibliotheek zoals ‘numpy’ gebruiken om een Python-lijst in gelijke delen te splitsen op basis van het gewenste aantal delen.

import numpy as np

my_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]
num_parts = 3
split_lists = np.array_split(my_list, num_parts)
print([list(arr) for arr in split_lists])

# Expected output:
# [[np.int32(1), np.int32(2), np.int32(3), np.int32(4), np.int32(5)], [np.int32(6), np.int32(7), np.int32(8), np.int32(9), np.int32(10)], [np.int32(11), np.int32(12), np.int32(13), np.int32(14), np.int32(15)]]Mogelijk gemaakt door

Een lijst halveren

Je kunt slicing gebruiken om een Python-lijst te halveren.

def split_in_half(lst):
    # Calculate the midpoint index of the list
    mid_index = len(lst) // 2
    # Return the two halves of the list
    return lst[:mid_index], lst[mid_index:]

# Example list
my_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

# Split the list into two halves
first_half, second_half = split_in_half(my_list)
print(first_half)
print(second_half)

# Expected output:
# [1, 2, 3, 4, 5]
# [6, 7, 8, 9, 10]Mogelijk gemaakt door

Bij een lijst met een oneven aantal elementen kun je aangeven dat het middelste element in de eerste helft moet vallen.

def split_in_half(lst):
    # Calculate the midpoint index of the list, including the middle element in the first half if the length is odd
    mid_index = (len(lst) + 1) // 2
    # Return the two halves of the list
    return lst[:mid_index], lst[mid_index:]

# Example list
my_list = [1, 2, 3, 4, 5, 6, 7, 8, 9]

# Split the list into two halves, handling odd-length
first_half, second_half = split_in_half(my_list)
print(first_half) 
print(second_half) 

# Expected output:
# [1, 2, 3, 4, 5]
# [6, 7, 8, 9]Mogelijk gemaakt door

De Python Developer biedt ook inzichten in het schrijven van geavanceerde code die je helpt geavanceerde lijst-splittingstechnieken te begrijpen.

Conclusie

Er zijn verschillende methoden om lijsten in Python te splitsen. Elke methode hangt af van het type lijst en je voorkeur voor efficiëntie. Als data-professional is het belangrijk de juiste methode te kiezen die past bij je analyse.

Voor een grondig begrip van het splitsen van lijsten in Python kun je meer leren in onze cursus Python Fundamentals. Je kunt ook de cursus Introduction to Python volgen om zeker te zijn dat je het werken met lijsten en andere datatypen in Python beheerst. De Python Cheat Sheet for Beginners is ook handig als je in één oogopslag wilt zien hoe je een lijst in Python splitst.

Auteur

Allan Ouko

Technical writer voor data science met praktische ervaring in data-analyse, business intelligence en data science. Ik schrijf praktische, op de industrie gerichte content over SQL, Python, Power BI, Databricks en data engineering, gebaseerd op analytisch werk in de echte wereld. Mijn schrijfwerk slaat een brug tussen technische diepgang en zakelijke impact, en helpt professionals om data om te zetten in onderbouwde beslissingen.

Veelgestelde vragen

Wanneer moet ik een lijst in Python splitsen?

Python-lijsten splitsen is belangrijk voor gegevensverwerking, vooral bij het beheren van grote datasets. De transformaties helpen wanneer je data splitst om analyses uit te voeren, zoals het trainen en testen van machinelearningmodellen.

Wat moet ik doen als de modules itertools en numpy een fout geven?

Zorg dat je de juiste Python-bibliotheken hebt geïnstalleerd. Als de fout blijft optreden, update dan en gebruik compatibele versies van de bibliotheken.

Wat is het verschil tussen het splitsen van een Python-lijst en partition()?

De partition()-methode retourneert drie tuples waarbij het scheidingsteken in het midden staat.

Kan ik een Python-lijst splitsen met een specifiek scheidingsteken of een bepaalde waarde?

Je moet het scheidingsteken of de waarde opgeven waarop je de lijst wilt splitsen.

Hoe verbeter ik de performance van mijn code wanneer ik een lijst in meerdere lijsten splitst?

Gebruik een herbruikbare functie wanneer je een lijst in meerdere lijsten splitst. Deze aanpak zorgt voor efficiëntie.

Onderwerpen

Python Data-analyse