তালিকায় সদৃশ সরিয়ে ফেলা হচ্ছে


995

তালিকার কোনও নকল আছে কিনা তা যাচাই করার জন্য আমার খুব সুন্দর একটি প্রোগ্রাম লিখতে হবে এবং এটি যদি সেগুলি সরিয়ে দেয় এবং নকল / সরানো হয়নি এমন আইটেমগুলির সাথে একটি নতুন তালিকা ফিরিয়ে দেয়। আমার কাছে যা আছে তা কিন্তু সত্য বলতে আমি কী করব তা জানি না।

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

22
আপনার বিবরণে বলা হয়েছে যে সদৃশগুলির জন্য আপনি "একটি তালিকা" চেক করেন, তবে আপনার কোড দুটি তালিকা পরীক্ষা করে।
ব্রেন্ডন লং


* সেট ব্যবহার করে: তালিকা (সেট (ELEMENTS_LIST)) * অভিধান ব্যবহার করে: তালিকা (ডক্টর.ফ্রমকিস (এলইএমএনটিএস_লাইস্ট))
শায়ান

উত্তর:


1640

আইটেমগুলির একটি অনন্য সংগ্রহ পাওয়ার জন্য সাধারণ পদ্ধতিটি হ'ল একটি set। সেটগুলি পৃথক পৃথক অবজেক্টের আনর্ডারড সংগ্রহ । যেকোন পুনরাবৃত্তযোগ্য থেকে একটি সেট তৈরি করতে, আপনি কেবল এটি বিল্ট-ইন ফাংশনে পাস করতে পারেন । আপনার যদি পরে আবার সত্যিকারের তালিকার প্রয়োজন হয় তবে আপনি একইভাবে ফাংশনে সেটটি পাস করতে পারেন ।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]

উদাহরণস্বরূপ ফলাফল থেকে আপনি দেখতে পাচ্ছেন, মূল ক্রমটি বজায় থাকে না । উপরে উল্লিখিত হিসাবে, সেটগুলি নিজেরাই নিরক্ষিত সংগ্রহ, সুতরাং অর্ডারটি হারিয়ে গেছে is কোনও সেটকে তালিকায় ফিরে রূপান্তর করার সময় একটি স্বেচ্ছাসেবী অর্ডার তৈরি হয়।

অর্ডার বজায় রাখা

যদি আদেশটি আপনার কাছে গুরুত্বপূর্ণ, তবে আপনাকে আলাদা পদ্ধতি ব্যবহার করতে হবে। এটির জন্য একটি সাধারণ সমাধান হ'ল OrderedDictসন্নিবেশের সময় কীগুলির ক্রম বজায় রাখার উপর নির্ভর করা :

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

পাইথন ৩.7 দিয়ে শুরু করে , অন্তর্নির্মিত অভিধানটি সন্নিবেশের ক্রমটিও বজায় রাখার গ্যারান্টিযুক্ত, সুতরাং আপনি পাইথন ৩.7 বা তার পরে (অথবা সিপিথন ৩.6) এ থাকলে সরাসরি এটি ব্যবহার করতে পারেন:

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

মনে রাখবেন যে এটিতে প্রথমে অভিধান তৈরি করার ওপরে একটি তালিকা তৈরি করার কিছুটা ওভারহেড থাকতে পারে। যদি আপনার অর্ডারটি সংরক্ষণের প্রয়োজন না হয় তবে আপনি একটি সেট ব্যবহার করে প্রায়শই ভাল হন, বিশেষত কারণ এটি আপনাকে আরও অনেক বেশি ক্রিয়াকলাপ দিয়ে কাজ করে। পরীক্ষা করে দেখুন এই প্রশ্নের আরো বিস্তারিত জানার এবং বিকল্প উপায়ে যখন সদৃশ অপসারণ অর্ডার সংরক্ষণ করার জন্য।


অবশেষে নোট করুন যে setপাশাপাশি OrderedDict/ dictসমাধানগুলি উভয়ই আপনার আইটেমগুলিকে হ্যাশযোগ্য হতে পারে । এর অর্থ সাধারণত যে তারা স্থাবর হতে হবে। যদি আপনাকে হ্যাশযোগ্য নয় এমন আইটেমগুলি নিয়ে কাজ করতে হয় (যেমন তালিকার অবজেক্টগুলি), তবে আপনাকে ধীর পন্থা ব্যবহার করতে হবে যেখানে আপনাকে মূলত প্রতিটি আইটেমকে নেস্টেড লুপে প্রতিটি আইটেমের সাথে তুলনা করতে হবে।


4
এটি অপসারণযোগ্য তালিকার উপাদানগুলির জন্য কাজ করে না (যেমন তালিকার একটি তালিকা)
নেজাদ

3
@ কেনেজাদ এটি শেষ অনুচ্ছেদে বলেছে।
অকর্মা

উফফফফফফফফফফফফফফফঃ পুরো জিনিসটি পড়া উচিত ছিল। আমি যা করতে পেরেছি তা তালিকার পরিবর্তে টিপলগুলি ব্যবহার করা ছিল যাতে এই পদ্ধতিটি এখনও কাজ করতে পারে।
কেজেদ

