પાયથોન લિસ્ટ કોમ્પ્રીહેન્સન્સ નોટેશનનો ઉપયોગ કરીને

બિઝનેસ

પાયથોનમાં, નવી સૂચિ જનરેટ કરતી વખતે સૂચિ સમજણ સંકેતનો ઉપયોગ કરવો સરળ છે.(List comprehensions)

આ લેખમાં, અમે પ્રથમ નીચેની ચર્ચા કરીશું

  • મૂળભૂત પ્રકારની સૂચિ સમજણ સંકેત
  • જો દ્વારા શરતી બ્રાન્ચિંગ સાથે સૂચી સમજણ સંકેત
  • ટર્નરી ઓપરેટર્સ સાથે સંયોજન (જો અન્ય જેવી પ્રક્રિયા હોય તો)
  • zip(),enumerate()આ સાથે સંયોજન
  • નેસ્ટેડ સૂચિ સમાવેશ નોટેશન

આગળ, અમે નમૂના કોડ સાથે સૂચિ સમજણ સંકેતના સમૂહને સમજાવીશું.

  • સમાવેશ નોટેશન સેટ કરો(Set comprehensions)
  • શબ્દકોશ સમાવેશ સંકેત(Dict comprehensions)
  • જનરેટર પ્રકાર(Generator expressions)

મૂળભૂત પ્રકારની સૂચિ સમજણ સંકેત

સૂચિ સમજણ સંકેત નીચે પ્રમાણે લખાયેલ છે.

[Expression for Any Variable Name in Iterable Object]

તે પુનરાવર્તિત ઑબ્જેક્ટના દરેક ઘટકને લે છે જેમ કે સૂચિ, ટ્યુપલ અથવા મનસ્વી ચલ નામ દ્વારા શ્રેણી અને અભિવ્યક્તિ સાથે તેનું મૂલ્યાંકન કરે છે. તત્વ તરીકે મૂલ્યાંકન પરિણામ સાથેની નવી સૂચિ પરત કરવામાં આવે છે.

નિવેદન માટે સમકક્ષ સાથે એક ઉદાહરણ આપવામાં આવ્યું છે.

squares = [i**2 for i in range(5)]
print(squares)
# [0, 1, 4, 9, 16]

squares = []
for i in range(5):
    squares.append(i**2)

print(squares)
# [0, 1, 4, 9, 16]

આ જ પ્રક્રિયા નકશા() સાથે કરી શકાય છે, પરંતુ તેની સરળતા અને સ્પષ્ટતા માટે સૂચિની સમજણને પ્રાધાન્ય આપવામાં આવે છે.

જો દ્વારા શરતી બ્રાન્ચિંગ સાથે સૂચી સમજણ સંકેત

જો શક્ય હોય તો સાથે શરતી શાખા કરવી. પોસ્ટફિક્સમાં નીચે પ્રમાણે if લખો.

[Expression for Any Variable Name in Iterable Object if Conditional Expression]

માત્ર પુનરાવર્તિત ઑબ્જેક્ટના ઘટકો જેની શરતી અભિવ્યક્તિ સાચી છે તે અભિવ્યક્તિ દ્વારા મૂલ્યાંકન કરવામાં આવે છે, અને એક નવી સૂચિ કે જેના ઘટકો પરિણામ છે તે પરત કરવામાં આવે છે.

તમે શરતી અભિવ્યક્તિમાં કોઈપણ ચલ નામનો ઉપયોગ કરી શકો છો.

નિવેદન માટે સમકક્ષ સાથે એક ઉદાહરણ આપવામાં આવ્યું છે.

odds = [i for i in range(10) if i % 2 == 1]
print(odds)
# [1, 3, 5, 7, 9]

odds = []
for i in range(10):
    if i % 2 == 1:
        odds.append(i)

print(odds)
# [1, 3, 5, 7, 9]

આ જ પ્રક્રિયા filter() સાથે કરી શકાય છે, પરંતુ તેની સરળતા અને સ્પષ્ટતા માટે સૂચિની સમજણને પ્રાધાન્ય આપવામાં આવે છે.

ટર્નરી ઓપરેટર્સ સાથે સંયોજન (જો અન્ય જેવી પ્રક્રિયા હોય તો)

