Python 3.7 - collections

संग्रह - कंटेनर डेटाटाइप्स




python

संग्रह - कंटेनर डेटाटाइप्स

स्रोत कोड: Lib/collections/__init__.py

यह मॉड्यूल विशिष्ट कंटेनर डेटाटाइप्स को लागू करता है जो पायथन के सामान्य उद्देश्य में निर्मित कंटेनर, dict , list , set और tuple

namedtuple() नामित क्षेत्रों के साथ टपल उप-वर्ग बनाने का कारखाना कार्य
deque तेजी से append और चबूतरे के साथ सूची की तरह कंटेनर या तो अंत में
ChainMap कई मैपिंग के एक दृश्य बनाने के लिए तानाशाह की तरह वर्ग
Counter हाथ धोने की वस्तुओं की गिनती के लिए तानाशाही उपवर्ग
OrderedDict आदेश प्रविष्टियों को याद रखने वाले तानाशाह उपवर्ग जोड़े गए थे
defaultdict गायब होने वाले मूल्यों की आपूर्ति करने के लिए फ़ैक्टरी फ़ंक्शन को कॉल करने वाला तानाशाह उपवर्ग
UserDict आसान तानाशाह उपवर्ग के लिए शब्दकोश वस्तुओं के आसपास आवरण
UserList आसान सूची उपवर्ग के लिए सूची ऑब्जेक्ट के आसपास आवरण
UserString आसान स्ट्रिंग उपवर्ग के लिए स्ट्रिंग ऑब्जेक्ट्स के आसपास रैपर

संस्करण 3.3 में परिवर्तित: collections.abc मॉड्यूल बेस क्लास को ले जाया गया। पीछे की संगतता के लिए, वे पायथन 3.7 के माध्यम से इस मॉड्यूल में दिखाई देते हैं। इसके बाद, उन्हें पूरी तरह से हटा दिया जाएगा।

चेनपॉइंट ऑब्जेक्ट्स

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

कई मैपिंग को जल्दी से लिंक करने के लिए एक ChainMap क्लास प्रदान की जाती है ताकि उन्हें एक इकाई के रूप में माना जा सके। यह अक्सर एक नया शब्दकोश बनाने और कई update() कॉल चलाने की तुलना में बहुत तेज है।

कक्षा का उपयोग नेस्टेड स्कोप अनुकरण करने के लिए किया जा सकता है और टेंपलेटिंग में उपयोगी है।

class collections.ChainMap(*maps)

एक ChainMap को बनाने के लिए एक ChainMap ग्रुप एक साथ कई ChainMap या अन्य मैपिंग करता है। यदि कोई मानचित्र निर्दिष्ट नहीं किया गया है, तो एक एकल खाली शब्दकोश प्रदान किया जाता है ताकि एक नई श्रृंखला में हमेशा कम से कम एक मानचित्रण हो।

अंतर्निहित मैपिंग को एक सूची में संग्रहीत किया जाता है। वह सूची सार्वजनिक है और नक्शे की विशेषता का उपयोग करके उसे एक्सेस या अपडेट किया जा सकता है। अन्य कोई राज्य नहीं है।

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

एक ChainMap संदर्भ द्वारा अंतर्निहित मैपिंग को शामिल करता है। इसलिए, यदि कोई अंतर्निहित मैपिंग अपडेट हो जाती है, तो उन परिवर्तनों को ChainMap में परिलक्षित किया ChainMap

सभी सामान्य शब्दकोश विधियों का समर्थन किया जाता है। इसके अलावा, एक मानचित्र विशेषता है, नए सब-कॉन्टैक्स बनाने के लिए एक विधि, और सभी मैपिंग के लिए एक संपत्ति है।

maps

मैपिंग की एक उपयोगकर्ता अद्यतन करने योग्य सूची। सूची को पहली-खोज से अंतिम-खोज करने का आदेश दिया गया है। यह एकमात्र संग्रहीत स्थिति है और इसे बदलने के लिए संशोधित किया जा सकता है जो मैपिंग खोजे जाते हैं। सूची में हमेशा कम से कम एक मैपिंग होनी चाहिए।

new_child(m=None)

वर्तमान उदाहरण में सभी मैप्स के बाद एक नया ChainMap देता है जिसमें एक नया मैप होता है। यदि m निर्दिष्ट किया गया है, तो यह मैपिंग की सूची के सामने नया नक्शा बन जाता है; यदि निर्दिष्ट नहीं किया गया है, तो एक खाली d.new_child() का उपयोग किया जाता है, ताकि d.new_child() लिए एक कॉल इसके बराबर हो: ChainMap({}, *d.maps) । इस पद्धति का उपयोग उप-शीर्षकों को बनाने के लिए किया जाता है जिन्हें किसी भी मूल मैपिंग में मानों को परिवर्तित किए बिना अपडेट किया जा सकता है।

संस्करण 3.4 में बदला गया: वैकल्पिक m पैरामीटर जोड़ा गया था।

parents

संपत्ति एक नया ChainMap जिसमें मौजूदा उदाहरण में पहले वाले को छोड़कर सभी नक्शे हैं। यह खोज में पहले मानचित्र को लंघन के लिए उपयोगी है। उपयोग किए गए मामले नेस्टेड स्कोप में उपयोग किए जाने वाले nonlocal कीवर्ड के लिए समान हैं। उपयोग के मामले अंतर्निहित super() फ़ंक्शन के लिए भी समानांतर होते हैं। d.parents का एक संदर्भ इसके बराबर है: ChainMap(*d.maps[1:])

यह भी देखें

ChainMap उदाहरण और व्यंजनों

यह खंड जंजीर नक्शों के साथ काम करने के विभिन्न तरीकों को दिखाता है।

पायथन की आंतरिक खोज श्रृंखला का अनुकरण करने का उदाहरण:

import builtins
pylookup = ChainMap(locals(), globals(), vars(builtins))

उपयोगकर्ता द्वारा निर्दिष्ट कमांड-लाइन तर्क देने का उदाहरण पर्यावरण चर पर पूर्ववर्तीता लेता है जो बदले में डिफ़ॉल्ट मानों पर पूर्वता लेता है:

import os, argparse

defaults = {'color': 'red', 'user': 'guest'}

parser = argparse.ArgumentParser()
parser.add_argument('-u', '--user')
parser.add_argument('-c', '--color')
namespace = parser.parse_args()
command_line_args = {k:v for k, v in vars(namespace).items() if v}

combined = ChainMap(command_line_args, os.environ, defaults)
print(combined['color'])
print(combined['user'])

नेस्टेड संदर्भों को अनुकरण करने के लिए ChainMap वर्ग का उपयोग करने के लिए उदाहरण पैटर्न:

c = ChainMap()        # Create root context
d = c.new_child()     # Create nested child context
e = c.new_child()     # Child of c, independent from d
e.maps[0]             # Current context dictionary -- like Python's locals()
e.maps[-1]            # Root context -- like Python's globals()
e.parents             # Enclosing context chain -- like Python's nonlocals

d['x']                # Get first key in the chain of contexts
d['x'] = 1            # Set value in current context
del d['x']            # Delete from current context
list(d)               # All nested values
k in d                # Check all nested values
len(d)                # Number of nested values
d.items()             # All nested items
dict(d)               # Flatten into a regular dictionary

ChainMap वर्ग केवल श्रृंखला में पहले मैपिंग के लिए अद्यतन (लिखता है और विलोपन) करता है जबकि लुकअप पूर्ण श्रृंखला की खोज करेंगे। हालाँकि, यदि गहरे लेखन और विलोपन वांछित हैं, तो एक उपवर्ग बनाना आसान है जो अद्यतन कुंजियों को श्रृंखला में गहरा पाया:

class DeepChainMap(ChainMap):
    'Variant of ChainMap that allows direct updates to inner scopes'

    def __setitem__(self, key, value):
        for mapping in self.maps:
            if key in mapping:
                mapping[key] = value
                return
        self.maps[0][key] = value

    def __delitem__(self, key):
        for mapping in self.maps:
            if key in mapping:
                del mapping[key]
                return
        raise KeyError(key)

>>> d = DeepChainMap({'zebra': 'black'}, {'elephant': 'blue'}, {'lion': 'yellow'})
>>> d['lion'] = 'orange'         # update an existing key two levels down
>>> d['snake'] = 'red'           # new keys get added to the topmost dict
>>> del d['elephant']            # remove an existing key one level down
>>> d                            # display result
DeepChainMap({'zebra': 'black', 'snake': 'red'}, {}, {'lion': 'orange'})

काउंटर वस्तुओं

सुविधाजनक और तेजी से लम्बाई का समर्थन करने के लिए एक काउंटर उपकरण प्रदान किया जाता है। उदाहरण के लिए:

>>> # Tally occurrences of words in a list
>>> cnt = Counter()
>>> for word in ['red', 'blue', 'red', 'green', 'blue', 'blue']:
...     cnt[word] += 1
>>> cnt
Counter({'blue': 3, 'red': 2, 'green': 1})

>>> # Find the ten most common words in Hamlet
>>> import re
>>> words = re.findall(r'\w+', open('hamlet.txt').read().lower())
>>> Counter(words).most_common(10)
[('the', 1143), ('and', 966), ('to', 762), ('of', 669), ('i', 631),
 ('you', 554),  ('a', 546), ('my', 514), ('hamlet', 471), ('in', 451)]
class collections.Counter([iterable-or-mapping])

एक Counter हैशटैटिक ऑब्जेक्ट्स की गिनती के लिए एक dict उपवर्ग है। यह एक अनियंत्रित संग्रह है जहां तत्वों को शब्दकोश कुंजियों के रूप में संग्रहीत किया जाता है और उनकी गणना को शब्दकोश मूल्यों के रूप में संग्रहीत किया जाता है। गणना को शून्य या नकारात्मक गणना सहित किसी भी पूर्णांक मान की अनुमति है। Counter क्लास अन्य भाषाओं में बैग या मल्टीसेट के समान है।

तत्वों को एक पुनरावृत्ति से गिना जाता है या दूसरे मैपिंग (या काउंटर) से आरंभ किया जाता है:

>>> c = Counter()                           # a new, empty counter
>>> c = Counter('gallahad')                 # a new counter from an iterable
>>> c = Counter({'red': 4, 'blue': 2})      # a new counter from a mapping
>>> c = Counter(cats=4, dogs=8)             # a new counter from keyword args

काउंटर ऑब्जेक्ट में एक शब्दकोश इंटरफ़ेस है, सिवाय इसके कि वे KeyError को बढ़ाने के बजाय गायब वस्तुओं के लिए एक शून्य गणना लौटाते हैं:

>>> c = Counter(['eggs', 'ham'])
>>> c['bacon']                              # count of a missing element is zero
0

किसी संख्या को शून्य पर सेट करने से काउंटर से कोई तत्व नहीं निकलता है। इसे पूरी तरह से हटाने के लिए del का उपयोग करें:

>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry

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

काउंटर ऑब्जेक्ट्स सभी शब्दकोशों के लिए उपलब्ध तीन तरीकों का समर्थन करते हैं:

elements()

इसकी गिनती के रूप में प्रत्येक बार दोहराए जाने वाले तत्वों पर एक पुनरावृत्त लौटें। तत्वों को मनमाने तरीके से वापस किया जाता है। यदि किसी तत्व की गिनती एक से कम है, तो elements() उसे अनदेखा कर देंगे।

>>> c = Counter(a=4, b=2, c=0, d=-2)
>>> sorted(c.elements())
['a', 'a', 'a', 'a', 'b', 'b']
most_common([n])

सबसे सामान्य तत्वों की सूची और सबसे आम से उनकी गिनती कम से कम पर लौटें। यदि n को छोड़ दिया गया है या None , तो most_common() काउंटर के सभी तत्वों को लौटाता है। समान गणना वाले तत्व मनमाने ढंग से दिए जाते हैं:

>>> Counter('abracadabra').most_common(3)  
[('a', 5), ('r', 2), ('b', 2)]
subtract([iterable-or-mapping])

तत्वों को एक चलने से या किसी अन्य मैपिंग (या काउंटर) से घटाया जाता है। update() तरह update() लेकिन उन्हें बदलने के बजाय मायने रखता है। इनपुट और आउटपुट दोनों शून्य या नकारात्मक हो सकते हैं।

>>> c = Counter(a=4, b=2, c=0, d=-2)
>>> d = Counter(a=1, b=2, c=3, d=4)
>>> c.subtract(d)
>>> c
Counter({'a': 3, 'b': 0, 'c': -3, 'd': -6})

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

Counter लिए दो वस्तुओं को छोड़कर सामान्य शब्दकोश विधियां उपलब्ध हैं जो काउंटरों के लिए अलग तरह से काम करती हैं।

fromkeys(iterable)

यह क्लास विधि Counter ऑब्जेक्ट्स के लिए लागू नहीं है।

update([iterable-or-mapping])

तत्वों को एक अन्य मानचित्रण (या काउंटर) से पुनरावृत्त या जोड़े जाने वाले से गिना जाता है। update() तरह update() लेकिन उन्हें बदलने के बजाय मायने रखता है। इसके अलावा, चलने योग्य तत्वों का एक अनुक्रम होने की उम्मीद है, न कि (key, value) जोड़े का एक क्रम।