এটি উদাহরণ হিসাবে যুক্ত করুন, টি = [3, 2, 1, 1, 2, 5, 6, 7, 8], পার্থক্যটি পরিষ্কারভাবে দেখায়!
sailfish009

"... প্রথমে অভিধান তৈরি করার ওভারহেড ... আপনার যদি ক্রমটি অর্ডার সংরক্ষণের প্রয়োজন না হয়, আপনি একটি সেট ব্যবহার করা ভাল।" - আমি এটি প্রোফাইল করেছি কারণ এটি সত্য যদি সত্য হয় তবে আমি কৌতূহলী ছিলাম। আমার সময়গুলি দেখায় যে প্রকৃতপক্ষে সেটটি সামান্য দ্রুত: 1 এম পুনরাবৃত্তির উপর প্রায় 4s এর নিখুঁত সময়ের পার্থক্য সহ 1 এম লুপের প্রতি লুপ (ডিক) প্রতি 1.53 vs এস প্রতি লুপের (সেট) প্রতি 1.12 µs সুতরাং যদি আপনি এটি একটি কঠোর অভ্যন্তরীণ লুপে করছেন তবে আপনি যত্ন নিতে পারেন, অন্যথায় সম্ভবত না।
মিলারদেব

414

পাইথন ২.7-তে , মূল ক্রমে রাখার সময় পুনরাবৃত্তিযোগ্য থেকে সদৃশগুলি সরিয়ে ফেলার নতুন উপায়টি হ'ল:

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

পাইথন 3.5 তে , অর্ডারডিক্টের একটি সি বাস্তবায়ন রয়েছে। আমার সময়গুলি দেখায় যে এটি এখন পাইথন 3.5 এর বিভিন্ন পদ্ধতির মধ্যে দ্রুত এবং সংক্ষিপ্ত উভয়ই।

পাইথন ৩.6-এ , নিয়মিত ডিক দুটি অর্ডারযুক্ত এবং কমপ্যাক্ট হয়ে ওঠে। (এই বৈশিষ্ট্যটি সিপিথন এবং পাইপাইয়ের জন্য রয়েছে তবে অন্যান্য বাস্তবায়নে এটি উপস্থিত নাও হতে পারে)। এটি আমাদের অর্ডার বজায় রাখার সময় ছাড়ের নতুন দ্রুততম উপায় দেয়:

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

পাইথন ৩.7-এ , সমস্ত বাস্তবায়ন জুড়ে নিয়মিত আদেশ উভয়েরই গ্যারান্টিযুক্ত। সুতরাং, সবচেয়ে সংক্ষিপ্ত এবং দ্রুত সমাধানটি হ'ল:

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

10
আমি মনে করি এটি আইটেমগুলিকে ঠিক রাখার একমাত্র উপায়।
হারবার্থ অমরাল


5
@ মার্তিজজনপিটারস সংশোধন: আমি মনে করি আইটেমগুলিকে শৃঙ্খলাবদ্ধ রাখার একমাত্র সহজ উপায়।
হারবার্থ অমরাল

11
এর জন্যও, মূল তালিকার বিষয়বস্তুটি অবশ্যই হাঁশতে হবে
ডেভিড

@ ডেভিড যেমন উল্লেখ করেছেন, মূল তালিকাটি অবশ্যই হাশেবল। এর অর্থ, এটি অভিধানের তালিকার জন্য কাজ করে না। TypeError: unhashable type: 'dictlist'
ক্রেজেড

186

এটি একটি ওয়ানলাইনার: list(set(source_list))কৌশলটি করবে।

setএমন একটি জিনিস যা সম্ভবত নকল থাকতে পারে না।

আপডেট: একটি অর্ডার-সংরক্ষণের পদ্ধতির দুটি লাইন:

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

এখানে আমরা এই তথ্যটি ব্যবহার করি যা OrderedDictকীগুলির সন্নিবেশ ক্রমের কথা মনে পড়ে এবং কোনও নির্দিষ্ট কীতে কোনও মান আপডেট হওয়ার পরে এটি পরিবর্তন হয় না। আমরা Trueমান হিসাবে সন্নিবেশ করি, তবে আমরা কিছু সন্নিবেশ করতে পারি, মানগুলি কেবল ব্যবহৃত হয় না। ( উপেক্ষিত মানগুলির সাথে setঅনেকটা কাজ করে dict))


4
এটি কেবলমাত্র source_listহাস্যযোগ্য হলে কাজ করে ।
অ্যাড্রিয়ান কেইস্টার

@ অ্যাড্রিয়ানকিস্টার: এটি সত্য। এখানে এমন অবজেক্ট রয়েছে যা যুক্তিসঙ্গত সমতা শব্দার্থক রয়েছে তবে ধাবনযোগ্য নয়, উদাহরণস্বরূপ। OTOH যদি আমাদের তাড়াহুড়ির মতো শর্টকাট না পাওয়া যায় তবে আমরা বর্তমানে সমস্ত অজানা উপাদানগুলির সাথে প্রতিটি উপাদানকে তুলনা করার একটি চতুর্ভুজ অ্যালগরিদম দিয়ে শেষ করি। সংক্ষিপ্ত ইনপুটগুলির জন্য এটি পুরোপুরি ঠিক আছে, বিশেষত প্রচুর নকলের সাথে।
9000

