Upang makabuo ng bagong listahan mula sa isang listahan (array) na ang mga elemento ay mga string, sa pamamagitan ng pagkuha lamang ng mga elemento ng mga string na nakakatugon sa ilang partikular na kundisyon, o sa pamamagitan ng pagsasagawa ng mga pagpapalit, conversion, atbp., gumamit ng mga pag-unawa sa listahan.
Pagkatapos ng maikling paliwanag ng mga pag-unawa sa listahan, ang mga sumusunod na nilalaman ay ipinaliwanag sa sample code.
- Pagkuha batay sa kung may kasamang partikular na string (bahagyang tugma)
- Palitan ang partikular na string
- I-extract sa pamamagitan ng pagsisimula o hindi pagsisimula sa isang partikular na string
- I-extract sa pamamagitan ng pagtatapos o hindi nagtatapos sa isang partikular na string
- Hinatulan at kinuha ayon sa kaso
- I-convert ang uppercase at lowercase
- Tinutukoy kung alphabetic o numeric na mga character ang ginagamit at kinukuha ang mga ito
- Maramihang kundisyon
- (computer) regular na pagpapahayag
Tandaan na ang mga listahan ay maaaring mag-imbak ng iba’t ibang uri ng data at mahigpit na naiiba sa mga array. Kung gusto mong pangasiwaan ang mga array sa mga prosesong nangangailangan ng laki ng memory at mga address ng memory o numerical processing ng malaking data, gumamit ng array (standard library) o NumPy.
- listahan ng pagsasama ng notasyon
- Naglalaman ng partikular na string (partial match) \ Hindi naglalaman:in
- Palitan ang partikular na string
- Nagsisimula sa isang partikular na string \ ay hindi nagsisimula:startswith()
- Nagtatapos sa isang partikular na string ng character \ hindi nagtatapos:endswith()
- Hinatulan at kinuha ayon sa kaso
- I-convert ang uppercase at lowercase
- Tinutukoy kung alphabetic o numeric na mga character ang ginagamit at kinukuha ang mga ito
- Maramihang kundisyon
- (computer) regular na pagpapahayag
listahan ng pagsasama ng notasyon
Kapag bumubuo ng isang bagong listahan mula sa isang listahan, ang mga pag-unawa sa listahan ay mas madaling isulat kaysa para sa mga loop.
[expression for any variable name in iterable object if conditional expression]
Kung ang elemento ay pipiliin lamang ng isang conditional expression, hindi ito pinoproseso ng isang expression, kaya ito ay tumatagal ng sumusunod na anyo
[variable name for variable name in original list if conditional expression]
Kung ang if conditional expression ay ginawa sa isang if not conditional expression, ito ay magiging isang negation, at ang mga elemento na hindi nakakatugon sa conditional expression ay maaaring makuha.
Naglalaman ng partikular na string (partial match) \ Hindi naglalaman:in
Sa “specific na string sa orihinal na string”, ibabalik ang True kung ang orihinal na string ay naglalaman ng partikular na string. Ito ay isang conditional expression.
Ang negation ng in ay tapos na sa not in.
l = ['oneXXXaaa', 'twoXXXbbb', 'three999aaa', '000111222']
l_in = [s for s in l if 'XXX' in s]
print(l_in)
# ['oneXXXaaa', 'twoXXXbbb']
l_in_not = [s for s in l if 'XXX' not in s]
print(l_in_not)
# ['three999aaa', '000111222']
Palitan ang partikular na string
Kung gusto mong palitan ang isang string ng mga elemento ng listahan, gamitin ang string method replace() para sa bawat elemento sa notasyon ng pag-unawa sa listahan.
Kung walang string na papalitan, hindi na kailangang piliin ang elemento sa if conditional expression dahil hindi ito babaguhin sa pamamagitan ng paglalapat ng replace().
l_replace = [s.replace('XXX', 'ZZZ') for s in l]
print(l_replace)
# ['oneZZZaaa', 'twoZZZbbb', 'three999aaa', '000111222']
Kung gusto mong palitan ang isang buong elemento na naglalaman ng isang partikular na string, i-extract ito gamit ang in at iproseso ito gamit ang ternary operator. Ang ternary operator ay nakasulat sa sumusunod na form.True Value if Conditional Expression else False Value
OK lang kung ang bahagi ng expression ng notasyon sa pag-unawa sa listahan ay isang ternary operator.
l_replace_all = ['ZZZ' if 'XXX' in s else s for s in l]
print(l_replace_all)
# ['ZZZ', 'ZZZ', 'three999aaa', '000111222']
Ang sumusunod ay isang buod ng mga resulta, na nakapaloob sa mga panaklong. Kung hindi ka sanay sa paggamit ng panaklong, maaaring mas madaling maunawaan at maiwasan ang mga pagkakamali. Sa gramatika, walang problema kahit na magsulat ka ng mga panaklong.
[('ZZZ' if ('XXX' in s) else s) for s in l]
Ang paggamit ng in bilang isang kundisyon ay nakakalito sa listahan ng pag-unawa sa notasyon sa, ngunit ito ay hindi mahirap kung alam mo ang syntactic na anyo ng listahan ng pag-unawa sa notasyon at mga operator ng ternary.
Nagsisimula sa isang partikular na string \ ay hindi nagsisimula:startswith()
Ang string method startswith() ay nagbabalik ng true kung ang string ay nagsisimula sa string na tinukoy sa argument.
l_start = [s for s in l if s.startswith('t')]
print(l_start)
# ['twoXXXbbb', 'three999aaa']
l_start_not = [s for s in l if not s.startswith('t')]
print(l_start_not)
# ['oneXXXaaa', '000111222']
Nagtatapos sa isang partikular na string ng character \ hindi nagtatapos:endswith()
Ang string method na endswith() ay nagbabalik ng true kung ang string ay nagtatapos sa string na tinukoy sa argument.
l_end = [s for s in l if s.endswith('aaa')]
print(l_end)
# ['oneXXXaaa', 'three999aaa']
l_end_not = [s for s in l if not s.endswith('aaa')]
print(l_end_not)
# ['twoXXXbbb', '000111222']
Hinatulan at kinuha ayon sa kaso
Ang mga pamamaraan ng string na isupper(),islower() ay maaaring gamitin upang matukoy kung ang isang string ay lahat ng upper o all lower case.
l_lower = [s for s in l if s.islower()]
print(l_lower)
# ['three999aaa']
I-convert ang uppercase at lowercase
Kung gusto mong i-convert ang lahat ng character sa upper o lower case, gamitin ang string method upper() at lower(). Kasama sa iba pang mga pamamaraan ang capitalize(), na naglalagay ng malaking titik lamang sa unang titik, at swapcase(), na nagpapalit ng malaki at maliliit na titik.
Tulad ng halimbawa ng pagpapalit sa itaas, gamitin ang ternary operator kung gusto mong iproseso lamang ang mga elementong nakakatugon sa kundisyon.
l_upper_all = [s.upper() for s in l]
print(l_upper_all)
# ['ONEXXXAAA', 'TWOXXXBBB', 'THREE999AAA', '000111222']
l_lower_to_upper = [s.upper() if s.islower() else s for s in l]
print(l_lower_to_upper)
# ['oneXXXaaa', 'twoXXXbbb', 'THREE999AAA', '000111222']
Tinutukoy kung alphabetic o numeric na mga character ang ginagamit at kinukuha ang mga ito
Ang mga pamamaraan ng string na isalpha() at isnumeric() ay maaaring gamitin upang matukoy kung ang isang string ay alphabetic, numeric, atbp.
l_isalpha = [s for s in l if s.isalpha()]
print(l_isalpha)
# ['oneXXXaaa', 'twoXXXbbb']
l_isnumeric = [s for s in l if s.isnumeric()]
print(l_isnumeric)
# ['000111222']
Maramihang kundisyon
Ang conditional expression na bahagi ng mga pag-unawa sa listahan ay maaaring maraming kundisyon. Maaari ding gamitin ang mga negatibong “hindi” kundisyon.
Kapag gumagamit ng tatlo o higit pang conditional expression, mas ligtas na ilagay ang bawat grupo sa panaklong () dahil mag-iiba ang resulta depende sa pagkakasunud-sunod.
l_multi = [s for s in l if s.isalpha() and not s.startswith('t')]
print(l_multi)
# ['oneXXXaaa']
l_multi_or = [s for s in l if (s.isalpha() and not s.startswith('t')) or ('bbb' in s)]
print(l_multi_or)
# ['oneXXXaaa', 'twoXXXbbb']
(computer) regular na pagpapahayag
Ang mga regular na expression ay nagbibigay-daan para sa lubos na kakayahang umangkop sa pagproseso.
Ang bagay na tugma ay ibinalik ng re.match() kapag tumutugma ito ay palaging tinutukoy na totoo kapag sinusuri gamit ang isang conditional na expression. Kung hindi ito tumugma, ibabalik nito ang Wala, na mali sa conditional expression. Kaya, kung gusto mong kunin lang ang mga elementong tumutugma sa regular na expression, ilapat lang ang re.match() sa conditional expression na bahagi ng list comprehension expression tulad ng dati.
import re
l = ['oneXXXaaa', 'twoXXXbbb', 'three999aaa', '000111222']
l_re_match = [s for s in l if re.match('.*XXX.*', s)]
print(l_re_match)
# ['oneXXXaaa', 'twoXXXbbb']
Ang re.sub(), na pumapalit sa katugmang bahagi ng isang regular na expression, ay kapaki-pakinabang din. Upang kunin at palitan lamang ang mga katugmang elemento, idagdag lamang ang “kung may kondisyong pagpapahayag”.
l_re_sub_all = [re.sub('(.*)XXX(.*)', r'\2---\1', s) for s in l]
print(l_re_sub_all)
# ['aaa---one', 'bbb---two', 'three999aaa', '000111222']
l_re_sub = [re.sub('(.*)XXX(.*)', r'\2---\1', s) for s in l if re.match('.*XXX.*', s)]
print(l_re_sub)
# ['aaa---one', 'bbb---two']
