cours
Comment diviser des listes en Python : Exemples de base et méthodes avancées
Les listes Python sont des tableaux dynamiques mutables utilisés pour stocker des éléments ordonnés. Le découpage de listes est une tâche courante en Python, essentielle pour manipuler et analyser des données de manière efficace.
Vous pouvez en apprendre davantage sur l'analyse des données en suivant le parcours professionnel Analyste de données avec Python pour affiner vos compétences, qui examine les différentes méthodes pour diviser les listes en Python, y compris les exemples pratiques et les meilleures pratiques.
La maîtrise de ces techniques améliorera vos compétences en matière de codage, ce qui rendra vos scripts plus efficaces et plus faciles à maintenir. Commençons.
La réponse rapide : Comment diviser une liste en Python
-
La façon la plus simple de diviser une liste en Python est de la découper avec l'opérateur
:
. Par exemple, nous pouvons diviser une liste de cette manière :split_list = my_list[:5]
, qui divise la liste au cinquième indice. -
Le reste de cet article explore d'autres méthodes pour diviser une liste, y compris les compréhensions de liste,
itertools
,numpy
, et bien d'autres encore. Chaque méthode présente des avantages uniques et convient à des cas d'utilisation différents, comme nous le verrons.
La méthode la plus courante : diviser une liste à l'aide du découpage en tranches
La liste de fractionnement Python à l'index est probablement la technique de liste de fractionnement la plus courante. La méthode de découpage garantit que la liste Python est divisée en sous-listes à l'index spécifié. Voici un guide étape par étape sur la façon de mettre en œuvre le découpage en tranches 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écifiquen
. - Identifiez l'indice de fractionnement : Indiquez l'index
n
dans lequel vous souhaitez découper la liste. - Créez la première tranche : Dans le code ci-dessous, créez
first_slice
pour qu'il contienne les éléments du début de la liste jusqu'à l'indexn
inclus. - Créez la deuxième tranche : Définissez
second_slice
pour inclure tous les éléments à partir de l'indexn
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) # Output: [1, 2, 3, 4]
# Print the second slice of the list
print("Second slice:", second_slice) # Output: [5, 6, 7, 8, 9, 10]
Exemple de sortie d'une liste fractionnée en Python par découpage. Image par l'auteur
Comprendre le découpage de listes en Python
Le découpage de liste en Python consiste à extraire une ou plusieurs sous-listes de la liste principale. Lorsque vous souhaitez diviser une liste en Python, vous devez comprendre la syntaxe de découpage pour mieux comprendre la sous-list appropriée. La syntaxe de découpage comprend un début, un arrêt et un pas.
# Example of slicing with start, stop, and step
slice[start:stop:step]
- Start indique le début de l'index du découpage.
- Stop indique la fin de l'index du tranchage
- Step indique les intervalles entre les tranches (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)
Selon le code ci-dessus, le découpage commence de l'index 2 à l'index 6 puisque la sous-liste ne comprend pas l'index 7.
Exemple de sortie de la syntaxe de découpage. Image par l'auteur
Les avantages de la liste fractionnée de Python en termes de lisibilité du code et d'efficacité sont les suivants :
- Simplifier la gestion des données : En divisant les données en morceaux gérables, les scientifiques des données peuvent facilement séparer les données d'apprentissage et de test dans l'apprentissage automatique.
- Accroître la modularité : L'écriture de fonctions avec des sous-listes spécifiques améliore la modularité de votre code.
- Optimiser les performances : L'utilisation de morceaux de liste plus petits permet un traitement plus rapide que l'utilisation de listes entières.
- Améliorer l'efficacité de la mémoire : La méthode crée des morceaux sans copier les données sous-jacentes, ce qui permet d'économiser 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 qu'un praticien des données peut rencontrer au cours de sa pratique.
Utilisation du découpage en listes
Le découpage de liste de Python utilise l'opérateur :
pour diviser la liste au niveau de l'index. Cette méthode utilise la technique de l'indexation pour spécifier le début et la fin du découpage.
Les différentes techniques de tranchage sont les suivantes :
Tranchage de l'indice positif
Cette méthode utilise les valeurs des indices positifs, en commençant de gauche à droite 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)
Exemple de sortie de la syntaxe de découpage utilisant des indices positifs. Image par l'auteur
Tranchage de l'indice négatif
Cette méthode de fractionnement de liste Python utilise les indices négatifs 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)
Exemple de sortie de la syntaxe de découpage utilisant des indices négatifs. Image par l'auteur
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)
Exemple de sortie de la syntaxe de découpage à l'aide de la méthode par étapes. Image par l'auteur
Omettre des 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)
Exemple de sortie de la syntaxe de découpage en omettant les indices. Image par l'auteur
Utilisation des compréhensions de listes
La compréhension des listes en Python permet de diviser une liste en morceaux 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)
Le code ci-dessus utilise Python pour diviser la liste en n
morceaux de taille 3 afin de renvoyer une nouvelle liste contenant des listes de morceaux de 3 valeurs.
Exemple de sortie d'une liste de fractionnement Python utilisant la compréhension du fractionnement. Image par l'auteur
Utilisation d'Itertools
Python split list using itertools utilise 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)
Exemple de sortie d'une liste de fractionnement Python à l'aide de itertools
. Image par l'auteur
Utilisation de numpy
La bibliothèque numpy de Python est utile pour diviser les tableaux en sous-listes. La fonction .array_split()
autorise les fractionnements lorsque le nombre de fractionnements est spécifié.
# 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])
Exemple de sortie d'une liste de fractionnement Python à l'aide de numpy
. Image par l'auteur
Diviser les listes en morceaux
La fonction Python suivante permet également de diviser une liste en morceaux. Ces morceaux peuvent être personnalisés en fonction du nombre dont l'utilisateur a besoin.
# 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)
Exemple de résultat de la division d'une liste en morceaux par Python. Image par l'auteur
Diviser les listes sur la base 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)
Exemple de sortie d'une liste de fractionnement Python basée sur des conditions. Image par l'auteur
Utilisation de boucles for
Les boucles For peuvent également être utilisées pour diviser des listes en Python sur la base 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)
Exemple de sortie d'une liste fractionnée en Python utilisant des boucles for. Image par l'auteur
Utilisation de la fonction zip()
Vous pouvez également utiliser la fonction zip()
de 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)
Exemple de sortie d'une liste de fractionnement Python à l'aide de la fonction zip()
. Image par l'auteur
Utilisation de la fonction enumerate()
La fonction enumerate()
divise les listes Python en utilisant des conditions d'indexation. Cette fonction utilise l'itération pour diviser une liste en morceaux é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)
Exemple de sortie d'une liste de fractionnement Python à l'aide de la fonction enumerate()
. Image par l'auteur
Python diviser une chaîne en liste
Utilisation de la méthode split()
La méthode split()
permet de diviser une chaîne de caractères en une liste en Python, en fonction d'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)
Exemple de résultat d'un découpage de chaîne en liste en Python à l'aide de la méthode split()
. Image par l'auteur
Utilisation de la méthode splitlines()
La méthode splitlines()
divise la chaîne de caractères en une liste Python basée sur le caractère de la 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)
Exemple de résultat d'un découpage de chaîne en liste en Python à l'aide de la méthode splitlines()
. Image par l'auteur
Utilisation de la méthode partition()
La méthode partition()
divise les chaînes de caractères en listes en Python en utilisant le séparateur donné. 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) # Output: ('Goodmorning', '/', 'to you')
Exemple de sortie d'une liste de chaînes de caractères fractionnées en Python à l'aide de la méthode partition()
. Image par l'auteur
Utiliser les 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 montre 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)
Exemple de sortie d'une liste de chaînes fractionnées en Python à l'aide d'expressions régulières. Image par l'auteur
Tableau de comparaison
Voici un tableau qui vous permettra de voir d'un coup d'œil quand les différentes techniques peuvent être utiles. Dans la pratique, la même technique peut fonctionner dans de nombreux cas sans qu'il y ait de différences marquées en termes de performances, de sorte que les indications sur les cas où une technique particulière est la plus utile peuvent être quelque peu exagérées.
Technique | Cas d'utilisation | Quand c'est utile |
---|---|---|
Trancher | Fractionnement d'une liste à un indice spécifique ou à une plage d'indices. | Utile pour les fractionnements simples et directs. |
Compréhension de listes | Création de sous-listes basées sur les valeurs ou les conditions de la liste. | Utile pour un fractionnement plus complexe basé sur des critères. |
itertools.islice | Découper une liste en morceaux d'une taille spécifiée à l'aide d'un itérateur. | Utile pour traiter efficacement les 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 des conditions | Division d'une liste en fonction de conditions telles que la divisibilité. | Utile pour séparer les données en sous-listes significatives. |
Boucles de forçage | Itération dans une liste pour créer des sous-listes d'une taille spécifique. | Utile pour mieux contrôler le processus de fractionnement. |
Fonction zip() | Jumelage d'éléments de deux listes. | Utile pour combiner les données de deux listes liées. |
énumérer() Fonction | Fractionnement de listes à l'aide de conditions d'indexation, souvent pour obtenir des morceaux de taille égale. | Utile pour créer des sous-listes également réparties. |
Méthode split() | Diviser les chaînes de caractères en listes sur la base d'un délimiteur spécifié. | Utile pour le traitement des données textuelles. |
Méthode splitlines() | Découpage des chaînes de caractères en listes sur la base des caractères de retour à la ligne. | Utile pour lire des données textuelles comportant plusieurs lignes. |
Méthode partition() | Diviser les chaînes de caractères en trois parties sur la base d'un séparateur spécifié. | Utile pour des scénarios de traitement de texte spécifiques. |
Expressions régulières | Utilisation des expressions rationnelles pour diviser les chaînes de caractères en listes basées sur des motifs complexes. | Utile pour la manipulation avancée de données textuelles. |
Devenez un scientifique ML
Les pièges les plus courants et comment les éviter
Un praticien des données peut rencontrer des erreurs courantes lorsqu'il manipule des listes fractionnées en Python. Vous trouverez ci-dessous quelques-uns des pièges les plus courants et la manière de les éviter.
Erreurs de décalage
L'erreur "off-by-one" se produit pendant le 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) # Output: [3, 4, 5]
# Incorrect usage:
sublist = my_list[2:4] # Incorrect, excludes index 4
print(sublist) # Output: [3, 4]
Pour éviter cette erreur, comprenez la séquence d'indexation en Python et sachez ce qu'il faut inclure ou exclure lors de l'indexation.
Erreurs avec les paquets utilisés
Vous pouvez également rencontrer des erreurs avec les paquets, en particulier lorsque la méthode de fractionnement nécessite des modules Python. Les paquets numpy
, re
et itertools
en sont des exemples. Pour éviter cette erreur, assurez-vous que les paquets sont correctement chargés et utilisés comme des versions compatibles.
Traiter les cas limites
Des cas limites peuvent se produire dans le découpage de la liste Python lorsque vous ne tenez pas compte de certains scénarios. Par exemple, l'extrait ci-dessous indique une fonction qui tente de diviser des listes en morceaux de 5 lorsque 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)
Pour éviter cette erreur, utilisez des instructions conditionnelles pour traiter le cas limite, 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)
Traitement des caractères spéciaux
Le fait de ne pas gérer correctement les caractères spéciaux peut également entraîner des erreurs lors de la division 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 de séparation de 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)
Bonnes pratiques et lignes directrices
Comme le fractionnement de listes en Python est une opération courante dans l'analyse de données, il est important de respecter certaines pratiques pour garantir l'efficacité de l'opération. Ces recommandations sont les suivantes
- Maintenir l'immutabilité dans la mesure du possible : Si la liste originale ne doit pas être modifiée, assurez-vous que vos opérations de découpage ne modifient pas la liste originale. Le découpage crée de nouvelles listes, ce qui ne pose généralement pas de problème, mais soyez vigilant lorsque vous travaillez avec des structures de données plus complexes.
- Optimisez les performances : Lorsque vous traitez de grandes listes, tenez 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 goulets d'étranglement au niveau des performances.
- Traiter les cas particuliers : Tenez compte des cas limites tels qu'une liste vide, une division au début ou à la fin de la liste, et des indices non valides. Veillez à ce que votre code puisse gérer ces scénarios avec élégance.
- Inclure la gestion des erreurs et la validation : La gestion des erreurs est particulièrement importante lorsque vous souhaitez diviser une liste en plusieurs listes en Python, afin que votre code ne se brise pas et ne crée pas de surprises.
Le cours de programmation Python de DataCamp offre une explication détaillée des meilleures pratiques pour écrire du code efficacement, en considérant des concepts communs comme la gestion des erreurs et la performance.
Techniques avancées de fractionnement de listes
Le fractionnement des listes peut être poussé à un niveau avancé en utilisant diverses méthodes qui offrent plus 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)
Exemple de résultat de la division d'une liste en plusieurs listes par Python. Image par l'auteur
Divisez 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 que vous souhaitez.
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])
Diviser une liste en deux
On peut utiliser le découpage en tranches pour diviser la liste Python en deux.
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)
Dans le cas d'une liste avec un nombre impair d'éléments, vous pouvez spécifier l'indice à 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)
Le développeur Python offre également des conseils sur la manière d'écrire du code avancé qui vous aidera à comprendre les techniques avancées de découpage de listes.
Conclusion
Il existe différentes méthodes pour diviser les listes en Python. Chaque méthode dépend du type de liste et de la préférence de l'utilisateur en matière d'efficacité. En tant que praticien des données, il est important de choisir la méthode de liste fractionnée qui convient à votre analyse.
Pour une compréhension approfondie de la liste de fractionnement de Python, vous pouvez en apprendre davantage dans notre cours, Python Fundamentals. Vous pouvez également suivre le cours Introduction à Python pour vous assurer que vous maîtrisez les opérations sur les listes et autres types de données en Python. L'Aide-mémoire Python pour les débutants est également utile lorsque vous souhaitez savoir comment diviser une liste en Python.
Devenez un scientifique ML
Questions fréquemment posées
Quand aurais-je besoin de diviser une liste en Python ?
La liste fractionnée Python est importante 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 des données pour effectuer des analyses, par exemple pour former et tester des modèles d'apprentissage automatique.
Que dois-je faire si les modules itertools et numpy renvoient une erreur ?
Assurez-vous que les bibliothèques Python appropriées sont installées. Si l'erreur persiste, assurez-vous de mettre à jour et d'utiliser les versions compatibles des bibliothèques.
Quelle est la différence entre la division d'une liste Python et la fonction partition() ?
La méthode partition()
renvoie trois tuples au milieu desquels se trouve l'argument conditionnel.
Puis-je diviser une liste Python avec un délimiteur spécifique ou une valeur donnée ?
Vous devez spécifier le délimiteur ou la valeur donnée 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 ?
Utilisez une fonction réutilisable lorsque vous divisez une liste en plusieurs listes. Cette approche est un gage d'efficacité.
Apprenez Python avec DataCamp
cours
Writing Efficient Python Code
cours
Object-Oriented Programming in Python
blog
Les 32 meilleures questions d'entretien sur AWS et leurs réponses pour 2024
blog
Q2 2023 DataCamp Donates Digest
blog
Les 20 meilleures questions d'entretien pour les flocons de neige, à tous les niveaux

Nisha Arya Ahmed
20 min
blog
2022-2023 Rapport annuel DataCamp Classrooms
blog
Nous avons fait don de bourses DataCamp Premium à un million de personnes, et ce n'est pas fini.
blog
Célébration de Saghar Hazinyar : Une boursière de DataCamp Donates et une diplômée de Code to Inspire

Fereshteh Forough
4 min