નીચે આપેલા દરેક કેસ માટે, પાયથોનમાં સૂચિ (એરે) પાસે ડુપ્લિકેટ તત્વો (બધા તત્વો અનન્ય/અનોખા છે) છે કે કેમ તે કેવી રીતે નિર્ધારિત કરવું તેનું વર્ણન નીચે આપેલ છે.
- તત્વમાં કોઈ સૂચિ વિનાની સૂચિ માટે
- ઘટકોની સૂચિ સાથેની સૂચિ માટે (દ્વિ-પરિમાણીય એરે, સૂચિઓની સૂચિ, વગેરે)
સૂચિમાંથી ડુપ્લિકેટ તત્વોને કેવી રીતે દૂર કરવા અથવા કાઢવા તે વિશે નીચેનો લેખ જુઓ.
નોંધ કરો કે સૂચિઓ વિવિધ પ્રકારના ડેટાને સંગ્રહિત કરી શકે છે અને એરેથી સખત રીતે અલગ છે. જો તમે પ્રક્રિયાઓમાં એરેને હેન્ડલ કરવા માંગતા હો કે જેમાં મેમરીનું કદ અને મેમરી સરનામાં અથવા મોટા ડેટાની સંખ્યાત્મક પ્રક્રિયાની જરૂર હોય, તો એરે (સ્ટાન્ડર્ડ લાઇબ્રેરી) અથવા NumPy નો ઉપયોગ કરો.
સૂચિમાં ડુપ્લિકેટ ઘટકો છે કે કેમ તે નક્કી કરો (જો તત્વની કોઈ સૂચિ નથી)
જો તત્વ પાસે અપડેટ કરી શકાય તેવી ઑબ્જેક્ટ ન હોય જેમ કે સૂચિ, સેટ સેટ પ્રકારનો કન્સ્ટ્રક્ટર સેટ() નો ઉપયોગ કરો.
- સંબંધિત:પાયથોનના સેટ પ્રકાર સાથે સેટ ઓપરેશન્સ (દા.ત., યુનિયન સેટ, પ્રોડક્ટ સેટ્સ અને સબસેટ્સ નક્કી કરવા)
સેટ પ્રકાર એ ડેટા પ્રકાર છે જેમાં કોઈ ડુપ્લિકેટ તત્વો નથી. જ્યારે કન્સ્ટ્રક્ટર સેટ()ને સૂચિ પસાર કરવામાં આવે છે, ત્યારે ડુપ્લિકેટ મૂલ્યોને અવગણવામાં આવે છે અને તત્વો તરીકે માત્ર અનન્ય મૂલ્યો સાથે સેટ પ્રકારનો ઑબ્જેક્ટ પરત કરવામાં આવે છે.
આ સેટ પ્રકારના ઑબ્જેક્ટમાં ઘટકોની સંખ્યા અને મૂળ સૂચિ બિલ્ટ-ઇન ફંક્શન len() નો ઉપયોગ કરીને મેળવવામાં આવે છે અને તેની સરખામણી કરવામાં આવે છે.
- જો ઘટકોની સંખ્યા સમાન હોય, તો મૂળ સૂચિમાં કોઈ ડુપ્લિકેટ ઘટકો નથી
- જો ઘટકોની સંખ્યા અલગ હોય તો ડુપ્લિકેટ તત્વો મૂળ સૂચિમાં શામેલ છે
ડુપ્લિકેટ તત્વો ન હોય તો ખોટા અને જો ડુપ્લિકેટ તત્વો હોય તો સાચા પરત કરતા કાર્યો નીચે મુજબ છે
def has_duplicates(seq):
return len(seq) != len(set(seq))
l = [0, 1, 2]
print(has_duplicates(l))
# False
l = [0, 1, 1, 2]
print(has_duplicates(l))
# True
ઉદાહરણ એ સૂચિ છે, પરંતુ સમાન કાર્યનો ઉપયોગ ટ્યુપલ્સ સાથે થઈ શકે છે.
મ્યુટેબલ (અપડેટ કરી શકાય તેવા) ઑબ્જેક્ટ્સ જેમ કે સૂચિઓ પ્રકારના સેટના ઘટકો હોઈ શકતા નથી. તેથી, તત્વો (દ્વિ-પરિમાણીય એરે, યાદીઓની યાદી, વગેરે) તરીકે યાદીઓ સાથેની યાદીઓ TypeError માં પરિણમશે. કાઉન્ટરમેઝર નીચે દર્શાવેલ છે.
l_2d = [[0, 1], [1, 1], [0, 1], [1, 0]]
# print(has_duplicates(l_2d))
# TypeError: unhashable type: 'list'
સૂચિમાં ડુપ્લિકેટ ઘટકો છે કે કેમ તે નક્કી કરો (જો તત્વની સૂચિ હોય તો)
ઘટકોની સૂચિ (જેમ કે સૂચિની સૂચિ) સાથેની સૂચિના કિસ્સામાં, ડુપ્લિકેટ ઘટકો છે કે કેમ તે નિર્ધારિત કરવા માટે નીચેના કાર્યોનો ઉપયોગ કરી શકાય છે.
def has_duplicates2(seq):
seen = []
unique_list = [x for x in seq if x not in seen and not seen.append(x)]
return len(seq) != len(unique_list)
l_2d = [[0, 0], [0, 1], [1, 1], [1, 0]]
print(has_duplicates2(l_2d))
# False
l_2d = [[0, 0], [0, 1], [1, 1], [1, 1]]
print(has_duplicates2(l_2d))
# True
સેટ() ને બદલે, સૂચિ સમજણ સંકેત એક સૂચિ બનાવે છે જેના ઘટકો ફક્ત અનન્ય મૂલ્યો છે, અને ઘટકોની સંખ્યાની તુલના કરવામાં આવે છે. વિગતો માટે નીચેનો લેખ જુઓ.
આ ફંક્શન એવી સૂચિઓ માટે પણ માન્ય છે કે જેમાં ઘટકોની સૂચિ નથી.
l = [0, 1, 2]
print(has_duplicates2(l))
# False
l = [0, 1, 1, 2]
print(has_duplicates2(l))
# True
અત્યાર સુધીનું ઉદાહરણ એ નિર્ધારણ છે કે ઘટકોની સૂચિ ડુપ્લિકેટ છે કે કેમ (સમાન સૂચિ ધરાવે છે).
શું દરેક સૂચિ ઓવરલેપના ઘટકો મૂળ સૂચિને એક પરિમાણમાં ફ્લેટ કર્યા પછી નક્કી કરી શકાય છે.
l_2d = [[0, 1], [2, 3]]
print(sum(l_2d, []))
# [0, 1, 2, 3]
print(has_duplicates(sum(l_2d, [])))
# False
l_2d = [[0, 1], [2, 0]]
print(has_duplicates(sum(l_2d, [])))
# True
અહીં, sum() નો ઉપયોગ યાદીને સપાટ કરવા માટે થાય છે, પરંતુ itertools.chain.from_iterable() નો પણ ઉપયોગ કરી શકાય છે. વધુમાં, જ્યારે ત્રણ કે તેથી વધુ પરિમાણોની સૂચિને સપાટ કરવામાં આવે છે, ત્યારે નવા કાર્યને વ્યાખ્યાયિત કરવું જરૂરી છે.
