আমি কীভাবে একটি তালিকা আইটেমের উপস্থিতি গণনা করতে পারি?
উত্তর:
আপনি যদি কেবল একটি আইটেমের গণনা চান তবে countপদ্ধতিটি ব্যবহার করুন :
>>> [1, 2, 3, 4, 1, 4, 1].count(1)
3
আপনি একাধিক আইটেম গণনা করতে চাইলে এটি ব্যবহার করবেন না । কলিং countএকটি লুপ প্রতিটি তালিকায় উপর একটি পৃথক পাস প্রয়োজন countকল, যা অভিনয়ের জন্য সর্বনাশা হতে পারে। আপনি যদি সমস্ত আইটেম, বা এমনকি একাধিক আইটেম গণনা করতে চান Counterতবে অন্যান্য উত্তরে বর্ণিত হিসাবে ব্যবহার করুন ।
ব্যবহারের Counterআপনি পাইথন 2.7 বা 3.x ব্যবহার করছেন এবং আপনি প্রতিটি উপাদানের জন্য ঘটনার সংখ্যা চাই:
>>> from collections import Counter
>>> z = ['blue', 'red', 'blue', 'yellow', 'blue', 'red']
>>> Counter(z)
Counter({'blue': 3, 'red': 2, 'yellow': 1})
isinstance। সুতরাং আপনি যে ডেটা নিয়ে কাজ করছেন সে সম্পর্কে আপনি যদি নিশ্চিত হন তবে প্রকার ও উদাহরণ পরীক্ষা না করে কোনও কাস্টম ফাংশনটি লেখাই ভাল।
isinstanceডাকছে? এমনকি কয়েক মিলিয়ন স্ট্রিং সহ, কল করাতে Counterকেবল একটি isinstanceকল জড়িত , এটির যুক্তি ম্যাপিং কিনা তা পরীক্ষা করে to আপনি সম্ভবত পুরোপুরি কী খাচ্ছেন তা ভুল বুঝেছেন।
Counterঅনেকগুলি পুনরাবৃত্ত গণনা না করে বড় পুনরাবৃত্তের গণনায় চলে গেছে। একটি মিলিয়ন-স্ট্রিং পুনরাবৃত্তযোগ্য গণনা Counterম্যানুয়াল বাস্তবায়নের চেয়ে দ্রুত চলে যাবে । আপনি যদি updateঅনেকগুলি পুনরাবৃত্ত লোকের সাথে কল করতে চান তবে আপনি জিনিসগুলিকে একটি পুনরাবৃত্তের সাথে যুক্ত করে দ্রুত করতে সক্ষম হতে পারেন itertools.chain।
একটি তালিকার মধ্যে একটি আইটেমের উপস্থিতি গণনা করা হচ্ছে
কেবলমাত্র একটি তালিকার আইটেমের উপস্থিতি গণনা করার জন্য আপনি ব্যবহার করতে পারেন count()
>>> l = ["a","b","b"]
>>> l.count("a")
1
>>> l.count("b")
2
তালিকার সমস্ত আইটেমের উপস্থিতি গণনা করা একটি তালিকার তালিকার সাথে তাল মিলিয়ে বা ট্যালি কাউন্টার তৈরি হিসাবেও পরিচিত।
সমস্ত আইটেম গণনা সহ গণনা করা ()
আইটেমগুলির উপস্থিতিগুলি lএকের মধ্যে গণনা করার জন্য কেবল একটি তালিকা উপলব্ধি এবং count()পদ্ধতিটি ব্যবহার করতে পারেন
[[x,l.count(x)] for x in set(l)](বা একইভাবে অভিধানের সাথে dict((x,l.count(x)) for x in set(l)))
উদাহরণ:
>>> l = ["a","b","b"]
>>> [[x,l.count(x)] for x in set(l)]
[['a', 1], ['b', 2]]
>>> dict((x,l.count(x)) for x in set(l))
{'a': 1, 'b': 2}
কাউন্টার সহ সমস্ত আইটেম গণনা করা ()
বিকল্পভাবে, গ্রন্থাগার Counterথেকে দ্রুত বর্গ রয়েছেcollections
Counter(l)উদাহরণ:
>>> l = ["a","b","b"]
>>> from collections import Counter
>>> Counter(l)
Counter({'b': 2, 'a': 1})
কাউন্টার কত দ্রুত?
Counterতালিকার তালিকাগুলির জন্য কত দ্রুত তা আমি পরীক্ষা করে দেখেছি । আমি কয়েকটি মূল্যবোধ নিয়ে উভয় পদ্ধতিই চেষ্টা করে দেখলাম nএবং এটি Counterপ্রায় 2 এর ধ্রুবক ফ্যাক্টর দ্বারা দ্রুততর হয়।
আমি যে স্ক্রিপ্টটি ব্যবহার করেছি তা এখানে:
from __future__ import print_function
import timeit
t1=timeit.Timer('Counter(l)', \
'import random;import string;from collections import Counter;n=1000;l=[random.choice(string.ascii_letters) for x in range(n)]'
)
t2=timeit.Timer('[[x,l.count(x)] for x in set(l)]',
'import random;import string;n=1000;l=[random.choice(string.ascii_letters) for x in range(n)]'
)
print("Counter(): ", t1.repeat(repeat=3,number=10000))
print("count(): ", t2.repeat(repeat=3,number=10000)
এবং আউটপুট:
Counter(): [0.46062711701961234, 0.4022796869976446, 0.3974247490405105]
count(): [7.779430688009597, 7.962715800967999, 8.420845870045014]
Counterহয় পথ বড় তালিকার জন্য দ্রুত। তালিকাটি বোঝার পদ্ধতিটি হল ও (এন ^ 2), Counterও (এন) হওয়া উচিত।
isinstance। সুতরাং আপনি যে ডেটা নিয়ে কাজ করছেন সে সম্পর্কে আপনি যদি নিশ্চিত হন তবে প্রকার ও উদাহরণ পরীক্ষা না করে কোনও কাস্টম ফাংশনটি লেখাই ভাল।
অভিধানে প্রতিটি আইটেমের সংখ্যার সংখ্যা পাওয়ার আরও একটি উপায়:
dict((i, a.count(i)) for i in a)n * (number of different items)অপারেশন নেবে , সেটটি তৈরি করতে যে সময় লাগে তা গণনা করা হবে না। ব্যবহার collections.Counterকরা সত্যিই অনেক ভাল।
i, কারণ এটি অভিধানে একই মানের একাধিক কী প্রবেশ করার চেষ্টা করবে। dict((i, a.count(i)) for i in a)
list.count(x)xএকটি তালিকায় প্রদর্শিত সময়ের সংখ্যা প্রদান করে
দেখুন: http://docs.python.org/tutorial/datastructures.html#more-on-lists
একটি আইটেম দেওয়া হয়েছে, আমি পাইথনের একটি তালিকায় এর উপস্থিতিগুলি কীভাবে গণনা করব?
এখানে একটি উদাহরণ তালিকা:
>>> l = list('aaaaabbbbcccdde')
>>> l
['a', 'a', 'a', 'a', 'a', 'b', 'b', 'b', 'b', 'c', 'c', 'c', 'd', 'd', 'e']list.count
আছে list.countপদ্ধতি
>>> l.count('b')
4এটি কোনও তালিকার পক্ষে কাজ করে works টিপলস এছাড়াও এই পদ্ধতি আছে:
>>> t = tuple('aabbbffffff')
>>> t
('a', 'a', 'b', 'b', 'b', 'f', 'f', 'f', 'f', 'f', 'f')
>>> t.count('f')
6collections.Counter
এবং তারপরে সংগ্রহ রয়েছে C আপনি যে কোনও পুনরাবৃত্তযোগ্য কাউন্টারে ফেলে দিতে পারেন, কেবল একটি তালিকা নয়, এবং কাউন্টার উপাদানগুলির গণনাগুলির একটি ডেটা কাঠামো ধরে রাখবে।
ব্যবহার:
>>> from collections import Counter
>>> c = Counter(l)
>>> c['b']
4কাউন্টারগুলি পাইথন অভিধানের উপর ভিত্তি করে তৈরি করা হয়, তাদের কীগুলি উপাদানগুলি রয়েছে তাই কীগুলি হ্যাশেবল হওয়া দরকার। এগুলি মূলত এমন সেটগুলির মতো যা তাদের মধ্যে অপ্রয়োজনীয় উপাদানগুলিকে মঞ্জুরি দেয়।
আরও ব্যবহার collections.Counter
আপনি আপনার কাউন্টার থেকে পুনরাবৃত্তিযোগ্যগুলি যোগ বা বিয়োগ করতে পারেন:
>>> c.update(list('bbb'))
>>> c['b']
7
>>> c.subtract(list('bbb'))
>>> c['b']
4এবং আপনি কাউন্টারের সাথে একাধিক সেট অপারেশনও করতে পারেন:
>>> c2 = Counter(list('aabbxyz'))
>>> c - c2 # set difference
Counter({'a': 3, 'c': 3, 'b': 2, 'd': 2, 'e': 1})
>>> c + c2 # addition of all elements
Counter({'a': 7, 'b': 6, 'c': 3, 'd': 2, 'e': 1, 'y': 1, 'x': 1, 'z': 1})
>>> c | c2 # set union
Counter({'a': 5, 'b': 4, 'c': 3, 'd': 2, 'e': 1, 'y': 1, 'x': 1, 'z': 1})
>>> c & c2 # set intersection
Counter({'a': 2, 'b': 2})পান্ডাস কেন নয়?
অন্য উত্তর থেকে পরামর্শ পাওয়া যায়:
পান্ডা ব্যবহার করবেন না কেন?
পান্ডাস একটি সাধারণ গ্রন্থাগার, তবে এটি স্ট্যান্ডার্ড লাইব্রেরিতে নেই। এটি প্রয়োজন হিসাবে যুক্ত করা তুচ্ছ নয় is
তালিকার অবজেক্টের পাশাপাশি স্ট্যান্ডার্ড লাইব্রেরিতে এই ব্যবহারের ক্ষেত্রে অন্তর্নিহিত সমাধান রয়েছে।
আপনার প্রকল্পের যদি ইতিমধ্যে পান্ডার প্রয়োজন না হয় তবে কেবল এই কার্যকারিতাটির জন্য এটি প্রয়োজনীয়তা বোকামি।
আমি প্রস্তাবিত সমস্ত সমাধান (এবং কয়েকটি নতুন) পারফ্ল্লট (আমার একটি ছোট প্রকল্প ) এর সাথে তুলনা করেছি ।
একটি আইটেম গণনা করা হচ্ছে
বড় পরিমাণে অ্যারেগুলির জন্য এটি সক্রিয় হয়
numpy.sum(numpy.array(a) == 1) অন্যান্য সমাধানের তুলনায় কিছুটা দ্রুত।
সমস্ত আইটেম গণনা করা হচ্ছে
numpy.bincount(a)আপনি কি চান
প্লটগুলি পুনরুত্পাদন করার কোড:
from collections import Counter
from collections import defaultdict
import numpy
import operator
import pandas
import perfplot
def counter(a):
return Counter(a)
def count(a):
return dict((i, a.count(i)) for i in set(a))
def bincount(a):
return numpy.bincount(a)
def pandas_value_counts(a):
return pandas.Series(a).value_counts()
def occur_dict(a):
d = {}
for i in a:
if i in d:
d[i] = d[i]+1
else:
d[i] = 1
return d
def count_unsorted_list_items(items):
counts = defaultdict(int)
for item in items:
counts[item] += 1
return dict(counts)
def operator_countof(a):
return dict((i, operator.countOf(a, i)) for i in set(a))
perfplot.show(
setup=lambda n: list(numpy.random.randint(0, 100, n)),
n_range=[2**k for k in range(20)],
kernels=[
counter, count, bincount, pandas_value_counts, occur_dict,
count_unsorted_list_items, operator_countof
],
equality_check=None,
logx=True,
logy=True,
)2।
from collections import Counter
from collections import defaultdict
import numpy
import operator
import pandas
import perfplot
def counter(a):
return Counter(a)
def count(a):
return dict((i, a.count(i)) for i in set(a))
def bincount(a):
return numpy.bincount(a)
def pandas_value_counts(a):
return pandas.Series(a).value_counts()
def occur_dict(a):
d = {}
for i in a:
if i in d:
d[i] = d[i]+1
else:
d[i] = 1
return d
def count_unsorted_list_items(items):
counts = defaultdict(int)
for item in items:
counts[item] += 1
return dict(counts)
def operator_countof(a):
return dict((i, operator.countOf(a, i)) for i in set(a))
perfplot.show(
setup=lambda n: list(numpy.random.randint(0, 100, n)),
n_range=[2**k for k in range(20)],
kernels=[
counter, count, bincount, pandas_value_counts, occur_dict,
count_unsorted_list_items, operator_countof
],
equality_check=None,
logx=True,
logy=True,
)আপনি যদি ব্যবহার করতে পারেন pandas, তবে value_countsউদ্ধারের জন্য রয়েছে।
>>> import pandas as pd
>>> a = [1, 2, 3, 4, 1, 4, 1]
>>> pd.Series(a).value_counts()
1 3
4 2
3 1
2 1
dtype: int64এটি স্বয়ংক্রিয়ভাবে পাশাপাশি ফ্রিকোয়েন্সি উপর ভিত্তি করে ফলাফল বাছাই।
আপনি যদি ফলাফলটি তালিকার তালিকায় আসতে চান তবে নীচের মতো করুন
>>> pd.Series(a).value_counts().reset_index().values.tolist()
[[1, 3], [4, 2], [3, 1], [2, 1]]পান্ডস ব্যবহার করছেন না কেন?
import pandas as pd
l = ['a', 'b', 'c', 'd', 'a', 'd', 'a']
# converting the list to a Series and counting the values
my_count = pd.Series(l).value_counts()
my_countআউটপুট:
a 3
d 2
b 1
c 1
dtype: int64যদি আপনি খুঁজছেন একটি নির্দিষ্ট উপাদান একটি গণনা জন্য বলতে একটি , চেষ্টা করে দেখুন:
my_count['a']আউটপুট:
3আমার আজ এই সমস্যাটি ছিল এবং আমার নিজের সমাধানটি ঘূর্ণায়মান করার আগে আমি SO পরীক্ষা করার চিন্তা করতাম। এই:
dict((i,a.count(i)) for i in a)বড় তালিকার জন্য সত্যই ধীর। আমার সমাধান
def occurDict(items):
d = {}
for i in items:
if i in d:
d[i] = d[i]+1
else:
d[i] = 1
return dকাউন্টার সমাধানের চেয়ে আসলে কিছুটা দ্রুত, কমপক্ষে পাইথন ২.7 এর জন্য।
# Python >= 2.6 (defaultdict) && < 2.7 (Counter, OrderedDict)
from collections import defaultdict
def count_unsorted_list_items(items):
"""
:param items: iterable of hashable items to count
:type items: iterable
:returns: dict of counts like Py2.7 Counter
:rtype: dict
"""
counts = defaultdict(int)
for item in items:
counts[item] += 1
return dict(counts)
# Python >= 2.2 (generators)
def count_sorted_list_items(items):
"""
:param items: sorted iterable of items to count
:type items: sorted iterable
:returns: generator of (item, count) tuples
:rtype: generator
"""
if not items:
return
elif len(items) == 1:
yield (items[0], 1)
return
prev_item = items[0]
count = 1
for item in items[1:]:
if prev_item == item:
count += 1
else:
yield (prev_item, count)
count = 1
prev_item = item
yield (item, count)
return
import unittest
class TestListCounters(unittest.TestCase):
def test_count_unsorted_list_items(self):
D = (
([], []),
([2], [(2,1)]),
([2,2], [(2,2)]),
([2,2,2,2,3,3,5,5], [(2,4), (3,2), (5,2)]),
)
for inp, exp_outp in D:
counts = count_unsorted_list_items(inp)
print inp, exp_outp, counts
self.assertEqual(counts, dict( exp_outp ))
inp, exp_outp = UNSORTED_WIN = ([2,2,4,2], [(2,3), (4,1)])
self.assertEqual(dict( exp_outp ), count_unsorted_list_items(inp) )
def test_count_sorted_list_items(self):
D = (
([], []),
([2], [(2,1)]),
([2,2], [(2,2)]),
([2,2,2,2,3,3,5,5], [(2,4), (3,2), (5,2)]),
)
for inp, exp_outp in D:
counts = list( count_sorted_list_items(inp) )
print inp, exp_outp, counts
self.assertEqual(counts, exp_outp)
inp, exp_outp = UNSORTED_FAIL = ([2,2,4,2], [(2,3), (4,1)])
self.assertEqual(exp_outp, list( count_sorted_list_items(inp) ))
# ... [(2,2), (4,1), (2,1)]নীচে তিনটি সমাধান রয়েছে:
দ্রুততম লুপের জন্য একটি ব্যবহার করছে এবং এটি একটি ডিক্টে সংরক্ষণ করছে।
import time
from collections import Counter
def countElement(a):
g = {}
for i in a:
if i in g:
g[i] +=1
else:
g[i] =1
return g
z = [1,1,1,1,2,2,2,2,3,3,4,5,5,234,23,3,12,3,123,12,31,23,13,2,4,23,42,42,34,234,23,42,34,23,423,42,34,23,423,4,234,23,42,34,23,4,23,423,4,23,4]
#Solution 1 - Faster
st = time.monotonic()
for i in range(1000000):
b = countElement(z)
et = time.monotonic()
print(b)
print('Simple for loop and storing it in dict - Duration: {}'.format(et - st))
#Solution 2 - Fast
st = time.monotonic()
for i in range(1000000):
a = Counter(z)
et = time.monotonic()
print (a)
print('Using collections.Counter - Duration: {}'.format(et - st))
#Solution 3 - Slow
st = time.monotonic()
for i in range(1000000):
g = dict([(i, z.count(i)) for i in set(z)])
et = time.monotonic()
print(g)
print('Using list comprehension - Duration: {}'.format(et - st))ফলাফল
#Solution 1 - Faster
{1: 4, 2: 5, 3: 4, 4: 6, 5: 2, 234: 3, 23: 10, 12: 2, 123: 1, 31: 1, 13: 1, 42: 5, 34: 4, 423: 3}
Simple for loop and storing it in dict - Duration: 12.032000000000153#Solution 2 - Fast
Counter({23: 10, 4: 6, 2: 5, 42: 5, 1: 4, 3: 4, 34: 4, 234: 3, 423: 3, 5: 2, 12: 2, 123: 1, 31: 1, 13: 1})
Using collections.Counter - Duration: 15.889999999999418#Solution 3 - Slow
{1: 4, 2: 5, 3: 4, 4: 6, 5: 2, 34: 4, 423: 3, 234: 3, 42: 5, 12: 2, 13: 1, 23: 10, 123: 1, 31: 1}
Using list comprehension - Duration: 33.0সঙ্গে সমস্ত উপাদান গণনা itertools.groupby()
তালিকায় থাকা সমস্ত উপাদানগুলির গণনা পাওয়ার পক্ষে কোনও সম্ভাবনা নেই itertools.groupby()।
"সদৃশ" গণনা সহ
from itertools import groupby
L = ['a', 'a', 'a', 't', 'q', 'a', 'd', 'a', 'd', 'c'] # Input list
counts = [(i, len(list(c))) for i,c in groupby(L)] # Create value-count pairs as list of tuples
print(counts)রিটার্নস
[('a', 3), ('t', 1), ('q', 1), ('a', 1), ('d', 1), ('a', 1), ('d', 1), ('c', 1)]লক্ষ্য করুন যে এটি কীভাবে প্রথম তিনটিকে aপ্রথম গ্রুপ হিসাবে সংযুক্ত করেছে , অন্য দলের অন্যান্য aতালিকাতে আরও উপস্থিত রয়েছে। ইনপুট তালিকাটি Lবাছাই না করায় এটি ঘটে । গ্রুপগুলি বাস্তবে পৃথক হওয়া উচিত যদি কখনও কখনও এটির উপকার হতে পারে।
অনন্য গণনা সহ
যদি স্বতন্ত্র গোষ্ঠী গণনাগুলি পছন্দ হয় তবে কেবল ইনপুট তালিকাটি বাছাই করুন:
counts = [(i, len(list(c))) for i,c in groupby(sorted(L))]
print(counts)রিটার্নস
[('a', 5), ('c', 1), ('d', 2), ('q', 1), ('t', 1)]দ্রষ্টব্য: অনন্য গণনা তৈরির জন্য, অন্যান্য উত্তরগুলির অনেকগুলি groupbyসমাধানের তুলনায় আরও সহজ এবং বেশি পঠনযোগ্য কোড সরবরাহ করে । তবে এটি এখানে সদৃশ গণনার উদাহরণের সাথে সমান্তরাল আঁকতে দেখানো হয়েছে।
এতে ব্যবহার করুন numpy এর প্রস্তাব ছিল bincount তবে এটা দিয়ে 1d অ্যারে কেবল কাজ করে অ নেতিবাচক পূর্ণসংখ্যার । এছাড়াও, ফলস্বরূপ অ্যারেটি বিভ্রান্তিকর হতে পারে (এতে নূন্যতম থেকে মূল তালিকার সর্বাধিক পর্যন্ত পূর্ণসংখ্যার উপস্থিতি রয়েছে এবং নিখোঁজ পূর্ণসংখ্যাগুলি সেট থাকে)।
নম্পির সাথে এটি করার আরও ভাল উপায় হ'ল সত্যকে সেট করা বৈশিষ্ট্যের সাথে অনন্য ফাংশনটি ব্যবহার করা return_counts। এটি অনন্য মূল্যবোধের অ্যারে এবং প্রতিটি অনন্য মানের সংঘটনগুলির একটি অ্যারে সহ একটি টিপল প্রদান করে।
# a = [1, 1, 0, 2, 1, 0, 3, 3]
a_uniq, counts = np.unique(a, return_counts=True) # array([0, 1, 2, 3]), array([2, 3, 1, 2]এবং তারপরে আমরা তাদের যুক্ত করতে পারি
dict(zip(a_uniq, counts)) # {0: 2, 1: 3, 2: 1, 3: 2}এটি অন্যান্য ডেটা ধরণের এবং "2 ডি তালিকাগুলি", যেমন উদার সাথে কাজ করে
>>> a = [['a', 'b', 'b', 'b'], ['a', 'c', 'c', 'a']]
>>> dict(zip(*np.unique(a, return_counts=True)))
{'a': 3, 'b': 3, 'c': 2}যদিও এটি খুব পুরানো প্রশ্ন, তবে আমি একটি লাইনার খুঁজে পাইনি, তাই আমি একটি তৈরি করেছি।
# original numbers in list
l = [1, 2, 2, 3, 3, 3, 4]
# empty dictionary to hold pair of number and its count
d = {}
# loop through all elements and store count
[ d.update( {i:d.get(i, 0)+1} ) for i in l ]
print(d)আপনি countOfএকটি অন্তর্নির্মিত মডিউলটির পদ্ধতিও ব্যবহার করতে পারেন operator।
>>> import operator
>>> operator.countOf([1, 2, 3, 4, 1, 4, 1], 1)
3countOfবাস্তবায়ন হয়? কীভাবে এটি আরও সুস্পষ্টের সাথে তুলনা করে list.count(সি বাস্তবায়নের ফলে কোনটি উপকার হয়)? কোন সুবিধা আছে?
সর্বাধিক দক্ষ নাও হতে পারে, নকলগুলি সরাতে অতিরিক্ত পাসের প্রয়োজন।
কার্যকরী বাস্তবায়ন:
arr = np.array(['a','a','b','b','b','c'])
print(set(map(lambda x : (x , list(arr).count(x)) , arr)))ফেরত:
{('c', 1), ('b', 3), ('a', 2)}বা হিসাবে ফিরে dict:
print(dict(map(lambda x : (x , list(arr).count(x)) , arr)))ফেরত:
{'b': 3, 'c': 1, 'a': 2}sum([1 for elem in <yourlist> if elem==<your_value>])এটি আপনার_মূল্যের উপস্থিতির পরিমাণ ফিরিয়ে দেবে
যদি আপনি নির্দিষ্ট উপাদানটির জন্য অনেকগুলি ঘটনা চান:
>>> from collections import Counter
>>> z = ['blue', 'red', 'blue', 'yellow', 'blue', 'red']
>>> single_occurrences = Counter(z)
>>> print(single_occurrences.get("blue"))
3
>>> print(single_occurrences.values())
dict_values([3, 2, 1])def countfrequncyinarray(arr1):
r=len(arr1)
return {i:arr1.count(i) for i in range(1,r+1)}
arr1=[4,4,4,4]
a=countfrequncyinarray(arr1)
print(a)l2=[1,"feto",["feto",1,["feto"]],['feto',[1,2,3,['feto']]]]
count=0
def Test(l):
global count
if len(l)==0:
return count
count=l.count("feto")
for i in l:
if type(i) is list:
count+=Test(i)
return count
print(Test(l2))এটি তালিকার তালিকায় তালিকাভুক্ত থাকলেও তালিকায় আইটেমটি পুনরাবৃত্তি করবে বা পুনরাবৃত্ত হবে
mylist = [1,7,7,7,3,9,9,9,7,9,10,0] print sorted(set([i for i in mylist if mylist.count(i)>2]))