ঠিক, ঠিক। আমি মনে করি আপনি যদি খুব সাধারণ ব্যবহারের বিষয়টি আমলে নেন তবে আপনার উত্তরটি উচ্চমানের হবে।
অ্যাড্রিয়ান কিস্টার

94
>>> 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]

32
নোট করুন যে এই পদ্ধতিটি ও (n ^ 2) সময়ে কাজ করে এবং বৃহত তালিকাগুলিতে খুব ধীর হয়।
dotancohen

@ ক্রিস_আর্যান্ডস: নিশ্চিত নয় যে frozensetঅ-হাস্যযোগ্য সামগ্রী নিয়ে কাজ করে। আমি এখনও ব্যবহারের সময় নন-হ্যাশযোগ্য ত্রুটি পাচ্ছি frozenset
অ্যাড্রিয়ান কিস্টার

85

আপনি যদি অর্ডারটির বিষয়ে চিন্তা না করেন তবে কেবল এটি করুন:

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

ক এর setনকল না থাকার গ্যারান্টি রয়েছে।


3
lহ্যাশযোগ্য না হলে কাজ করে না ।
অ্যাড্রিয়ান কিস্টার

41

অনুলিপিগুলির প্রথম উপাদানের ক্রম ধরে নতুন তালিকা তৈরি করতে To 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]

প্রতিটি নতুন উপাদান এটি যুক্ত করার আগে তালিকায় আগে উপস্থিত হয় নি এটি পরীক্ষা করে। এছাড়াও এটি আমদানির প্রয়োজন হয় না।


3
এটিতে ও (এন ^ 2) এর একটি সময়ের জটিলতা রয়েছে । উত্তরগুলির সাথে setএবং OrderedDictকম রীতিযুক্ত জটিলতা থাকতে পারে।
blubberdiblub

আমি আমার
কোডটিতে

@ ব্লুবার্ডিব্লাব আপনি কী ব্যাখ্যা করতে পারেন সেট এবং অর্ডারডিক্টে আরও কী কোড দক্ষ ব্যবস্থা রয়েছে যা তাদের কম সময় ব্যয় করতে পারে? (এগুলি লোড করার ওভারহেড বাদে)
ইলিয়াস ইলিয়াডিস

@ এলিয়াসিলিয়াডিস সেট এবং ডিক ব্যবহারের হ্যাশ বা (কিছুটা ভারসাম্যযুক্ত) গাছের সাধারণ প্রয়োগসমূহ । আপনাকে সেট বা ডিক তৈরি এবং এটির (একাধিকবার) অনুসন্ধান করার কথা বিবেচনা করতে হবে, তবে তাদের মোড়কযুক্ত জটিলতা সাধারণত এখনও ও (এন ^ 2) এর চেয়ে কম থাকে । সরল পরিভাষায় "এমরোটাইজড" এর অর্থ গড় গড় (তাদের গড়ের তুলনায় আরও জটিলতার সাথে খারাপ পরিস্থিতি থাকতে পারে)। এটি কেবল তখনই প্রাসঙ্গিক যখন আপনার প্রচুর আইটেম থাকে।
blubberdiblub

25

একজন সহকর্মী আজ কোডরেভিউয়ের জন্য তার কোডের অংশ হিসাবে গ্রহণযোগ্য উত্তর আমার কাছে প্রেরণ করেছেন। যদিও আমি অবশ্যই প্রশ্নের উত্তরে কমনীয়তার প্রশংসা করছি, তবে আমি অভিনয়টি নিয়ে সন্তুষ্ট নই। আমি এই সমাধানটি চেষ্টা করেছি (আমি দেখার সময় কমাতে সেট ব্যবহার করি )

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

এখানে পরিমাপের ফলাফল রয়েছে

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

ফলাফল অর্ডারডিক্টের মতো খারাপ নয় , তবে মূল সমাধানের চেয়ে 3 বারেরও বেশি

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

লুপযুক্ত তুলনাটি দ্রুত করতে সেট কুইক লুকআপ ব্যবহার করে দুর্দান্ত। অর্ডার তালিকায় গুরুত্বপূর্ণ না হলে (সেট (এক্স)) এর চেয়ে 6x দ্রুত
জোপ

@ জুপ, এটি আমার সহকর্মীর জন্য আমার প্রথম প্রশ্ন - আদেশটি গুরুত্ব দেয়; অন্যথায়, এটি তুচ্ছ সমস্যা হত
আগ্নেয়গিরি

আদেশ সেটের অপ্টিমাইজ সংস্করণ, কেউ জন্য যারা আগ্রহী হয়: def unique(iterable):; seen = set(); seen_add = seen.add; return [item for item in iterable if not item in seen and not seen_add(item)]
ডাঃডিডি

