Comment diviser des listes en Python : Exemples de base et méthodes avancées

Les listes Python sont des types de données dynamiques et modifiables utilisés pour stocker des éléments ordonnés. Le fractionnement de listes est une tâche courante en Python, essentielle pour manipuler et analyser efficacement les données. 

Vous pouvez approfondir vos connaissances en analyse de données en suivant le cursus professionnel Data Analyst with Python afin d'affiner vos compétences. Ce cursus explore les différentes méthodes permettant de diviser des listes dans Python, et comprend des exemples pratiques et des bonnes pratiques. 

La maîtrise de ces techniques améliorera vos compétences en codage, rendant vos scripts plus efficaces et plus faciles à maintenir. Commençons.

Réponse rapide : Comment diviser une liste en Python

• La méthode la plus simple pour diviser une liste en Python consiste à utiliser l'opérateur de tranche (slicing) avec l'opérateur :. Par exemple, nous pouvons diviser une liste de la manière suivante : split_list = my_list[:5], ce qui divise la liste au cinquième index. 

• La suite de cet article explore d'autres méthodes pour diviser une liste, notamment les compréhensions de listes, itertools, numpy, et bien d'autres encore. Chaque méthode présente des avantages uniques et convient à différents cas d'utilisation, comme nous le verrons.

Méthode la plus courante : diviser une liste à l'aide du découpage

La division de liste Python à l'index est probablement la technique de division de liste la plus courante. La méthode slicing garantit que la liste Python est divisée en sous-listes à l'index spécifié. Voici un guide étape par étape sur la manière de mettre en œuvre le découpage en Python.

• Définir la liste : Supposons que vous disposiez d'une liste [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] et que vous souhaitiez la diviser à un index spécifique n.
• Identifier l'indice de division : Veuillez indiquer l'n d'index où vous souhaitez découper la liste.
• Créer la première tranche : Dans le code ci-dessous, veuillez créer first_slice pour contenir les éléments du début de la liste jusqu'à l'index n, sans l'inclure.
• Créer la deuxième tranche : Définissez second_slice pour inclure tous les éléments de l'index n jusqu'à la fin de la liste.

# 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]

Comprendre le fractionnement de listes en Python

Le découpage de liste en Python consiste à extraire une ou plusieurs sous-listes d'une liste principale. Lorsque vous souhaitez diviser une liste en Python, il est important de comprendre la syntaxe de découpage afin de mieux appréhender la sous-liste appropriée. La syntaxe de découpage est la suivante : slice[start:stop:step].

1. Le paramètre « Start » indique le début de l'index du découpage.
2. Stop indique la fin de l'index du découpage.
3. L'intervalle entre les tranches est indiqué (1 par défaut).

# 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]

Conformément au code ci-dessus, le découpage commence à l'index 2 et se termine à l'index 6, car la sous-liste n'inclut pas l'index 7.

Les avantages de la fonction split de Python en termes de lisibilité et d'efficacité du code sont les suivants :

• Simplification de la gestion des données : En divisant les données en segments gérables, les scientifiques des données peuvent facilement séparer les données d'entraînement et de test dans l'apprentissage automatique.
• Modularité accrue : L'écriture de fonctions avec des sous-listes spécifiques améliore la modularité de votre code.
• Optimisation des performances : L'utilisation de segments de liste plus petits permet un traitement plus rapide par rapport à l'utilisation de listes entières.
• Amélioration de l'efficacité de la mémoire : Cette méthode crée des blocs sans copier les données sous-jacentes, ce qui permet d'optimiser l'utilisation de la mémoire.

Différentes techniques pour diviser des listes en Python

Il existe différentes méthodes pour diviser une liste en Python. Vous trouverez ci-dessous des exemples courants auxquels un professionnel des données peut être confronté dans le cadre de son activité.

Utilisation du découpage de liste

Le découpage de liste Python utilise l'opérateur : pour diviser la liste à l'index. Cette méthode utilise la technique d'indexation pour définir le début et la fin du découpage.

Les différentes techniques de découpe comprennent les suivantes :

Découpage d'index positif

Cette méthode utilise les valeurs d'indices positives, en commençant de gauche à droite, pour accéder aux éléments de la liste.

# 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]

Découpage d'index négatif

Cette méthode Python de division de liste utilise les valeurs d'indices négatives en commençant par le dernier élément de la liste, de droite à gauche.

# 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]

Utilisation de la méthode par étapes

Cette approche utilise des conditions spécifiques pour diviser la liste lors de l'accès à différents éléments.

# 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]

Omettre les indices

Cette méthode découpe la liste Python en ne renvoyant que les éléments requis dans une liste.

# 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]

Utilisation des compréhensions de listes

La compréhension de liste Python permet de diviser une liste en segments en fonction des valeurs de la liste existante.

# 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]]

n Le code ci-dessus utilise Python pour diviser la liste en segments de trois éléments afin de renvoyer une nouvelle liste contenant des segments de trois valeurs.

Utilisation d'Itertools

La fonction Python split list utilisant itertools exploite le module Python pour transformer les données par itération.

# 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]]

Utilisation de numpy

La bibliothèque numpy de Python est utile pour diviser des tableaux en sous-listes. La fonction .array_split() permet d'effectuer des divisions en spécifiant le nombre de divisions.

# 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)]]

Diviser les listes en segments

La fonction Python suivante permet également de diviser une liste en plusieurs parties. Ces segments peuvent être personnalisés en fonction du nombre requis par l'utilisateur.

# 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]]

Diviser des listes en fonction de conditions

Lorsque vous souhaitez diviser une liste en Python, vous pouvez définir certaines règles/conditions pour la sous-liste. Cette méthode vous permet de créer une sous-liste qui répond à ces conditions.

# 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]

Utilisation des boucles « for »

Les boucles « for » peuvent également être utilisées pour diviser des listes en Python en fonction de conditions et par itération.

# 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]]

Utilisation de la fonction zip()

Vous pouvez également utiliser la fonction zip() en Python pour diviser une liste par paires.

# 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')]

Utilisation de la fonction enumerate()

La fonction enumerate() divise les listes Python en utilisant des conditions d'index. Cette fonction utilise l'itération pour diviser une liste en segments égaux.

# 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]]

Python : diviser une chaîne en liste

Utilisation de la méthode split()

La méthode split() divise une chaîne en une liste en Python, en utilisant un délimiteur spécifié. La méthode renvoie les sous-chaînes en fonction du nombre de délimiteurs dans la chaîne donnée.

# 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']

Utilisation de la méthode splitlines()

La méthode splitlines() divise une chaîne en une liste Python en fonction du caractère de nouvelle ligne.

# 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']

Utilisation de la méthode partition()

La méthode partition() divise les chaînes de caractères en listes dans Python en utilisant le séparateur spécifié. Cette méthode renvoie trois parties : la chaîne avant le séparateur, le séparateur et tout ce qui suit le séparateur sous forme de liste.

# 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')

Utilisation des expressions régulières

En Python, les expressions régulières peuvent également être utilisées pour diviser une chaîne en une liste. L'exemple ci-dessous illustre comment procéder en utilisant des espaces blancs.

# 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']

Tableau comparatif

Voici un tableau qui vous permettra de voir en un coup d'œil quand les différentes techniques peuvent être utiles. En pratique, la même technique peut s'appliquer à de nombreux cas sans différence notable en termes de performances. Par conséquent, les recommandations concernant les situations dans lesquelles une technique particulière est la plus utile peuvent être quelque peu exagérées.