Python Language
संग्रह मॉड्यूल

परिचय

टिप्पणियों

collections.Counter

काउंटर एक तानाशाह उप वर्ग है जो आपको वस्तुओं को आसानी से गिनने की अनुमति देता है। इसमें उन वस्तुओं की आवृत्तियों के साथ काम करने की उपयोगिता विधियां हैं जिन्हें आप गिन रहे हैं।

import collections
counts = collections.Counter([1,2,3])

उपरोक्त कोड एक ऑब्जेक्ट बनाता है, मायने रखता है, जिसमें कंस्ट्रक्टर को दिए गए सभी तत्वों की आवृत्तियों होती हैं। इस उदाहरण का मान Counter({1: 1, 2: 1, 3: 1})

कंस्ट्रक्टर उदाहरण

पत्र काउंटर

>>> collections.Counter('Happy Birthday')
Counter({'a': 2, 'p': 2, 'y': 2, 'i': 1, 'r': 1, 'B': 1, ' ': 1, 'H': 1, 'd': 1, 'h': 1, 't': 1})

शब्द काउंटर

>>> collections.Counter('I am Sam Sam I am That Sam-I-am That Sam-I-am! I do not like that Sam-I-am'.split())
Counter({'I': 3, 'Sam': 2, 'Sam-I-am': 2, 'That': 2, 'am': 2, 'do': 1, 'Sam-I-am!': 1, 'that': 1, 'not': 1, 'like': 1})

व्यंजनों

>>> c = collections.Counter({'a': 4, 'b': 2, 'c': -2, 'd': 0})

व्यक्तिगत तत्व की गिनती करें

>>> c['a']
4

व्यक्तिगत तत्व की गिनती सेट करें

>>> c['c'] = -3
>>> c
Counter({'a': 4, 'b': 2, 'd': 0, 'c': -3})

काउंटर में तत्वों की कुल संख्या प्राप्त करें (4 + 2 + 0 - 3)

>>> sum(c.itervalues())  # negative numbers are counted!
3

तत्व प्राप्त करें (केवल सकारात्मक काउंटर वाले लोग ही रखे जाएं)

>>> list(c.elements())
['a', 'a', 'a', 'a', 'b', 'b']

0 या ऋणात्मक मान वाली कुंजियाँ निकालें

>>> c - collections.Counter()
Counter({'a': 4, 'b': 2})

सब हटा दो

>>> c.clear()
>>> c
Counter()

व्यक्तिगत तत्वों को हटा दें

>>> c.update({'a': 3, 'b':3})
>>> c.update({'a': 2, 'c':2})  # adds to existing, sets if they don't exist
>>> c
Counter({'a': 5, 'b': 3, 'c': 2})
>>> c.subtract({'a': 3, 'b': 3, 'c': 3})  # subtracts (negative values are allowed)
>>> c
Counter({'a': 2, 'b': 0, 'c': -1})

collections.defaultdict

collections.defaultdict (default_factory) के एक उपवर्ग रिटर्न dict कुंजियां अनुपलब्ध लिए एक डिफ़ॉल्ट मान है। तर्क एक फ़ंक्शन होना चाहिए जो बिना किसी तर्क के साथ डिफ़ॉल्ट मान लौटाता है। यदि कुछ भी पारित नहीं होता है, तो यह None को None चूकता है।

>>> state_capitals = collections.defaultdict(str)
>>> state_capitals
defaultdict(<class 'str'>, {})

एक डिफॉल्ट का संदर्भ देता है जो अपने default_factory विधि के साथ एक स्ट्रिंग ऑब्जेक्ट बनाएगा।

defaultdict का एक विशिष्ट उपयोग defaultdict में से एक का उपयोग करना है जैसे कि str , int , list या dict रूप में default_factory, क्योंकि ये बिना किसी तर्क के साथ खाली प्रकारों में वापस आते हैं:

>>> str()
''
>>> int()
0
>>> list
[]

डिफ़ॉल्ट को एक कुंजी के साथ कॉल करना जो मौजूद नहीं है एक त्रुटि उत्पन्न नहीं करता है क्योंकि यह एक सामान्य शब्दकोश में होगा।