25

পান্ডা এবং নম্পি ব্যবহার করেও সমাধান রয়েছে। তারা ফাংশনটি ব্যবহার করতে হবে তাই তারা উভয়ই অলস অ্যারে ফিরিয়ে দেয়.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সাজানো ফিরে আসে is আপনি যদি এই উত্তর হিসাবে আদেশটি সংরক্ষণে রাখতে চান তবে :

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

অন্যের তুলনায় সমাধানটি এত মার্জিত নয়, তবে, পান্ডাস.উনিক () এর সাথে তুলনা করে, numpy.unique () আপনাকে যাচাই করা অক্ষের পাশাপাশি নেস্টেড অ্যারেগুলি অনন্য কিনা তাও পরীক্ষা করতে দেয়।


এটি তালিকাটিকে নম্পি অ্যারে রূপান্তরিত করবে যা একটি জগাখিচুড়ি এবং স্ট্রিংয়ের জন্য কাজ করবে না।
ব্যবহারকারী 227666

1
@ ব্যবহারকারী 227666 আপনার পর্যালোচনার জন্য ধন্যবাদ তবে এটি সত্য নয় এটি স্ট্রিংয়ের সাথেও কাজ করে এবং আপনি তালিকা পেতে চাইলে টোলিস্ট যুক্ত করতে পারেন ...
জিএম

1
আমি মনে করি এটি একটি স্লেজহ্যামার দিয়ে মৌমাছি মারার চেষ্টা করার মতো দয়ালু। কাজ, নিশ্চিত! তবে, কেবল এই উদ্দেশ্যে একটি লাইব্রেরি আমদানি করা একটু ওভারকিল হতে পারে, না?
ডিবোস্মিত রায়

@ ডেবোস্মিতরে আপনি ডেটা সায়েন্সে কাজ করলে এটি কার্যকর হতে পারে যেখানে সাধারণত আপনি নিম্পি নিয়ে কাজ করেন এবং আপনাকে বারবার ন্যাপির অ্যারে দিয়ে কাজ করতে হবে।
জিএম

2020 @DebosmitRay আমি আশা করি তুমি আপনার মন এবং ব্যবহার numpy পরিবর্তন সেরা উত্তর / প্রত্যেক সময় আপনি যা করতে পারেন পান্ডাস
অহংবোধের

21

করার আরেকটি উপায়:

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

1
নোট করুন যে আধুনিক পাইথন সংস্করণগুলিতে (২.7+ আমি মনে করি, তবে আমি নিশ্চিত মনে করতে পারি না), keys()একটি অভিধান দেখায় অবজেক্টটি ফিরিয়ে দেয়, তালিকা নয়।
ডাস্টিন ওয়াইট

16

সহজ এবং সহজ:

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]

5
তবুও চতুর্ভুজ জটিলতা - inও (এন) অপারেশন এবং আপনার cleanlistসর্বাধিক nসংখ্যার => সবচেয়ে খারাপ-কেস ~ হে (এন ^ 2)
জের্মেনকু

6
পার্শ্ব প্রতিক্রিয়া জন্য তালিকা বোধগম্য ব্যবহার করা উচিত নয়।
জিন-ফ্রান্সোইস ফ্যাব্রে

13

এই উত্তরে, দুটি বিভাগ হবে: দুটি অনন্য সমাধান এবং নির্দিষ্ট সমাধানের জন্য গতির একটি গ্রাফ।

সদৃশ আইটেমগুলি সরানো হচ্ছে

এই উত্তরগুলির বেশিরভাগটি কেবলমাত্র নকল আইটেমগুলি মুছতে পারে যেগুলি হ্যাশযোগ্য , তবে এই প্রশ্নটি বোঝায় না যে এটির জন্য কেবল ধাবনযোগ্য আইটেমের প্রয়োজন নেই , অর্থাত্ আমি এমন কিছু সমাধান সরবরাহ করব যা হ্যাশেবলের প্রয়োজন হয় না offer আইটেমগুলির ।

সংগ্রহসমূহ.কাউন্টার স্ট্যান্ডার্ড লাইব্রেরির একটি শক্তিশালী সরঞ্জাম যা এটির জন্য নিখুঁত হতে পারে। এর মধ্যে একটি মাত্র অন্য সমাধান রয়েছে যা এর মধ্যে কাউন্টারও রয়েছে। যাইহোক, এই সমাধানটি হ্যাশ করার ক্ষেত্রেও সীমাবদ্ধ কীগুলির মধ্যে ।

