Python Language
Itertools मॉड्यूल

वाक्य - विन्यास

• import itertools

एक समारोह का उपयोग कर एक iterable वस्तु से आइटम समूहीकरण

एक चलने योग्य के साथ शुरू करें जिसे समूहीकृत करने की आवश्यकता है

lst = [("a", 5, 6), ("b", 2, 4), ("a", 2, 5), ("c", 2, 6)]

प्रत्येक ट्यूपल में दूसरे तत्व के आधार पर समूहीकृत जनरेटर उत्पन्न करें:

def testGroupBy(lst):
    groups = itertools.groupby(lst, key=lambda x: x[1])
    for key, group in groups:
        print(key, list(group))

testGroupBy(lst)

# 5 [('a', 5, 6)]
# 2 [('b', 2, 4), ('a', 2, 5), ('c', 2, 6)]

केवल निरंतर तत्वों के समूह को समूहीकृत किया जाता है। उदाहरण के लिए, Groupby को कॉल करने से पहले आपको उसी कुंजी को छाँटना पड़ सकता है, (अंतिम तत्व बदल गया है)

lst = [("a", 5, 6), ("b", 2, 4), ("a", 2, 5), ("c", 5, 6)]
testGroupBy(lst)

# 5 [('a', 5, 6)]
# 2 [('b', 2, 4), ('a', 2, 5)]
# 5 [('c', 5, 6)]

Groupby द्वारा लौटाया गया समूह एक पुनरावृत्ति है जो अगले पुनरावृत्ति से पहले अमान्य होगा। उदाहरण के लिए, यदि आप समूहों को कुंजी द्वारा क्रमबद्ध करना चाहते हैं तो निम्न कार्य नहीं करेगा। समूह 5 खाली है क्योंकि जब समूह 2 लाया जाता है तो यह 5 अमान्य हो जाता है

lst = [("a", 5, 6), ("b", 2, 4), ("a", 2, 5), ("c", 2, 6)]
groups = itertools.groupby(lst, key=lambda x: x[1])
for key, group in sorted(groups):
    print(key, list(group))

# 2 [('c', 2, 6)]
# 5 []

सॉर्टिंग को सही ढंग से करने के लिए, सॉर्ट करने से पहले इट्रेटर से एक सूची बनाएं

groups = itertools.groupby(lst, key=lambda x: x[1])
for key, group in sorted((key, list(group)) for key, group in groups):
    print(key, list(group))
      
# 2 [('b', 2, 4), ('a', 2, 5), ('c', 2, 6)]
# 5 [('a', 5, 6)]

एक जनरेटर का टुकड़ा लें

Itertools "islice" आप एक जनरेटर टुकड़ा करने के लिए अनुमति देता है:

results = fetch_paged_results()  # returns a generator
limit = 20  # Only want the first 20 results
for data in itertools.islice(results, limit):
    print(data)

आम तौर पर आप एक जनरेटर का टुकड़ा नहीं कर सकते:

def gen():
    n = 0
    while n < 20:
        n += 1
        yield n

for part in gen()[:3]:
    print(part)

दे देंगे

Traceback (most recent call last):
  File "gen.py", line 6, in <module>
    for part in gen()[:3]:
TypeError: 'generator' object is not subscriptable

हालाँकि, यह काम करता है:

import itertools

def gen():
    n = 0
    while n < 20:
        n += 1
        yield n

for part in itertools.islice(gen(), 3):
    print(part)

ध्यान दें कि एक नियमित स्लाइस की तरह, आप start , stop और step तर्कों का भी उपयोग कर सकते हैं:

itertools.islice(iterable, 1, 30, 3)

itertools.product

यह फ़ंक्शन आपको पुनरावृत्तियों की सूची के कार्टेशियन उत्पाद पर पुनरावृति करने देता है।

उदाहरण के लिए,

for x, y in itertools.product(xrange(10), xrange(10)):
    print x, y

के बराबर है

for x in xrange(10):
    for y in xrange(10):
        print x, y

सभी अजगर कार्यों की तरह जो एक चर संख्या के तर्कों को स्वीकार करते हैं, हम * ऑपरेटर के साथ, unpacking के लिए itertools.product के लिए एक सूची पारित कर सकते हैं।

इस प्रकार,

its = [xrange(10)] * 2
for x,y in itertools.product(*its):
    print x, y

पिछले उदाहरणों के दोनों के समान परिणाम उत्पन्न करता है।

