Halimbawa 1: Pagsasama-sama ng Mga Listahan sa Operator na '+'.
Maaari naming gamitin ang operator na '+' sa Python upang pagsamahin ang mga listahan. Gamit ang operator na '+', maaari kang sumali sa dalawa o higit pang mga listahan upang bumuo ng isang bagong listahan. Kapag ginamit mo ang operator na '+' na may mga listahan, isang bagong listahan ang gagawin at ang mga elemento ng orihinal na mga listahan ay makokopya sa bagong listahan sa pagkakasunud-sunod na lalabas ang mga ito.
Narito ang isang simpleng halimbawa:
sheet 1 = [ 1 , 2 , 3 ]
listahan2 = [ 4 , 5 , 6 ]
resulta_listahan = list1 + list2
print ( resulta_listahan )
Mayroon kaming dalawang listahan sa paglalarawang ito: 'list1' at 'list2'. Ginagamit namin ang operator na '+' upang isama ang mga ito sa isang listahan. Kapag ginamit sa mga listahan, pinagsasama-sama ng operator na '+' ang mga ito na nangangahulugang pinagsasama nito ang mga elemento ng pangalawang listahan hanggang sa dulo ng una. Kaya, pagkatapos isagawa ang 'result_list = list1 + list2', ang 'result_list' ay maglalaman ng mga elemento ng parehong 'list1' at 'list2' sa pagkakasunud-sunod kung saan sila ay pinagsama-sama.
Bagama't maigsi ang pamamaraang ito, tandaan na lumilikha ito ng bagong listahan na maaaring hindi mahusay para sa malalaking listahan dahil sa overhead ng paggawa ng kopya.
Halimbawa 2: Paggamit ng Extend() Method
Ang mga item ng isang iterable ay maaaring idagdag sa dulo ng isang umiiral na listahan gamit ang extend() na paraan. Binabago nito ang orihinal na listahan sa lugar, hindi katulad ng operator na '+' na lumilikha ng bagong listahan.
Ipagpalagay natin na mayroon tayong listahan ng mga mag-aaral sa isang klase, at gusto naming palawigin ang listahang ito sa pamamagitan ng pagdaragdag ng mga pangalan ng mga bagong mag-aaral na kamakailang sumali gamit ang extend() na paraan. Narito kung paano mo ito magagawa:
klase_mga mag-aaral = [ 'Alice' , 'Bella' , 'Charlie' ]
bagong_estudyante = [ 'David' , 'Eva' , 'Adan' ]
klase_mga mag-aaral. pahabain ( bagong_estudyante )
print ( 'Na-update na Listahan ng mga Mag-aaral:' , klase_mga mag-aaral )
Sa halimbawang ito, ang orihinal na listahan na 'class_students' ay naglalaman ng mga pangalan ng mga kasalukuyang mag-aaral. Kasama sa listahan ng 'new_students' ang mga pangalan ng mga mag-aaral na sumali kamakailan sa klase. Sa pamamagitan ng paglalapat ng extend() na paraan, idinaragdag namin ang mga pangalan ng mga bagong mag-aaral sa dulo ng orihinal na listahan.
Halimbawa 3: Paglalapat ng '+=' Operator para sa Concatenation
Ang operator na '+=' ay isang shorthand para sa extend() na paraan. Binabago nito ang listahan sa lugar, pinagsasama ang mga elemento ng kanang listahan sa kaliwang listahan.
Ipagpalagay na mayroon kaming isang listahan ng mga paboritong kulay at gusto naming i-update ito sa pamamagitan ng pagdaragdag ng higit pang mga kulay gamit ang '+=' operator.
paboritong_kulay = [ 'asul' , 'berde' , 'pula' ]karagdagang_kulay = [ 'purple' , 'orange' , 'dilaw' ]
paboritong_kulay + = karagdagang_kulay
print ( 'Na-update na Mga Paboritong Kulay:' , paboritong_kulay )
Sa sitwasyong ito, magsisimula kami sa isang listahan ng aming mga paboritong kulay na kinakatawan ng 'paborito_kulay'. Pagkatapos, mayroon kaming ilang bagong kulay na gusto naming isama sa listahan ng 'mga karagdagang_kulay'. Gamit ang '+= operator', pinagsama namin ang mga bagong kulay sa aming mga dati nang paborito, binabago ang listahan ng 'favorite_colors'.
Pagkatapos ng operasyon, kapag nag-print kami ng 'Aming Na-update na Mga Paboritong Kulay', makikita namin ang sumusunod na resulta:
Halimbawa 4: Paggamit ng “*” Operator
Ang operator na '*' ay maaaring gamitin para sa pagtitiklop ng listahan. Ngunit kapag inilapat sa mga listahan, maaari itong pagsamahin ang mga ito sa pamamagitan ng pag-uulit ng mga elemento.
Narito ang isang halimbawa:
original_list = [ 1 , 2 , 3 ]concatenated_list = original_list * 3
print ( concatenated_list )
Sa kasong ito, magsisimula tayo sa isang 'original_list' na naglalaman ng mga elemento [1, 2, 3]. Gamit ang operator na '*', gumawa kami ng bagong listahan na kung saan ay ang 'concatenated_list' na binubuo ng tatlong pag-uulit ng mga elemento mula sa orihinal na listahan.
Bagama't hindi gaanong karaniwan ang diskarteng ito para sa concatenation, ipinapakita nito ang flexibility ng mga operator ng Python.
Halimbawa 5: Paglalapat ng Itertools.chain() Function
Ang function na itertools.chain() ay bahagi ng module na 'itertools' at ginagamit upang pagsama-samahin ang iterable (tulad ng mga listahan, tuple, o iba pang mga iterable na bagay) sa iisang 'iterable'. Hindi tulad ng ilang iba pang paraan ng pagsasama-sama, ang itertools.chain() ay hindi gumagawa ng bagong listahan ngunit gumagawa ng isang iterator sa mga elemento ng input iterables.
mula sa itertools angkat kadenaL1 = [ 1 , 2 , 3 ]
L2 = [ 'x' , 'at' , 'Kasama' ]
concatenated_itetable = kadena ( L1 , L2 )
resulta_listahan = listahan ( concatenated_itetable )
print ( resulta_listahan )
Sa ibinigay na halimbawa, mayroon kaming dalawang listahan - 'L1' ay naglalaman ng mga numerong halaga [1, 2, 3] at 'L2' ay naglalaman ng mga alphabetic na character ['x', 'y', 'z']. Gamit ang function na itertools.chain(), pinagsasama-sama namin ang mga listahang ito sa isang iterable, na kinakatawan ng 'concatenated_iterable'. Ang list() function ay inilapat upang i-convert ang iterable sa isang listahan na nagreresulta sa pinagsamang listahan [1, 2, 3, “x”, “y”, “z”].
Halimbawa 6: List Slicing
Sa pamamagitan ng pagbibigay ng hanay ng mga indeks, ang list slicing ay isang pamamaraan na nagbibigay-daan sa amin na makuha ang isang subset ng isang listahan. Kabilang dito ang paggamit ng colon (:) operator sa loob ng mga square bracket upang ipahiwatig ang simula, paghinto, at, opsyonal, mga halaga ng hakbang.
Narito ang halimbawang code:
actual_list = [ 1 , 2 , 3 , 4 , 5 ]sliced_list = actual_list [ 1 : 4 ]
print ( sliced_list )
Sinimulan namin ang paglalarawan sa isang orihinal na listahan ng mga numero na tinutukoy bilang 'actual_list' na naglalaman ng mga elemento [1, 2, 3, 4, 5]. Kinukuha namin ang isang partikular na segment ng listahan sa pamamagitan ng paggamit ng list slicing na isang malakas na feature sa Python. Ang slice na “actual_list[1:4]” ay ginagamit sa pagkakataong ito, at pinipili nito ang mga elemento mula index 1 hanggang index 3 (ngunit hindi mula sa index 4). Ang resulta ay isang bagong listahan, pinangalanang 'sliced_list', na naglalaman ng hiniwang bahagi [2, 3, 4].
Halimbawa 7: Pagsasama sa Zip() Function
Pinagsasama ng function na zip() ang mga elemento mula sa maraming iterable, na lumilikha ng mga pares o tuple ng mga kaukulang elemento. Ang bawat elemento ng pag-ulit sa parehong index ay ginagamit upang gawin ang mga pares na ito.
mga mag-aaral = [ 'Alice' , 'Bob' , 'Charlie' ]mga grado = [ 85 , 92 , 78 ]
student_grade_pares = zip ( mga mag-aaral , mga grado )
resulta_dict = dict ( student_grade_pares )
print ( 'Pares ng Mag-aaral sa Baitang:' , resulta_dict )
Sa halimbawang ito, pinapares ng function na zip() ang mga pangalan ng mag-aaral mula sa listahan ng 'mga mag-aaral' sa kanilang mga katumbas na marka mula sa listahan ng 'mga grado' na nagreresulta sa isang diksyunaryo kung saan ang bawat mag-aaral ay nauugnay sa kani-kanilang grado.
Konklusyon
Sa konklusyon, nag-aalok ang Python ng maraming paraan upang pagsamahin ang mga listahan, bawat isa ay may mga pakinabang nito. Habang ginalugad namin ang iba't ibang pamamaraan, mula sa prangka na '+' na operator hanggang sa mas nuanced na zip() function, naging maliwanag na ang Python ay nagbibigay ng iba't ibang istilo at kagustuhan sa programming. Depende sa gawaing nasa kamay, ang mga salik tulad ng pagiging madaling mabasa, kahusayan ng memorya, at ang uri ng data na pinoproseso ay tutukuyin kung aling paraan ang pinakamahusay.