ઉપરના ઉદાહરણમાં, ફક્ત તે જ ઘટકો પર પ્રક્રિયા કરવામાં આવે છે જે માપદંડને પૂર્ણ કરે છે, અને જે માપદંડને પૂર્ણ કરતા નથી તેઓને નવી સૂચિમાંથી બાકાત રાખવામાં આવે છે.

જો તમે શરતના આધારે પ્રક્રિયાને સ્વિચ કરવા માંગતા હો, અથવા જો તમે એવા તત્વો પર પ્રક્રિયા કરવા માંગતા હોવ કે જે સ્થિતિને અલગ રીતે સંતોષતા નથી, જેમ કે અન્ય રીતે, તો ટર્નરી ઓપરેટરનો ઉપયોગ કરો.

પાયથોનમાં, ટર્નરી ઓપરેટર નીચે પ્રમાણે લખી શકાય છે

Value When True if Conditional Expression else Value When False

નીચે બતાવ્યા પ્રમાણે સૂચિની સમજણ સંકેતના અભિવ્યક્તિ ભાગમાં તેનો ઉપયોગ થાય છે.

[Value When True if Conditional Expression else Value When False for Any Variable Name in Iterable Object]

નિવેદન માટે સમકક્ષ સાથે એક ઉદાહરણ આપવામાં આવ્યું છે.

odd_even = ['odd' if i % 2 == 1 else 'even' for i in range(10)]
print(odd_even)
# ['even', 'odd', 'even', 'odd', 'even', 'odd', 'even', 'odd', 'even', 'odd']

odd_even = []
for i in range(10):
    if i % 2 == 1:
        odd_even.append('odd')
    else:
        odd_even.append('even')

print(odd_even)
# ['even', 'odd', 'even', 'odd', 'even', 'odd', 'even', 'odd', 'even', 'odd']

સાચા અને ખોટા મૂલ્યો માટે મનસ્વી ચલ નામોનો ઉપયોગ કરીને અભિવ્યક્તિઓ લખવાનું પણ શક્ય છે.

જો સ્થિતિ સંતોષાય છે, તો થોડી પ્રક્રિયા કરવામાં આવે છે, અન્યથા મૂળ પુનરાવર્તિત ઑબ્જેક્ટનું મૂલ્ય યથાવત રાખવામાં આવે છે.

odd10 = [i * 10 if i % 2 == 1 else i for i in range(10)]
print(odd10)
# [0, 10, 2, 30, 4, 50, 6, 70, 8, 90]

zip() અને enumerate() સાથે સંયોજન

ઉપયોગી ફંક્શન કે જેઓ ફોર સ્ટેટમેન્ટમાં વારંવાર ઉપયોગમાં લેવાય છે તેમાં zip(), જે બહુવિધ પુનરાવર્તિત શબ્દોને જોડે છે, અને enumerate(), જે તેના અનુક્રમણિકા સાથે મૂલ્ય પરત કરે છે.

અલબત્ત, zip() અને enumerate() નો ઉપયોગ યાદીની સમજણ સાથે શક્ય છે. તે કોઈ ખાસ વાક્યરચના નથી, અને જો તમે for સ્ટેટમેન્ટ સાથેના પત્રવ્યવહારને ધ્યાનમાં લો તો તે મુશ્કેલ નથી.

zip()નું ઉદાહરણ.

l_str1 = ['a', 'b', 'c']
l_str2 = ['x', 'y', 'z']

l_zip = [(s1, s2) for s1, s2 in zip(l_str1, l_str2)]
print(l_zip)
# [('a', 'x'), ('b', 'y'), ('c', 'z')]

l_zip = []
for s1, s2 in zip(l_str1, l_str2):
    l_zip.append((s1, s2))

print(l_zip)
# [('a', 'x'), ('b', 'y'), ('c', 'z')]

enumerate() નું ઉદાહરણ.

l_enu = [(i, s) for i, s in enumerate(l_str1)]
print(l_enu)
# [(0, 'a'), (1, 'b'), (2, 'c')]

l_enu = []
for i, s in enumerate(l_str1):
    l_enu.append((i, s))

print(l_enu)
# [(0, 'a'), (1, 'b'), (2, 'c')]

જો ઉપયોગ કરતી વખતે વિચાર પહેલા જેવો જ છે.

