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

Q: Quelle est la différence entre diviser une liste Python et partition() ?

La méthode partition() méthode renvoie trois tuples où l'argument conditionnel se trouve au milieu.

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]Propulsé par

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

Le paramètre « Start » indique le début de l'index du découpage.
Stop indique la fin de l'index du découpage.
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]Propulsé par

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]Propulsé par

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]Propulsé par

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]Propulsé par

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]Propulsé par

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]]Propulsé par

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]]Propulsé par

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)]]Propulsé par

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]]Propulsé par

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]Propulsé par

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]]Propulsé par

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')]Propulsé par

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]]Propulsé par

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']Propulsé par

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']Propulsé par

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')Propulsé par

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']Propulsé par

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.

Technique	Cas d'utilisation	Quand cela est utile
Découpe	Diviser une liste à un index spécifique ou à une plage d'index.	Utile pour les divisions simples et directes.
Compréhensions de listes	Création de sous-listes basées sur les valeurs ou les conditions de la liste.	Utile pour les divisions plus complexes basées sur des critères.
itertools.islice	Diviser une liste en segments d'une taille spécifiée à l'aide d'un itérateur.	Utile pour gérer efficacement de grandes listes.
numpy.array_split	Diviser les tableaux en sous-listes en fonction du nombre de divisions souhaitées.	Utile pour traiter efficacement les données numériques.
Fractionnement basé sur l'état	Diviser une liste en fonction de conditions telles que la divisibilité.	Utile pour séparer les données en sous-listes significatives.
Boucles « for »	Parcourir une liste pour créer des sous-listes d'une taille spécifique.	Ceci est utile pour exercer un meilleur contrôle sur le processus de fractionnement.
Fonction zip()	Association d'éléments provenant de deux listes.	Utile pour combiner les données de deux listes connexes.
Fonction enumerate()	Diviser des listes à l'aide de conditions d'index, généralement pour obtenir des segments de taille égale.	Utile pour créer des sous-listes réparties de manière égale.
Méthode split()	Diviser des chaînes en listes en fonction d'un délimiteur spécifié.	Utile pour le traitement des données textuelles.
Méthode splitlines()	Diviser des chaînes en listes en fonction des caractères de nouvelle ligne.	Utile pour lire des données textuelles comportant plusieurs lignes.
Méthode partition()	Diviser les chaînes en trois parties en fonction d'un séparateur spécifié.	Utile pour des scénarios spécifiques de traitement de texte.
Expressions régulières	Utilisation d'expressions régulières pour diviser des chaînes en listes selon des modèles complexes.	Utile pour la manipulation avancée de données textuelles.

Pièges courants et comment les éviter

Un praticien des données peut rencontrer certaines erreurs courantes lors du traitement de listes fractionnées en Python. Vous trouverez ci-dessous quelques-uns des pièges courants et la manière de les éviter.

Erreurs d'un élément

L'erreur « off-by-one » se produit lors du découpage de base lorsque vous incluez moins ou plus d'indices que nécessaire dans la liste.

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]Propulsé par

Pour éviter cette erreur, il est important de bien comprendre la séquence d'indexation en Python et de savoir ce qu'il convient d'inclure ou d'exclure lors de l'indexation.

Problèmes avec les paquets utilisés

Vous pourriez également rencontrer des erreurs avec les paquets, en particulier lorsque la méthode de fractionnement nécessite des modules Python. Parmi les exemples, on peut citer les paquets numpy, re et itertools. Pour éviter cette erreur, veuillez vous assurer que les paquets sont correctement chargés et utilisés dans des versions compatibles.

Gestion des cas limites

Des cas limites peuvent survenir lors du fractionnement d'une liste Python si certains scénarios ne sont pas pris en compte. Par exemple, l'extrait ci-dessous indique une fonction qui tente de diviser des listes en morceaux de 5 alors que la liste ne contient que 4 éléments.

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)]Propulsé par

Pour éviter cette erreur, veuillez utiliser des instructions conditionnelles pour gérer les cas limites, comme indiqué ci-dessous.

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]]Propulsé par

Gestion des caractères spéciaux

Une gestion inadéquate des caractères spéciaux peut également entraîner des erreurs lors du fractionnement de listes de chaînes en Python. Ces caractères spéciaux comprennent les espaces blancs, les virgules ou les caractères alphanumériques.

L'exemple ci-dessous montre comment éviter cette erreur en spécifiant le caractère permettant de diviser la liste de chaînes.

# 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']]Propulsé par

Meilleures pratiques et lignes directrices