কাউন্টারে অনির্ভরযোগ্য কীগুলি মঞ্জুরি দেওয়ার জন্য, আমি একটি ধারক শ্রেণী তৈরি করেছি, যা অবজেক্টের ডিফল্ট হ্যাশ ফাংশনটি পাওয়ার চেষ্টা করবে, কিন্তু যদি এটি ব্যর্থ হয় তবে এটি তার পরিচয় ফাংশনটি চেষ্টা করবে। এটি একটি সংজ্ঞায়িত EQ এবং একটি হ্যাশ পদ্ধতি। আমাদের দ্রবণে অলাভযোগ্য আইটেমগুলিকে অনুমতি দেওয়ার জন্য এটি যথেষ্ট হওয়া উচিত । অদৃশ্যযোগ্য বস্তুগুলি হ্যাশযোগ্য বলে মনে করা হবে। যাইহোক, এই হ্যাশ ফাংশনটি অবিশ্বাস্য জিনিসগুলির জন্য পরিচয় ব্যবহার করে, যার অর্থ দুটি সমান বস্তু যা উভয়ই অবিশ্বাস্যরূপে কাজ করবে না। আমি আপনাকে এটিকে ওভাররাইড করার পরামর্শ দিচ্ছি এবং সমতুল্য মিউটটেবল টাইপের হ্যাশ ব্যবহার করতে এটি পরিবর্তন করার পরামর্শ দিচ্ছি (যেমন 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]

রিমড হ'ল নন-অর্ডার করা বাছাই, oremd বাছাইয়ের আদেশ দেওয়া হয়। কোনটি দ্রুত তা আপনি পরিষ্কারভাবে বলতে পারবেন, তবে আমি যেভাবেই হোক তা ব্যাখ্যা করব। অ-অর্ডারযুক্ত বাছাই করা কিছুটা দ্রুত। এটি কম ডেটা রাখে, যেহেতু এটির অর্ডার প্রয়োজন হয় না।

এখন, আমি প্রতিটি উত্তরের গতির তুলনাও দেখাতে চেয়েছিলাম। সুতরাং, আমি এখন এটি করব।

সবচেয়ে দ্রুততম কোন কাজটি?

সদৃশ অপসারণের জন্য, আমি কয়েকটি উত্তর থেকে 10 টি ফাংশন সংগ্রহ করেছি। আমি প্রতিটি ফাংশনের গতি গণনা করেছি এবং matplotlib.pyplot ব্যবহার করে একটি গ্রাফে রেখেছি

আমি এটিকে গ্রাফিংয়ের তিন রাউন্ডে বিভক্ত করেছি। একটি হ্যাশযোগ্য এমন কোনও বস্তু যা হ্যাশ করা যায়, হ্যাশ করা যায় না এমন কোনও বস্তু যা হ্যাশ করা যায় না। অর্ডার করা সিকোয়েন্স হ'ল একটি ক্রম যা আদেশ সংরক্ষণ করে, একটি আনর্ডারড সিকোয়েন্সটি অর্ডার সংরক্ষণ করে না। এখন, এখানে আরও কয়েকটি পদ রয়েছে:

আনর্ডার্ড হ্যাশেবল এমন কোনও পদ্ধতির জন্য ছিল যা ডুপ্লিকেটগুলি সরিয়ে , যাতে অ আদেশটি রাখার প্রয়োজন ছিল না। এটি অবিশ্বাস্যদের জন্য কাজ করতে হয়নি, তবে এটি পারে।

অর্ডার দিয়েছি হাসাবলিকে এমন কোনও পদ্ধতির জন্য হয়েছিল যা তালিকায় থাকা আইটেমগুলির ক্রম রেখেছিল, তবে এটি অবিশ্বাস্যদের জন্য কাজ করতে হয়নি, তবে এটি পারে।

অদৃশ্যযোগ্য আদেশ এমন কোনও পদ্ধতি যা তালিকার আইটেমগুলির বজায় রাখে এবং অবিশ্বাস্যদের জন্য কাজ করে।

Y- অক্ষের উপর এটি যে পরিমাণ সেকেন্ড নিয়েছিল তা হল।

এক্স-অক্ষে ফাংশনটি প্রয়োগ করা হয়েছিল সেই সংখ্যাটি।

