Deque In Python – Tutorial med eksempler

Hvis du er en Python-udvikler, har du sandsynligvis hørt om en deque eller "dobbelt-endet kø." Det er et kraftfuldt værktøj, der kan øge din applikations effektivitet og fremskynde dens ydeevne.

En deque er en specialiseret containerdatatype, der giver hurtigere tilføjelse og pop-operationer fra begge ender af containeren. Dette gør det til et værdifuldt værktøj til implementering af køer og stakke, som er almindelige listelignende datatyper i computere.

Det er en meget optimeret datastruktur på lavt niveau, der er meget nyttig til en række forskellige applikationer. Som Python-programmør er en deque et værktøj, som du vil have i dit arsenal.

Fortsæt med at læse for at lære mere om Deques, og hvordan du kan implementere dem i din !

Indholdsfortegnelse

• Hvad er en Deque?
  • Funktioner i A Python Deque
  • Anvendelser af A Deque
• Sådan oprettes og initialiseres en Deque
  • Brug af deque()-funktionen
  • Initialisering af en Deque med elementer
• Sådan udføres almindelige deque-operationer
  • Tilføjelse af elementer til en Deque
  • Tilføjelse af flere dataelementer til en Deque
  • Fjernelse af elementer fra en Deque
  • Fjernelse af alle elementer fra en Deque
  • Adgang til elementer i en Deque
  • Ændring af elementer i en Deque
• Sådan arbejder du med en Deque som en kø
  • Brug af append() og popleft() metoder
  • Kontrollerer, om en Deque Queue er tom
• Arbejde med Deque som en stak
  • Brug af append() og pop() metoder
  • Søger efter et tomt Deque-objekt
• Hvad er en begrænset Deque?
  • • Input Begrænset Deque
    • Output Begrænset Deque
• Lad os afslutte dette

Hvad er en Deque?

Hvis du er ny til Python eller computerprogrammering generelt, undrer du dig måske over, hvad en deque er. Deque står for " double-ended queue ", og det er en datastruktur, der giver dig mulighed for at tilføje og fjerne elementer fra begge ender af køen.

Det ligner en almindelig kø, men med den ekstra fleksibilitet at kunne tilføje og fjerne elementer fra både for- og bagsiden af ​​køen. Dette er muligt, fordi Pythons deque er implementeret som en dobbelt linket liste.

I Python implementeres deques ved hjælp af samlingsmodulet, som giver en deque-klasse. Denne klasse giver en række metoder til at tilføje og fjerne elementer fra deque.

Det giver også funktioner til andre nyttige operationer, såsom at rotere bordet eller rydde det helt.

Funktioner i A Python Deque

I modsætning til en almindelig liste, som har en O(n)-tidskompleksitet for append- og pop-operationer, giver en deque en O(1)-tidskompleksitet. Dette gør det betydeligt hurtigere og hukommelseseffektivt til disse læse-og-skrive-operationer.

Her er nogle flere Python-deque-funktioner, du bør vide om:

• Det er en foranderlig datastruktur.

• Det kan gemme flere datatyper, f.eks. heltal, tupler, arrays osv.

• Det understøtter indeksering, men ikke udskæringsoperationer.

• Det understøtter ikke sortering på stedet

• Det understøtter almindelige indbyggede iterable funktioner og operationer som i , sorted() , len() , reverse() osv.

Anvendelser af A Deque

Deques er nyttige af forskellige årsager. For eksempel kan de bruges til at implementere en kø eller en stak, som begge er almindelige datastrukturer inden for datalogi.

De kan også bruges til effektivt at behandle data i realtid, såsom i streaming-applikationer eller i systemer, der kræver hurtig adgang til data.

Udover at blive brugt til køer og stakke, kan deques også bruges til at implementere bredde-første søgealgoritmer. De er også nyttige til at opretholde et glidende vindue af elementer i en større rækkefølge.

Sådan oprettes og initialiseres en Deque

Du kan oprette en deque ved hjælp af en indbygget funktion fra samlingsmodulet. Lad os se nærmere på, hvordan du kan oprette og udfylde denne datastruktur.

Brug af deque()-funktionen

For at oprette en deque i Python kan du bruge den indbyggede deque() funktion fra samlingsmodulet. Denne funktion returnerer et nyt tomt deque-objekt, som du kan bruge til at implementere en dobbeltkø.

Her er et eksempel på, hvordan man opretter et tomt deque-objekt:

from collections import deque 

my_deque = deque() 

Du kan også oprette en deque med indledende elementer ved at overføre en iterabel (liste, tuple, osv.) til deque()- funktionen. Deque vil blive initialiseret med elementerne i iterable, fra venstre mod højre.

Her er et eksempel:

from collections import deque

my_list = [1, 2, 3, 4, 5] 
my_deque = deque(my_list)

Initialisering af en Deque med elementer

Du kan også initialisere en tom deque med elementer ved hjælp af forskellige metoder. En måde at gøre dette på er at bruge metoderne append() og appendleft() til at tilføje elementer til deque fra henholdsvis højre og venstre side.

Her er et eksempel:

from collections import deque

