સૂચિ (એરે) માંથી નવી સૂચિ જનરેટ કરવા માટે કે જેના તત્વો શબ્દમાળાઓ છે, અમુક શરતોને સંતોષતા સ્ટ્રીંગના ઘટકોને બહાર કાઢીને અથવા અવેજી, રૂપાંતરણો વગેરે કરીને, સૂચિ સમજણનો ઉપયોગ કરો.
સૂચિની સમજણની સંક્ષિપ્ત સમજૂતી પછી, નીચેની સામગ્રી નમૂના કોડ સાથે સમજાવવામાં આવી છે.
- ચોક્કસ સ્ટ્રિંગ શામેલ છે કે નહીં તેના આધારે નિષ્કર્ષણ (આંશિક મેળ)
- ચોક્કસ શબ્દમાળા બદલો
- ચોક્કસ સ્ટ્રિંગથી શરૂ કરીને અથવા શરૂ કરીને બહાર કાઢો
- ચોક્કસ સ્ટ્રિંગ સાથે અંત અથવા સમાપ્ત ન કરીને બહાર કાઢો
- કેસ દ્વારા ન્યાય અને અર્ક
- અપરકેસ અને લોઅરકેસમાં કન્વર્ટ કરો
- આલ્ફાબેટીક કે ન્યુમેરિક કેરેક્ટરનો ઉપયોગ કરવામાં આવ્યો છે કે કેમ તે નક્કી કરે છે અને તેને બહાર કાઢે છે
- બહુવિધ શરતો
- (કમ્પ્યુટર) નિયમિત અભિવ્યક્તિ
નોંધ કરો કે સૂચિઓ વિવિધ પ્રકારના ડેટાને સંગ્રહિત કરી શકે છે અને એરેથી સખત રીતે અલગ છે. જો તમે પ્રક્રિયાઓમાં એરેને હેન્ડલ કરવા માંગતા હો કે જેમાં મેમરીનું કદ અને મેમરી સરનામાં અથવા મોટા ડેટાની સંખ્યાત્મક પ્રક્રિયાની જરૂર હોય, તો એરે (સ્ટાન્ડર્ડ લાઇબ્રેરી) અથવા NumPy નો ઉપયોગ કરો.
- સૂચિ સમાવેશ નોટેશન
- ચોક્કસ સ્ટ્રિંગ ધરાવે છે (આંશિક મેળ) \ સમાવતું નથી:in
- ચોક્કસ શબ્દમાળા બદલો
- ચોક્કસ સ્ટ્રિંગથી શરૂ થાય છે \ શરૂ થતું નથી:startswith()
- ચોક્કસ અક્ષર શબ્દમાળા સાથે સમાપ્ત થાય છે \ અંત નથી:endswith()
- કેસ દ્વારા ન્યાય અને અર્ક
- અપરકેસ અને લોઅરકેસમાં કન્વર્ટ કરો
- આલ્ફાબેટીક કે ન્યુમેરિક કેરેક્ટરનો ઉપયોગ કરવામાં આવ્યો છે કે કેમ તે નક્કી કરે છે અને તેને બહાર કાઢે છે
- બહુવિધ શરતો
- (કમ્પ્યુટર) નિયમિત અભિવ્યક્તિ
સૂચિ સમાવેશ નોટેશન
જ્યારે સૂચિમાંથી નવી સૂચિ જનરેટ કરવામાં આવે છે, ત્યારે લૂપ્સ કરતાં સૂચિની સમજણ લખવા માટે સરળ છે.
[expression for any variable name in iterable object if conditional expression]
જો તત્વ માત્ર શરતી અભિવ્યક્તિ દ્વારા પસંદ કરવાનું હોય, તો તે અભિવ્યક્તિ દ્વારા પ્રક્રિયા કરવામાં આવતું નથી, તેથી તે નીચેનું સ્વરૂપ લે છે
[variable name for variable name in original list if conditional expression]
જો શરતી અભિવ્યક્તિને જો શરતી અભિવ્યક્તિમાં બનાવવામાં આવે, તો તે નકાર બની જાય છે, અને શરતી અભિવ્યક્તિને સંતોષતા ન હોય તેવા ઘટકોને બહાર કાઢી શકાય છે.
ચોક્કસ સ્ટ્રિંગ ધરાવે છે (આંશિક મેળ) \ સમાવતું નથી:in
“ઓરિજિનલ સ્ટ્રિંગમાં ચોક્કસ સ્ટ્રિંગ” માં, જો મૂળ સ્ટ્રિંગમાં ચોક્કસ સ્ટ્રિંગ હોય તો ટ્રુ પરત કરે છે. આ એક શરતી અભિવ્યક્તિ છે.
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']
ચોક્કસ શબ્દમાળા બદલો
જો તમે સૂચિ ઘટકોની સ્ટ્રિંગ બદલવા માંગતા હો, તો સૂચિની સમજણ સંકેતમાં દરેક ઘટક માટે સ્ટ્રિંગ પદ્ધતિ બદલી()નો ઉપયોગ કરો.
જો બદલવા માટે કોઈ સ્ટ્રિંગ ન હોય, તો if conditional અભિવ્યક્તિમાં તત્વ પસંદ કરવાની કોઈ જરૂર નથી કારણ કે તે replace() લાગુ કરીને બદલાશે નહીં.
l_replace = [s.replace('XXX', 'ZZZ') for s in l]
print(l_replace)
# ['oneZZZaaa', 'twoZZZbbb', 'three999aaa', '000111222']
જો તમે ચોક્કસ સ્ટ્રિંગ ધરાવતા સમગ્ર ઘટકને બદલવા માંગો છો, તો તેને ઇન સાથે બહાર કાઢો અને તેને ટર્નરી ઓપરેટર સાથે પ્રક્રિયા કરો. ટર્નરી ઓપરેટર નીચેના ફોર્મમાં લખાયેલ છે.True Value if Conditional Expression else False Value
તે બરાબર છે જો સૂચિ સમજણ સંકેતનો અભિવ્યક્તિ ભાગ તૃણિય ઓપરેટર હોય.
l_replace_all = ['ZZZ' if 'XXX' in s else s for s in l]
print(l_replace_all)
# ['ZZZ', 'ZZZ', 'three999aaa', '000111222']
નીચે આપેલા પરિણામોનો સારાંશ છે, જે કૌંસમાં બંધ છે. જો તમે કૌંસનો ઉપયોગ કરવા માટે ટેવાયેલા નથી, તો તે સમજવામાં અને ભૂલો ટાળવા માટે સરળ બની શકે છે. વ્યાકરણની દૃષ્ટિએ જો તમે કૌંસ લખો તો પણ કોઈ સમસ્યા નથી.
[('ZZZ' if ('XXX' in s) else s) for s in l]
શરત તરીકે in નો ઉપયોગ સૂચિ સમજણ સંકેત સાથે ગૂંચવણમાં મૂકે છે, પરંતુ જો તમે સૂચિ સમજણ સંકેત અને ટર્નરી ઓપરેટર્સના સિન્ટેક્ટિક સ્વરૂપથી વાકેફ હોવ તો તે મુશ્કેલ નથી.
ચોક્કસ સ્ટ્રિંગથી શરૂ થાય છે \ શરૂ થતું નથી:startswith()
સ્ટ્રિંગ મેથડ startswith() સાચી પરત કરે છે જો સ્ટ્રિંગ દલીલમાં ઉલ્લેખિત સ્ટ્રિંગથી શરૂ થાય છે.
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']
ચોક્કસ અક્ષર શબ્દમાળા સાથે સમાપ્ત થાય છે \ અંત નથી:endswith()
શબ્દમાળા પદ્ધતિ endswith() સાચી પરત કરે છે જો સ્ટ્રિંગ દલીલમાં ઉલ્લેખિત સ્ટ્રિંગ સાથે સમાપ્ત થાય છે.
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']
કેસ દ્વારા ન્યાય અને અર્ક
સ્ટ્રિંગ પદ્ધતિઓ isupper(),islower() નો ઉપયોગ એ નક્કી કરવા માટે કરી શકાય છે કે સ્ટ્રીંગ તમામ અપર છે કે તમામ લોઅર કેસ.
l_lower = [s for s in l if s.islower()]
print(l_lower)
# ['three999aaa']
અપરકેસ અને લોઅરકેસમાં કન્વર્ટ કરો
જો તમે બધા અક્ષરોને અપર કે લોઅર કેસમાં કન્વર્ટ કરવા માંગતા હો, તો અપર() અને લોઅર() સ્ટ્રિંગ પદ્ધતિઓનો ઉપયોગ કરો. અન્ય પદ્ધતિઓમાં કેપિટલાઇઝ(), જે ફક્ત પ્રથમ અક્ષરને કેપિટલાઇઝ કરે છે, અને સ્વેપકેસ(), જે મોટા અને નાના અક્ષરોને સ્વેપ કરે છે.
ઉપરના અવેજી ઉદાહરણની જેમ, જો તમે માત્ર એવા તત્વો પર પ્રક્રિયા કરવા માંગતા હોવ જે સ્થિતિને સંતોષે છે તો ટર્નરી ઓપરેટરનો ઉપયોગ કરો.
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']
આલ્ફાબેટીક કે ન્યુમેરિક કેરેક્ટરનો ઉપયોગ કરવામાં આવ્યો છે કે કેમ તે નક્કી કરે છે અને તેને બહાર કાઢે છે
સ્ટ્રિંગ પદ્ધતિઓ isalpha() અને isnumeric() નો ઉપયોગ એ નક્કી કરવા માટે કરી શકાય છે કે શું સ્ટ્રિંગ તમામ આલ્ફાબેટીક, ન્યુમેરિક, વગેરે છે.
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']
બહુવિધ શરતો
સૂચિની સમજણનો શરતી અભિવ્યક્તિ ભાગ બહુવિધ શરતો હોઈ શકે છે. નકારાત્મક “નથી” શરતોનો પણ ઉપયોગ કરી શકાય છે.
ત્રણ અથવા વધુ શરતી અભિવ્યક્તિઓનો ઉપયોગ કરતી વખતે, દરેક જૂથને કૌંસમાં બંધ કરવું વધુ સુરક્ષિત છે () કારણ કે પરિણામ ક્રમના આધારે બદલાશે.
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']
(કમ્પ્યુટર) નિયમિત અભિવ્યક્તિ
નિયમિત અભિવ્યક્તિઓ અત્યંત લવચીક પ્રક્રિયા માટે પરવાનગી આપે છે.
મેચ ઑબ્જેક્ટ re.match() દ્વારા પરત કરવામાં આવે છે જ્યારે તે મેળ ખાય છે જ્યારે શરતી અભિવ્યક્તિ સાથે મૂલ્યાંકન કરવામાં આવે ત્યારે તે હંમેશા સાચું હોવાનું નક્કી કરવામાં આવે છે. જો તે મેળ ખાતું નથી, તો તે કંઈ નહીં આપે, જે શરતી અભિવ્યક્તિમાં ખોટું છે. તેથી, જો તમે રેગ્યુલર એક્સપ્રેશન સાથે મેળ ખાતા ઘટકોને જ એક્સટ્રેક્ટ કરવા માંગતા હો, તો પહેલાની જેમ જ સૂચિની સમજણ અભિવ્યક્તિના શરતી અભિવ્યક્તિ ભાગમાં re.match() લાગુ કરો.
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']
re.sub(), જે નિયમિત અભિવ્યક્તિના મેળ ખાતા ભાગને બદલે છે, તે પણ ઉપયોગી છે. ફક્ત મેળ ખાતા ઘટકોને કાઢવા અને બદલવા માટે, ફક્ત “જો શરતી અભિવ્યક્તિ” ઉમેરો.
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']
