Accéder au contenu principal

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

Apprenez à diviser des listes Python à l'aide de techniques telles que le découpage, les compréhensions de listes et itertools. Veuillez découvrir quand utiliser chaque méthode pour une gestion optimale des données.
· 11 min lire

Explorez l'IA

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,