>>> state_capitals['Alaska']
''
>>> state_capitals
defaultdict(<class 'str'>, {'Alaska': ''})

साथ एक और उदाहरण int :

>>> fruit_counts = defaultdict(int)
>>> fruit_counts['apple'] += 2  # No errors should occur
>>> fruit_counts
default_dict(int, {'apple': 2})
>>> fruit_counts['banana']  # No errors should occur
0
>>> fruit_counts  # A new key is created
default_dict(int, {'apple': 2, 'banana': 0})

सामान्य शब्दकोश विधियां डिफ़ॉल्ट डिक्शनरी के साथ काम करती हैं

>>> state_capitals['Alabama'] = 'Montgomery'
>>> state_capitals
defaultdict(<class 'str'>, {'Alabama': 'Montgomery', 'Alaska': ''})

Default_factory के रूप में list का उपयोग करना प्रत्येक नई कुंजी के लिए एक सूची बनाएगा।

>>> s = [('NC', 'Raleigh'), ('VA', 'Richmond'), ('WA', 'Seattle'), ('NC', 'Asheville')]
>>> dd = collections.defaultdict(list)
>>> for k, v in s:
...     dd[k].append(v)
>>> dd
defaultdict(<class 'list'>, 
    {'VA': ['Richmond'], 
     'NC': ['Raleigh', 'Asheville'], 
     'WA': ['Seattle']})

collections.OrderedDict

पायथन शब्दकोशों में चाबियों का क्रम मनमाना है: वे उस क्रम से शासित नहीं होते हैं जिसमें आप उन्हें जोड़ते हैं।

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

