આ વિભાગ યાદી (એરે) માંથી ડુપ્લિકેટ તત્વોને દૂર કરીને અથવા કાઢીને પાયથોનમાં નવી સૂચિ કેવી રીતે જનરેટ કરવી તેનું વર્ણન કરે છે.
નીચેની વિગતો અહીં વર્ણવેલ છે.
- ડુપ્લિકેટ તત્વો દૂર કરો અને નવી સૂચિઓ બનાવો
- મૂળ સૂચિનો ક્રમ સાચવશો નહીં:
set() - મૂળ સૂચિનો ક્રમ સાચવે છે:
dict.fromkeys(),sorted() - દ્વિ-પરિમાણીય એરે (સૂચિઓની સૂચિ)
- મૂળ સૂચિનો ક્રમ સાચવશો નહીં:
- ડુપ્લિકેટ તત્વોને બહાર કાઢો અને નવી સૂચિ બનાવો
- મૂળ સૂચિનો ક્રમ સાચવશો નહીં
- મૂળ સૂચિનો ક્રમ સાચવે છે
- દ્વિ-પરિમાણીય એરે (સૂચિઓની સૂચિ)
આ જ ખ્યાલ સૂચિને બદલે ટ્યુપલ પર લાગુ કરી શકાય છે.
માટે નીચેનો લેખ જુઓ
- જો તમે નક્કી કરવા માંગતા હો કે સૂચિ અથવા ટ્યૂપલમાં ડુપ્લિકેટ તત્વો છે
- જો તમે એક સૂચિને બદલે બહુવિધ સૂચિઓમાં સામાન્ય અથવા સામાન્ય ન હોય તેવા ઘટકોને બહાર કાઢવા માંગો છો
નોંધ કરો કે સૂચિઓ વિવિધ પ્રકારના ડેટાને સંગ્રહિત કરી શકે છે અને એરેથી સખત રીતે અલગ છે. જો તમે પ્રક્રિયાઓમાં એરેને હેન્ડલ કરવા માંગતા હો કે જેમાં મેમરીનું કદ અને મેમરી સરનામાં અથવા મોટા ડેટાની સંખ્યાત્મક પ્રક્રિયાની જરૂર હોય, તો એરે (સ્ટાન્ડર્ડ લાઇબ્રેરી) અથવા NumPy નો ઉપયોગ કરો.
ડુપ્લિકેટ તત્વો દૂર કરો અને નવી સૂચિઓ બનાવો
મૂળ સૂચિનો ક્રમ સાચવશો નહીં:set()
જો મૂળ સૂચિના ક્રમને સાચવવાની કોઈ જરૂર નથી, તો set() નો ઉપયોગ કરો, જે સમૂહ પ્રકારનો સમૂહ બનાવે છે.
સેટ પ્રકાર એ ડેટા પ્રકાર છે જેમાં કોઈ ડુપ્લિકેટ તત્વો નથી. જ્યારે સૂચિ અથવા અન્ય ડેટા પ્રકાર સેટ() પર પસાર કરવામાં આવે છે, ત્યારે ડુપ્લિકેટ મૂલ્યોને અવગણવામાં આવે છે અને પ્રકાર સમૂહનો ઑબ્જેક્ટ પરત કરવામાં આવે છે જેમાં ફક્ત અનન્ય મૂલ્યો ઘટકો હોય છે.
જો તમે તેને ટ્યુપલ બનાવવા માંગતા હો, તો ટ્યુપલ() નો ઉપયોગ કરો.
l = [3, 3, 2, 1, 5, 1, 4, 2, 3]
print(set(l))
# {1, 2, 3, 4, 5}
print(list(set(l)))
# [1, 2, 3, 4, 5]
અલબત્ત, તે સેટ તરીકે પણ છોડી શકાય છે. સેટ પ્રકાર સેટ વિશે વધુ માહિતી માટે નીચેનો લેખ જુઓ.
- સંબંધિત:પાયથોનના સેટ પ્રકાર સાથે સેટ ઓપરેશન્સ (દા.ત., યુનિયન સેટ, પ્રોડક્ટ સેટ્સ અને સબસેટ્સ નક્કી કરવા)
મૂળ સૂચિનો ક્રમ સાચવે છે:dict.fromkeys(),sorted()
જો તમે મૂળ સૂચિના ક્રમને સાચવવા માંગતા હોવ, તો શબ્દકોષના પ્રકારમાંથી કીઝ() અથવા બિલ્ટ-ઇન ફંક્શન સોર્ટેડ() નો ઉપયોગ કરો.
dict.fromkeys() એક નવો ડિક્શનરી ઑબ્જેક્ટ બનાવે છે જેની ચાવીઓ દલીલોમાં ઉલ્લેખિત સૂચિ, ટ્યુપલ્સ વગેરે છે. જો બીજી દલીલ અવગણવામાં આવે, તો મૂલ્ય કંઈ નથી.
શબ્દકોશ કીમાં ડુપ્લિકેટ તત્વો ન હોવાથી, ડુપ્લિકેટ મૂલ્યોને સેટ() માં અવગણવામાં આવે છે. વધુમાં, ડિક્શનરી ઑબ્જેક્ટને સૂચિ મેળવવા માટે સૂચિ () માટે દલીલ તરીકે પસાર કરી શકાય છે જેના ઘટકો શબ્દકોશ કી છે.
print(dict.fromkeys(l))
# {3: None, 2: None, 1: None, 5: None, 4: None}
print(list(dict.fromkeys(l)))
# [3, 2, 1, 5, 4]
Python 3.7 (CPython 3.6 છે) થી ખાતરી આપવામાં આવી છે કે dict.fromkeys() દલીલ ક્રમનો ક્રમ સાચવે છે. પહેલાનાં વર્ઝનમાં બિલ્ટ-ઇન ફંક્શન સોર્ટેડ() નો ઉપયોગ નીચે મુજબ છે.
સૉર્ટ કરેલી દલીલ કી માટે સૂચિ ટ્યુપલ મેથડ ઇન્ડેક્સ() નો ઉલ્લેખ કરો, જે તત્વોની સૉર્ટ કરેલી સૂચિ આપે છે.
index() એ એક પદ્ધતિ છે જે મૂલ્યની અનુક્રમણિકા (સૂચિમાંના ઘટકની સંખ્યા) પરત કરે છે, જે મૂળ સૂચિના ક્રમના આધારે સૂચિને સૉર્ટ કરવા માટે sorted() ની કી તરીકે સ્પષ્ટ કરી શકાય છે. દલીલ કી એક કૉલેબલ (કૉલ કરી શકાય તેવા) ઑબ્જેક્ટ તરીકે ઉલ્લેખિત છે, તેથી () લખશો નહીં.
print(sorted(set(l), key=l.index))
# [3, 2, 1, 5, 4]
દ્વિ-પરિમાણીય એરે (સૂચિઓની સૂચિ)
દ્વિ-પરિમાણીય એરે (સૂચિઓની સૂચિ) માટે, set() અથવા dict.fromkeys() નો ઉપયોગ કરવાની પદ્ધતિ TypeError માં પરિણમે છે.
l_2d = [[1, 1], [0, 1], [0, 1], [0, 0], [1, 0], [1, 1], [1, 1]]
# l_2d_unique = list(set(l_2d))
# TypeError: unhashable type: 'list'
# l_2d_unique_order = dict.fromkeys(l_2d)
# TypeError: unhashable type: 'list'
આનું કારણ એ છે કે બિન-હેશેબલ ઑબ્જેક્ટ્સ જેમ કે સૂચિઓ ટાઇપ સેટ અથવા ટાઇપ ડિક્ટની કીના ઘટકો હોઈ શકતા નથી.
નીચેના કાર્યોને વ્યાખ્યાયિત કરો મૂળ સૂચિનો ક્રમ સચવાયેલો છે અને એક-પરિમાણીય સૂચિઓ અને ટ્યુપલ્સ માટે કાર્ય કરે છે.
def get_unique_list(seq):
seen = []
return [x for x in seq if x not in seen and not seen.append(x)]
print(get_unique_list(l_2d))
# [[1, 1], [0, 1], [0, 0], [1, 0]]
print(get_unique_list(l))
# [3, 2, 1, 5, 4]
સૂચિ સમજણ સંકેતનો ઉપયોગ થાય છે.
અહીં, અમે નીચેનાનો ઉપયોગ કરીએ છીએ
- જો અને ઓપરેટરના શોર્ટ-સર્કિટ મૂલ્યાંકનમાં “X અને Y” માં X ખોટું છે, તો Y નું મૂલ્યાંકન કરવામાં આવતું નથી (એક્ઝ્યુટેડ નથી).
- append() પદ્ધતિ કંઈ નહીં આપે.
જો મૂળ સૂચિ ક્રમના ઘટકો જોયેલામાં અસ્તિત્વમાં નથી, તો પછી અને પછીનું મૂલ્યાંકન કરવામાં આવે છે.
see.append(x) ને એક્ઝિક્યુટ કરવામાં આવે છે અને એલિમેન્ટ જોવામાં ઉમેરવામાં આવે છે.
કારણ કે append() મેથડ કંઈ નહીં આપે અને None is False, not seen.append(x) નું મૂલ્યાંકન સાચું થાય છે.
સૂચિ સમજણ સંકેતમાં શરતી અભિવ્યક્તિ સાચી બને છે અને અંતિમ જનરેટ કરેલ સૂચિના ઘટક તરીકે ઉમેરવામાં આવે છે.
જો મૂળ સૂચિ ક્રમના ઘટકો જોવામાં હાજર હોય, તો x જે દેખાયું નથી તે ખોટું છે, અને સૂચિની સમજણ અભિવ્યક્તિ માટે શરતી અભિવ્યક્તિ False છે.
તેથી, તેઓ અંતિમ જનરેટ કરેલ સૂચિના ઘટકો તરીકે ઉમેરવામાં આવતા નથી.
બીજી પદ્ધતિ NumPy ના કાર્ય np.unique() માં દલીલ અક્ષને સેટ કરવાની છે, જો કે પરિણામ સૉર્ટ કરવામાં આવશે.
ડુપ્લિકેટ તત્વોને બહાર કાઢો અને નવી સૂચિ બનાવો
મૂળ સૂચિનો ક્રમ સાચવશો નહીં
મૂળ સૂચિમાંથી માત્ર ડુપ્લિકેટ તત્વો કાઢવા માટે, સંગ્રહનો ઉપયોગ કરો. કાઉન્ટર().
કીઓ તરીકે ઘટકો અને મૂલ્યો તરીકે ઘટકોની સંખ્યા સાથે સંગ્રહ પરત કરે છે.કાઉન્ટર (શબ્દકોષનો પેટા વર્ગ).
import collections
l = [3, 3, 2, 1, 5, 1, 4, 2, 3]
print(collections.Counter(l))
# Counter({3: 3, 2: 2, 1: 2, 5: 1, 4: 1})
તે શબ્દકોશનો પેટા વર્ગ હોવાથી, વસ્તુઓ() નો ઉપયોગ કી અને મૂલ્યો પુનઃપ્રાપ્ત કરવા માટે કરી શકાય છે. તે કીઓ કાઢવા માટે પૂરતી છે જેની સંખ્યા બે અથવા વધુ છે.
print([k for k, v in collections.Counter(l).items() if v > 1])
# [3, 2, 1]
મૂળ સૂચિનો ક્રમ સાચવે છે
ઉપરના ઉદાહરણમાં બતાવ્યા પ્રમાણે, પાયથોન 3.7 થી, સંગ્રહની ચાવીઓ. કાઉન્ટર મૂળ સૂચિનો ક્રમ જાળવી રાખે છે અને તેથી વધુ.
અગાઉના સંસ્કરણોમાં, sorted() સાથે સૉર્ટ કરવું પૂરતું છે, જેમ કે ડુપ્લિકેટ ઘટકોને કાઢી નાખવામાં આવે છે.
print(sorted([k for k, v in collections.Counter(l).items() if v > 1], key=l.index))
# [3, 2, 1]
જો તમે ડુપ્લિકેટ્સ જેમ છે તેમ કાઢવા માંગો છો, તો મૂળ સૂચિમાંથી બે કે તેથી વધુ સંખ્યાવાળા ઘટકોને ખાલી છોડી દો. ઓર્ડર પણ સાચવેલ છે.
cc = collections.Counter(l)
print([x for x in l if cc[x] > 1])
# [3, 3, 2, 1, 1, 2, 3]
દ્વિ-પરિમાણીય એરે (સૂચિઓની સૂચિ)
દ્વિ-પરિમાણીય એરે (સૂચિઓની સૂચિ) માટે, જ્યારે મૂળ સૂચિનો ક્રમ જાળવી રાખવામાં આવતો નથી અને જ્યારે તેને અનુક્રમે જાળવી રાખવામાં આવે છે ત્યારે નીચેના કાર્યો શક્ય છે. તે એક-પરિમાણીય સૂચિઓ અને ટ્યુપલ્સ માટે પણ કામ કરે છે.
l_2d = [[1, 1], [0, 1], [0, 1], [0, 0], [1, 0], [1, 1], [1, 1]]
def get_duplicate_list(seq):
seen = []
return [x for x in seq if not seen.append(x) and seen.count(x) == 2]
def get_duplicate_list_order(seq):
seen = []
return [x for x in seq if seq.count(x) > 1 and not seen.append(x) and seen.count(x) == 1]
print(get_duplicate_list(l_2d))
# [[0, 1], [1, 1]]
print(get_duplicate_list_order(l_2d))
# [[1, 1], [0, 1]]
print(get_duplicate_list(l))
# [3, 1, 2]
print(get_duplicate_list_order(l))
# [3, 2, 1]
જો તમે ડુપ્લિકેટ્સ સાથે એક્સટ્રેક્ટ કરવા માંગતા હો, તો મૂળ સૂચિમાંથી બે અથવા વધુની ગણતરી સાથે ઘટકોને છોડી દો.
print([x for x in l_2d if l_2d.count(x) > 1])
# [[1, 1], [0, 1], [0, 1], [1, 1], [1, 1]]
નોંધ કરો કે કાઉન્ટ() ની કોમ્પ્યુટેશનલ જટિલતા O(n) હોવાથી, ઉપર દર્શાવેલ ફંક્શન કે જે કાઉન્ટ()ને વારંવાર એક્ઝિક્યુટ કરે છે તે ખૂબ જ બિનકાર્યક્ષમ છે. ત્યાં એક સ્માર્ટ રસ્તો હોઈ શકે છે.
કાઉન્ટર એ શબ્દકોશનો સબક્લાસ છે, તેથી જો તમે લિસ્ટ અથવા ટપલ કે જેના તત્વો લિસ્ટ અથવા અન્ય બિન-હેશેબલ ઑબ્જેક્ટ્સ છે સંગ્રહોમાંથી પસાર કરો છો.
# print(collections.Counter(l_2d))
# TypeError: unhashable type: 'list'