Counter ऑब्जेक्ट्स के साथ काम करने के लिए सामान्य पैटर्न:

sum(c.values())                 # total of all counts
c.clear()                       # reset all counts
list(c)                         # list unique elements
set(c)                          # convert to a set
dict(c)                         # convert to a regular dictionary
c.items()                       # convert to a list of (elem, cnt) pairs
Counter(dict(list_of_pairs))    # convert from a list of (elem, cnt) pairs
c.most_common()[:-n-1:-1]       # n least common elements
+c                              # remove zero and negative counts

Counter ऑब्जेक्ट्स के संयोजन के लिए मल्टीसेट्स (शून्य से अधिक की गिनती वाले काउंटर) बनाने के लिए कई गणितीय संचालन प्रदान किए जाते हैं। जोड़ और घटाव, संबंधित तत्वों की गिनती को जोड़कर या घटाकर काउंटरों को जोड़ते हैं। प्रतिच्छेदन और संघ, न्यूनतम और अधिकतम संगत संख्याओं को लौटाता है। प्रत्येक ऑपरेशन हस्ताक्षरित गणनाओं के साथ इनपुट स्वीकार कर सकता है, लेकिन आउटपुट शून्य या उससे कम की गणना के साथ परिणामों को बाहर कर देगा।

>>> c = Counter(a=3, b=1)
>>> d = Counter(a=1, b=2)
>>> c + d                       # add two counters together:  c[x] + d[x]
Counter({'a': 4, 'b': 3})
>>> c - d                       # subtract (keeping only positive counts)
Counter({'a': 2})
>>> c & d                       # intersection:  min(c[x], d[x]) 
Counter({'a': 1, 'b': 1})
>>> c | d                       # union:  max(c[x], d[x])
Counter({'a': 3, 'b': 2})

एक खाली काउंटर जोड़ने या एक खाली काउंटर से घटाने के लिए एकरूप जोड़ और घटाव शॉर्टकट हैं।

>>> c = Counter(a=2, b=-4)
>>> +c
Counter({'a': 2})
>>> -c
Counter({'b': 4})

संस्करण 3.3 में नया: यूनीरी प्लस, यूनरी माइनस और इन-प्लेस मल्टीसेट ऑपरेशन के लिए जोड़ा गया समर्थन।

ध्यान दें

काउंटर्स को मुख्य रूप से रनिंग काउंट्स का प्रतिनिधित्व करने के लिए सकारात्मक पूर्णांक के साथ काम करने के लिए डिज़ाइन किया गया था; हालांकि, अन्य प्रकार या नकारात्मक मूल्यों की आवश्यकता वाले मामलों का अनावश्यक रूप से उपयोग न करने के लिए देखभाल की गई थी। उन उपयोग के मामलों में मदद करने के लिए, यह खंड न्यूनतम सीमा और प्रकार के प्रतिबंधों का दस्तावेजीकरण करता है।

  • Counter क्लास अपने आप में एक शब्दकोश उपवर्ग है जिसकी कुंजियों और मूल्यों पर कोई प्रतिबंध नहीं है। मानों का अर्थ संख्याओं का प्रतिनिधित्व करना है, लेकिन आप मूल्य क्षेत्र में कुछ भी संग्रहीत कर सकते हैं।
  • सबसे most_common() विधि के लिए केवल यह आवश्यक है कि मूल्य क्रमबद्ध हों।
  • इन-प्लेस ऑपरेशन्स जैसे कि c[key] += 1 , वैल्यू टाइप को केवल सपोर्ट एडिशन और घटाव की जरूरत होती है। इसलिए अंश, फ्लोट, और दशमलव काम करेंगे और नकारात्मक मूल्यों का समर्थन किया जाता है। update() और subtract() लिए भी यही सच है जो इनपुट और आउटपुट दोनों के लिए नकारात्मक और शून्य मान की अनुमति देता है।
  • मल्टीसेट विधियों को केवल सकारात्मक मान वाले मामलों के उपयोग के लिए डिज़ाइन किया गया है। इनपुट नकारात्मक या शून्य हो सकते हैं, लेकिन केवल सकारात्मक मान वाले आउटपुट बनाए जाते हैं। कोई प्रकार के प्रतिबंध नहीं हैं, लेकिन मूल्य प्रकार को इसके अलावा, घटाव और तुलना का समर्थन करने की आवश्यकता है।
  • elements() विधि में पूर्णांक गणना की आवश्यकता होती है। यह शून्य और नकारात्मक मायने रखता है।

यह भी देखें

  • स्मालटाक में बैग क्लास
  • Multisets लिए विकिपीडिया प्रविष्टि।
  • उदाहरणों के साथ C ++ मल्टीसेट्स ट्यूटोरियल।
  • मल्टीसेट्स और उनके उपयोग के मामलों पर गणितीय संचालन के लिए, नूथ, डोनाल्ड देखें। कंप्यूटर प्रोग्रामिंग वॉल्यूम II, धारा 4.6.3, व्यायाम 19
  • तत्वों के दिए गए सेट पर दिए गए आकार के सभी अलग-अलग मल्टीसमेट्स की गणना करने के लिए, itertools.combinations_with_replacement() :

    map(Counter, combinations_with_replacement('ABC', 2)) # --> AA AB AC BB BC CC
    

वस्तुओं को नष्ट करना

class collections.deque([iterable[, maxlen]])

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

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

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

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

Deque ऑब्जेक्ट्स निम्न विधियों का समर्थन करते हैं:

append(x)

डी के दाईं ओर x जोड़ें।

appendleft(x)

डी के बाईं ओर x जोड़ें।

clear()

इसे 0 से लंबाई के साथ छोड़ते हुए सभी तत्वों को हटा दें।

copy()

मृग की उथली प्रतिलिपि बनाएँ।

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

count(x)

X के बराबर deque तत्वों की संख्या गिनें।

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

extend(iterable)

पुनरावृत्त तर्क से तत्वों को जोड़कर, deque के दाईं ओर बढ़ाएं।

extendleft(iterable)

तत्वों से पुनरावृत्ति द्वारा छल के बाईं ओर बढ़ाएँ। ध्यान दें, बाईं ओर की श्रृंखला में परिणाम के तर्क में तत्वों के क्रम को उलट दिया गया है।

index(x[, start[, stop]])

एक्स में पोजीशन में (इंडेक्स शुरू होने के बाद या बाद में और इंडेक्स स्टॉप से पहले)। पहला मैच लौटाता है या नहीं मिलने पर ValueError बढ़ाता है।

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