আমরা অর্ডারার্ড হ্যাশাবলগুলির জন্য সিকোয়েন্স তৈরি করেছি এবং নিম্নলিখিত বোধগম্যতার সাথে হ্যাশাবলদের অর্ডার করেছি: [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 বেশি সময় নিয়েছে। এছাড়াও আমার ব্যক্তিগত মতামত হিসাবে, আমি ভেবেছিলাম এটি পড়ার জন্য সম্ভবত কিছুটা সহজ দেখায়।

কিংবদন্তির কীগুলি হ'ল আমি ফাংশনের সবচেয়ে গুরুত্বপূর্ণ অংশ হিসাবে অনুমান করার চেষ্টা করেছি note কোন ফাংশনটি সবচেয়ে খারাপ বা সেরা করে? গ্রাফ নিজেই কথা বলে।

যে স্থির সঙ্গে, এখানে গ্রাফ আছে।

আনর্ডার্ড হ্যাশাবল

এখানে চিত্র বর্ণনা লিখুন (জুম ইন) এখানে চিত্র বর্ণনা লিখুন

অর্ডার করা হ্যাশাবলসকে

এখানে চিত্র বর্ণনা লিখুন (জুম ইন) এখানে চিত্র বর্ণনা লিখুন

অনাহাশাবলকে অর্ডার দিয়েছি

এখানে চিত্র বর্ণনা লিখুন (জুম ইন) এখানে চিত্র বর্ণনা লিখুন


11

আমার তালিকায় আমার একটি ডিক ছিল তাই আমি উপরোক্ত পদ্ধতির ব্যবহার করতে পারিনি। আমি ত্রুটি পেয়েছি:

TypeError: unhashable type:

তাই আপনি যদি আপনার পছন্দের অর্ডার এবং / অথবা কিছু কিছু আইটেম unhashable । তাহলে আপনি এটি দরকারী খুঁজে পেতে পারেন:

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

6
mapপার্শ্ব প্রতিক্রিয়া সহ লিস্টকম্পের চেয়ে পার্শ্ব প্রতিক্রিয়া সহ আরও বিভ্রান্তিকর। এছাড়াও, lambda x: unique_list.append(x)পাস করার জন্য কেবল একটি ক্লানকিয়ার এবং ধীর পথ unique_list.append
অবতারিত

মাত্র এক লাইনে উপাদান যুক্ত করার জন্য খুব দরকারী উপায়, ধন্যবাদ!
ZLNK

2
@ জেডএলএনকে দয়া করে এটি কখনও ব্যবহার করবেন না। ধারণাগতভাবে কুৎসিত হওয়া ছাড়াও এটি অত্যন্ত অদক্ষ, কারণ আপনি প্রকৃতপক্ষে একটি সম্ভাব্য বৃহত তালিকা তৈরি করেন এবং কেবল প্রাথমিক পুনরাবৃত্তি সম্পাদন করার জন্য এটিকে ফেলে দেন।
এলি করভিগো

10

আমি এখন পর্যন্ত এখানে দেখেছি সমস্ত ক্রম-সংরক্ষণের পন্থাগুলি হয় নিষ্পাপ তুলনা (O (n ^ 2) সেরা সময়-জটিলতা সহ) বা ভারী ওজন OrderedDicts/ set+ listসংমিশ্রণগুলি যা হ্যাশযোগ্য ইনপুটগুলিতে সীমাবদ্ধ use এখানে একটি হ্যাশ-স্বতন্ত্র ও (নলন) সমাধান রয়েছে:

আপডেট যোগ 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]]))] 

তবুও, এই সমাধানের জন্য পরীক্ষামূলক উপাদান প্রয়োজন। আমি এটিকে আমার তালিকাগুলির তালিকার স্বতন্ত্র ব্যবহার করব: এটি tuple()তালিকাগুলি এবং হ্যাশ করার ব্যথা । | | | | - সাধারণভাবে বলতে গেলে, হ্যাশ প্রক্রিয়াটি পুরো ডেটার আকারের সমানুপাতিক সময় নেয়, যখন এই সমাধানটি কেবলমাত্র তালিকার দৈর্ঘ্যের উপর নির্ভর করে ও (nlog (n)) সময় নেয় takes
loxaxs

আমি মনে করি যে সেট-ভিত্তিক পদ্ধতিটি বাছাই + অজানা সনাক্তকরণের চেয়ে সমান সস্তা (O (n লগ এন)) বা সস্তা aper (যদিও এই পদ্ধতিটি আরও ভালভাবে সমান্তরাল হবে)) এটি প্রাথমিক ক্রমটি ঠিক সংরক্ষণ করে না, তবে এটি অনুমানযোগ্য আদেশ দেয়।
9000

@ 9000 এটি সত্য আমি কখনও হ্যাশ-টেবিল-ভিত্তিক পদ্ধতির সময়-জটিলতার কথা উল্লেখ করি নি, যা স্পষ্টতই ও (এন)। এখানে আপনি হ্যাশ-টেবিলগুলি সংযুক্ত করে অনেক উত্তর খুঁজে পেতে পারেন। এগুলি সর্বজনীন নয়, কারণ তাদের জন্য হ্যাশযোগ্য বস্তুগুলির প্রয়োজন। তাছাড়া এগুলি অনেক বেশি স্মৃতি-নিবিড়।
এলি করভিগো

এই উত্তরটি পড়তে এবং বুঝতে সময় নেয়। যখন আপনি সূচকগুলি ব্যবহার করছেন না তখন কি গণনা করার কোনও বিন্দু আছে? reduce() ইতিমধ্যে একটি সাজানো সংগ্রহে কাজ করছে srt_enum, কেন তুমি প্রয়োগ করেছেন sortedআবার?
ব্রায়োনি

@ ব্রায়োনি প্রথম ধরণের সমান মানগুলি গোছানোর জন্য রয়েছে, দ্বিতীয় ক্রমটি প্রাথমিক ক্রম পুনরুদ্ধার করার জন্য রয়েছে। মূল আপেক্ষিক ক্রম ট্র্যাক রাখতে গণনা প্রয়োজন।
এলি করভিগো

9

আপনি যদি অর্ডার সংরক্ষণ করতে চান এবং এখানে কোনও বাহ্যিক মডিউল ব্যবহার না করা এটি করার একটি সহজ উপায়:

>>> 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]

দ্রষ্টব্য: এই পদ্ধতিটি উপস্থিতির ক্রম সংরক্ষণ করে, সুতরাং উপরে যেমন দেখা গেছে, একজনের পরে নয়জন আসবে কারণ এটি প্রথমবার উপস্থিত হয়েছিল। এটি যাইহোক, আপনি একইভাবে ফল পাবেন

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

তবে এটি অনেক খাটো এবং দ্রুত চলে।

এটি কাজ করে কারণ প্রতিটি সময় fromkeysফাংশন একটি নতুন কী তৈরি করার চেষ্টা করে, যদি মানটি ইতিমধ্যে বিদ্যমান থাকে তবে এটি এটিকে ওভাররাইট করে দেবে। যদিও এটি অভিধানে কোনওভাবেই প্রভাব ফেলবে না, fromkeysএমন একটি অভিধান তৈরি করে যেখানে সমস্ত কীগুলির মান রয়েছে None, তাই কার্যকরভাবে এটি সমস্ত নকলকে এইভাবে মুছে ফেলে।



8

আপনি এটি করতে পারেন:

>>> 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 [, start [, end]])
প্রথম আইটেমের তালিকায় শূন্য-ভিত্তিক সূচকটি প্রদান করুন যার মান x। যদি এরকম কোনও আইটেম না থাকে তবে একটি ভ্যালু এরির উত্থাপন করে।


এটি মারাত্মকভাবে অদক্ষ। list.indexএকটি লিনিয়ার-টাইম অপারেশন, আপনার সমাধানটিকে চতুর্ভুজ তৈরি করে making
এলি করভিগো

তুমি ঠিক বলছো. তবে আমি এটিও বিশ্বাস করি যে এটি সমাধানটি মোটামুটি সুস্পষ্ট a এখানে সমস্ত কিছু ইতিমধ্যে রয়েছে।
অটোনাল


7

অর্ডার সংরক্ষণের সাথে বৈকল্পিক হ্রাস করুন:

ধরুন আমাদের তালিকা রয়েছে:

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 এক্স দ্রুত তবে আরও পরিশীলিত

>>> 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]

7

ব্যবহার করছে একটি তালিকা থেকে সদৃশ অপসারণ করার শ্রেষ্ঠ পদ্ধতির সেট () ফাংশন, পাইথন পাওয়া যায়, আবার যে রূপান্তর তালিকায় সেট

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

@ মিটজাভারী খুশি!
অনুরাগ মিশরা

নতুন তালিকা এবং সেট ইনস্ট্যান্ট করা বিনামূল্যে নয়। যদি আমরা তাড়াতাড়ি পরপর (যেমন খুব শক্ত লুপে) বহুবার এটি করি এবং তালিকাগুলি খুব ছোট হয় তবে কী ঘটবে?
জেড 4-স্তর

6

আপনি নিম্নলিখিত ফাংশন ব্যবহার করতে পারেন:

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)

['এটি', 'হ'ল', 'এ', 'তালিকা', 'সহ', 'দ্বিপক্ত', 'ইন', 'দ্য']


5

এটি করার বিভিন্ন উপায়ের জন্য আরও অনেক উত্তর রয়েছে তবে তারা সমস্ত ব্যাচের ক্রিয়াকলাপ, এবং তাদের মধ্যে কিছু আসল ক্রমকে ফেলে দেয়। এটি আপনার প্রয়োজনের উপর নির্ভর করে ঠিক আছে তবে আপনি যদি প্রতিটি মানের প্রথম উদাহরণ অনুসারে মানগুলি নিয়ে পুনরাবৃত্তি করতে চান এবং অনুলিপিগুলি অন-দ্য ফ্লাইয়ে বনাম সমস্ত একবারে সরাতে চান তবে আপনি ব্যবহার করতে পারেন এই জেনারেটর:

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]

seen = set(iterable); for item in seen: yield itemপ্রায় অবশ্যই দ্রুত। (আমি এই নির্দিষ্ট ক্ষেত্রে চেষ্টা করি নি, তবে এটি আমার অনুমান হবে))
dylnmc

2
@ অডিএনএমসি, এটি একটি ব্যাচ অপারেশন এবং এটি অর্ডারও হারায়। আমার উত্তরটি বিশেষভাবে ফ্লাইটে ও প্রথম সংক্রমণের উদ্দেশ্যে করা হয়েছিল। :)
সাইফেজ


5

আরও একটি ভাল পদ্ধতির হতে পারে,

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]

এবং অর্ডার সংরক্ষণ করা হয়।


যদিও এটি ভারী লাইব্রেরি ব্যবহার করে ভাল কাজ করতে পারে উদ্দেশ্যে পাণ্ডার ওভারকিলের মতো বলে মনে হয়।
গ্লুটেক্সো

4

এটির খুব বেশি ঝামেলা ছাড়াই অর্ডারটির বিষয়ে যত্নশীল (অর্ডারডটিক্ট এবং অন্যান্য)। সম্ভবত সর্বাধিক পাইথোনিক উপায় বা সংক্ষিপ্ততম উপায় নয়, তবে কৌশলটি করেছেন:

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