>>> d = {'foo': 5, 'bar': 6}
>>> print(d)
{'foo': 5, 'bar': 6}
>>> d['baz'] = 7
>>> print(a)
{'baz': 7, 'foo': 5, 'bar': 6}
>>> d['foobar'] = 8
>>> print(a)
{'baz': 7, 'foo': 5, 'bar': 6, 'foobar': 8}
```

(ऊपर उल्लिखित मनमाना आदेश का मतलब है कि आपको यहां दिखाए गए उपरोक्त कोड के साथ अलग-अलग परिणाम मिल सकते हैं।)

जिस क्रम में कुंजियाँ दिखाई देती हैं, वह क्रम होता है, जिसके लिए वे अधिक पुनरावृत्त होंगे, उदाहरण के for लूप का उपयोग करना।

collections.OrderedDict । श्रेणीबद्ध डिक्शनरी में ऑब्जेक्ट्स के क्रम को बनाए रखने वाली डिक्शनरी प्रदान की जाती है। OrderedDict गए आइटमों की एक श्रृंखला के साथ नीचे दिए गए आदेश के अनुसार बनाया जा सकता है (यहां, टपल की-वैल्यू जोड़े की सूची):

>>> from collections import OrderedDict
>>> d = OrderedDict([('foo', 5), ('bar', 6)])
>>> print(d)
OrderedDict([('foo', 5), ('bar', 6)])
>>> d['baz'] = 7
>>> print(d)
OrderedDict([('foo', 5), ('bar', 6), ('baz', 7)])
>>> d['foobar'] = 8
>>> print(d)
OrderedDict([('foo', 5), ('bar', 6), ('baz', 7), ('foobar', 8)])

या हम एक खाली OrderedDict बना सकते हैं और फिर आइटम जोड़ सकते हैं:

>>> o = OrderedDict()
>>> o['key1'] = "value1"
>>> o['key2'] = "value2"
>>> print(o)
OrderedDict([('key1', 'value1'), ('key2', 'value2')])

OrderedDict माध्यम से OrderedDict उन्हें जोड़े गए क्रम में महत्वपूर्ण पहुंच की अनुमति देता है।

यदि हम किसी मौजूदा कुंजी को नया मान देते हैं तो क्या होता है?

>>> d['foo'] = 4
>>> print(d)
OrderedDict([('foo', 4), ('bar', 6), ('baz', 7), ('foobar', 8)])

OrderedDict में कुंजी अपना मूल स्थान बनाए रखती है।

collections.namedtuple

इस तरह namedtuple का उपयोग करके एक नए प्रकार के Person परिभाषित करें:

Person = namedtuple('Person', ['age', 'height', 'name'])

दूसरा तर्क उन विशेषताओं की सूची है जो टुपल के पास होंगी। आप इन विशेषताओं को या तो स्थान या अल्पविराम से अलग स्ट्रिंग के रूप में सूचीबद्ध कर सकते हैं:

Person = namedtuple('Person', 'age, height, name')

या

Person = namedtuple('Person', 'age height name')

एक बार परिभाषित होने पर, एक नामित टपल को ऑब्जेक्ट को आवश्यक मापदंडों के साथ कॉल करके त्वरित किया जा सकता है, जैसे:

dave = Person(30, 178, 'Dave')

नामित तर्कों का भी उपयोग किया जा सकता है:

jack = Person(age=30, height=178, name='Jack S.')

अब आप नेमटुपल के गुणों का उपयोग कर सकते हैं:

print(jack.age)  # 30
print(jack.name)  # 'Jack S.'

typename (हमारे उदाहरण 'Person' ) का पहला तर्क typename । यह कंस्ट्रक्टर और टाइपनेम के लिए एक ही शब्द का उपयोग करने के लिए विशिष्ट है, लेकिन वे अलग हो सकते हैं:

Human = namedtuple('Person',  'age, height, name')
dave = Human(30, 178, 'Dave')
print(dave)  # yields: Person(age=30, height=178, name='Dave')

collections.deque

पुनरावृत्ति के डेटा के साथ बाएं-से-दाएं (एपेंड () का उपयोग करके) एक नया deque ऑब्जेक्ट लौटाता है। यदि पुनरावृत्त निर्दिष्ट नहीं है, तो नया deque खाली है।

डेक्स ढेर और कतारों का एक सामान्यीकरण है (नाम का उच्चारण "डेक" है और "डबल-एंडेड क्वीन्स" के लिए छोटा है)। Deques के दोनों ओर से धागे की सुरक्षित, स्मृति कुशल संलग्न कर देता है और पॉप का समर्थन deque किसी भी दिशा में लगभग एक ही हे (1) के प्रदर्शन के साथ।

हालांकि सूची ऑब्जेक्ट समान संचालन का समर्थन करते हैं, वे तेजी से निर्धारित लंबाई के संचालन के लिए अनुकूलित होते हैं और पॉप (0) और इंसर्ट (0, v) संचालन के लिए मेमोरी मूवमेंट लागत (एन) ओ के लिए आते हैं, जो अंतर्निहित डेटा प्रतिनिधित्व के आकार और स्थिति दोनों को बदलते हैं। ।

संस्करण 2.4 में नया।

यदि maxlen निर्दिष्ट नहीं है या None , तो देवता मनमानी लंबाई तक बढ़ सकते हैं। अन्यथा, निर्दिष्ट निर्दिष्ट लंबाई के लिए deque बाध्य है। एक बार एक deque लंबाई की deque पूरी हो जाने पर, जब नई वस्तुओं को जोड़ा जाता है, तो संबंधित संख्या को विपरीत छोर से छोड़ दिया जाता है। बंधे हुए लंबाई वाले देवता यूनिक्स में टेल फिल्टर के समान कार्यक्षमता प्रदान करते हैं। वे लेन-देन पर नज़र रखने और डेटा के अन्य पूल के लिए भी उपयोगी हैं, जहां केवल सबसे हालिया गतिविधि रुचि है।

संस्करण 2.6 में परिवर्तित: अधिकतम पैरामीटर जोड़ा गया।

>>> from collections import deque
>>> d = deque('ghi')                 # make a new deque with three items
>>> for elem in d:                   # iterate over the deque's elements
...     print elem.upper()
G
H
I

>>> d.append('j')                    # add a new entry to the right side
>>> d.appendleft('f')                # add a new entry to the left side
>>> d                                # show the representation of the deque
deque(['f', 'g', 'h', 'i', 'j'])

>>> d.pop()                          # return and remove the rightmost item
'j'
>>> d.popleft()                      # return and remove the leftmost item
'f'
>>> list(d)                          # list the contents of the deque
['g', 'h', 'i']
>>> d[0]                             # peek at leftmost item
'g'
>>> d[-1]                            # peek at rightmost item
'i'

>>> list(reversed(d))                # list the contents of a deque in reverse
['i', 'h', 'g']
>>> 'h' in d                         # search the deque
True
>>> d.extend('jkl')                  # add multiple elements at once
>>> d
deque(['g', 'h', 'i', 'j', 'k', 'l'])
>>> d.rotate(1)                      # right rotation
>>> d
deque(['l', 'g', 'h', 'i', 'j', 'k'])
>>> d.rotate(-1)                     # left rotation
>>> d
deque(['g', 'h', 'i', 'j', 'k', 'l'])

>>> deque(reversed(d))               # make a new deque in reverse order
deque(['l', 'k', 'j', 'i', 'h', 'g'])
>>> d.clear()                        # empty the deque
>>> d.pop()                          # cannot pop from an empty deque
Traceback (most recent call last):
  File "<pyshell#6>", line 1, in -toplevel-
    d.pop()
IndexError: pop from an empty deque

>>> d.extendleft('abc')              # extendleft() reverses the input order
>>> d
deque(['c', 'b', 'a'])

स्रोत: https://docs.python.org/2/library/collections.html

collections.ChainMap

ChainMap 3.3 में नया है

एक नया ChainMap ऑब्जेक्ट देता है जिसमें कई maps दिए गए हैं। यह ऑब्जेक्ट एकल, अप करने योग्य दृश्य बनाने के लिए एक साथ कई डाइक या अन्य मैपिंग को समूहित करता है।

ChainMap एस नेस्टेड संदर्भों और ओवरले को प्रबंधित करने में उपयोगी हैं। अजगर दुनिया में एक उदाहरण Django के टेम्पलेट इंजन में Context वर्ग के कार्यान्वयन में पाया जाता है। यह कई मैपिंग को जल्दी से जोड़ने के लिए उपयोगी है ताकि परिणाम को एक इकाई के रूप में माना जा सके। यह अक्सर एक नया शब्दकोश बनाने और कई update() कॉल चलाने की तुलना में बहुत तेज है।

कभी भी लुकअप मानों की एक श्रृंखला होती है, जो ChainMap लिए एक मामला हो सकता है। एक उदाहरण में उपयोगकर्ता निर्दिष्ट मान और डिफ़ॉल्ट मानों का शब्दकोश दोनों शामिल हैं। एक अन्य उदाहरण वेब उपयोग में पाए जाने वाले POST और GET पैरामीटर मानचित्र हैं, जैसे Django या फ्लास्क। ChainMap के उपयोग के माध्यम से दो अलग-अलग शब्दकोशों का एक संयुक्त दृश्य देता है।

maps पैरामीटर सूची को पहले-खोज से अंतिम-खोज करने का आदेश दिया गया है। जब तक कोई कुंजी नहीं मिलती तब तक लुकअप अंतर्निहित मैपिंग को क्रमिक रूप से खोजता है। इसके विपरीत, लिखते हैं, अद्यतन करते हैं, और विलोपन केवल पहली मैपिंग पर काम करते हैं।

import collections

# define two dictionaries with at least some keys overlapping.
dict1 = {'apple': 1, 'banana': 2}
dict2 = {'coconut': 1, 'date': 1, 'apple': 3}

# create two ChainMaps with different ordering of those dicts.
combined_dict = collections.ChainMap(dict1, dict2)
reverse_ordered_dict = collections.ChainMap(dict2, dict1)

ऑर्डर के प्रभाव पर ध्यान दें, जो बाद के लुकअप में पहले पाया जाता है

for k, v in combined_dict.items():
    print(k, v)
    
date 1
apple 1
banana 2
coconut 1

for k, v in reverse_ordered_dict.items():
    print(k, v)

date 1
apple 3
banana 2
coconut 1