ලැයිස්තුවක් තුළ අනුපිටපත් තිබේදැයි පරීක්ෂා කිරීම සඳහා මට වැඩසටහනක් ලිවීමට අවශ්‍යය. එය එසේ කරන්නේ නම් ඒවා ඉවත් කර අනුපිටපත් නොකළ / ඉවත් නොකළ අයිතම සමඟ නව ලැයිස්තුවක් ලබා දේ. මෙය මා සතුව ඇති නමුත් අවංකව කිවහොත් කුමක් කළ යුතුදැයි මම නොදනිමි.

def remove_duplicates():
    t = ['a', 'b', 'c', 'd']
    t2 = ['a', 'c', 'd']
    for t in t2:
        t.append(t.remove())
    return t

අද්විතීය අයිතම එකතුවක් ලබා ගැනීම සඳහා පොදු ප්‍රවේශය වන්නේ a set. කට්ටල unordered එකතු පැහැදිලි වස්තූන්. ඕනෑම ක්‍රියාකාරීත්වයකින් කට්ටලයක් සෑදීම සඳහා, ඔබට එය හුදෙක් සාදන ලද set()ශ්‍රිතයට යැවිය හැකිය . ඔබට පසුව නැවත සැබෑ ලැයිස්තුවක් අවශ්‍ය නම්, ඔබට ඒ හා සමානව කට්ටලය list()ශ්‍රිතයට යැවිය හැකිය .

පහත උදාහරණයෙන් ඔබ කිරීමට උත්සාහ කරන ඕනෑම දෙයක් ආවරණය කළ යුතුය:

>>> t = [1, 2, 3, 1, 2, 5, 6, 7, 8]
>>> t
[1, 2, 3, 1, 2, 5, 6, 7, 8]
>>> list(set(t))
[1, 2, 3, 5, 6, 7, 8]
>>> s = [1, 2, 3]
>>> list(set(t) - set(s))
[8, 5, 6, 7]

උදාහරණ ප්‍රති result ලයෙන් ඔබට පෙනෙන පරිදි, මුල් අනුපිළිවෙල පවත්වා ගෙන යන්නේ නැත . ඉහත සඳහන් කළ පරිදි, කට්ටල අනුපිළිවෙලට නැති එකතු කිරීම් වන බැවින් ඇණවුම නැති වී යයි. කට්ටලයක් නැවත ලැයිස්තුවකට පරිවර්තනය කිරීමේදී, අත්තනෝමතික අනුපිළිවෙලක් නිර්මාණය වේ.

පිළිවෙල පවත්වා ගැනීම

ඇණවුම ඔබට වැදගත් නම්, ඔබට වෙනත් යාන්ත්‍රණයක් භාවිතා කිරීමට සිදුවනු ඇත. මේ සඳහා ඉතා පොදු විසඳුමක් වන්නේ OrderedDictඇතුළත් කිරීමේදී යතුරු අනුපිළිවෙල තබා ගැනීම කෙරෙහි විශ්වාසය තැබීමයි:

>>> from collections import OrderedDict
>>> list(OrderedDict.fromkeys(t))
[1, 2, 3, 5, 6, 7, 8]

පයිතන් 3.7 සිට ඇරඹෙන ශබ්දකෝෂය ඇතුළු කිරීමේ අනුපිළිවෙල පවත්වා ගෙන යාම සහතික කර ඇත, එබැවින් ඔබ පයිතන් 3.7 හෝ ඊට පසුව (හෝ සීපයිතන් 3.6) සිටී නම් එය කෙලින්ම භාවිතා කළ හැකිය:

>>> list(dict.fromkeys(t))
[1, 2, 3, 5, 6, 7, 8]

මෙය මුලින් ශබ්ද කෝෂයක් සෑදීමට හා ඉන් පසුව ලැයිස්තුවක් සෑදීමට යම්කිසි පොදු කාර්යයක් තිබිය හැකි බව සලකන්න. ඔබට ඇණවුම සුරැකීමට ඇත්ත වශයෙන්ම අවශ්‍ය නොවන්නේ නම්, ඔබ බොහෝ විට කට්ටලයක් භාවිතා කිරීමට වඩා හොඳය, විශේෂයෙන් එය ඔබට වැඩ කිරීමට තවත් බොහෝ මෙහෙයුම් ලබා දෙන බැවිනි. අනුපිටපත් ඉවත් කිරීමේදී ඇණවුම ආරක්ෂා කර ගැනීම සඳහා වැඩි විස්තර සහ විකල්ප ක්‍රම සඳහා මෙම ප්‍රශ්නය බලන්න .