insert(i, x)

स्थिति में x को x में सम्मिलित करें i

यदि प्रविष्टि अधिकतम सीमा से अधिक बढ़ने के लिए एक बंधे हुए कारण का कारण बनेगी , तो एक IndexError उठाया जाता है।

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

pop()

किसी तत्व को हटाकर दाईं ओर से वापस करें। यदि कोई तत्व मौजूद नहीं है, तो एक IndexError उठाता है।

popleft()

एक तत्व को हटाकर बाईं ओर से हटा दें। यदि कोई तत्व मौजूद नहीं है, तो एक IndexError उठाता है।

remove(value)

मान की पहली घटना को निकालें। यदि नहीं मिला है, तो एक ValueError उठाता है।

reverse()

इन तत्वों के स्थान को उल्टा कर दें और फिर वापस लौटें।

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

rotate(n=1)

सही करने के लिए deque n चरणों को घुमाएं। यदि एन नकारात्मक है, तो बाईं ओर घुमाएं।

जब डॉक खाली नहीं होता है, तो दाईं ओर एक कदम d.appendleft(d.pop()) बराबर होता है, और एक कदम बाईं ओर d.append(d.popleft()) बराबर होता है।

ख़राब वस्तुएं भी केवल एक ही विशेषता प्रदान करती हैं:

maxlen

एक आकार का अधिकतम आकार या यदि None

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

उपरोक्त के अलावा, देवता पुनरावृत्ति, अचार, len(d) , reversed(d) , copy.copy(d) , copy.deepcopy(d) , ऑपरेटर के साथ सदस्यता परीक्षण, और d[-1] जैसे सब्स्क्रिप्ट संदर्भों का समर्थन करते हैं। d[-1] । अनुक्रमित पहुंच O (1) दोनों सिरों पर है लेकिन बीच में O (n) तक धीमी हो जाती है। तीव्र यादृच्छिक अभिगम के लिए, इसके बजाय सूचियों का उपयोग करें।

संस्करण 3.5 में शुरू, देवताओं का समर्थन __add__() , __mul__() , और __imul__()

उदाहरण:

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

deque व्यंजनों

यह खंड देवताओं के साथ काम करने के विभिन्न तरीकों को दर्शाता है।

बंधे हुए लंबाई के देवता यूनिक्स में tail फिल्टर के समान कार्यक्षमता प्रदान करते हैं:

def tail(filename, n=10):
    'Return the last n lines of a file'
    with open(filename) as f:
        return deque(f, n)

देवताओं का उपयोग करने का एक और तरीका दाएं से जोड़कर और बाईं ओर पॉपिंग करके हाल ही में जोड़े गए तत्वों के अनुक्रम को बनाए रखना है:

def moving_average(iterable, n=3):
    # moving_average([40, 30, 50, 46, 39, 44]) --> 40.0 42.0 45.0 43.0
    # http://en.wikipedia.org/wiki/Moving_average
    it = iter(iterable)
    d = deque(itertools.islice(it, n-1))
    d.appendleft(0)
    s = sum(d)
    for elem in it:
        s += elem - d.popleft()
        d.append(elem)
        yield s / n

एक राउंड-रॉबिन शेड्यूलर को एक deque में संग्रहीत इनपुट deque साथ लागू किया जा सकता है। स्थिति शून्य में सक्रिय पुनरावृत्तिकर्ता से उपज ली जाती है। यदि वह इटरेटर समाप्त हो गया है, तो इसे popleft() साथ हटाया जा सकता है; अन्यथा, इसे rotate() साथ अंत में वापस चक्रित किया जा सकता है rotate() विधि:

def roundrobin(*iterables):
    "roundrobin('ABC', 'D', 'EF') --> A D E B F C"
    iterators = deque(map(iter, iterables))
    while iterators:
        try:
            while True:
                yield next(iterators[0])
                iterators.rotate(-1)
        except StopIteration:
            # Remove an exhausted iterator.
            iterators.popleft()

rotate() विधि से deque स्लाइसिंग और विलोपन को लागू करने का तरीका deque । उदाहरण के लिए, del d[n] का एक शुद्ध पायथन कार्यान्वयन rotate() लिए तत्वों को बदलने के लिए rotate() विधि पर निर्भर करता है:

def delete_nth(d, n):
    d.rotate(-n)
    d.popleft()
    d.rotate(n)

deque स्लाइसिंग को लागू करने के लिए, एक समान दृष्टिकोण का उपयोग करके rotate() एक लक्ष्य तत्व को डेक्स के बाईं ओर लाने के लिए उपयोग करें। popleft() साथ पुरानी प्रविष्टियाँ निकालें popleft() , extend() साथ नई प्रविष्टियाँ जोड़ें extend() , और फिर घुमाव को उल्टा करें। उस दृष्टिकोण पर मामूली बदलाव के साथ, फोर्थ स्टाइल स्टैक जोड़तोड़ को लागू करना आसान है जैसे कि dup , drop , swap , over , pick , rot और roll

डिफ़ॉल्ट ऑब्जेक्ट्स

class collections.defaultdict([default_factory[, ...]])

एक नया शब्दकोश जैसी वस्तु लौटाता है। defaultdict बिल्ट-इन defaultdict वर्ग का एक उपवर्ग है। यह एक विधि को ओवरराइड करता है और एक लिखने योग्य उदाहरण चर जोड़ता है। शेष कार्यक्षमता dict वर्ग के लिए समान है और यहां प्रलेखित नहीं है।

पहला तर्क default_factory विशेषता के लिए प्रारंभिक मूल्य प्रदान करता है; यह None को None चूकता है। शेष सभी तर्कों को उसी तरह से माना जाता है जैसे कि उन्हें कीवर्ड तर्क सहित dict पास भेजा गया था।

defaultdict मानक मानक संचालन के अलावा निम्नलिखित विधि का समर्थन करते हैं:

__missing__(key)

यदि default_factory विशेषता None , तो यह KeyError अपवाद को तर्क के रूप में कुंजी के साथ उठाता है।

यदि default_factory कोई None , तो यह दिए गए कुंजी के लिए एक डिफ़ॉल्ट मान प्रदान करने के लिए तर्कों के बिना कहा जाता है, यह मान कुंजी के लिए शब्दकोश में डाला जाता है, और वापस आ जाता है।

यदि कॉलिंग default_factory एक अपवाद उठाता है तो यह अपवाद अपरिवर्तित है।

अनुरोधित कुंजी नहीं मिलने पर यह विधि __getitem__() वर्ग की विधि __getitem__() है; जो भी लौटता है या उठाता है उसे __getitem__() द्वारा लौटाया या उठाया जाता है।