1. আপনার কখনও অন্তর্নির্মিত নামগুলি ছায়া করা উচিত নয় (কমপক্ষে, যতটা গুরুত্বপূর্ণ list); ২. আপনার পদ্ধতিটি অত্যন্ত খারাপ স্কেল করে: এটি উপাদানগুলির সংখ্যায় চতুর্ভুজ list
এলি করভিগো

1. সঠিক, কিন্তু এটি একটি উদাহরণ ছিল; 2. সঠিক, এবং ঠিক কারণেই আমি এটি অফার করেছি। এখানে পোস্ট করা সমস্ত সমাধানের পক্ষে ভাল এবং কনস রয়েছে। কিছু ত্যাগ সরলতা বা শৃঙ্খলা, আমার ত্যাগ তাত্পর্যযোগ্যতা।
সিজিএফ

এটি একটি "শ্লেমিল চিত্রশিল্পী" অ্যালগরিদম ...
জেড 4-স্তর

4

তালিকার সদৃশ অপসারণের জন্য নীচের কোডটি সহজ

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]


2
যদি আপনি অর্ডার সম্পর্কে চিন্তা করেন না, তবে এটি উল্লেখযোগ্যভাবে বেশি সময় নেয়। list(set(..))(1 মিলিয়নেরও বেশি পাস) এই সমাধানটি প্রায় 10 সেকেন্ডে পরাজিত করবে - যদিও এই পদ্ধতির প্রায় 12 সেকেন্ড list(set(..))সময় লাগে , কেবল প্রায় 2 সেকেন্ড সময় লাগে!
dylnmc

@dylnmc এটিও একটি উল্লেখযোগ্যভাবে পুরানো উত্তরের
এলি করভিগো

4

প্রত্যুত্তর তালিকাভুক্ত অন্যদের কাছে দ্রুততম পাইথোনিক সমাধানটি এখানে রয়েছে।

সংক্ষিপ্ত-সার্কিট মূল্যায়নের বাস্তবায়ন বিশদ ব্যবহার করে তালিকার বোঝাপড়া ব্যবহার করতে দেয় যা যথেষ্ট দ্রুত is visited.add(item)সর্বদা Noneফলাফল হিসাবে ফিরে আসে , যা হিসাবে মূল্যায়ন করা হয় False, তাই ডান দিকেor সর্বদা এই জাতীয় অভিব্যক্তির ফলাফল হবে।

সময় আপনি নিজেই

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


4

দুর্ভাগ্যবশত। এখানে বেশিরভাগ উত্তর হয় হয় অর্ডার সংরক্ষণ করে না বা খুব দীর্ঘ। এখানে একটি সহজ, সংরক্ষণের উত্তর সংরক্ষণ করুন is

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)

এটি আপনাকে সদৃশ মুছে ফেলা হলেও অর্ডার সংরক্ষণ করে এক্স দেবে।


4

আপনি setসদৃশগুলি অপসারণ করতে ব্যবহার করতে পারেন:

mylist = list(set(mylist))

তবে নোট করুন ফলাফল আনর্ডার্ড করা হবে। যদি এটি একটি সমস্যা হয়:

mylist.sort()

আপনি কেবল এটি করতে পারেন: মাইলিস্ট = সাজানো (তালিকা (সেট (মাইলিস্ট)))
এরিক ক্যাম্পোপডাল

3

পাইথন 3 এ খুব সহজ উপায়:

>>> n = [1, 2, 3, 4, 1, 1]
>>> n
[1, 2, 3, 4, 1, 1]
>>> m = sorted(list(set(n)))
>>> m
[1, 2, 3, 4]

2
sorted(list(...))অপ্রয়োজনীয় ( sortedইতিমধ্যে স্পষ্টতই তার যুক্তিটিকে একটি নতুনতে রূপান্তরিত করে, এটি সাজিয়ে তোলে list, তারপরে নতুনটি ফেরত দেয় list, সুতরাং উভয়টি ব্যবহার করে অপ্রয়োজনীয় অস্থায়ী করা হয় list)। listফলাফলটি বাছাই করা দরকার হলেই ব্যবহার করুন , ফলাফলটি বাছাই করা দরকার হলেই ব্যবহার করুন sorted
শ্যাডোর্যাঞ্জার

3

পাইথন বিল্ট-ইন টাইপের ম্যাজিক

অজগরটিতে, এই জাতীয় জটিল ঘটনাগুলি প্রক্রিয়া করা খুব সহজ এবং কেবল পাইথনের বিল্ট-ইন টাইপ দ্বারা।

আমাকে কীভাবে করতে হয় তা দেখিয়ে দিন!

পদ্ধতি 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)

আপনি ফলাফল পাবেন:

[
  ['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']
]

কারণ টিপল হ্যাশেবল এবং আপনি সহজেই তালিকা এবং টুপলের মধ্যে ডেটা রূপান্তর করতে পারেন

আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.