पायथन में देवताओं को कैसे लागू किया जाता है, और वे सूचियों से भी बदतर कब हैं?

Question 1

मैंने हाल ही में जांच में पाया है कि मेरे कोड को अधिक कुशल बनाने के लिए पायथन में विभिन्न डेटा संरचनाएं कैसे कार्यान्वित की जाती हैं। यह जांचने के लिए कि सूचियां और देवता कैसे काम करते हैं, मैंने पाया कि जब मैं शिफ्ट करना चाहता हूं और ओ (एन) से सूचियों में हे (1) के लिए देवताओं में सूचियों को कम करना चाहता हूं तो लाभ प्राप्त कर सकते हैं (सूचियों को निर्धारित लंबाई सरणियों के रूप में लागू किया जा रहा है) पूरी तरह से नकल करने के लिए हर बार कुछ सामने की तरफ डाला जाता है, आदि ...)। मैं यह नहीं जान सकता कि एक डॉक कैसे लागू किया जाता है, और इसकी डाउनसाइड्स बनाम सूचियों की बारीकियों की बारीकियां हैं। क्या कोई मुझे इन दो सवालों पर बता सकता है?

Question 2

https://github.com/python/cpython/blob/v3.8.1/Modules/_collectionsmodule.c

ए नोड्स dequeobjectकी दोहरी-लिंक की गई सूची से बना है block।

तो हां, एक dequeउत्तर के रूप में एक (दोगुना) लिंक्ड सूची है जो एक अन्य उत्तर का सुझाव देता है।

विस्तृत करना: इसका मतलब यह है कि रद्दीकरण सहित यादृच्छिक-अभिगम और निश्चित लंबाई के संचालन के लिए पायथन सूचियां बहुत बेहतर हैं, जबकि अनुक्रमणिका के साथ चीजों को धकेलने और बंद करने के लिए देवता बहुत अधिक उपयोगी हैं, लेकिन अनुक्रमण (लेकिन स्लाइसिंग, दिलचस्प रूप से नहीं) किया जा रहा है। सूचियों की तुलना में संभव लेकिन धीमा।

Question 3

जांच करें collections.deque। डॉक्स से:

प्रत्येक पक्ष में लगभग एक ही O (1) प्रदर्शन के साथ, Deque का समर्थन थ्रेड-सेफ, मेमोरी कुशल एपेंड और पॉप के दोनों ओर से होता है।

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

जैसा कि यह कहता है, पॉप (0) या इंसर्ट (0, v) का उपयोग करते हुए सूची वस्तुओं के साथ बड़े दंड का उपयोग करते हैं। आप एक पर स्लाइस / इंडेक्स ऑपरेशंस का उपयोग नहीं dequeकर सकते हैं, लेकिन आप उपयोग कर सकते हैं popleft/ appendleft, जो ऑपरेशन के dequeलिए अनुकूलित है। यहाँ यह प्रदर्शित करने के लिए एक सरल बेंचमार्क है:

import time
from collections import deque

num = 100000

def append(c):
    for i in range(num):
        c.append(i)

def appendleft(c):
    if isinstance(c, deque):
        for i in range(num):
            c.appendleft(i)
    else:
        for i in range(num):
            c.insert(0, i)
def pop(c):
    for i in range(num):
        c.pop()

def popleft(c):
    if isinstance(c, deque):
        for i in range(num):
            c.popleft()
    else:
        for i in range(num):
            c.pop(0)

for container in [deque, list]:
    for operation in [append, appendleft, pop, popleft]:
        c = container(range(num))
        start = time.time()
        operation(c)
        elapsed = time.time() - start
        print "Completed %s/%s in %.2f seconds: %.1f ops/sec" % (container.__name__, operation.__name__, elapsed, num / elapsed)

मेरी मशीन पर परिणाम:

Completed deque/append in 0.02 seconds: 5582877.2 ops/sec
Completed deque/appendleft in 0.02 seconds: 6406549.7 ops/sec
Completed deque/pop in 0.01 seconds: 7146417.7 ops/sec
Completed deque/popleft in 0.01 seconds: 7271174.0 ops/sec
Completed list/append in 0.01 seconds: 6761407.6 ops/sec
Completed list/appendleft in 16.55 seconds: 6042.7 ops/sec
Completed list/pop in 0.02 seconds: 4394057.9 ops/sec
Completed list/popleft in 3.23 seconds: 30983.3 ops/sec

Question 4

dequeवस्तुओं के लिए प्रलेखन प्रविष्टि में से अधिकांश को आप जो जानना चाहते हैं, मुझे संदेह है। उल्लेखनीय उद्धरण:

प्रत्येक पक्ष में लगभग एक ही O (1) प्रदर्शन के साथ, Deque का समर्थन थ्रेड-सेफ, मेमोरी कुशल एपेंड और पॉप के दोनों ओर से होता है।

परंतु...

अनुक्रमित पहुंच O (1) दोनों सिरों पर है लेकिन बीच में O (n) तक धीमी हो जाती है। तीव्र यादृच्छिक अभिगम के लिए, इसके बजाय सूचियों का उपयोग करें।

मुझे यह बताने के लिए स्रोत पर एक नज़र डालनी होगी कि क्या कार्यान्वयन एक लिंक की गई सूची है या कुछ और, लेकिन यह मुझे लगता है जैसे कि dequeएक दोहरी-लिंक की गई सूची के रूप में लगभग समान विशेषताएं हैं।

Question 5

अन्य सभी उपयोगी उत्तरों के अलावा, यहां पायथन सूचियों, देवताओं, सेटों और शब्दकोशों पर विभिन्न कार्यों के समय की जटिलता (बिग-ओह) की तुलना में कुछ और जानकारी दी गई है। इससे किसी विशेष समस्या के लिए सही डेटा संरचना का चयन करने में मदद मिलेगी।

Question 6

हालांकि, मुझे बिल्कुल यकीन नहीं है कि पायथन ने इसे कैसे लागू किया है, यहां मैंने केवल सरणियों का उपयोग करके क्युओं का कार्यान्वयन लिखा है। इसमें पाइथन की क्यू के समान जटिलता है।

class ArrayQueue:
""" Implements a queue data structure """

def __init__(self, capacity):
    """ Initialize the queue """

    self.data = [None] * capacity
    self.size = 0
    self.front = 0

def __len__(self):
    """ return the length of the queue """

    return self.size

def isEmpty(self):
    """ return True if the queue is Empty """

    return self.data == 0

def printQueue(self):
    """ Prints the queue """

    print self.data 

def first(self):
    """ Return the first element of the queue """

    if self.isEmpty():
        raise Empty("Queue is empty")
    else:
        return self.data[0]

def enqueue(self, e):
    """ Enqueues the element e in the queue """

    if self.size == len(self.data):
        self.resize(2 * len(self.data))
    avail = (self.front + self.size) % len(self.data) 
    self.data[avail] = e
    self.size += 1

def resize(self, num):
    """ Resize the queue """

    old = self.data
    self.data = [None] * num
    walk = self.front
    for k in range(self.size):
        self.data[k] = old[walk]
        walk = (1+walk)%len(old)
    self.front = 0

def dequeue(self):
    """ Removes and returns an element from the queue """

    if self.isEmpty():
        raise Empty("Queue is empty")
    answer = self.data[self.front]
    self.data[self.front] = None 
    self.front = (self.front + 1) % len(self.data)
    self.size -= 1
    return answer

class Empty(Exception):
""" Implements a new exception to be used when stacks are empty """

pass

और यहाँ आप कुछ कोड के साथ इसका परीक्षण कर सकते हैं:

def main():
""" Tests the queue """ 

Q = ArrayQueue(5)
for i in range(10):
    Q.enqueue(i)
Q.printQueue()    
for i in range(10):
    Q.dequeue()
Q.printQueue()    


if __name__ == '__main__':
    main()

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