ध्यान दें कि __missing__() अलावा किसी भी संचालन के लिए नहीं कहा जाता है। इसका अर्थ है कि सामान्य डिक्शनरी की तरह get() विल, डिफ़ॉल्ट_फैक्ट का उपयोग करने के बजाय डिफ़ॉल्ट के रूप में None लौटाता है।

defaultdict ऑब्जेक्ट निम्नलिखित उदाहरण चर का समर्थन करते हैं:

default_factory

इस विशेषता का उपयोग __missing__() विधि द्वारा किया जाता है; यह अनुपस्थित होने पर, पहले तर्क से निर्माणकर्ता के लिए, यदि मौजूद हो या None , से आरंभ किया जाता है।

defaultdict उदाहरण

default_factory रूप में list का उपयोग करना, सूचियों के शब्दकोश में कुंजी-मूल्य जोड़े के अनुक्रम को समूहित करना आसान है:

>>> s = [('yellow', 1), ('blue', 2), ('yellow', 3), ('blue', 4), ('red', 1)]
>>> d = defaultdict(list)
>>> for k, v in s:
...     d[k].append(v)
...
>>> sorted(d.items())
[('blue', [2, 4]), ('red', [1]), ('yellow', [1, 3])]

जब प्रत्येक कुंजी पहली बार सामने आती है, तो यह पहले से ही मैपिंग में नहीं है; इसलिए एक प्रविष्टि स्वतः ही default_factory फ़ंक्शन का उपयोग करके बनाई जाती है जो एक खाली list list.append() ऑपरेशन तब नई सूची के लिए मान संलग्न करता है। जब चाबियाँ फिर से सामने आती हैं, तो लुक-अप सामान्य रूप से आगे बढ़ता है (उस कुंजी की सूची लौटाता है) और list.append() ऑपरेशन सूची में एक और मूल्य जोड़ता है। यह तकनीक dict.setdefault() का उपयोग करके समतुल्य तकनीक की तुलना में सरल और तेज है:

>>> d = {}
>>> for k, v in s:
...     d.setdefault(k, []).append(v)
...
>>> sorted(d.items())
[('blue', [2, 4]), ('red', [1]), ('yellow', [1, 3])]

defaultdict को int सेट करना defaultdict को गिनती के लिए उपयोगी बनाता है (जैसे अन्य भाषाओं में बैग या मल्टीसेट):

>>> s = 'mississippi'
>>> d = defaultdict(int)
>>> for k in s:
...     d[k] += 1
...
>>> sorted(d.items())
[('i', 4), ('m', 1), ('p', 2), ('s', 4)]

जब कोई पत्र पहली बार सामने आता है, तो वह मैपिंग से गायब होता है, इसलिए default_factory फंक्शन int को शून्य की डिफ़ॉल्ट संख्या की आपूर्ति करने के लिए कहता है। इंक्रीमेंट ऑपरेशन फिर प्रत्येक अक्षर के लिए गिनती बनाता है।

फ़ंक्शन int जो हमेशा शून्य देता है, निरंतर कार्यों का एक विशेष मामला है। निरंतर कार्यों को बनाने का एक तेज़ और अधिक लचीला तरीका एक लंबो फ़ंक्शन का उपयोग करना है जो किसी भी निरंतर मूल्य (न केवल शून्य) की आपूर्ति कर सकता है:

>>> def constant_factory(value):
...     return lambda: value
>>> d = defaultdict(constant_factory('<missing>'))
>>> d.update(name='John', action='ran')
>>> '%(name)s %(action)s to %(object)s' % d
'John ran to <missing>'

सेट करने के लिए default_factory set करना defaultdict को सेट का शब्दकोश बनाने के लिए उपयोगी बनाता है:

>>> s = [('red', 1), ('blue', 2), ('red', 3), ('blue', 4), ('red', 1), ('blue', 4)]
>>> d = defaultdict(set)
>>> for k, v in s:
...     d[k].add(v)
...
>>> sorted(d.items())
[('blue', {2, 4}), ('red', {1, 3})]

नामित फ़ील्ड () नामांकित फ़ील्ड के साथ टुपल्स के लिए फ़ैक्टरी फ़ंक्शन

नामित ट्यूपल्स एक टपल में प्रत्येक स्थिति को अर्थ प्रदान करते हैं और अधिक पठनीय, स्व-दस्तावेजीकरण कोड के लिए अनुमति देते हैं। जहाँ भी नियमित रूप से ट्यूपल्स का उपयोग किया जाता है, उनका उपयोग किया जा सकता है, और वे स्थिति सूचकांक के बजाय नाम से खेतों तक पहुंचने की क्षमता जोड़ते हैं।

collections.namedtuple(typename, field_names, *, rename=False, defaults=None, module=None)

एक नया tuple उपवर्ग नाम टाइपनाम लौटाता है । नए उपवर्ग का उपयोग टपल-जैसी वस्तुओं को बनाने के लिए किया जाता है, जिसमें विशेषता लुकअप के साथ-साथ अनुक्रमित और पुनरावृत्त होने के साथ फ़ील्ड सुलभ होते हैं। उपवर्ग के उदाहरणों में सहायक डॉकस्ट्रिंग (टाइपनाम और फ़ील्ड_नाम के साथ) और एक सहायक __repr__() विधि है जो एक name=value प्रारूप में टपल सामग्री को सूचीबद्ध करती है।

Field_names स्ट्रिंग्स का एक क्रम है जैसे ['x', 'y'] । वैकल्पिक रूप से, field_names व्हॉट्सएप और / या अल्पविराम द्वारा अलग किए गए प्रत्येक फ़ील्डनाम के साथ एक एकल स्ट्रिंग हो सकता है, उदाहरण के लिए 'x y' या 'x, y'

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

यदि नाम सही है, तो अमान्य फ़ील्ड को स्वचालित रूप से स्थितीय नामों से बदल दिया जाता है। उदाहरण के लिए, ['abc', 'def', 'ghi', 'abc'] example ['abc', 'def', 'ghi', 'abc'] को and duplicate abc ['abc', '_1', 'ghi', '_3'] , जिससे कीवर्ड डिफ और डुप्लिकेट नाम का abc समाप्त हो जाता है ।

डिफॉल्ट None हो सकता है या डिफ़ॉल्ट मानों का iterable None हो सकता। चूंकि डिफ़ॉल्ट मान वाले फ़ील्ड को डिफ़ॉल्ट के बिना किसी भी फ़ील्ड के बाद आना चाहिए, चूक को सबसे सही मापदंडों पर लागू किया जाता है। उदाहरण के लिए, यदि फ़ील्डनाम ['x', 'y', 'z'] और चूक हैं (1, 2) , तो x एक आवश्यक तर्क होगा, y 1 डिफ़ॉल्ट होगा, और z 2 डिफ़ॉल्ट होगा ।

