En Python, pour diviser une liste en sous-listes en fonction d'une valeur particulière. L'idée est de parcourir la liste d'origine et de regrouper les éléments en sous-listes chaque fois que la valeur spécifiée est rencontrée. Il est souvent nécessaire de manipuler et de traiter des listes, notamment lorsqu'il s'agit de grandes quantités de données. Une opération fréquente consiste à diviser une liste en plusieurs sous-listes selon une valeur spécifique. Lorsque vous souhaitez combiner des composants ou analyser différents sous-ensembles de données, cette procédure peut être utile.
Façons de diviser des listes en listes en fonction de la condition
Voici les différentes méthodes que nous pouvons utiliser pour diviser des listes en listes en fonction de la condition donnée.
- Utiliser une itération simple
- Utiliser la compréhension de liste
- Utiliser des boucles for
- Utiliser la récursivité
- Utiliser Itertools
- Utiliser NumPy
Fractionner la liste en Python à l'aide de l'itération
Dans Python , nous diviserons une liste en listes par valeur particulière en utilisant Itération simple . Le code initialise une liste et une valeur particulière. Il divise ensuite la liste en sous-listes en fonction de la valeur particulière en itérant sur chaque élément de la liste.
Python3
test_list>=> [>1>,>4>,>5>,>6>,>4>,>5>,>6>,>5>,>4>]> print>(>'The original list : '> +> str>(test_list))> particular_value>=> 5> result>=> []> temp_list>=> []> for> i>in> test_list:> >if> i>=>=> particular_value:> >temp_list.append(i)> >result.append(temp_list)> >temp_list>=> []> >else>:> >temp_list.append(i)> result.append(temp_list)> print>(>'The list after splitting by a value : '> +> str>(result))> |
>
>
Sortir
The original list : [1, 4, 5, 6, 4, 5, 6, 5, 4] The list after splitting by a value : [[1, 4, 5], [6, 4, 5], [6, 5], [4]]>
Diviser une liste Python en morceaux à l'aide de la compréhension de liste
En Python, nous diviserons une liste en listes par valeur particulière en utilisant Compréhension de la liste . Ce problème peut être résolu en deux parties. Dans la première partie, nous obtenons la liste d'index par laquelle la division doit être effectuée en utilisant énumérer fonction. Et puis on peut joindre les valeurs selon les indices en utilisant fermeture éclair et découpage de liste.
Python3
listes en java
test_list>=> [>1>,>4>,>5>,>6>,>4>,>5>,>6>,>5>,>4>]> print>(>'The original list : '> +> str>(test_list))> # using list comprehension Split list into lists by particular value> size>=> len>(test_list)> idx_list>=> [idx>+> 1> for> idx, val>in> >enumerate>(test_list)>if> val>=>=> 5>]> res>=> [test_list[i: j]>for> i, j>in> >zip>([>0>]>+> idx_list, idx_list>+> >([size]>if> idx_list[>->1>] !>=> size>else> []))]> print>(>'The list after splitting by a value : '> +> str>(res))> |
>
>
Sortir
police de caractères
The original list : [1, 4, 5, 6, 4, 5, 6, 5, 4] The list after splitting by a value : [[1, 4, 5], [6, 4, 5], [6, 5], [4]]>
Liste fractionnée en Python à l'aide de boucles For
En Python, nous diviserons une liste en listes par valeur particulière en utilisant pour la boucle s. Le code convertit l'annonce d'origine en une représentation sous forme de chaîne et remplace le prix particulier par un délimiteur (*). Il divise ensuite le changement chaîne sur le délimiteur pour acquérir des sous-chaînes.
Python3
test_list>=> [>1>,>4>,>5>,>6>,>4>,>5>,>6>,>5>,>4>]> print>(>'The original list : '> +> str>(test_list))> x>=> list>(>map>(>str>, test_list))> x>=> ' '>.join(x)> x>=> x.replace(>'5'>,>'5*'>)> y>=> x.split(>'*'>)> res>=> []> for> i>in> y:> >i>=> i.strip()> >i>=> i.split(>' '>)> >b>=> []> >for> j>in> i:> >b.append(>int>(j))> >res.append(b)> print>(>'The list after splitting by a value : '> +> str>(res))> |
>
>
Sortir
The original list : [1, 4, 5, 6, 4, 5, 6, 5, 4] The list after splitting by a value : [[1, 4, 5], [6, 4, 5], [6, 5], [4]]>
Diviser une liste en plusieurs listes à l'aide de la récursion
En Python, nous diviserons une liste en listes par valeur particulière en utilisant Récursivité . Le code définit un récursif fonction appelé split_list_recursive qui divise une liste donnée en sous-listes chaque fois qu'une valeur particulière apparaît. Il utilise la récursivité et deux listes temporaires (result et temp_list) pour stocker les sous-listes résultantes.
Python3
def> split_list_recursive(test_list, result, temp_list, particular_value):> >if> not> test_list:> >result.append(temp_list)> >return> >if> test_list[>0>]>=>=> particular_value:> >result.append(temp_list>+> [particular_value])> >split_list_recursive(test_list[>1>:], result, [], particular_value)> >else>:> >split_list_recursive(test_list[>1>:],> >result,> >temp_list>+> [test_list[>0>]],> >particular_value)> test_list>=> [>1>,>4>,>5>,>6>,>4>,>5>,>6>,>5>,>4>]> particular_value>=> 5> result>=> []> print>(>'The original list:'>, test_list)> split_list_recursive(test_list, result, [], particular_value)> print>(>'The list after splitting by value:'>, result)> |
>
>
Sortir
The original list: [1, 4, 5, 6, 4, 5, 6, 5, 4] The list after splitting by value: [[1, 4, 5], [6, 4, 5], [6, 5], [4]]>
Liste fractionnée en Python à l'aide d'Itertools
En Python, nous diviserons une liste en listes par valeur particulière en utilisant itertools . Le code définit une fonction appelée split_list qui prend une liste et une valeur en entrée. Il utilise le itertools.groupby() fonction pour regrouper des éléments consécutifs dans le liste selon qu'ils sont égaux à la valeur donnée.
Python3
import> itertools> def> split_list(lst, val):> >return> [>list>(group)>for> k,> >group>in> >itertools.groupby(lst,>lambda> x: x>=>=>val)>if> not> k]> original_lst>=> [>1>,>4>,>5>,>6>,>4>,>5>,>6>,>5>,>4>]> split_lst>=> split_list(original_lst,>6>)> print>(>'The original list:'>, original_lst)> print>(>'The list after splitting by a value:'>, split_lst)> |
remplacer en java
>
>
Sortir
The original list: [1, 4, 5, 6, 4, 5, 6, 5, 4] The list after splitting by a value: [[1, 4, 5], [4, 5], [5, 4]]>
Fractionner la liste en Python en utilisant NumPy
En Python, nous diviserons une liste en listes par valeur particulière en utilisant Numpy. Le code prend une liste et une valeur particulière en entrée. Il convertit ensuite la liste en un NumPy tableau et trouve les indices où la valeur particulière apparaît.
Python3
import> numpy as np> test_list>=> [>1>,>4>,>5>,>6>,>4>,>5>,>6>,>5>,>4>]> particular_value>=> 5> arr>=> np.array(test_list)> idx>=> np.where(arr>=>=> particular_value)[>0>]> subarrays>=> np.split(arr, idx>+>1>)> result>=> [subarray.tolist()>for> subarray>in> subarrays>if> len>(subarray)>>0>]> print>(>'The original list:'>, test_list)> print>(>'The list after splitting by a value:'>, result)> |
>
>
Sortir
The original list: [1, 4, 5, 6, 4, 5, 6, 5, 4] The list after splitting by a value: [[1, 4, 5], [6, 4, 5], [6, 5], [4]>