>>> from itertools import product
>>> a=[1,2,3,4]
>>> b=['a','b','c']
>>> product(a,b)
<itertools.product object at 0x0000000002712F78>
>>> for i in product(a,b):
...     print i
...
(1, 'a')
(1, 'b')
(1, 'c')
(2, 'a')
(2, 'b')
(2, 'c')
(3, 'a')
(3, 'b')
(3, 'c')
(4, 'a')
(4, 'b')
(4, 'c')

itertools.count

परिचय:

यह सरल कार्य संख्याओं की अनंत श्रृंखला उत्पन्न करता है। उदाहरण के लिए...

for number in itertools.count():
    if number > 20:
        break
    print(number)

ध्यान दें कि हमें हमेशा के लिए टूट जाना चाहिए या यह प्रिंट हो जाएगा!

आउटपुट:

0
1
2
3
4
5
6
7
8
9
10

तर्क:

count() दो तर्क लेता है, start और step :

for number in itertools.count(start=10, step=4):
    print(number)
    if number > 20:
        break

आउटपुट:

10
14
18
22

itertools.takewhile

itertools.takewhile आपको तब तक एक क्रम से आइटम लेने में सक्षम बनाता है जब तक कि कोई शर्त पहले False हो जाती।

def is_even(x):
    return x % 2 == 0


lst = [0, 2, 4, 12, 18, 13, 14, 22, 23, 44]
result = list(itertools.takewhile(is_even, lst))

print(result)
  

यह आउटपुट [0, 2, 4, 12, 18] ।

ध्यान दें कि, पहली संख्या जो विधेय का उल्लंघन करती है (यानी: बूलियन मान लौटाने वाला फ़ंक्शन) is_even है, 13 । एक बार जब takewhile एक मूल्य का सामना करता है जो दिए गए विधेय के लिए False उत्पादन करता है, तो यह टूट जाता है।

takewhile द्वारा उत्पादित आउटपुट नीचे दिए गए कोड से उत्पन्न आउटपुट के समान है।

def takewhile(predicate, iterable):
    for x in iterable:
        if predicate(x):
            yield x
        else:
            break

नोट: takewhile और dropwhile द्वारा उत्पादित परिणामों का संयोजन मूल पुनरावृत्ति पैदा करता है।

result = list(itertools.takewhile(is_even, lst)) + list(itertools.dropwhile(is_even, lst))

itertools.dropwhile

itertools.dropward आपको एक शर्त के बाद आइटम को पहले अनुक्रम में ले जाने में सक्षम बनाता है जब पहली बार False हो जाता है।

def is_even(x):
    return x % 2 == 0


lst = [0, 2, 4, 12, 18, 13, 14, 22, 23, 44]
result = list(itertools.dropwhile(is_even, lst))

print(result)
  

यह आउटपुट [13, 14, 22, 23, 44] ।

( यह उदाहरण takewhile लिए उदाहरण के takewhile लेकिन dropwhile का उपयोग कर dropwhile । )

ध्यान दें कि, पहली संख्या जो विधेय का उल्लंघन करती है (यानी: बूलियन मान लौटाने वाला फ़ंक्शन) is_even है, 13 । इससे पहले के सभी तत्व, त्याग दिए जाते हैं।

dropwhile द्वारा उत्पादित आउटपुट नीचे दिए गए कोड से उत्पन्न आउटपुट के समान है।

def dropwhile(predicate, iterable):
    iterable = iter(iterable)
    for x in iterable:
        if not predicate(x):
            yield x
            break
    for x in iterable:
        yield x

takewhile और dropwhile द्वारा उत्पादित परिणामों का संयोजन मूल पुनरावृत्ति पैदा करता है।

result = list(itertools.takewhile(is_even, lst)) + list(itertools.dropwhile(is_even, lst))

दो पुनरावृत्तियों को तब तक छोड़ना जब तक वे दोनों समाप्त न हो जाएं

बिल्ट-इन फ़ंक्शन zip() , itertools.zip_longest दो पुनरावृत्तियों के छोटे से अंत तक itertools.zip_longest जारी रखेगा।

from itertools import zip_longest
a = [i for i in range(5)] # Length is 5
b = ['a', 'b', 'c', 'd', 'e', 'f', 'g'] # Length is 7
for i in zip_longest(a, b):
    x, y = i  # Note that zip longest returns the values as a tuple
    print(x, y)

एक वैकल्पिक fillvalue तर्क पारित किया जा सकता है ( '' लिए चूक) जैसे:

for i in zip_longest(a, b, fillvalue='Hogwash!'):
    x, y = i  # Note that zip longest returns the values as a tuple
    print(x, y)

पायथन 2.6 और 2.7 में, इस फ़ंक्शन को itertools.izip_longest कहा जाता है।