यदि मॉड्यूल को परिभाषित किया गया है, तो नाम के टपल का __module__ गुण उस मान पर सेट है।

नामित टुपल उदाहरणों में प्रति-इंस्टेंस शब्दकोष नहीं होते हैं, इसलिए वे हल्के होते हैं और नियमित रूप से ट्यूपल्स की तुलना में अधिक मेमोरी की आवश्यकता नहीं होती है।

संस्करण 3.1 में बदला: नाम बदलने के लिए जोड़ा गया समर्थन।

संस्करण 3.6 में परिवर्तित: क्रिया और नाम का पैरामीटर कीवर्ड-केवल तर्क बन गए।

संस्करण 3.6 में परिवर्तित: मॉड्यूल पैरामीटर जोड़ा गया।

संस्करण 3.7 में परिवर्तित: _source पैरामीटर और _source विशेषता निकालें।

संस्करण 3.7 में परिवर्तित: चूक पैरामीटर और _field_defaults विशेषता को जोड़ा गया।

>>> # Basic example
>>> Point = namedtuple('Point', ['x', 'y'])
>>> p = Point(11, y=22)     # instantiate with positional or keyword arguments
>>> p[0] + p[1]             # indexable like the plain tuple (11, 22)
33
>>> x, y = p                # unpack like a regular tuple
>>> x, y
(11, 22)
>>> p.x + p.y               # fields also accessible by name
33
>>> p                       # readable __repr__ with a name=value style
Point(x=11, y=22)

नामांकित tuples विशेष रूप से csv या sqlite3 मॉड्यूल द्वारा दिए गए tuples परिणाम के लिए फ़ील्ड नाम निर्दिष्ट करने के लिए उपयोगी होते हैं:

EmployeeRecord = namedtuple('EmployeeRecord', 'name, age, title, department, paygrade')

import csv
for emp in map(EmployeeRecord._make, csv.reader(open("employees.csv", "rb"))):
    print(emp.name, emp.title)

import sqlite3
conn = sqlite3.connect('/companydata')
cursor = conn.cursor()
cursor.execute('SELECT name, age, title, department, paygrade FROM employees')
for emp in map(EmployeeRecord._make, cursor.fetchall()):
    print(emp.name, emp.title)

Tuples से विरासत में मिली विधियों के अलावा, tuples नाम तीन अतिरिक्त विधियों और दो विशेषताओं का समर्थन करता है। फ़ील्ड नामों के साथ टकराव को रोकने के लिए, विधि और विशेषता नाम अंडरस्कोर से शुरू होते हैं।

classmethod somenamedtuple._make(iterable)

क्लास विधि जो एक मौजूदा अनुक्रम या चलने योग्य से एक नया उदाहरण बनाती है।

>>> t = [11, 22]
>>> Point._make(t)
Point(x=11, y=22)
somenamedtuple._asdict()

एक नया OrderedDict लौटें, जो फ़ील्ड नामों को उनके संबंधित मानों में मैप करता है:

>>> p = Point(x=11, y=22)
>>> p._asdict()
OrderedDict([('x', 11), ('y', 22)])

संस्करण 3.1 में बदला गया: एक नियमित रूप से OrderedDict बजाय एक OrderedDict

somenamedtuple._replace(**kwargs)

नए क्षेत्रों के साथ निर्दिष्ट फ़ील्ड्स की जगह नामित टपल का नया उदाहरण लौटाएँ:

>>> p = Point(x=11, y=22)
>>> p._replace(x=33)
Point(x=33, y=22)

>>> for partnum, record in inventory.items():
...     inventory[partnum] = record._replace(price=newprices[partnum], timestamp=time.now())
somenamedtuple._fields

क्षेत्र के नामों को सूचीबद्ध करने वाले तारों का टपल। आत्मनिरीक्षण के लिए उपयोगी और मौजूदा नामित ट्यूपल से नए नामित टपल प्रकार बनाने के लिए।

>>> p._fields            # view the field names
('x', 'y')

>>> Color = namedtuple('Color', 'red green blue')
>>> Pixel = namedtuple('Pixel', Point._fields + Color._fields)
>>> Pixel(11, 22, 128, 255, 0)
Pixel(x=11, y=22, red=128, green=255, blue=0)
somenamedtuple._fields_defaults

डिफॉल्ट मैपिंग के लिए फील्ड मैपिंग नाम।

>>> Account = namedtuple('Account', ['type', 'balance'], defaults=[0])
>>> Account._fields_defaults
{'balance': 0}
>>> Account('premium')
Account(type='premium', balance=0)

एक फ़ील्ड जिसका नाम स्ट्रिंग में संग्रहीत है, को पुनः प्राप्त करने के लिए, getattr() फ़ंक्शन का उपयोग करें:

>>> getattr(p, 'x')
11

किसी नामांकित को डिक्शनरी में परिवर्तित करने के लिए, डबल-स्टार-ऑपरेटर का उपयोग करें (जैसा कि अनप्लग आर्ग्यूमेंट लिस्ट में वर्णित है):

>>> d = {'x': 11, 'y': 22}
>>> Point(**d)
Point(x=11, y=22)

चूंकि नामित टपल एक नियमित पायथन वर्ग है, इसलिए उपवर्ग के साथ कार्यक्षमता जोड़ना या बदलना आसान है। यहां बताया गया है कि परिकलित फ़ील्ड और निश्चित-चौड़ाई प्रिंट प्रारूप कैसे जोड़ा जाए:

>>> class Point(namedtuple('Point', ['x', 'y'])):
...     __slots__ = ()
...     @property
...     def hypot(self):
...         return (self.x ** 2 + self.y ** 2) ** 0.5
...     def __str__(self):
...         return 'Point: x=%6.3f  y=%6.3f  hypot=%6.3f' % (self.x, self.y, self.hypot)

>>> for p in Point(3, 4), Point(14, 5/7):
...     print(p)
Point: x= 3.000  y= 4.000  hypot= 5.000
Point: x=14.000  y= 0.714  hypot=14.018

ऊपर दिखाया गया उपवर्ग एक खाली __slots__ को __slots__ सेट करता है। यह उदाहरण शब्दकोशों के निर्माण को रोककर स्मृति की आवश्यकताओं को कम रखने में मदद करता है।

नए, संग्रहीत फ़ील्ड को जोड़ने के लिए उपवर्ग उपयोगी नहीं है। इसके बजाय, केवल _fields विशेषता से एक नया नाम टाइप करें _fields :