#Initialize the empty deque
my_deque = deque()
print(my_deque)

#Add Values to the deque
my_deque.append(1) 
my_deque.append(2) 
my_deque.appendleft(3) 

print(my_deque)

Efter at have kørt denne kode, vil dequeen indeholde elementerne [3, 1, 2].

En anden måde at initialisere en deque med elementer er at sende en liste over elementer til deque() -funktionen.

Her er et eksempel:

from collections import deque

my_deque = deque([1, 2, 3]) 

Ved at køre denne kode oprettes et deque-objekt, der indeholder elementerne [1, 2, 3] .

Samlet set er oprettelse og initialisering af en deque i Python ligetil og kan gøres ved hjælp af den indbyggede deque() funktion. Du kan også gøre dette ved at tilføje elementer til en tom deque ved hjælp af metoderne append() og appendleft() .

Sådan udføres almindelige deque-operationer

Der er mange operationer, du kan udføre på deque-objekter i Python. Lad os se nogle af de mere populære.

Tilføjelse af elementer til en Deque

Du kan tilføje elementer til en deque ved hjælp af metoderne append() og appendleft() . Append () -metoden tilføjer et element til højre ende af deque, mens appendleft()- metoden tilføjer et element til venstre ende af deque.

Her er et eksempel:

import collections 

# Create an empty deque 
my_deque = collections.deque() 

# Add elements to the deque 
my_deque.append(1) 
my_deque.appendleft(2) 
my_deque.append(3) 

print(my_deque) 

# Output: 
deque([2, 1, 3])

Tilføjelse af flere dataelementer til en Deque

Hvis du ikke ønsker at tilføje dataelementer til en deque en efter en, kan du fremskynde processen med funktionerne extend() eller extendleft() . Disse funktioner tager en iterabel ind og tilføjer den iterables indhold til henholdsvis slutningen eller venstre ende af deque.

Her er et eksempel:

from collections import deque

my_list = [1, 2, 3, 4, 5] 
my_deque = deque(my_list)

#Creating a tuple and list
cont = (11, 12, 13, 14)
full = [10,20,30]

#Extending the deque from the right
my_deque.extend(cont)
print(my_deque)

#Extending the deque from the left
my_deque.extendleft(full)
print(my_deque)

I koden ovenfor tilføjer funktionen extend() de multiple værdier i kont tuplen til slutningen af ​​deque. Dernæst tilføjer funktionen extendleft() de flere dataelementer i den fulde liste til venstre ende af deque.

Fjernelse af elementer fra en Deque

Du kan fjerne elementer fra en Python-deque ved hjælp af pop() og popleft() metoderne. Pop () -metoden fjerner og returnerer elementet længst til højre i deque, mens popleft()- metoden fjerner og returnerer elementet længst til venstre i deque.

Her er et eksempel:

import collections 

#Create a deque with some elements 
my_deque = collections.deque([1, 2, 3, 4, 5]) 

#Remove elements from the deque 
my_deque.pop() 
my_deque.popleft() 

print(my_deque) 

# Output: deque([2, 3, 4])

Du kan også fjerne en bestemt værdi fra en deque ved hjælp af remove() -funktionen. Funktionen fjerner den første forekomst af den angivne værdi fra deque.

Her er et eksempel:

import collections 

#Create a deque with some elements 
my_deque = collections.deque([1, 2, 1, 4, 5]) 

#Remove elements from the deque 
my_deque.remove(1)

print(my_deque) 

# Output: deque([2, 1, 4, 5])

Hvis elementet ikke findes, vil Python returnere en ValueError .

Fjernelse af alle elementer fra en Deque

For at fjerne alle elementerne fra en Deque og returnere den til en tom tilstand, kan vi bruge clear()- funktionen. Sådan fungerer det:

from collections import deque 

#Create a deque with some elements 
my_deque = deque([1, 2, 1, 4, 5]) 

#Remove all elements from the deque 
my_deque.clear()

print(my_deque) 

# Output: 
deque([])

Adgang til elementer i en Deque

Du kan få adgang til elementer i en Python-deque ved hjælp af indekseringsoperatoren [] . Du kan også bruge en negativ værdi i indekseringsoperatoren for at få adgang til deque-elementerne fra højre.

Indekseringen starter fra 0 for elementet længst til venstre og -1 for elementet længst til højre. Her er et eksempel:

import collections 

# Create a deque with some elements 
my_deque = collections.deque([1, 2, 3, 4, 5]) 

# Access elements of the deque 
print(my_deque[0]) 
# Output: 1 

print(my_deque[-1]) 
# Output: 5 

Ændring af elementer i en Deque

Du kan ændre elementer i en Python-deque ved at bruge indekseringsoperatoren " [] " og tildelingsoperatoren " = ". Her er et eksempel:

from collections import deque

# Create a deque with some elements 
my_deque = deque([1, 2, 3, 4, 5]) 
print(my_deque)

# Modify elements of the deque 
my_deque[0] = 10 
my_deque[-1] = 50 

print(my_deque) 

I ovenstående kode ændrer indekseringsoperatøren det første og sidste element i deque til henholdsvis 10 og 50.