Itertools मॉड्यूल में संयोजन विधि

itertools.combinations एक सूची के k -combination अनुक्रम का एक जनरेटर लौटाएगा।

दूसरे शब्दों में: यह इनपुट सूची के सभी संभावित k- वार संयोजनों के tuples का एक जनरेटर लौटाएगा।

उदाहरण के लिए:

यदि आपके पास एक सूची है:

a = [1,2,3,4,5]
b = list(itertools.combinations(a, 2))
print b

आउटपुट:

[(1, 2), (1, 3), (1, 4), (1, 5), (2, 3), (2, 4), (2, 5), (3, 4), (3, 5), (4, 5)]

उपरोक्त आउटपुट एक जनरेटर है जिसे इनपुट सूची के सभी संभावित जोड़ी- वार संयोजनों के tuples की सूची में बदल दिया गया a

आप सभी 3-संयोजनों को भी देख सकते हैं:

a = [1,2,3,4,5]
b = list(itertools.combinations(a, 3))
print b

आउटपुट:

[(1, 2, 3), (1, 2, 4), (1, 2, 5), (1, 3, 4),
 (1, 3, 5), (1, 4, 5), (2, 3, 4), (2, 3, 5),
 (2, 4, 5), (3, 4, 5)]

एक साथ कई पुनरावृत्तियों का पीछा करते हुए

एक एकल जनरेटर बनाने के लिए itertools.chain का उपयोग करें जो क्रम में कई जनरेटर से मूल्यों का उत्पादन करेगा।

from itertools import chain
a = (x for x in ['1', '2', '3', '4'])
b = (x for x in ['x', 'y', 'z'])
' '.join(chain(a, b))

का परिणाम:

'1 2 3 4 x y z'

एक वैकल्पिक कंस्ट्रक्टर के रूप में, आप classmethod chain.from_iterable उपयोग कर सकते हैं जो अपने एकल पैरामीटर को पुनरावृत्तियों के पुनरावृत्ति के रूप में लेता है। उपरोक्त परिणाम प्राप्त करने के लिए:

' '.join(chain.from_iterable([a,b])

जबकि chain एक मनमानी संख्या ले सकती है, chain.from_iterable एक अनंत संख्या में पुनरावृत्ति करने का एकमात्र तरीका है।

itertools.repeat

कुछ एन बार दोहराएँ:

>>> import itertools
>>> for i in itertools.repeat('over-and-over', 3):
...    print(i)
over-and-over
over-and-over
over-and-over

एक पुनरावृत्त में संख्याओं का संचित योग प्राप्त करें

>>> import itertools as it
>>> import operator

>>> list(it.accumulate([1,2,3,4,5]))
[1, 3, 6, 10, 15]

>>> list(it.accumulate([1,2,3,4,5], func=operator.mul)) 
[1, 2, 6, 24, 120]

एक पुनरावृत्ति में तत्वों के माध्यम से चक्र

cycle एक अनंत पुनरावृत्ति है।

>>> import itertools as it
>>> it.cycle('ABCD')
A B C D A B C D A B C D ...

इसलिए, अनंत लूप से बचने के लिए इसका उपयोग करते समय सीमाएं देने का ध्यान रखें। उदाहरण:

>>> # Iterate over each element in cycle for a fixed range
>>> cycle_iterator = it.cycle('abc123')
>>> [next(cycle_iterator) for i in range(0, 10)]
['a', 'b', 'c', '1', '2', '3', 'a', 'b', 'c', '1']

itertools.permutations

itertools.permutations पुनरावृत्ति तत्वों के क्रमिक आर-लंबाई क्रमपरिवर्तन के साथ एक जनरेटर देता है।

a = [1,2,3]
list(itertools.permutations(a))
# [(1, 2, 3), (1, 3, 2), (2, 1, 3), (2, 3, 1), (3, 1, 2), (3, 2, 1)]

list(itertools.permutations(a, 2))
[(1, 2), (1, 3), (2, 1), (2, 3), (3, 1), (3, 2)]

यदि सूची a डुप्लिकेट तत्व है, जिसके परिणामस्वरूप क्रमपरिवर्तन डुप्लिकेट तत्वों, तो आप उपयोग कर सकते हैं set अद्वितीय क्रमपरिवर्तन पाने के लिए:

a = [1,2,1]
list(itertools.permutations(a))
# [(1, 2, 1), (1, 1, 2), (2, 1, 1), (2, 1, 1), (1, 1, 2), (1, 2, 1)]

set(itertools.permutations(a))
# {(1, 1, 2), (1, 2, 1), (2, 1, 1)}