>>> Point3D = namedtuple('Point3D', Point._fields + ('z',))

Docstrings को __doc__ फ़ील्ड में सीधे असाइनमेंट बनाकर अनुकूलित किया जा सकता है:

>>> Book = namedtuple('Book', ['id', 'title', 'authors'])
>>> Book.__doc__ += ': Hardcover book in active collection'
>>> Book.id.__doc__ = '13-digit ISBN'
>>> Book.title.__doc__ = 'Title of first printing'
>>> Book.authors.__doc__ = 'List of authors sorted by last name'

संस्करण 3.5 में परिवर्तित: संपत्ति डॉकस्ट्रिंग्स लेखन योग्य बन गए।

प्रोटोटाइप उदाहरण को अनुकूलित करने के लिए _replace() का उपयोग करके डिफ़ॉल्ट मानों को लागू किया जा सकता है:

>>> Account = namedtuple('Account', 'owner balance transaction_count')
>>> default_account = Account('<owner name>', 0.0, 0)
>>> johns_account = default_account._replace(owner='John')
>>> janes_account = default_account._replace(owner='Jane')

यह भी देखें

  • जनवरी Kaliszewski द्वारा मेटाक्लस मिक्स-इन के साथ टपल एब्लेस बेस क्लास नाम की रेसिपी। टुपल्स के लिए एक सार आधार वर्ग प्रदान करने के अलावा , यह एक वैकल्पिक metaclass आधारित निर्माणकर्ता का भी समर्थन करता है जो उपयोग के मामलों के लिए सुविधाजनक है जहां टुपल्स को उपवर्गित किया जा रहा है।
  • types.SimpleNamespace() टपल के बजाय एक अंतर्निहित शब्दकोश के आधार पर एक उत्परिवर्ती नाम स्थान के लिए देखें ।
  • typing.NamedTuple() टुपल्स के लिए टाइप संकेत जोड़ने का एक तरीका देखें ।

आदेशित वस्तुएं

ऑर्डर किए गए शब्दकोश नियमित शब्दकोश की तरह हैं, लेकिन वे उस आदेश को याद करते हैं जो आइटम सम्मिलित किए गए थे। जब एक आदेशित शब्दकोश में पुनरावृत्ति होती है, तो आइटम को उसी क्रम में लौटाया जाता है, जब उनकी चाबियाँ पहले जोड़ी जाती थीं।

class collections.OrderedDict([items])

सामान्य dict विधियों का समर्थन करते हुए, एक स्पष्ट उपवर्ग का एक उदाहरण लौटाएं । ऑर्डरडीडक्ट एक ऐसा आदेश है जो कि उस आदेश को याद करता है जिसे पहले चाबियाँ डाली गई थीं। यदि कोई नया प्रविष्टि मौजूदा प्रविष्टि को अधिलेखित करता है, तो मूल प्रविष्टि स्थिति अपरिवर्तित रह जाती है। एक प्रविष्टि को हटाना और इसे पुन: स्थापित करना इसे अंत तक ले जाएगा।

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

popitem(last=True)

popitem() आदेश दिया शब्दकोशों रिटर्न के लिए विधि और एक (कुंजी, मूल्य) जोड़ी को हटा। जोड़े में लौटा दिए जाते हैं LIFO आदेश अगर पिछले सच है या है फीफो आदेश अगर गलत।

move_to_end(key, last=True)

एक आदेशित शब्दकोश के किसी भी छोर पर एक मौजूदा कुंजी ले जाएँ । आइटम सही अंत में ले जाया करता है, तो है पिछले सच (डिफ़ॉल्ट) या शुरुआत करने के लिए है अगर पिछले गलत है। KeyError यदि कुंजी मौजूद नहीं है , तो उठाता है:

>>> d = OrderedDict.fromkeys('abcde')
>>> d.move_to_end('b')
>>> ''.join(d.keys())
'acdeb'
>>> d.move_to_end('b', last=False)
>>> ''.join(d.keys())
'bacde'

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

सामान्य मानचित्रण विधियों के अलावा, आदेश दिए गए शब्दकोशों का उपयोग करके रिवर्स पुनरावृत्ति का भी समर्थन करते हैं reversed()

OrderedDict वस्तुओं के बीच समानता परीक्षण आदेश-संवेदनशील होते हैं और इन्हें लागू किया जाता है list(od1.items())==list(od2.items()) OrderedDict वस्तुओं और अन्य Mapping वस्तुओं के बीच समानता परीक्षण नियमित शब्दकोश की तरह आदेश-असंवेदनशील हैं। यह OrderedDict वस्तुओं को एक नियमित शब्दकोश का उपयोग करने के लिए कहीं भी प्रतिस्थापित करने की अनुमति देता है।

संस्करण 3.5 में परिवर्तित: अब उपयोग की जाने वाली वस्तुओं, कुंजियों और मूल्यों के views का OrderedDict उल्टा चलना इसका समर्थन करता है reversed()

संस्करण 3.6 में परिवर्तित: PEP 468 की स्वीकृति के साथ , ऑर्डर को OrderedDict कंस्ट्रक्टर और उसकी update() विधि को दिए गए कीवर्ड तर्कों के लिए बरकरार रखा गया है ।

OrderedDict उदाहरण और व्यंजनों

चूंकि एक आदेश दिया गया शब्दकोश इसके सम्मिलन क्रम को याद रखता है, इसलिए इसे क्रमबद्ध शब्दकोश बनाने के लिए छँटाई के साथ संयोजन में उपयोग किया जा सकता है:

>>> # regular unsorted dictionary
>>> d = {'banana': 3, 'apple': 4, 'pear': 1, 'orange': 2}

>>> # dictionary sorted by key
>>> OrderedDict(sorted(d.items(), key=lambda t: t[0]))
OrderedDict([('apple', 4), ('banana', 3), ('orange', 2), ('pear', 1)])

>>> # dictionary sorted by value
>>> OrderedDict(sorted(d.items(), key=lambda t: t[1]))
OrderedDict([('pear', 1), ('orange', 2), ('banana', 3), ('apple', 4)])

>>> # dictionary sorted by length of the key string
>>> OrderedDict(sorted(d.items(), key=lambda t: len(t[0])))
OrderedDict([('pear', 1), ('apple', 4), ('orange', 2), ('banana', 3)])

प्रविष्टियों को हटाए जाने पर नए सॉर्ट किए गए शब्दकोशों अपने क्रम को बनाए रखते हैं। लेकिन जब नई चाबियाँ जोड़ी जाती हैं, तो कुंजियों को अंत तक जोड़ दिया जाता है और सॉर्ट नहीं किया जाता है।