l_zip_if = [(s1, s2) for s1, s2 in zip(l_str1, l_str2) if s1 != 'b']
print(l_zip_if)
# [('a', 'x'), ('c', 'z')]

દરેક તત્વનો ઉપયોગ નવા તત્વની ગણતરી કરવા માટે પણ થઈ શકે છે.

l_int1 = [1, 2, 3]
l_int2 = [10, 20, 30]

l_sub = [i2 - i1 for i1, i2 in zip(l_int1, l_int2)]
print(l_sub)
# [9, 18, 27]

નેસ્ટેડ સૂચિ સમાવેશ નોટેશન

લૂપ્સ માટે નેસ્ટિંગની જેમ, લિસ્ટ કોમ્પ્રીહેન્સન નોટેશન પણ નેસ્ટ કરી શકાય છે.

[Expression for Variable Name 1 in Iterable Object 1
    for Variable Name 2 in Iterable Object 2
        for Variable Name 3 in Iterable Object 3 ... ]

સગવડ માટે, લાઇન બ્રેક્સ અને ઇન્ડેન્ટેશન ઉમેરવામાં આવ્યા છે, પરંતુ વ્યાકરણ માટે જરૂરી નથી; તેઓ એક લાઇન પર ચાલુ રાખી શકાય છે.

નિવેદન માટે સમકક્ષ સાથે એક ઉદાહરણ આપવામાં આવ્યું છે.

matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]

flat = [x for row in matrix for x in row]
print(flat)
# [1, 2, 3, 4, 5, 6, 7, 8, 9]

flat = []
for row in matrix:
    for x in row:
        flat.append(x)

print(flat)
# [1, 2, 3, 4, 5, 6, 7, 8, 9]

બહુવિધ ચલોનો ઉપયોગ કરવો પણ શક્ય છે.

cells = [(row, col) for row in range(3) for col in range(2)]
print(cells)
# [(0, 0), (0, 1), (1, 0), (1, 1), (2, 0), (2, 1)]

તમે શરતી શાખા પણ કરી શકો છો.

cells = [(row, col) for row in range(3)
         for col in range(2) if col == row]
print(cells)
# [(0, 0), (1, 1)]

દરેક પુનરાવર્તિત ઑબ્જેક્ટ માટે શરતી રીતે શાખા કરવી પણ શક્ય છે.

cells = [(row, col) for row in range(3) if row % 2 == 0
         for col in range(2) if col % 2 == 0]
print(cells)
# [(0, 0), (2, 0)]

સમાવેશ નોટેશન સેટ કરો(Set comprehensions)

ચોરસ કૌંસ [] યાદીની સમજણ સંકેતમાં સર્પાકાર કૌંસમાં બદલવાથી {} સમૂહ (સેટ-ટાઈપ ઑબ્જેક્ટ) બનાવે છે.

{Expression for Any Variable Name in Iterable Object}

s = {i**2 for i in range(5)}

print(s)
# {0, 1, 4, 9, 16}

શબ્દકોશ સમાવેશ સંકેત(Dict comprehensions)

ડિક્શનરી (ડિક્ટ ટાઇપ ઑબ્જેક્ટ્સ) પણ સમજણ સંકેત સાથે જનરેટ કરી શકાય છે.

{}, અને કી: મૂલ્ય તરીકે અભિવ્યક્તિ ભાગમાં કી અને મૂલ્યનો ઉલ્લેખ કરો.

{Key: Value for Any Variable Name in Iterable Object}

કી અને મૂલ્ય માટે કોઈપણ અભિવ્યક્તિનો ઉલ્લેખ કરી શકાય છે.

l = ['Alice', 'Bob', 'Charlie']

d = {s: len(s) for s in l}
print(d)
# {'Alice': 5, 'Bob': 3, 'Charlie': 7}

કી અને મૂલ્યોની સૂચિમાંથી નવો શબ્દકોશ બનાવવા માટે, zip() ફંક્શનનો ઉપયોગ કરો.

keys = ['k1', 'k2', 'k3']
values = [1, 2, 3]

d = {k: v for k, v in zip(keys, values)}
print(d)
# {'k1': 1, 'k2': 2, 'k3': 3}

જનરેટર પ્રકાર(Generator expressions)