Étant donné que la division de listes en Python est une opération courante dans l'analyse de données, il est essentiel de respecter certaines pratiques afin de garantir l'efficacité. Ces recommandations comprennent :

Préserver l'immuabilité lorsque cela est possible : Si la liste d'origine ne doit pas être modifiée, veuillez vous assurer que vos opérations de découpage n'altèrent pas la liste d'origine. Le découpage crée de nouvelles listes, ce qui ne pose généralement pas de problème, mais il est important d'en tenir compte lorsque vous travaillez avec des structures de données plus complexes.
Optimisation des performances : Lorsque vous traitez des listes volumineuses, veuillez tenir compte des implications en termes de performances. Le découpage est généralement efficace, mais la copie inutile de grandes listes peut entraîner des goulots d'étranglement au niveau des performances.
Gérer les cas particuliers : Veuillez prendre en considération les cas limites tels qu'une liste vide, une division au début ou à la fin de la liste, et des indices non valides. Veuillez vous assurer que votre code peut gérer ces scénarios de manière appropriée.
Intégrer la gestion des erreurs et la validation : La gestion des erreurs est particulièrement importante lorsque vous souhaitez diviser une liste en plusieurs listes dans Python, afin que votre code ne se rompe pas et ne crée pas de surprises.

Le cours de programmation Python de DataCamp fournit une explication détaillée des meilleures pratiques pour écrire du code de manière efficace, en tenant compte de concepts courants tels que la gestion des erreurs et les performances.

Techniques avancées de fractionnement de listes

Le fractionnement des listes peut être poussé à un niveau avancé en utilisant diverses méthodes qui offrent davantage de contrôle et de flexibilité.

Diviser la liste en plusieurs listes

Vous pouvez diviser la liste Python en plusieurs listes en spécifiant la division à des indices spécifiques. Par exemple, le code ci-dessous divise la liste à l'index suivant : 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]]Propulsé par

Diviser la liste en parties égales

Vous pouvez également utiliser une bibliothèque intégrée telle que numpy pour diviser une liste Python en parties égales en fonction du nombre de parties souhaité.

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)]]Propulsé par

Diviser une liste en deux

Il est possible d'utiliser le découpage pour diviser une liste Python en deux parties.

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]Propulsé par

Dans le cas d'une liste comportant un nombre impair d'éléments, il est possible de spécifier l'index à inclure dans la première moitié.

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]Propulsé par

Le développeur Python fournit également des informations sur la manière d'écrire du code avancé qui vous aidera à comprendre les techniques avancées de fractionnement de listes.

Conclusion

Il existe différentes méthodes pour diviser des listes en Python. Chaque méthode dépend du type de liste et des préférences de l'utilisateur en matière d'efficacité. En tant que professionnel des données, il est essentiel de sélectionner la méthode de fractionnement de liste la mieux adaptée à votre analyse.

Pour une compréhension approfondie de la fonction split de Python, nous vous invitons à suivre notre cours Python Fundamentals. Vous pouvez également suivre le cours Introduction à Python afin de vous assurer de maîtriser le fonctionnement des listes et autres types de données dans Python. Le guide Python pour débutants est également utile lorsque vous souhaitez obtenir un aperçu de la manière de diviser une liste en Python.

Auteur

Allan Ouko

Je crée des articles qui simplifient la science des données et l'analyse, en les rendant faciles à comprendre et accessibles.

Questions fréquemment posées

Dans quelles circonstances aurais-je besoin de diviser une liste en Python ?

La fonction split de Python est essentielle pour le traitement des données, en particulier lors de la gestion de grands ensembles de données. Les transformations sont utiles lorsque vous divisez les données pour effectuer des analyses, telles que la formation et le test de modèles d'apprentissage automatique.

Que dois-je faire si les modules itertools et numpy renvoient une erreur ?

Veuillez vous assurer que les bibliothèques Python appropriées sont installées. Si l'erreur persiste, veuillez vous assurer de mettre à jour et d'utiliser les versions compatibles des bibliothèques.

Quelle est la différence entre diviser une liste Python et partition() ?

La méthode partition() méthode renvoie trois tuples où l'argument conditionnel se trouve au milieu.

Est-il possible de diviser une liste Python à l'aide d'un délimiteur spécifique ou d'une valeur donnée ?

Il est nécessaire de préciser le délimiteur ou la valeur fournie pour diviser la liste.

Comment puis-je m'assurer d'améliorer les performances de mon code lorsque je divise une liste en plusieurs listes ?

Veuillez utiliser une fonction réutilisable lorsque vous divisez une liste en plusieurs listes. Cette approche garantit l'efficacité.

Sujets

Python Analyse des données