Dette er de grundlæggende handlinger, du kan udføre på et deque-objekt i Python. Med disse operationer kan du effektivt implementere forskellige datastrukturer såsom køer, stakke og mere.

Sådan arbejder du med en Deque som en kø

Du kan bruge en deque i Python til at implementere en kødatastruktur. En kø er en abstrakt datatype, der opererer på en først ind først ud (FIFO) basis.

Det betyder, at du kan tilføje nye varer fra den ene ende af køen og skubbe gamle varer ud fra den anden ende.

En god måde at forklare dette på er en linje i en butik. Typisk vil den første person, der ankommer, være i spidsen for køen og vil blive behandlet først.

Nyankomne bliver nødt til at gå bagerst i køen og vente på deres tur. Så den første ind vil være den først besvarede, mens den sidst ind vil være den sidst behandlede.

Sådan kan du bruge en deque til at implementere køer.

Brug af append() og popleft() metoder

For at bruge en deque som en kø, kan du bruge append() metoden til at tilføje elementer til højre ende af deque. Derudover kan du bruge popleft() metoden til at fjerne elementer fra venstre ende af deque.

Dette er en meget effektiv måde at implementere en kø i Python. Her er et eksempel:

from collections import deque 

queue = deque() 
queue.append(1) 
queue.append(2) 
queue.append(3) 

print(queue) 
# Output: deque([1, 2, 3]) 

x = queue.popleft() 
print(x) 
# Output: 1 

print(queue) 
# Output: deque([2, 3]) 

As you can see, the append() method adds elements to the right end of the deque, and the popleft() method removes elements from the left end of the deque.

This is exactly what we need in a queue implementation.

Checking if a Deque Queue is Empty

To check if a deque is empty, you can use the not operator. Here is an example:

from collections import deque 

queue = deque() 
if not queue: 
   print("Queue is empty") 
else: 
   print("Queue is not empty") 

This will output “Queue is empty” because the deque is empty. If you add elements to the deque, it will no longer be empty.

In conclusion, using a deque as a queue in Python is very efficient and easy to implement.

Working with Deque as a Stack

Just like queues, stacks are another example of abstract data types that you can use in organizing data. Unlike queues, stacks operate in a last in first out (LIFO) fashion.

This means the last element into the deque will be the first element out. Here’s how you can implement this using the underlying data structure.

Using append() and pop() Methods

When using Deque as a stack, you can add elements to the top of the stack using the append() method. This method adds the element to the right end of the deque.

Similarly, you can remove elements from the top of the stack using the pop() method. This method removes and returns the rightmost element of the deque.

For example, let’s say you have a deque called “my_stack” and you want to add an element to the top of the stack. You can use the following code:

 my_stack.append(5) 

This will add the element 5 to the top of the stack.

If you want to remove the top element from the stack, you can use the pop() method: `

bal = my_stack.pop() 

print(bal)
# Output: 5

This will remove and return the rightmost element of the deque, which in this case is 5.

Checking for an Empty Deque Object

You can check if a deque stack is empty by using the boolean operator “not“. If the deque is empty, “not my_deque” will return True. Otherwise, it will return False.

For example, let’s say you have a deque stack called “my_deque” and you want to check if it is empty. You can use the following code:

if not my_deque: 
   print("The deque is empty") 

else: 
   print("The deque is not empty") 

This will print “The deque is empty” if the deque is empty. If it is not empty, the output will be “The deque is not empty“.

When working with Deque as a stack, it is important to keep track of whether the stack is empty or not. If you try to pop an element from an empty stack, you will get an IndexError.

What is A Restricted Deque?

A restricted deque is a double-ended queue with some restrictions placed on data append and pop operations on either end of the deque. There are two main types of restricted deques; Input restricted deque and output restricted deques

Let’s look at them:

Input Restricted Deque

An input-restricted deque allows you to pop or delete data elements from both ends of the deque. However, you can only insert data elements from one end of the deque.

This is very useful in applications with memory constraints. You can use it to add data elements in chronological order while retaining the ability to discard data from any end of the deque.

Output Restricted Deque

An output-restricted deque allows you to insert data from both ends of the deque. However, you can only delete items from one end of the deque called the front end.

An output-restricted deque is very useful in cases where you need to implement a FIFO data structure, but still want the functionality to append data from both ends.

Let’s Wrap This UP

By now, you should have a good understanding of the deque module in Python and how it can be used to implement efficient queues and stacks.

Deques are a versatile data structure that offers many advantages over traditional lists. These advantages are apparent when it comes to memory-efficient append and pop operations.

They are also a great choice when you need to implement a stack or a double-ended queue. Some of the key benefits of using deques include:

• Efficient O(1) append and pop operations from both ends of the deque

• Fast O(1) access to the first and last elements of the deque

• Built-in support for thread-safe, atomic operations

• Flexible methods for inserting, removing, and rotating elements in the deque

Overall, the deque module is a powerful tool that can help you write more efficient and maintainable Python code. Whether you are working on a small script or a large-scale project, deques are definitely worth considering as an alternative to traditional lists or other data structures!

Klar til at lære mere om Python, se vores afspilningsliste nedenfor