જો સૂચિની સમજણ સંકેતમાં ચોરસ કૌંસ [] નો ઉપયોગ રાઉન્ડ કૌંસ તરીકે કરવામાં આવે છે (), તો ટ્યુપલને બદલે જનરેટર પરત કરવામાં આવે છે. આને જનરેટર એક્સપ્રેશન કહેવામાં આવે છે.

સૂચિ સમજણ સંકેતનું ઉદાહરણ.

l = [i**2 for i in range(5)]

print(l)
# [0, 1, 4, 9, 16]

print(type(l))
# <class 'list'>

જનરેટર અભિવ્યક્તિનું ઉદાહરણ. જો તમે જનરેટર જેવું છે તેમ પ્રિન્ટ કરો છો, તો તે તેના સમાવિષ્ટોને છાપશે નહીં, પરંતુ જો તમે તેને સ્ટેટમેન્ટ માટે ચલાવો છો, તો તમે સામગ્રીઓ મેળવી શકો છો.

g = (i**2 for i in range(5))

print(g)
# <generator object <genexpr> at 0x10af944f8>

print(type(g))
# <class 'generator'>

for i in g:
    print(i)
# 0
# 1
# 4
# 9
# 16

જનરેટર અભિવ્યક્તિઓ શરતી શાખા અને માળખાને જો તેમજ સૂચિ સમજણ સંકેતનો ઉપયોગ કરવાની મંજૂરી આપે છે.

g_cells = ((row, col) for row in range(0, 3)
           for col in range(0, 2) if col == row)

print(type(g_cells))
# <class 'generator'>

for i in g_cells:
    print(i)
# (0, 0)
# (1, 1)

ઉદાહરણ તરીકે, જો લીસ્ટ કોમ્પ્રીહેન્સન નોટેશનનો ઉપયોગ કરીને મોટી સંખ્યામાં એલિમેન્ટ્સ સાથેની યાદી જનરેટ કરવામાં આવે છે અને પછી સ્ટેટમેન્ટ ફોર સ્ટેટમેન્ટ સાથે લૂપ કરવામાં આવે છે, તો જો લિસ્ટ કોમ્પ્રીહેન્સન નોટેશનનો ઉપયોગ કરવામાં આવે તો તમામ ઘટકો ધરાવતી સૂચિ શરૂઆતમાં જનરેટ થશે. બીજી બાજુ, જો તમે જનરેટર અભિવ્યક્તિનો ઉપયોગ કરો છો, તો દરેક વખતે લૂપનું પુનરાવર્તન થાય છે, તત્વો એક પછી એક જનરેટ થાય છે, આમ વપરાયેલી મેમરીની માત્રા ઘટાડે છે.

જો જનરેટર અભિવ્યક્તિ ફંક્શનની એકમાત્ર દલીલ છે, તો રાઉન્ડ કૌંસ () અવગણી શકાય છે.

print(sum([i**2 for i in range(5)]))
# 30

print(sum((i**2 for i in range(5))))
# 30

print(sum(i**2 for i in range(5)))
# 30

પ્રોસેસિંગ સ્પીડની વાત કરીએ તો, જ્યારે તમામ તત્વો પર પ્રક્રિયા કરવામાં આવે છે ત્યારે જનરેટર નોટેશન કરતાં સૂચિની સમજણ ઘણી વખત ઝડપી હોય છે.

જો કે, બધા() અથવા કોઈપણ() સાથે નિર્ણય કરતી વખતે, ઉદાહરણ તરીકે, જ્યારે ખોટું અથવા સાચું હોય ત્યારે પરિણામ નક્કી થાય છે, તેથી જનરેટર અભિવ્યક્તિઓનો ઉપયોગ સૂચિ સમજણ સંકેતનો ઉપયોગ કરતાં વધુ ઝડપી હોઈ શકે છે.

ત્યાં કોઈ ટ્યુપલ કોમ્પ્રીહેન્સન નોટેશન નથી, પરંતુ જો તમે જનરેટર એક્સપ્રેશનનો ઉપયોગ tuple() ની દલીલ તરીકે કરો છો, તો તમે કોમ્પ્રીહેન્સન નોટેશનમાં ટ્યુપલ જનરેટ કરી શકો છો.

t = tuple(i**2 for i in range(5))

print(t)
# (0, 1, 4, 9, 16)

print(type(t))
# <class 'tuple'>
Copied title and URL