Programmā Python, lai sadalītu sarakstu apakšsarakstos, pamatojoties uz noteiktu vērtību. Ideja ir atkārtot sākotnējo sarakstu un grupēt elementus apakšsarakstā ikreiz, kad tiek konstatēta norādītā vērtība. Bieži vien ir nepieciešams manipulēt ar sarakstiem un apstrādāt tos, it īpaši, ja tiek strādāts ar lielu datu apjomu. Viena bieža darbība ir saraksta sadalīšana vairākos apakšsarakstos atbilstoši noteiktai vērtībai. Ja vēlaties apvienot komponentus vai analizēt dažādas datu apakškopas, šī procedūra var būt noderīga.
Veidi, kā sadalīt sarakstus sarakstos, pamatojoties uz stāvokli
Šeit ir norādītas dažādas metodes, kuras varam izmantot, lai sadalītu sarakstus sarakstos, pamatojoties uz konkrēto nosacījumu.
- Vienkāršās iterācijas izmantošana
- Izmantojot saraksta izpratni
- Izmantojot cilpas
- Rekursijas izmantošana
- Izmantojot Itertools
- Izmantojot NumPy
Sadaliet sarakstu Python, izmantojot iterāciju
In Python , mēs sadalīsim sarakstu sarakstos pēc noteiktas vērtības, izmantojot Vienkārša iterācija . Kods inicializē sarakstu un noteiktu vērtību. Pēc tam tas sadala sarakstu apakšsarakstos, pamatojoties uz konkrēto vērtību, atkārtojot katru saraksta elementu.
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))> |
Java pamata valoda
>
>
Izvade
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]]>
Sadaliet Python sarakstu gabalos, izmantojot saraksta izpratni
Programmā Python mēs sadalīsim sarakstu sarakstos pēc noteiktas vērtības, izmantojot Saraksta izpratne . Šo problēmu var atrisināt divās daļās, pirmajā daļā mēs iegūstam indeksu sarakstu, pēc kura ir jāveic sadalīšana, izmantojot uzskaitīt funkciju. Un tad mēs varam apvienot vērtības atbilstoši indeksiem, izmantojot rāvējslēdzējs un saraksta sagriešana.
Python3
c# slēdzis
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))> |
>
>
Izvade
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]]>
Sadaliet sarakstu Python, izmantojot For Loops
Programmā Python mēs sadalīsim sarakstu sarakstos pēc noteiktas vērtības, izmantojot cilpai s. Kods pārvērš sākotnējo ierakstu virknes attēlojumā un aizvieto konkrēto cenu ar atdalītāju (*). Pēc tam tas sadala mainīto virkne uz norobežotāja, lai iegūtu apakšvirknes.
Python3
char uz virkni
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))> |
>
>
Izvade
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]]>
Sadaliet sarakstu vairākos sarakstos, izmantojot Recursion
Programmā Python mēs sadalīsim sarakstu sarakstos pēc noteiktas vērtības, izmantojot Rekursija . Kods definē rekursīvu funkciju ko sauc par split_list_recursive, kas sadala doto sarakstu apakšsarakstos ikreiz, kad rodas noteikta vērtība. Tas izmanto rekursiju un divus pagaidu sarakstus (result un temp_list), lai saglabātu iegūtos apakšsarakstus.
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)> |
>
np vidējais
>
Izvade
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]]>
Sadaliet sarakstu Python, izmantojot Itertools
Programmā Python mēs sadalīsim sarakstu sarakstos pēc noteiktas vērtības, izmantojot itertorīki . Kods definē funkciju, ko sauc par split_list, kas kā ievadi izmanto sarakstu un vērtību. Tas izmanto itertools.groupby() funkcija grupēt secīgos elementus sarakstu pamatojoties uz to, vai tie ir vienādi ar doto vērtību.
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)> |
>
apaļa matemātika java
>
Izvade
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]]>
Sadaliet sarakstu Python, izmantojot NumPy
Python sarakstā mēs sadalīsim sarakstu sarakstus pēc noteiktas vērtības, izmantojot Numpy. Kods izmanto sarakstu un noteiktu vērtību kā ievadi. Pēc tam tas pārvērš sarakstu par a NumPy masīvs un atrod indeksus, kuros ir konkrētā vērtība.
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)>>> print>(>'The original list:'>, test_list)> print>(>'The list after splitting by a value:'>, result)> |
>
>
Izvade
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]>