यह एक आदेशित शब्दकोश संस्करण बनाने के लिए भी सीधे-आगे है जो कि उस आदेश को याद करता है जिसे कुंजियाँ अंतिम रूप से सम्मिलित की गई थीं । यदि कोई नई प्रविष्टि किसी मौजूदा प्रविष्टि को अधिलेखित करती है, तो मूल प्रविष्टि स्थिति बदल जाती है और अंत में चली जाती है:

class LastUpdatedOrderedDict(OrderedDict):
    'Store items in the order the keys were last added'

    def __setitem__(self, key, value):
        if key in self:
            del self[key]
        OrderedDict.__setitem__(self, key, value)

एक आदेशित शब्दकोश को Counter वर्ग के साथ जोड़ा जा सकता है ताकि काउंटर को याद रहे कि आदेश तत्वों को पहले सामना किया गया है:

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),)

उपयोगकर्ता ऑब्जेक्ट्स

कक्षा, UserDict शब्दकोश वस्तुओं के आसपास एक आवरण के रूप में कार्य करती है। इस वर्ग की आवश्यकता को आंशिक रूप से सीधे उपवर्ग की क्षमता द्वारा दबा दिया गया है dict ; हालाँकि, इस वर्ग के साथ काम करना आसान हो सकता है क्योंकि अंतर्निहित शब्दकोश एक विशेषता के रूप में सुलभ है।

class collections.UserDict([initialdata])

एक शब्दकोश का अनुकरण करने वाला वर्ग। उदाहरण की सामग्री को एक नियमित शब्दकोश में रखा जाता है, जो उदाहरणों की data विशेषता के माध्यम से सुलभ है UserDict । यदि इनिशियलडाटा प्रदान किया जाता है, data तो इसकी सामग्री के साथ इनिशियलाइज़ किया जाता है; ध्यान दें कि आरंभिकता का एक संदर्भ नहीं रखा जाएगा, जिससे इसे अन्य उद्देश्यों के लिए उपयोग किया जा सके।

मैपिंग के तरीकों और संचालन का समर्थन करने के अलावा, UserDict उदाहरण निम्नलिखित विशेषता प्रदान करते हैं:

data

एक वास्तविक शब्दकोश UserDict कक्षा की सामग्री को संग्रहीत करता था ।

उपयोगकर्तासूची ऑब्जेक्ट्स

यह वर्ग सूची ऑब्जेक्ट के आसपास एक आवरण के रूप में कार्य करता है। यह आपकी स्वयं की सूची-जैसी कक्षाओं के लिए एक उपयोगी आधार वर्ग है जो उनसे विरासत में मिली है और मौजूदा तरीकों को ओवरराइड कर सकती है या नए जोड़ सकती है। इस तरह, कोई सूची में नए व्यवहार जोड़ सकता है।

इस वर्ग की आवश्यकता को आंशिक रूप से सीधे उपवर्ग की क्षमता द्वारा दबा दिया गया है list ; हालाँकि, इस वर्ग के साथ काम करना आसान हो सकता है क्योंकि अंतर्निहित सूची एक विशेषता के रूप में सुलभ है।

class collections.UserList([list])

वह वर्ग जो किसी सूची का अनुकरण करता है। उदाहरण की सामग्री को एक नियमित सूची में रखा जाता है, जो उदाहरणों की data विशेषता के माध्यम से सुलभ है UserList । उदाहरण की सामग्री शुरू में सूची की एक प्रति के लिए निर्धारित की जाती है , खाली सूची के लिए डिफ़ॉल्ट [] सूची किसी भी चलने योग्य हो सकती है, उदाहरण के लिए एक वास्तविक पायथन सूची या UserList वस्तु।

परिवर्तनशील अनुक्रमों के तरीकों और संचालन का समर्थन करने के अलावा, UserList उदाहरण निम्नलिखित विशेषता प्रदान करते हैं:

data

एक वास्तविक list वस्तु UserList वर्ग की सामग्री को संग्रहीत करने के लिए उपयोग किया जाता है ।

उपवर्ग की आवश्यकताएं: UserList एक निर्माणकर्ता की पेशकश करने के लिए उपवर्गों की अपेक्षा की जाती है जिसे या तो कोई तर्क या एक तर्क के साथ कहा जा सकता है। सूची संचालन जो वास्तविक कार्यान्वयन वर्ग का एक उदाहरण बनाने के लिए एक नया अनुक्रम प्रयास लौटाते हैं। ऐसा करने के लिए, यह मानता है कि निर्माणकर्ता को एक एकल पैरामीटर के साथ बुलाया जा सकता है, जो कि डेटा स्रोत के रूप में उपयोग किया जाने वाला अनुक्रम ऑब्जेक्ट है।

यदि एक व्युत्पन्न वर्ग इस आवश्यकता का पालन नहीं करना चाहता है, तो इस वर्ग द्वारा समर्थित सभी विशेष विधियों को ओवरराइड करने की आवश्यकता होगी; कृपया उन मामलों के बारे में जानकारी के लिए स्रोतों से परामर्श करें जिन्हें उस मामले में प्रदान करने की आवश्यकता है।

UserString ऑब्जेक्ट

वर्ग, UserString स्ट्रिंग ऑब्जेक्ट्स के चारों ओर एक आवरण के रूप में कार्य करता है। इस वर्ग की आवश्यकता को आंशिक रूप से सीधे उपवर्ग की क्षमता द्वारा दबा दिया गया है str ; हालाँकि, इस वर्ग के साथ काम करना आसान हो सकता है क्योंकि अंतर्निहित स्ट्रिंग एक विशेषता के रूप में सुलभ है।

class collections.UserString(seq)

क्लास जो एक स्ट्रिंग ऑब्जेक्ट का अनुकरण करती है। उदाहरण की सामग्री को नियमित स्ट्रिंग ऑब्जेक्ट में रखा जाता है, जो इंस्टेंस की data विशेषता के माध्यम से सुलभ है UserString । उदाहरण की सामग्री शुरू में seq की एक प्रति में सेट की गई है । Seq तर्क किसी भी वस्तु जो एक तार में निर्मित का उपयोग कर में बदला जा सकता हो सकता है str कार्य करते हैं।

स्ट्रिंग के तरीकों और संचालन का समर्थन करने के अलावा, UserString उदाहरण निम्नलिखित विशेषता प्रदान करते हैं:

data

एक वास्तविक str वस्तु UserString वर्ग की सामग्री को संग्रहीत करने के लिए उपयोग किया जाता है ।

संस्करण 3.5 में परिवर्तित: नए तरीकों __getnewargs__ , __rmod__ , casefold , format_map , isprintable , और maketrans

Original text