අවසාන වශයෙන් සලකන්න, setසහ OrderedDict/ dictවිසඳුම් යන දෙකටම ඔබේ අයිතම සෝදාගත හැකි බව . මෙයින් සාමාන්‍යයෙන් අදහස් කරන්නේ ඒවා වෙනස් කළ නොහැකි බවයි. ඔබට හැෂ් කළ නොහැකි අයිතම සමඟ ගනුදෙනු කිරීමට සිදුවුවහොත් (උදා.

පයිතන් 2.7 හි , අනුපිළිවෙල මුල් අනුපිළිවෙලෙහි තබා ගනිමින් නැවත සැකසිය හැකි දේකින් ඉවත් කිරීමේ නව ක්‍රමය:

>>> from collections import OrderedDict
>>> list(OrderedDict.fromkeys('abracadabra'))
['a', 'b', 'r', 'c', 'd']

පයිතන් 3.5 හි, ඕඩර්ඩෙක්ට් හි සී ක්‍රියාත්මක කිරීමක් ඇත. මගේ වේලාවන්ට අනුව මෙය දැන් පයිතන් 3.5 සඳහා වන විවිධ ප්‍රවේශයන්ගෙන් වේගවත්ම හා කෙටිම වේ.

පයිතන් 3.6 හි නිත්‍ය නියෝගය ඇණවුම් කළ හා සංයුක්ත විය. (මෙම ලක්ෂණය CPython සහ PyPy සඳහා රඳවා තබා ඇති නමුත් වෙනත් ක්‍රියාත්මක කිරීම් වලදී නොපවතී). ඇණවුම රඳවා තබා ගනිමින් අඩු කිරීමේ නව වේගවත් ක්‍රමයක් එමඟින් අපට ලබා දෙයි:

>>> list(dict.fromkeys('abracadabra'))
['a', 'b', 'r', 'c', 'd']

පයිතන් 3.7 හි , සියලු ක්‍රියාත්මක කිරීම් හරහා ඇණවුම් කරන ලද දෙකටම නිත්‍ය නියෝගය සහතික කෙරේ. ඉතින්, කෙටිම හා වේගවත්ම විසඳුම වන්නේ:

>>> list(dict.fromkeys('abracadabra'))
['a', 'b', 'r', 'c', 'd']

එය එක් ලයිනර් ය: list(set(source_list))උපක්‍රමය කරනු ඇත.

A setයනු අනුපිටපත් තිබිය නොහැකි දෙයකි.

යාවත්කාලීන කිරීම: ඇණවුම සුරැකීමේ ප්‍රවේශය පේළි දෙකකි:

from collections import OrderedDict
OrderedDict((x, True) for x in source_list).keys()

මෙහිදී අපි OrderedDictයතුරු ඇතුළු කිරීමේ අනුපිළිවෙල සිහිපත් කරන කාරණය භාවිතා කරන අතර විශේෂිත යතුරක අගයක් යාවත්කාලීන වූ විට එය වෙනස් නොවේ. අපි Trueඅගයන් ලෙස ඇතුළු කරමු , නමුත් අපට ඕනෑම දෙයක් ඇතුළත් කළ හැකිය, අගයන් පමණක් භාවිතා නොවේ. ( නොසලකා හරින ලද අගයන් සමඟ setබොහෝ දේ ක්‍රියා කරයි dict.)

>>> t = [1, 2, 3, 1, 2, 5, 6, 7, 8]
>>> t
[1, 2, 3, 1, 2, 5, 6, 7, 8]
>>> s = []
>>> for i in t:
       if i not in s:
          s.append(i)
>>> s
[1, 2, 3, 5, 6, 7, 8]

ඔබ ඇණවුම ගැන සැලකිල්ලක් නොදක්වන්නේ නම්, මෙය කරන්න:

def remove_duplicates(l):
    return list(set(l))

A setහි අනුපිටපත් නොමැති බවට සහතික වේ.

හි අනුපිටපත් වල පළමු මූලද්‍රව්‍යයන්ගේ අනුපිළිවෙල රඳවා ගනිමින් නව ලැයිස්තුවක් සෑදීම L

newlist=[ii for n,ii in enumerate(L) if ii not in L[:n]]

උදාහරණයක් ලෙස if L=[1, 2, 2, 3, 4, 2, 4, 3, 5]එසේ newlistවනු ඇත[1,2,3,4,5]

එක් එක් නව අංග එකතු කිරීමට පෙර ලැයිස්තුවේ මීට පෙර නොපෙන්වා ඇති බව මෙය පරීක්ෂා කරයි. එසේම එයට ආනයන අවශ්‍ය නොවේ.

සගයකු විසින් ඔහුගේ කේතයේ කොටසක් ලෙස පිළිගත් පිළිතුර අද කේත සමාලෝචනයක් සඳහා මා වෙත යවා ඇත. ප්‍රශ්නයේ ඇති පිළිතුරේ අලංකාරය මම නිසැකවම අගය කරන අතර, කාර්ය සාධනය ගැන මම සතුටු නොවෙමි. මම මෙම විසඳුම අත්හදා බැලුවෙමි ( බැලීමේ කාලය අඩු කිරීම සඳහා මම කට්ටලය භාවිතා කරමි )

def ordered_set(in_list):
    out_list = []
    added = set()
    for val in in_list:
        if not val in added:
            out_list.append(val)
            added.add(val)
    return out_list

කාර්යක්ෂමතාව සංසන්දනය කිරීම සඳහා, මම පූර්ණ සංඛ්‍යා 100 ක අහඹු නියැදියක් භාවිතා කළෙමි - 62 අද්විතීය විය

from random import randint
x = [randint(0,100) for _ in xrange(100)]

In [131]: len(set(x))
Out[131]: 62

මිනුම්වල ප්රති results ල මෙන්න

In [129]: %timeit list(OrderedDict.fromkeys(x))
10000 loops, best of 3: 86.4 us per loop

In [130]: %timeit ordered_set(x)
100000 loops, best of 3: 15.1 us per loop

හොඳයි, කට්ටලය විසඳුමෙන් ඉවත් කළහොත් කුමක් සිදුවේද?

def ordered_set(inlist):
    out_list = []
    for val in inlist:
        if not val in out_list:
            out_list.append(val)
    return out_list

ප්‍රති der ලය ඕඩර්ඩෙක්ට් මෙන් නරක නැත , නමුත් තවමත් මුල් විසඳුමට වඩා 3 ගුණයකට වඩා වැඩිය

In [136]: %timeit ordered_set(x)
10000 loops, best of 3: 52.6 us per loop

පැන්ඩාස් සහ නැම්පි භාවිතා කරමින් විසඳුම් ද ඇත. ඔවුන් දෙදෙනාම සංඛ්‍යාත්මක අරාව නැවත ලබා දෙන බැවින් ඔබට .tolist()ලැයිස්තුවක් අවශ්‍ය නම් ශ්‍රිතය භාවිතා කළ යුතුය.

t=['a','a','b','b','b','c','c','c']
t2= ['c','c','b','b','b','a','a','a']

පැන්ඩා විසඳුම

පැන්ඩස් ශ්‍රිතය භාවිතා කිරීම unique():

import pandas as pd
pd.unique(t).tolist()
>>>['a','b','c']
pd.unique(t2).tolist()
>>>['c','b','a']

නිරුවත් විසඳුම

අංකිත ශ්‍රිතය භාවිතා කිරීම unique() .

import numpy as np
np.unique(t).tolist()
>>>['a','b','c']
np.unique(t2).tolist()
>>>['a','b','c']

Numpy.unique () ද අගයන් වර්ග කරන බව සලකන්න . එබැවින් ලැයිස්තුව t2නැවත වර්ග කර ඇත. ඔබට ඇණවුම සුරැකීමට අවශ්‍ය නම් මෙම පිළිතුරෙහි මෙන් භාවිතා කරන්න :

_, idx = np.unique(t2, return_index=True)
t2[np.sort(idx)].tolist()
>>>['c','b','a']

අනෙක් ඒවාට සාපේක්ෂව විසඳුම එතරම් අලංකාර නොවේ, කෙසේ වෙතත්, pandas.unique () හා සසඳන විට numpy.unique () තෝරාගත් එක් අක්ෂයක් ඔස්සේ කූඩු අරා අද්විතීයද යන්න පරීක්ෂා කිරීමට ඔබට ඉඩ සලසයි.

කළ හැකි තවත් ක්‍රමයක්:

>>> seq = [1,2,3,'a', 'a', 1,2]
>> dict.fromkeys(seq).keys()
['a', 1, 2, 3]

සරල හා පහසු:

myList = [1, 2, 3, 1, 2, 5, 6, 7, 8]
cleanlist = []
[cleanlist.append(x) for x in myList if x not in cleanlist]

ප්‍රතිදානය:

>>> cleanlist 
[1, 2, 3, 5, 6, 7, 8]

මෙම පිළිතුරෙහි, කොටස් දෙකක් වනු ඇත: අද්විතීය විසඳුම් දෙකක් සහ නිශ්චිත විසඳුම් සඳහා වේගයේ ප්‍රස්ථාරයක්.

අනුපිටපත් අයිතම ඉවත් කිරීම

මෙම පිළිතුරු බොහොමයක් ඉවත් කළ හැකි අනුපිටපත් අයිතම පමණක් ඉවත් කරයි , නමුත් මෙම ප්‍රශ්නයට ඇඟවෙන්නේ එය හැෂ් කළ හැකි අයිතම පමණක් අවශ්‍ය නොවන බවයි, එයින් අදහස් කරන්නේ මම හැෂ් කළ නොහැකි විසඳුම් කිහිපයක් ඉදිරිපත් කරමි .

collection.Counter යනු සම්මත පුස්තකාලයේ ප්‍රබල මෙවලමක් වන අතර මේ සඳහා පරිපූර්ණ විය හැකිය. එහි ඇත්තේ කවුන්ටරයක් ​​ඇති තවත් එක් විසඳුමක් පමණි. කෙසේ වෙතත්, එම විසඳුම හැෂ් කළ හැකි යතුරු වලට පමණක් සීමා වේ .

කවුන්ටරයේ වෙනස් කළ නොහැකි යතුරු වලට ඉඩ දීම සඳහා, මම බහාලුම් පන්තියක් සෑදුවෙමි, එය වස්තුවේ පෙරනිමි හැෂ් ශ්‍රිතය ලබා ගැනීමට උත්සාහ කරනු ඇත, නමුත් එය අසමත් වුවහොත් එය එහි අනන්‍යතා ක්‍රියාකාරිත්වය උත්සාහ කරනු ඇත. එය eq සහ hash ක්‍රමයක් ද අර්ථ දක්වයි . අපගේ විසඳුමෙහි වෙනස් කළ නොහැකි අයිතමවලට ඉඩ දීමට මෙය ප්‍රමාණවත් විය යුතුය . වෙනස් කළ නොහැකි වස්තූන් ඒවා සේදිය හැකි ලෙස සලකනු ලැබේ. කෙසේ වෙතත්, මෙම හැෂ් ශ්‍රිතය වෙනස් කළ නොහැකි වස්තූන් සඳහා අනන්‍යතාවය භාවිතා කරයි, එයින් අදහස් කරන්නේ වෙනස් කළ නොහැකි සමාන වස්තු දෙකක් ක්‍රියා නොකරන බවයි. මම ඔබට යෝජනා කරන්නේ මෙය ඉක්මවා ගොස් සමාන විකෘති වර්ගයක හැෂ් භාවිතා කිරීම සඳහා එය වෙනස් කිරීම ( ලැයිස්තුවක් hash(tuple(my_list))නම් භාවිතා කිරීම වැනි my_list).

මමත් විසඳුම් දෙකක් කළා. ඕඩර්ඩෙක්ට් සහ කවුන්ටරය යන දෙකෙහිම උප පංතියක් භාවිතා කරමින් අයිතමවල අනුපිළිවෙල පවත්වා ගෙන යන තවත් විසඳුමක් වන එය 'ඕඩර්කවුන්ටර්' ලෙස නම් කර ඇත. දැන්, කාර්යයන් මෙන්න:

from collections import OrderedDict, Counter

class Container:
    def __init__(self, obj):
        self.obj = obj
    def __eq__(self, obj):
        return self.obj == obj
    def __hash__(self):
        try:
            return hash(self.obj)
        except:
            return id(self.obj)

class OrderedCounter(Counter, OrderedDict):
     'Counter that remembers the order elements are first encountered'

     def __repr__(self):
         return '%s(%r)' % (self.__class__.__name__, OrderedDict(self))

     def __reduce__(self):
         return self.__class__, (OrderedDict(self),)

def remd(sequence):
    cnt = Counter()
    for x in sequence:
        cnt[Container(x)] += 1
    return [item.obj for item in cnt]

def oremd(sequence):
    cnt = OrderedCounter()
    for x in sequence:
        cnt[Container(x)] += 1
    return [item.obj for item in cnt]

remd යනු ඇණවුම් නොකළ වර්ග කිරීමකි, oremd වර්ග කිරීම ඇණවුම් කර ඇත. කුමන එකක් වේගවත් දැයි ඔබට පැහැදිලිව පැවසිය හැකිය, නමුත් මම කෙසේ හෝ පැහැදිලි කරමි. ඇණවුම් නොකළ වර්ග කිරීම තරමක් වේගවත් වේ. ඇණවුමක් අවශ්‍ය නොවන බැවින් එය අඩු දත්ත ප්‍රමාණයක් තබා ගනී.

දැන්, මටත් අවශ්‍ය වූයේ එක් එක් පිළිතුරේ වේග සැසඳීම් පෙන්වීමට ය. ඉතින්, මම දැන් ඒක කරන්නම්.

වේගවත්ම කාර්යය කුමක්ද?

අනුපිටපත් ඉවත් කිරීම සඳහා, මම පිළිතුරු කිහිපයකින් කාර්යයන් 10 ක් රැස් කළෙමි. මම එක් එක් ශ්‍රිතයේ වේගය ගණනය කර matplotlib.pyplot භාවිතා කර ප්‍රස්ථාරයකට දැමුවෙමි .

මම මෙය ග්‍රැෆිං වට තුනකට බෙදුවෙමි. හැෂබල් යනු හෑෂ් කළ හැකි ඕනෑම වස්තුවකි, නිරුපද්‍රිතව යනු හැෂ් කළ නොහැකි ඕනෑම වස්තුවකි. ඇණවුම් කරන ලද අනුක්‍රමයක් යනු අනුපිළිවෙල ආරක්ෂා කරන අනුක්‍රමයකි, අනුපිළිවෙලක් නැති අනුක්‍රමයක් අනුපිළිවෙල ආරක්ෂා නොකරයි. දැන්, තවත් කොන්දේසි කිහිපයක් මෙන්න:

ඇණවුම් නොකළ හැෂබල් යනු අනුපිටපත් ඉවත් කරන ඕනෑම ක්‍රමයක් සඳහා වන අතර එය අනිවාර්යයෙන්ම ඇණවුම තබා ගත යුතු නැත. එයට වෙනස් කළ නොහැකි දේ සඳහා වැඩ කිරීමට අවශ්‍ය නොවීය, නමුත් එයට හැකි විය.

හැෂබල් ඇණවුම් කළා යනු ලැයිස්තුවේ ඇති අයිතමවල අනුපිළිවෙල තබා ඇති ඕනෑම ක්‍රමයක් සඳහා වන නමුත් එයට වෙනස් කළ නොහැකි දේ සඳහා වැඩ කිරීමට අවශ්‍ය නොවීය, නමුත් එයට හැකි විය.

වෙනස් කළ නොහැකි ලෙස ඇණවුම් කර ඇත යනු ලැයිස්තුවේ ඇති අයිතමවල අනුපිළිවෙල තබා ගත හැකි හා වෙනස් කළ නොහැකි දේ සඳහා වැඩ කරන ඕනෑම ක්‍රමයකි.

Y- අක්ෂය මත ගත වූ තත්පර ගණන වේ.

X- අක්ෂය මත ශ්‍රිතය යොදන අංකය වේ.

අපි ඇණවුම් නොකළ හැෂබල් සඳහා අනුක්‍රමයන් ජනනය කළ අතර පහත දැක්වෙන අවබෝධය ඇතිව ඇණවුම් කළ හැෂබල්: [list(range(x)) + list(range(x)) for x in range(0, 1000, 10)]

ඇණවුම් කළ නොහැකි දේ සඳහා: [[list(range(y)) + list(range(y)) for y in range(x)] for x in range(0, 1000, 10)]

පරාසය තුළ 'පියවරක්' ඇති බව සලකන්න, එය නොමැතිව මෙය 10x කාලයක් ගතවනු ඇත. මගේ පෞද්ගලික මතය අනුව, එය කියවීමට ටිකක් පහසු යැයි මම සිතුවෙමි.

පුරාවෘත්තයේ යතුරු මම ශ්‍රිතයේ වඩාත්ම වැදගත් කොටස් ලෙස අනුමාන කිරීමට උත්සාහ කළ දේ ද සටහන් කරන්න. නරකම හෝ හොඳම දේ කරන්නේ කුමන කාර්යය සඳහාද? ප්රස්ථාරය තමාටම කථා කරයි.

එය සමථයකට පත් කිරීමත් සමඟ, මෙන්න ප්‍රස්ථාර.

අනුපිළිවෙලට නැති හැෂබල්ස්

(විශාලනය කර ඇත)

ඇණවුම් කළ හැෂබල්ස්

(විශාලනය කර ඇත)

නොකැඩූ ලෙස ඇණවුම් කර ඇත

(විශාලනය කර ඇත)

මගේ ලැයිස්තුවේ ආ ict ාවක් මා සතුව තිබූ බැවින් ඉහත ප්‍රවේශය භාවිතා කිරීමට මට නොහැකි විය. මට දෝෂය ඇතිවිය:

TypeError: unhashable type:

එබැවින් ඔබ ඇණවුම ගැන සැලකිලිමත් වන්නේ නම් සහ / හෝ සමහර අයිතම වෙනස් කළ නොහැක . එවිට ඔබට මෙය ප්‍රයෝජනවත් විය හැකිය:

def make_unique(original_list):
    unique_list = []
    [unique_list.append(obj) for obj in original_list if obj not in unique_list]
    return unique_list

සමහරු අතුරු ආබාධයක් සහිත ලැයිස්තු අවබෝධය හොඳ විසඳුමක් ලෙස නොසැලකේ. මෙන්න විකල්පයක්:

def make_unique(original_list):
    unique_list = []
    map(lambda x: unique_list.append(x) if (x not in unique_list) else False, original_list)
    return unique_list

මා මෙතෙක් දැක ඇති සියලුම ඇණවුම්-සංරක්ෂණ ප්‍රවේශයන් එක්කෝ බොළඳ සංසන්දනය (O (n ^ 2 සමඟ) කාල-සංකීර්ණතාව සමඟ හොඳම) හෝ අධික බර OrderedDicts/ set+list භාවිතා කළ හැකි යෙදවුම් වලට පමණක් සීමා වූ සංයෝජන භාවිතා කරයි. හැෂ්-ස්වාධීන O (nlogn) විසඳුමක් මෙන්න:

යාවත්කාලීන කිරීම keyතර්කය, ප්‍රලේඛනය සහ පයිතන් 3 අනුකූලතාව එක් කළේය.

# from functools import reduce <-- add this import on Python 3

def uniq(iterable, key=lambda x: x):
    """
    Remove duplicates from an iterable. Preserves order. 
    :type iterable: Iterable[Ord => A]
    :param iterable: an iterable of objects of any orderable type
    :type key: Callable[A] -> (Ord => B)
    :param key: optional argument; by default an item (A) is discarded 
    if another item (B), such that A == B, has already been encountered and taken. 
    If you provide a key, this condition changes to key(A) == key(B); the callable 
    must return orderable objects.
    """
    # Enumerate the list to restore order lately; reduce the sorted list; restore order
    def append_unique(acc, item):
        return acc if key(acc[-1][1]) == key(item[1]) else acc.append(item) or acc 
    srt_enum = sorted(enumerate(iterable), key=lambda item: key(item[1]))
    return [item[1] for item in sorted(reduce(append_unique, srt_enum, [srt_enum[0]]))] 

ඔබට ඇණවුම සුරැකීමට අවශ්‍ය නම් සහ මෙහි කිසිදු බාහිර මොඩියුලයක් භාවිතා නොකිරීම මෙය කිරීමට පහසු ක්‍රමයකි:

>>> t = [1, 9, 2, 3, 4, 5, 3, 6, 7, 5, 8, 9]
>>> list(dict.fromkeys(t))
[1, 9, 2, 3, 4, 5, 6, 7, 8]

සටහන: මෙම ක්‍රමය පෙනුමේ අනුපිළිවෙල ආරක්ෂා කරයි, එබැවින්, ඉහත දැක්වෙන පරිදි, නවයක් එකකට පසු පැමිණෙන්නේ එය දර්ශනය වූ පළමු අවස්ථාව වන බැවිනි. කෙසේ වෙතත්, මෙය කිරීමෙන් ඔබට ලැබෙන ප්‍රති result ලයම වේ

from collections import OrderedDict
ulist=list(OrderedDict.fromkeys(l))

නමුත් එය වඩා කෙටි වන අතර වේගයෙන් ධාවනය වේ.

මෙය ක්‍රියාත්මක වන්නේ fromkeysශ්‍රිතය නව යතුරක් නිර්මාණය කිරීමට උත්සාහ කරන සෑම අවස්ථාවකම , අගය දැනටමත් තිබේ නම් එය නැවත ලියයි. කෙසේ වෙතත් මෙය ශබ්දකෝෂයට කිසිසේත් බලපාන්නේ නැත, fromkeysසියලු යතුරු වල වටිනාකම ඇති ශබ්දකෝෂයක් නිර්මාණය කරන Noneබැවින් effectively ලදායී ලෙස එය සියලු අනුපිටපත් මේ ආකාරයෙන් ඉවත් කරයි.

කට්ටල භාවිතා කිරීමට උත්සාහ කරන්න:

import sets
t = sets.Set(['a', 'b', 'c', 'd'])
t1 = sets.Set(['a', 'b', 'c'])

print t | t1
print t - t1

ඔබට මෙය කළ හැකිය:

>>> t = [1, 2, 3, 3, 2, 4, 5, 6]
>>> s = [x for i, x in enumerate(t) if i == t.index(x)]
>>> s
[1, 2, 3, 4, 5, 6]

ඉහත ක්‍රියා කිරීමට හේතුව එම indexක්‍රමය මඟින් මූලද්‍රව්‍යයක පළමු දර්ශකය පමණක් ලබා දීමයි. අනුපිටපත් මූලද්‍රව්‍යවල ඉහළ දර්ශක ඇත. මෙහි යොමු වන්න :

list.index (x [, ආරම්භය [, අවසානය]])
x හි අගය x වන පළමු අයිතමයේ ලැයිස්තුවේ ශුන්‍ය පාදක දර්ශකය ලබා දෙන්න. එවැනි අයිතමයක් නොමැති නම් අගය දෝෂයක් මතු කරයි.

ඇණවුම් සංරක්ෂණය සමඟ ප්‍රභේදය අඩු කරන්න:

අපට ලැයිස්තුවක් ඇතැයි උපකල්පනය කරන්න:

l = [5, 6, 6, 1, 1, 2, 2, 3, 4]

ප්‍රභේදය අඩු කරන්න (අකාර්යක්ෂම):

>>> reduce(lambda r, v: v in r and r or r + [v], l, [])
[5, 6, 1, 2, 3, 4]

5 x වේගවත් නමුත් වඩා නවීනයි

>>> reduce(lambda r, v: v in r[1] and r or (r[0].append(v) or r[1].add(v)) or r, l, ([], set()))[0]
[5, 6, 1, 2, 3, 4]

පැහැදිලි කිරීම:

default = (list(), set())
# user list to keep order
# use set to make lookup faster

def reducer(result, item):
    if item not in result[1]:
        result[0].append(item)
        result[1].add(item)
    return result

reduce(reducer, l, default)[0]

ලැයිස්තුවකින් අනුපිටපත් ඉවත් කිරීමේ හොඳම ප්‍රවේශය වන්නේ පයිතන් වලින් ලබා ගත හැකි කට්ටල () ශ්‍රිතය භාවිතා කර නැවත එම කට්ටලය ලැයිස්තුවට පරිවර්තනය කිරීමයි.

In [2]: some_list = ['a','a','v','v','v','c','c','d']
In [3]: list(set(some_list))
Out[3]: ['a', 'c', 'd', 'v']

ඔබට පහත ශ්‍රිතය භාවිතා කළ හැකිය:

def rem_dupes(dup_list): 
    yooneeks = [] 
    for elem in dup_list: 
        if elem not in yooneeks: 
            yooneeks.append(elem) 
    return yooneeks

උදාහරණය :

my_list = ['this','is','a','list','with','dupicates','in', 'the', 'list']

භාවිතය:

rem_dupes(my_list)

['මෙය', 'යනු', 'අ', 'ලැයිස්තුව', 'සමඟ', 'අනුපිටපත්', 'තුළ', 'ද']

ඉතා ප්‍රමාද පිළිතුර. ලැයිස්තු අනුපිළිවෙල ගැන ඔබ තැකීමක් නොකරන්නේ නම් *arg, අනුපිටපත් ඉවත් කිරීමට ඔබට පුළුල් කිරීම භාවිතා කළ හැකිය , එනම්:

l = [*{*l}]

නිරූපණය

මෙය කිරීමට විවිධ ක්‍රම යෝජනා කරන තවත් බොහෝ පිළිතුරු ඇත, නමුත් ඒවා සියල්ලම කණ්ඩායම් මෙහෙයුම් වන අතර සමහර ඒවා මුල් ඇණවුම ඉවත දමයි. ඔබට අවශ්‍ය දේ මත පදනම්ව එය හොඳ විය හැකි නමුත්, එක් එක් අගයේ පළමු අවස්ථාවෙහි අනුපිළිවෙලින් ඔබට අගයන් නැවත සැකසීමට අවශ්‍ය නම්, සහ පියාසර කරන විට එකවරම අනුපිටපත් ඉවත් කිරීමට ඔබට අවශ්‍ය නම්, ඔබට භාවිතා කළ හැකිය මෙම උත්පාදක යන්ත්රය:

def uniqify(iterable):
    seen = set()
    for item in iterable:
        if item not in seen:
            seen.add(item)
            yield item

මෙය උත්පාදක යන්ත්රයක් / අනුකාරකයක් ලබා දෙයි, එබැවින් ඔබට එය ඕනෑම තැනක භාවිතා කළ හැකිය.

for unique_item in uniqify([1, 2, 3, 4, 3, 2, 4, 5, 6, 7, 6, 8, 8]):
    print(unique_item, end=' ')

print()

ප්‍රතිදානය:

1 2 3 4 5 6 7 8

ඔබට එය අවශ්‍ය නම් list, ඔබට මෙය කළ හැකිය:

unique_list = list(uniqify([1, 2, 3, 4, 3, 2, 4, 5, 6, 7, 6, 8, 8]))

print(unique_list)

ප්‍රතිදානය:

[1, 2, 3, 4, 5, 6, 7, 8]

කට්ටලය භාවිතා නොකර

data=[1, 2, 3, 1, 2, 5, 6, 7, 8]
uni_data=[]
for dat in data:
    if dat not in uni_data:
        uni_data.append(dat)

print(uni_data) 

setඅනුපිටපත් ඉවත් කිරීමට ඔබට භාවිතා කළ හැකිය :

mylist = list(set(mylist))

නමුත් ප්‍රති results ල පිළිවෙලට නැති බව සලකන්න. එය ගැටලුවක් නම්:

mylist.sort()

තවත් හොඳ ප්‍රවේශයක් විය හැක්කේ,

import pandas as pd

myList = [1, 2, 3, 1, 2, 5, 6, 7, 8]
cleanList = pd.Series(myList).drop_duplicates().tolist()
print(cleanList)

#> [1, 2, 3, 5, 6, 7, 8]

ඇණවුම සංරක්ෂණය කර ඇත.

මෙය ඕනෑවට වඩා කරදරයකින් තොරව ඇණවුම ගැන සැලකිලිමත් වේ (OrderdDict & වෙනත්). බොහෝ විට වඩාත්ම පයිතොනික් ක්‍රමය හෝ කෙටිම ක්‍රමය නොව උපක්‍රමය කරයි:

def remove_duplicates(list):
    ''' Removes duplicate items from a list '''
    singles_list = []
    for element in list:
        if element not in singles_list:
            singles_list.append(element)
    return singles_list

ලැයිස්තුවේ අනුපිටපත් ඉවත් කිරීම සඳහා පහත කේතය සරල ය

def remove_duplicates(x):
    a = []
    for i in x:
        if i not in a:
            a.append(i)
    return a

print remove_duplicates([1,2,2,3,3,4])

එය ආපසු [1,2,3,4]

පිළිතුරු ලැයිස්තුගත කර ඇති අනෙක් අයට ලැබෙන වේගවත්ම පයිතොනික් විසඳුම මෙන්න.

කෙටි පරිපථ ඇගයීම ක්‍රියාත්මක කිරීමේ තොරතුරු භාවිතා කිරීම මඟින් ලැයිස්තු අවබෝධය භාවිතා කිරීමට ඉඩ ලබා දේ. visited.add(item)සෑම විටම ප්‍රති Noneresult ලයක් ලෙස නැවත පැමිණේ , එය ඇගයීමට ලක් කෙරේFalse ප්‍රති , එබැවින් දකුණු පසor සෑම විටම එවැනි ප්‍රකාශනයක ප්‍රති result ලය වනු ඇත.

ඔබම කාලය ගත කරන්න

def deduplicate(sequence):
    visited = set()
    adder = visited.add  # get rid of qualification overhead
    out = [adder(item) or item for item in sequence if item not in visited]
    return out

කට්ටලය භාවිතා කිරීම :

a = [0,1,2,3,4,3,3,4]
a = list(set(a))
print a

අද්විතීය භාවිතා කිරීම :

import numpy as np
a = [0,1,2,3,4,3,3,4]
a = np.unique(a).tolist()
print a

අවාසනාවට. මෙහි බොහෝ පිළිතුරු එක්කෝ ඇණවුම ආරක්ෂා නොකරයි හෝ දිගු වේ. මෙන්න සරල, ඇණවුම් සංරක්ෂණ පිළිතුරකි.

s = [1,2,3,4,5,2,5,6,7,1,3,9,3,5]
x=[]

[x.append(i) for i in s if i not in x]
print(x)

මෙමඟින් ඔබට x අනුපිටපත් ඉවත් කර ඇණවුම සුරැකෙනු ඇත.

මැජික් ඔෆ් පයිතන් බිල්ට්-ඉන් වර්ගය

පයිතන් වලදී, මෙවැනි සංකීර්ණ අවස්ථා සැකසීම ඉතා පහසු වන අතර පයිතන්ගේ බිල්ට් වර්ගය අනුව පමණි.

කරන්නේ කෙසේදැයි මම ඔබට පෙන්වන්නම්!

ක්රමය 1: සාමාන්ය නඩුව

ලැයිස්තුවේ අනුපිටපත් කළ මූලද්‍රව්‍යය ඉවත් කර පිළිවෙලට පිළිවෙලට තබා ගැනීමේ ක්‍රමය ( 1 පේළි කේතය )

line = [1, 2, 3, 1, 2, 5, 6, 7, 8]
new_line = sorted(set(line), key=line.index) # remove duplicated element
print(new_line)

ඔබට ප්‍රති .ලය ලැබෙනු ඇත

[1, 2, 3, 5, 6, 7, 8]

ක්රමය 2: විශේෂ අවස්ථාව

TypeError: unhashable type: 'list'

වෙනස් කළ නොහැකි ( පේළි කේත 3 ) සැකසීමේ විශේෂ අවස්ථාව

line=[['16.4966155686595', '-27.59776154691', '52.3786295521147']
,['16.4966155686595', '-27.59776154691', '52.3786295521147']
,['17.6508629295574', '-27.143305738671', '47.534955022564']
,['17.6508629295574', '-27.143305738671', '47.534955022564']
,['18.8051102904552', '-26.688849930432', '42.6912804930134']
,['18.8051102904552', '-26.688849930432', '42.6912804930134']
,['19.5504702331098', '-26.205884452727', '37.7709192714727']
,['19.5504702331098', '-26.205884452727', '37.7709192714727']
,['20.2929416861422', '-25.722717575124', '32.8500163147157']
,['20.2929416861422', '-25.722717575124', '32.8500163147157']]

tuple_line = [tuple(pt) for pt in line] # convert list of list into list of tuple
tuple_new_line = sorted(set(tuple_line),key=tuple_line.index) # remove duplicated element
new_line = [list(t) for t in tuple_new_line] # convert list of tuple into list of list

print (new_line)

ඔබට ප්‍රති result ලය ලැබෙනු ඇත:

[
  ['16.4966155686595', '-27.59776154691', '52.3786295521147'], 
  ['17.6508629295574', '-27.143305738671', '47.534955022564'], 
  ['18.8051102904552', '-26.688849930432', '42.6912804930134'], 
  ['19.5504702331098', '-26.205884452727', '37.7709192714727'], 
  ['20.2929416861422', '-25.722717575124', '32.8500163147157']
]

ටුපල් හැෂ් කළ හැකි නිසා ඔබට ලැයිස්තුව සහ ටුපල් අතර පහසුවෙන් දත්ත පරිවර්තනය කළ හැකිය