Liste scindée en morceaux en Python

1. Fractionner une liste en Python en morceaux à l’aide de la méthode de compréhension des listes
2. Liste partagée en Python en morceaux en utilisant la méthode itertools
3. Liste fractionnée en Python en morceaux en utilisant la fonction lambda
4. Diviser la liste en Python en morceaux en utilisant la méthode lambda & islice
5. Liste fractionnée en Python en morceaux en utilisant la méthode NumPy
6. Diviser la liste en morceaux en Python en utilisant une fonction définie par l’utilisateur

Une des structures de données Python qui peut contenir des valeurs ou des éléments mixtes est appelée listes. Cet article présente différentes façons de diviser une liste en morceaux. Vous pouvez utiliser n’importe quel exemple de code qui correspond à vos spécifications.

Fractionner une liste en Python en morceaux à l’aide de la méthode de compréhension des listes

Nous pouvons utiliser la compréhension de liste pour diviser une liste Python en morceaux. C’est un moyen efficace d’encapsuler les opérations pour rendre le code plus facile à comprendre.

L’exemple de code complet est donné ci-dessous.

test_list = ["1", "2", "3", "4", "5", "6", "7", "8", "9", "10"]

n = 3

output = [test_list[i : i + n] for i in range(0, len(test_list), n)]
print(output)

Production :

[['1', '2', '3'], ['4', '5', '6'], ['7', '8', '9'], ['10']]

range(0, len(test_list), n) renvoie une plage de nombres commençant à 0 et se terminant par len(test_list) avec un pas de n. Par exemple, range(0, 10, 3) retournera (0, 3, 6, 9).

test_list[i:i + n] obtient la partie de la liste qui commence à l’index i et se termine exclusivement à i + n. Le dernier morceau de la liste fractionnée est test_list[9], mais les indices calculés test_list[9:12] ne soulèveront pas d’erreur mais seront égaux à test_list[9].

Liste partagée en Python en morceaux en utilisant la méthode itertools

Cette méthode fournit un générateur qui doit être itéré en utilisant une boucle for. Un générateur est un moyen efficace de décrire un itérateur.

from itertools import zip_longest

test_list = ["1", "2", "3", "4", "5", "6", "7", "8", "9", "10"]


def group_elements(n, iterable, padvalue="x"):
    return zip_longest(*[iter(iterable)] * n, fillvalue=padvalue)


for output in group_elements(3, test_list):
    print(output)

Production :

('1', '2', '3')
('4', '5', '6')
('7', '8', '9')
('10', 'x', 'x')

[iter(iterable)]*n génère un itérateur et l’a itéré n fois dans la liste. Un round-robin de chaque itérateur est alors effectivement effectué par izip-longest; comme il s’agit d’un itérateur similaire, chaque appel de ce type est avancé, ce qui fait que chaque round-robin produit un tuple de n objets.

Liste fractionnée en Python en morceaux en utilisant la fonction lambda

Il est possible d’utiliser une fonction lambda de base pour diviser la liste en une certaine taille ou en morceaux plus petits. Cette fonction fonctionne sur la liste originale et la variable de taille N, elle itére sur tous les éléments de la liste et la divise en morceaux de taille N.

L’exemple de code complet est donné ci-dessous :

test_list = ["1", "2", "3", "4", "5", "6", "7", "8", "9", "10"]

x = 3


def final_list(test_list, x):
    return [test_list[i : i + x] for i in range(0, len(test_list), x)]


output = final_list(test_list, x)

print("The Final List is:", output)

Production :

The Final List is: [['1', '2', '3'], ['4', '5', '6'], ['7', '8', '9'], ['10']]

Diviser la liste en Python en morceaux en utilisant la méthode lambda & islice

Une fonction lambda peut être utilisée avec la fonction islice et produire un générateur qui itére sur la liste. La fonction islice crée un itérateur qui extrait les éléments sélectionnés de l’itérable. Si le départ est différent de zéro, les éléments itérables seront ignorés avant que le départ ne soit atteint. Les éléments sont alors renvoyés consécutivement, à moins qu’une étape ne soit fixée à un niveau supérieur à celui qui entraîne le saut d’éléments.

L’exemple de code complet est donné ci-dessous :

from itertools import islice

test_list = ["1", "2", "3", "4", "5", "6", "7", "8", "9", "10"]


def group_elements(lst, chunk_size):
    lst = iter(lst)
    return iter(lambda: tuple(islice(lst, chunk_size)), ())


for new_list in group_elements(test_list, 3):
    print(new_list)

Production :

('1', '2', '3')
('4', '5', '6')
('7', '8', '9')
('10',)

Liste fractionnée en Python en morceaux en utilisant la méthode NumPy

La bibliothèque NumPy peut également être utilisée pour diviser la liste en morceaux de taille N. La fonction array_split() divise le tableau en sous-tableaux de taille spécifique n.

L’exemple de code complet est donné ci-dessous :

import numpy

n = numpy.arange(11)

final_list = numpy.array_split(n, 4)
print("The Final List is:", final_list)

La fonction arange ordonne les valeurs en fonction de l’argument donné et la fonction array_split() produit les listes/sous-tableaux en fonction du paramètre donné en paramètre.

Production :

The Final List is: [array([0, 1, 2]), array([3, 4, 5]), array([6, 7, 8]), array([ 9, 10])]

Diviser la liste en morceaux en Python en utilisant une fonction définie par l’utilisateur

Cette méthode permet d’itérer sur la liste et de produire des morceaux consécutifs de taille n, où n désigne le nombre auquel une division doit être mise en œuvre. Un mot-clé yield est utilisé dans cette fonction et permet d’arrêter et de restaurer une fonction au fur et à mesure que la valeur tourne lorsque l’exécution est suspendue. Ce sont les distinctions importantes par rapport à une fonction normale. Une fonction normale ne peut pas revenir là où elle s’est arrêtée. La fonction est appelée Generator lorsque nous utilisons une instruction yield dans une fonction. Un générateur produit ou renvoie des valeurs et ne peut pas être nommé comme une simple fonction, mais plutôt comme une fonction itérable, c’est-à-dire utilisant une boucle.

L’exemple de code complet est le suivant.

test_list = ["1", "2", "3", "4", "5", "6", "7", "8", "9", "10"]


def split_list(lst, n):
    for i in range(0, len(lst), n):
        yield lst[i : i + n]


n = 3

output = list(split_list(test_list, n))
print(output)

Production :

[['1', '2', '3'], ['4', '5', '6'], ['7', '8', '9'], ['10']]